[flang][NFC] Change how error symbols are recorded

[tskeith]

Summary

When an error is associated with a symbol, it was marked with a flag
from Symbol::Flag. The problem with that is that you need a mutable
symbol to do that. Instead, store the set of error symbols in the
SemanticsContext. This allows for some const_casts to be eliminated.

Also, improve the internal error that occurs if SetError is called
but no fatal error has been reported.

[PeteSteinfeld]

All builds, tests, and looks good.

flang/include/flang/Semantics/semantics.h

public:
   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 *);
   bool HasError(const parser::Name &);
-  void SetError(Symbol &, bool = true);
+  void SetError(const Symbol &, bool = true);
 
   template <typename... A> parser::Message &Say(A &&...args) {
     CHECK(location_);
     return messages_.Say(*location_, std::forward<A>(args)...);
   }
   template <typename... A>
   parser::Message &Say(parser::CharBlock at, A &&...args) {
     return messages_.Say(at, std::forward<A>(args)...);
public:
   void ActivateIndexVar(const parser::Name &, IndexVarKind);
   void DeactivateIndexVar(const parser::Name &);
   SymbolVector GetIndexVars(IndexVarKind);
   SourceName GetTempName(const Scope &);
 
 private:
   void CheckIndexVarRedefine(
       const parser::CharBlock &, const Symbol &, parser::MessageFixedText &&);
-  bool CheckError(bool);
+  void CheckError(const Symbol &);
 
   const common::IntrinsicTypeDefaultKinds &defaultKinds_;
   const common::LanguageFeatureControl languageFeatures_;
   parser::AllSources &allSources_;
   std::optional<parser::CharBlock> location_;
   std::vector<std::string> searchDirectories_;
   std::string moduleDirectory_{"."s};
   std::string moduleFileSuffix_{".mod"};
   bool warnOnNonstandardUsage_{false};
   bool warningsAreErrors_{false};
   bool debugModuleWriter_{false};
   const evaluate::IntrinsicProcTable intrinsics_;
   Scope globalScope_;
   parser::Messages messages_;
   evaluate::FoldingContext foldingContext_;
   ConstructStack constructStack_;
   struct IndexVarInfo {
     parser::CharBlock location;
     IndexVarKind kind;
   };
   std::map<SymbolRef, const IndexVarInfo> activeIndexVars_;
+  std::set<SymbolRef> errorSymbols_;
   std::vector<std::string> tempNames_;
 };
 
 class Semantics {
 public:
   explicit Semantics(SemanticsContext &context, parser::Program &program,
       parser::CookedSource &cooked, bool debugModuleWriter = false)
       : context_{context}, program_{program}, cooked_{cooked} {

flang/include/flang/Semantics/symbol.h

using Details = std::variant<UnknownDetails, MainProgramDetails, ModuleDetails,
     GenericDetails, ProcBindingDetails, NamelistDetails, CommonBlockDetails,
     FinalProcDetails, TypeParamDetails, MiscDetails>;
 llvm::raw_ostream &operator<<(llvm::raw_ostream &, const Details &);
 std::string DetailsToString(const Details &);
 
 class Symbol {
 public:
   ENUM_CLASS(Flag,
-      Error, // an error has been reported on this symbol
       Function, // symbol is a function
       Subroutine, // symbol is a subroutine
       StmtFunction, // symbol is a statement function (Function is set too)
       Implicit, // symbol is implicitly typed
       ImplicitOrError, // symbol must be implicitly typed or it's an error
       ModFile, // symbol came from .mod file
       ParentComp, // symbol is the "parent component" of an extended type
       CrayPointer, CrayPointee,

flang/include/flang/Semantics/type.h

public:
   // The "raw" type parameter list is a simple transcription from the
   // parameter list in the parse tree, built by calling AddRawParamValue().
   // It can be used with forward-referenced derived types.
   void AddRawParamValue(const std::optional<parser::Keyword> &, ParamValue &&);
   // Checks the raw parameter list against the definition of a derived type.
   // Converts the raw parameter list to a map, naming each actual parameter.
   void CookParameters(evaluate::FoldingContext &);
   // Evaluates type parameter expressions.
-  void EvaluateParameters(evaluate::FoldingContext &);
+  void EvaluateParameters(SemanticsContext &);
   void AddParamValue(SourceName, ParamValue &&);
   // Creates a Scope for the type and populates it with component
   // instantiations that have been specialized with actual type parameter
   // values, which are cooked &/or evaluated if necessary.
   void Instantiate(Scope &, SemanticsContext &);
 
   ParamValue *FindParameter(SourceName);
   const ParamValue *FindParameter(SourceName target) const {

flang/lib/Semantics/expression.cpp

MaybeExpr ExpressionAnalyzer::Analyze(const parser::ArrayElement &ae) {
   if (MaybeExpr baseExpr{Analyze(ae.base)}) {
     if (ae.subscripts.empty()) {
       // will be converted to function call later or error reported
       return std::nullopt;
     } else if (baseExpr->Rank() == 0) {
       if (const Symbol * symbol{GetLastSymbol(*baseExpr)}) {
         if (!context_.HasError(symbol)) {
           Say("'%s' is not an array"_err_en_US, symbol->name());
-          context_.SetError(const_cast<Symbol &>(*symbol));
+          context_.SetError(*symbol);
         }
       }
     } else if (std::optional<DataRef> dataRef{
                    ExtractDataRef(std::move(*baseExpr))}) {
       return ApplySubscripts(
           std::move(*dataRef), AnalyzeSectionSubscripts(ae.subscripts));
     } else {
       Say("Subscripts may be applied only to an object, component, or array constant"_err_en_US);
if (details->kind() == semantics::SubprogramKind::Module) {
       semantics::ResolveSpecificationParts(context_, symbol);
       if (symbol.has<semantics::SubprogramNameDetails>()) {
         // When the symbol hasn't had its details updated, we must have
         // already been in the process of resolving the function's
         // specification part; but recursive function calls are not
         // allowed in specification parts (10.1.11 para 5).
         Say("The module function '%s' may not be referenced recursively in a specification expression"_err_en_US,
             symbol.name());
-        context_.SetError(const_cast<Symbol &>(symbol));
+        context_.SetError(symbol);
         return false;
       }
     } else { // 10.1.11 para 4
       Say("The internal function '%s' may not be referenced in a specification expression"_err_en_US,
           symbol.name());
-      context_.SetError(const_cast<Symbol &>(symbol));
+      context_.SetError(symbol);
       return false;
     }
   }
   return true;
 }
 
 // Resolve a call to a generic procedure with given actual arguments.
 // adjustActuals is called on procedure bindings to handle pass arg.

flang/lib/Semantics/resolve-names.cpp

void DeclarationVisitor::Post(const parser::DerivedTypeSpec &x) {
   if (dtDetails.isForwardReferenced()) {
     DeclTypeSpec &type{currScope().MakeDerivedType(category, std::move(*spec))};
     SetDeclTypeSpec(type);
     return;
   }
   // Normalize parameters to produce a better search key.
   spec->CookParameters(GetFoldingContext());
   if (!spec->MightBeParameterized()) {
-    spec->EvaluateParameters(GetFoldingContext());
+    spec->EvaluateParameters(context());
   }
   if (const DeclTypeSpec *
       extant{currScope().FindInstantiatedDerivedType(*spec, category)}) {
     // This derived type and parameter expressions (if any) are already present
     // in this scope.
     SetDeclTypeSpec(*extant);
   } else {
     DeclTypeSpec &type{currScope().MakeDerivedType(category, std::move(*spec))};
for (auto &paramName : std::get<std::list<parser::Name>>(stmt.statement.t)) {
     if (!symbol) {
       Say(paramName,
           "No definition found for type parameter '%s'"_err_en_US); // C742
       // No symbol for a type param.  Create one and mark it as containing an
       // error to improve subsequent semantic processing
       BeginAttrs();
       Symbol *typeParam{MakeTypeSymbol(
           paramName, TypeParamDetails{common::TypeParamAttr::Len})};
-      typeParam->set(Symbol::Flag::Error);
+      context().SetError(*typeParam);
       EndAttrs();
     } else if (!symbol->has<TypeParamDetails>()) {
       Say2(paramName, "'%s' is not defined as a type parameter"_err_en_US,
           *symbol, "Definition of '%s'"_en_US); // C741
     }
     if (!paramNames.insert(paramName.source).second) {
       Say(paramName,
           "Duplicate type parameter name: '%s'"_err_en_US); // C731

 
 // Return true if it is ok to declare this component in the current scope.
 // Otherwise, emit an error and return false.
 bool DeclarationVisitor::OkToAddComponent(
     const parser::Name &name, const Symbol *extends) {
   for (const Scope *scope{&currScope()}; scope;) {
     CHECK(scope->IsDerivedType());
     if (auto *prev{FindInScope(*scope, name)}) {
-      if (!prev->test(Symbol::Flag::Error)) {
+      if (!context().HasError(*prev)) {
         auto msg{""_en_US};
         if (extends) {
           msg = "Type cannot be extended as it has a component named"
                 " '%s'"_err_en_US;
         } else if (prev->test(Symbol::Flag::ParentComp)) {
           msg = "'%s' is a parent type of this type and so cannot be"
                 " a component"_err_en_US;
         } else if (scope != &currScope()) {

flang/lib/Semantics/semantics.cpp

const DeclTypeSpec &SemanticsContext::MakeLogicalType(int kind) {
   return globalScope_.MakeLogicalType(KindExpr{kind});
 }
 
 bool SemanticsContext::AnyFatalError() const {
   return !messages_.empty() &&
       (warningsAreErrors_ || messages_.AnyFatalError());
 }
 bool SemanticsContext::HasError(const Symbol &symbol) {
-  return CheckError(symbol.test(Symbol::Flag::Error));
+  return errorSymbols_.count(symbol) > 0;
 }
 bool SemanticsContext::HasError(const Symbol *symbol) {
-  return CheckError(!symbol || HasError(*symbol));
+  return !symbol || HasError(*symbol);
 }
 bool SemanticsContext::HasError(const parser::Name &name) {
   return HasError(name.symbol);
 }
-void SemanticsContext::SetError(Symbol &symbol, bool value) {
+void SemanticsContext::SetError(const Symbol &symbol, bool value) {
   if (value) {
-    CHECK(AnyFatalError());
-    symbol.set(Symbol::Flag::Error);
+    CheckError(symbol);
+    errorSymbols_.emplace(symbol);
   }
 }
-bool SemanticsContext::CheckError(bool error) {
-  CHECK(!error || AnyFatalError());
-  return error;
+void SemanticsContext::CheckError(const Symbol &symbol) {
+  if (!AnyFatalError()) {
+    std::string buf;
+    llvm::raw_string_ostream ss{buf};
+    ss << symbol;
+    common::die(
+        "No error was reported but setting error on: %s", ss.str().c_str());
+  }
 }
 
 const Scope &SemanticsContext::FindScope(parser::CharBlock source) const {
   return const_cast<SemanticsContext *>(this)->FindScope(source);
 }
 
 Scope &SemanticsContext::FindScope(parser::CharBlock source) {
   if (auto *scope{globalScope_.FindScope(source)}) {

flang/lib/Semantics/tools.cpp

SymbolVector OrderParameterDeclarations(const Symbol &typeSymbol) {
   const auto &paramDecls{typeSymbol.get<DerivedTypeDetails>().paramDecls()};
   result.insert(result.end(), paramDecls.begin(), paramDecls.end());
   return result;
 }
 
 const DeclTypeSpec &FindOrInstantiateDerivedType(Scope &scope,
     DerivedTypeSpec &&spec, SemanticsContext &semanticsContext,
     DeclTypeSpec::Category category) {
-  spec.CookParameters(semanticsContext.foldingContext());
-  spec.EvaluateParameters(semanticsContext.foldingContext());
+  spec.EvaluateParameters(semanticsContext);
   if (const DeclTypeSpec *
       type{scope.FindInstantiatedDerivedType(spec, category)}) {
     return *type;
   }
   // Create a new instantiation of this parameterized derived type
   // for this particular distinct set of actual parameter values.
   DeclTypeSpec &type{scope.MakeDerivedType(category, std::move(spec))};
   type.derivedTypeSpec().Instantiate(scope, semanticsContext);

flang/lib/Semantics/type.cpp

if (FindParameter(name)) {
           "Multiple values given for type parameter '%s'"_err_en_US, name);
     } else {
       value.set_attr(attr);
       AddParamValue(name, std::move(value));
     }
   }
 }
 
-void DerivedTypeSpec::EvaluateParameters(
-    evaluate::FoldingContext &foldingContext) {
+void DerivedTypeSpec::EvaluateParameters(SemanticsContext &context) {
+  evaluate::FoldingContext &foldingContext{context.foldingContext()};
   CookParameters(foldingContext);
   if (evaluated_) {
     return;
   }
   evaluated_ = true;
   auto &messages{foldingContext.messages()};
 
   // Fold the explicit type parameter value expressions first.  Do not
   // fold them within the scope of the derived type being instantiated;
   // these expressions cannot use its type parameters.  Convert the values
   // of the expressions to the declared types of the type parameters.
   auto parameterDecls{OrderParameterDeclarations(typeSymbol_)};
   for (const Symbol &symbol : parameterDecls) {
     const SourceName &name{symbol.name()};
     if (ParamValue * paramValue{FindParameter(name)}) {
       if (const MaybeIntExpr & expr{paramValue->GetExplicit()}) {
         if (auto converted{evaluate::ConvertToType(symbol, SomeExpr{*expr})}) {
           SomeExpr folded{
               evaluate::Fold(foldingContext, std::move(*converted))};
           if (auto *intExpr{std::get_if<SomeIntExpr>(&folded.u)}) {
             paramValue->SetExplicit(std::move(*intExpr));
             continue;
           }
         }
-        if (!symbol.test(Symbol::Flag::Error)) {
+        if (!context.HasError(symbol)) {
           evaluate::SayWithDeclaration(messages, symbol,
               "Value of type parameter '%s' (%s) is not convertible to its"
               " type"_err_en_US,
               name, expr->AsFortran());
         }
       }
     }
   }
void DerivedTypeSpec::EvaluateParameters(SemanticsContext &context) {
   for (const Symbol &symbol : parameterDecls) {
     const SourceName &name{symbol.name()};
     if (!FindParameter(name)) {
       const TypeParamDetails &details{symbol.get<TypeParamDetails>()};
       if (details.init()) {
         auto expr{
             evaluate::Fold(foldingContext, common::Clone(details.init()))};
         AddParamValue(name, ParamValue{std::move(*expr), details.attr()});
-      } else if (!symbol.test(Symbol::Flag::Error)) {
+      } else if (!context.HasError(symbol)) {
         messages.Say(name_,
             "Type parameter '%s' lacks a value and has no default"_err_en_US,
             name);
       }
     }
   }
 }
 
void DerivedTypeSpec::Instantiate(
   instantiated_ = true;
   auto &foldingContext{context.foldingContext()};
   if (IsForwardReferenced()) {
     foldingContext.messages().Say(typeSymbol_.name(),
         "The derived type '%s' was forward-referenced but not defined"_err_en_US,
         typeSymbol_.name());
     return;
   }
-  CookParameters(foldingContext);
-  EvaluateParameters(foldingContext);
+  EvaluateParameters(context);
   const Scope &typeScope{DEREF(typeSymbol_.scope())};
   if (!MightBeParameterized()) {
     scope_ = &typeScope;
     for (auto &pair : typeScope) {
       Symbol &symbol{*pair.second};
       if (DeclTypeSpec * type{symbol.GetType()}) {
         if (DerivedTypeSpec * derived{type->AsDerived()}) {
           if (!(derived->IsForwardReferenced() &&