[flang] Fix crashes due to failure to find a subprogram

[klausler]

Summary

In error recovery situations, the mappings from source locations
to scopes were failing in a way that tripped some asserts.
Specifically, FindPureProcedureContaining() wasn't coping well
when starting at the global scope. (And since the global scope
no longer has a source range, clean up the Semantics constructor
to avoid confusion.)

[PeteSteinfeld]

All builds, tests, and looks good.

[awarzynski]

LGTM, thanks. Before merging, could you please fix the clang-tidy warning? No need to upload another version here.

flang/lib/Semantics/tools.cpp

85

As pointed out by clang-tidy, you can skip else here without changing the semantics: https://llvm.org/docs/CodingStandards.html#don-t-use-else-after-a-return.

[klausler]

flang/lib/Semantics/tools.cpp

85

We don't always follow that LLVM rule in the more functional style used in f18. This whole function is essentially one big expression that would be a single return statement if C++ could handle it.

flang/include/flang/Semantics/semantics.h

std::map<SymbolRef, const IndexVarInfo, SymbolAddressCompare>
       activeIndexVars_;
   UnorderedSymbolSet errorSymbols_;
   std::set<std::string> tempNames_;
 };
 
 class Semantics {
 public:
   explicit Semantics(SemanticsContext &context, parser::Program &program,
-      parser::CharBlock charBlock, bool debugModuleWriter = false)
+      bool debugModuleWriter = false)
       : context_{context}, program_{program} {
     context.set_debugModuleWriter(debugModuleWriter);
-    context.globalScope().AddSourceRange(charBlock);
   }
 
   SemanticsContext &context() const { return context_; }
   bool Perform();
   const Scope &FindScope(const parser::CharBlock &where) const {
     return context_.FindScope(where);
   }
   bool AnyFatalError() const { return context_.AnyFatalError(); }

flang/lib/Frontend/FrontendActions.cpp

bool PrescanAndSemaAction::BeginSourceFileAction(CompilerInstance &c1) {
   // Report the diagnostics from parsing
   ci.parsing().messages().Emit(llvm::errs(), ci.allCookedSources());
 
   auto &parseTree{*ci.parsing().parseTree()};
 
   // Prepare semantics
   setSemantics(std::make_unique<Fortran::semantics::Semantics>(
       ci.invocation().semanticsContext(), parseTree,
-      ci.parsing().cooked().AsCharBlock(), ci.invocation().debugModuleDir()));
+      ci.invocation().debugModuleDir()));
   auto &semantics = this->semantics();
 
   // Run semantic checks
   semantics.Perform();
 
   // Report the diagnostics from the semantic checks
   semantics.EmitMessages(ci.semaOutputStream());
 

flang/lib/Semantics/check-io.cpp

if (auto expr{AnalyzeExpr(context_, *var)}) {
             .Attach(std::move(*whyNot));
       }
     }
   }
 }
 
 void IoChecker::CheckForPureSubprogram() const { // C1597
   CHECK(context_.location());
-  if (FindPureProcedureContaining(context_.FindScope(*context_.location()))) {
-    context_.Say("External I/O is not allowed in a pure subprogram"_err_en_US);
+  if (const Scope *
+      scope{context_.globalScope().FindScope(*context_.location())}) {
+    if (FindPureProcedureContaining(*scope)) {
+      context_.Say(
+          "External I/O is not allowed in a pure subprogram"_err_en_US);
+    }
   }
 }
 
 } // namespace Fortran::semantics

flang/lib/Semantics/scope.cpp

for (auto &child : children_) {
     if (auto *scope{child.FindScope(source)}) {
       return scope;
     }
   }
   return isContained ? this : nullptr;
 }
 
 void Scope::AddSourceRange(const parser::CharBlock &source) {
-  for (auto *scope = this; !scope->IsGlobal(); scope = &scope->parent()) {
+  for (auto *scope{this}; !scope->IsGlobal(); scope = &scope->parent()) {
     scope->sourceRange_.ExtendToCover(source);
   }
 }
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &os, const Scope &scope) {
   os << Scope::EnumToString(scope.kind()) << " scope: ";
   if (auto *symbol{scope.symbol()}) {
     os << *symbol << ' ';

flang/lib/Semantics/tools.cpp

 const Scope &GetProgramUnitContaining(const Symbol &symbol) {
   return GetProgramUnitContaining(symbol.owner());
 }
 
 const Scope *FindPureProcedureContaining(const Scope &start) {
   // N.B. We only need to examine the innermost containing program unit
   // because an internal subprogram of a pure subprogram must also
   // be pure (C1592).
+  if (start.IsGlobal()) {
+    return nullptr;
+  } else {
     const Scope &scope{GetProgramUnitContaining(start)};
     return IsPureProcedure(scope) ? &scope : nullptr;
   }
+}
 
 static bool MightHaveCompatibleDerivedtypes(
     const std::optional<evaluate::DynamicType> &lhsType,
     const std::optional<evaluate::DynamicType> &rhsType) {
   const DerivedTypeSpec *lhsDerived{evaluate::GetDerivedTypeSpec(lhsType)};
   const DerivedTypeSpec *rhsDerived{evaluate::GetDerivedTypeSpec(rhsType)};
   if (!lhsDerived || !rhsDerived) {
     return false;

flang/tools/f18/f18.cpp

std::string CompileFortran(std::string path, Fortran::parser::Options options,
   }
   auto &parseTree{*parsing.parseTree()};
   if (driver.measureTree) {
     MeasureParseTree(parseTree);
   }
   if (!driver.debugNoSemantics || driver.dumpSymbols ||
       driver.dumpUnparseWithSymbols || driver.getDefinition ||
       driver.getSymbolsSources) {
-    Fortran::semantics::Semantics semantics{semanticsContext, parseTree,
-        parsing.cooked().AsCharBlock(), driver.debugModuleWriter};
+    Fortran::semantics::Semantics semantics{
+        semanticsContext, parseTree, driver.debugModuleWriter};
     semantics.Perform();
     Fortran::semantics::RuntimeDerivedTypeTables tables;
     if (!semantics.AnyFatalError()) {
       tables =
           Fortran::semantics::BuildRuntimeDerivedTypeTables(semanticsContext);
       if (!tables.schemata) {
         llvm::errs() << driver.prefix
                      << "could not find module file for __fortran_type_info\n";