From 3fc0f54b249f5cd12c254518031585b0bb42685a Mon Sep 17 00:00:00 2001
From: peter klausler <pklausler@nvidia.com>
Date: Mon, 19 Nov 2018 11:14:41 -0800
Subject: [PATCH] [flang] Analyze wrapped expressions

Original-commit: flang-compiler/f18@b34db5d38f03b11b85890696569a22d506a98736
Reviewed-on: https://github.com/flang-compiler/f18/pull/228
---
 flang/lib/semantics/expression.cc | 37 +++++++++++++++++++++++++++++++++++++
 flang/lib/semantics/expression.h  | 22 ++++++++++++++++++++--
 2 files changed, 57 insertions(+), 2 deletions(-)

diff --git a/flang/lib/semantics/expression.cc b/flang/lib/semantics/expression.cc
index 5139f4a..396bc1a 100644
--- a/flang/lib/semantics/expression.cc
+++ b/flang/lib/semantics/expression.cc
@@ -1260,6 +1260,43 @@ evaluate::MaybeExpr AnalyzeExpr(
   return evaluate::ExprAnalyzer{context}.Analyze(expr);
 }
 
+template<typename A>
+evaluate::MaybeExpr AnalyzeWrappedExpr(
+    SemanticsContext &context, const A &expr) {
+  evaluate::ExprAnalyzer ea{context};
+  return evaluate::AnalyzeHelper(ea, expr);
+}
+
+evaluate::MaybeExpr AnalyzeExpr(
+    SemanticsContext &context, const parser::Scalar<parser::Expr> &expr) {
+  return AnalyzeWrappedExpr(context, expr);
+}
+evaluate::MaybeExpr AnalyzeExpr(
+    SemanticsContext &context, const parser::Constant<parser::Expr> &expr) {
+  return AnalyzeWrappedExpr(context, expr);
+}
+evaluate::MaybeExpr AnalyzeExpr(
+    SemanticsContext &context, const parser::Integer<parser::Expr> &expr) {
+  return AnalyzeWrappedExpr(context, expr);
+}
+evaluate::MaybeExpr AnalyzeExpr(SemanticsContext &context,
+    const parser::Scalar<parser::Constant<parser::Expr>> &expr) {
+  return AnalyzeWrappedExpr(context, expr);
+}
+evaluate::MaybeExpr AnalyzeExpr(SemanticsContext &context,
+    const parser::Scalar<parser::Integer<parser::Expr>> &expr) {
+  return AnalyzeWrappedExpr(context, expr);
+}
+evaluate::MaybeExpr AnalyzeExpr(SemanticsContext &context,
+    const parser::Integer<parser::Constant<parser::Expr>> &expr) {
+  return AnalyzeWrappedExpr(context, expr);
+}
+evaluate::MaybeExpr AnalyzeExpr(SemanticsContext &context,
+    const parser::Scalar<parser::Integer<parser::Constant<parser::Expr>>>
+        &expr) {
+  return AnalyzeWrappedExpr(context, expr);
+}
+
 class Mutator {
 public:
   Mutator(SemanticsContext &context) : context_{context} {}
diff --git a/flang/lib/semantics/expression.h b/flang/lib/semantics/expression.h
index 0d686f9..2ab9f9a 100644
--- a/flang/lib/semantics/expression.h
+++ b/flang/lib/semantics/expression.h
@@ -22,18 +22,36 @@
 namespace Fortran::parser {
 struct Expr;
 struct Program;
+template<typename> struct Scalar;
+template<typename> struct Integer;
+template<typename> struct Constant;
 }
 
 namespace Fortran::semantics {
 
 class SemanticsContext;
 
-using MaybeExpr = std::optional<evaluate::Expr<evaluate::SomeType>>;
-
 // Semantic analysis of one expression.
 std::optional<evaluate::Expr<evaluate::SomeType>> AnalyzeExpr(
     SemanticsContext &, const parser::Expr &);
 
+std::optional<evaluate::Expr<evaluate::SomeType>> AnalyzeExpr(
+    SemanticsContext &, const parser::Scalar<parser::Expr> &);
+std::optional<evaluate::Expr<evaluate::SomeType>> AnalyzeExpr(
+    SemanticsContext &, const parser::Constant<parser::Expr> &);
+std::optional<evaluate::Expr<evaluate::SomeType>> AnalyzeExpr(
+    SemanticsContext &, const parser::Integer<parser::Expr> &);
+std::optional<evaluate::Expr<evaluate::SomeType>> AnalyzeExpr(
+    SemanticsContext &, const parser::Scalar<parser::Constant<parser::Expr>> &);
+std::optional<evaluate::Expr<evaluate::SomeType>> AnalyzeExpr(
+    SemanticsContext &, const parser::Scalar<parser::Integer<parser::Expr>> &);
+std::optional<evaluate::Expr<evaluate::SomeType>> AnalyzeExpr(
+    SemanticsContext &,
+    const parser::Integer<parser::Constant<parser::Expr>> &);
+std::optional<evaluate::Expr<evaluate::SomeType>> AnalyzeExpr(
+    SemanticsContext &,
+    const parser::Scalar<parser::Integer<parser::Constant<parser::Expr>>> &);
+
 // Semantic analysis of all expressions in a parse tree, which is
 // decorated with typed representations for top-level expressions.
 void AnalyzeExpressions(parser::Program &, SemanticsContext &);
-- 
2.7.4