[flang] Remove needless "anyIntrinsicDefinedOps", fixing iterative expr analysis

[klausler]

Summary

The flag "anyIntrinsicDefinedOps" is always set nowadays, as there are intrinsic
modules that define operator(==) and (!=). This disables the iterative
expression analysis mechanism, also unnecessarily, and it is possible to
overflow the stack when analyzing very deep expression trees like the ones
that show up in artificial stress tests. Remove the flag.

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:
   UnorderedSymbolSet errorSymbols_;
   std::set<std::string> tempNames_;
   const Scope *builtinsScope_{nullptr}; // module __Fortran_builtins
   Scope *ppcBuiltinTypesScope_{nullptr}; // module __Fortran_PPC_types
   std::optional<const Scope *> cudaBuiltinsScope_; // module __CUDA_builtins
   const Scope *ppcBuiltinsScope_{nullptr}; // module __ppc_intrinsics
   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 && !context_.anyDefinedIntrinsicOperator()) {
+    if (!wasIterativelyAnalyzing) {
       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);
   } else {
     auto kind{std::get<parser::ProcedureStmt::Kind>(x.t)};