[flang] Allow for user-defined intrinsic operators (regression)

[klausler]

Summary

The recent code that uses an iterative rather than recursive walk
over the parse tree when processing expressions needs to allow for
the rare case in which an intrinsic operator (e.g., +) is extended
by a generic interface in the program.

flang/include/flang/Semantics/semantics.h

SemanticsContext &set_warningsAreErrors(bool x) {
     return *this;
   }
 
   SemanticsContext &set_debugModuleWriter(bool x) {
     debugModuleWriter_ = x;
     return *this;
   }
 
+  bool anyDefinedIntrinsicOperator() const {
+    return anyDefinedIntrinsicOperator_;
+  }
+  SemanticsContext &set_anyDefinedIntrinsicOperator(bool yes = true) {
+    anyDefinedIntrinsicOperator_ = yes;
+    return *this;
+  }
+
   const DeclTypeSpec &MakeNumericType(TypeCategory, int kind = 0);
   const DeclTypeSpec &MakeLogicalType(int kind = 0);
 
   bool AnyFatalError() const;
 
   // Test or set the Error flag on a Symbol
   bool HasError(const Symbol &);
   bool HasError(const Symbol *);
private:
   };
   std::map<SymbolRef, const IndexVarInfo, SymbolAddressCompare>
       activeIndexVars_;
   UnorderedSymbolSet errorSymbols_;
   std::set<std::string> tempNames_;
   const Scope *builtinsScope_{nullptr}; // module __Fortran_builtins
   std::list<parser::Program> modFileParseTrees_;
   std::unique_ptr<CommonBlockMap> commonBlockMap_;
+  bool anyDefinedIntrinsicOperator_{false};
 };
 
 class Semantics {
 public:
   explicit Semantics(SemanticsContext &context, parser::Program &program,
       bool debugModuleWriter = false)
       : context_{context}, program_{program} {
     context.set_debugModuleWriter(debugModuleWriter);

flang/lib/Semantics/expression.cpp

 
 MaybeExpr ExpressionAnalyzer::Analyze(const parser::Expr &expr) {
   bool wasIterativelyAnalyzing{iterativelyAnalyzingSubexpressions_};
   MaybeExpr result;
   if (useSavedTypedExprs_) {
     if (expr.typedExpr) {
       return expr.typedExpr->v;
     }
-    if (!wasIterativelyAnalyzing) {
+    if (!wasIterativelyAnalyzing && !context_.anyDefinedIntrinsicOperator()) {
       iterativelyAnalyzingSubexpressions_ = true;
       result = IterativelyAnalyzeSubexpressions(expr);
     }
   }
   if (!result) {
     result = ExprOrVariable(expr, expr.source);
   }
   iterativelyAnalyzingSubexpressions_ = wasIterativelyAnalyzing;

flang/lib/Semantics/resolve-names.cpp

void InterfaceVisitor::Post(const parser::EndInterfaceStmt &) {
   genericInfo_.pop();
 }
 
 // Create a symbol in genericSymbol_ for this GenericSpec.
 bool InterfaceVisitor::Pre(const parser::GenericSpec &x) {
   if (auto *symbol{FindInScope(GenericSpecInfo{x}.symbolName())}) {
     SetGenericSymbol(*symbol);
   }
+  if (const auto *opr{std::get_if<parser::DefinedOperator>(&x.u)}; opr &&
+      std::holds_alternative<parser::DefinedOperator::IntrinsicOperator>(
+          opr->u)) {
+    context().set_anyDefinedIntrinsicOperator(true);
+  }
   return false;
 }
 
 bool InterfaceVisitor::Pre(const parser::ProcedureStmt &x) {
   if (!isGeneric()) {
     Say("A PROCEDURE statement is only allowed in a generic interface block"_err_en_US);
     return false;
   }