[flang] Allow global scope names that clash with intrinsic modules

[klausler]

Summary

Intrinsic module names are not in the user's namespace, so they
are free to declare global names that conflict with intrinsic
modules.

flang/lib/Semantics/mod-file.cpp

static bool VerifyHeader(llvm::ArrayRef<char> content) {
   std::string_view expectSum{sv.substr(ModHeader::magicLen, ModHeader::sumLen)};
   std::string actualSum{CheckSum(sv.substr(ModHeader::len))};
   return expectSum == actualSum;
 }
 
 Scope *ModFileReader::Read(const SourceName &name,
     std::optional<bool> isIntrinsic, Scope *ancestor, bool silent) {
   std::string ancestorName; // empty for module
+  Symbol *notAModule{nullptr};
+  bool fatalError{false};
   if (ancestor) {
     if (auto *scope{ancestor->FindSubmodule(name)}) {
       return scope;
     }
     ancestorName = ancestor->GetName().value().ToString();
   } else {
     if (!isIntrinsic.value_or(false)) {
       auto it{context_.globalScope().find(name)};
       if (it != context_.globalScope().end()) {
-        return it->second->scope();
+        Scope *scope{it->second->scope()};
+        if (scope->kind() == Scope::Kind::Module) {
+          return scope;
+        } else {
+          notAModule = scope->symbol();
+          // USE, NON_INTRINSIC global name isn't a module?
+          fatalError = isIntrinsic.has_value();
+        }
       }
     }
     if (isIntrinsic.value_or(true)) {
       auto it{context_.intrinsicModulesScope().find(name)};
       if (it != context_.intrinsicModulesScope().end()) {
         return it->second->scope();
       }
     }
   }
   parser::Parsing parsing{context_.allCookedSources()};
   parser::Options options;
   options.isModuleFile = true;
   options.features.Enable(common::LanguageFeature::BackslashEscapes);
   options.features.Enable(common::LanguageFeature::OpenMP);
-  if (!isIntrinsic.value_or(false)) {
+  if (!isIntrinsic.value_or(false) && !notAModule) {
+    // Scan non-intrinsic module directories
     options.searchDirectories = context_.searchDirectories();
     // If a directory is in both lists, the intrinsic module directory
     // takes precedence.
     for (const auto &dir : context_.intrinsicModuleDirectories()) {
       std::remove(options.searchDirectories.begin(),
           options.searchDirectories.end(), dir);
     }
   }
   if (isIntrinsic.value_or(true)) {
     for (const auto &dir : context_.intrinsicModuleDirectories()) {
       options.searchDirectories.push_back(dir);
     }
   }
   auto path{ModFileName(name, ancestorName, context_.moduleFileSuffix())};
-  const auto *sourceFile{parsing.Prescan(path, options)};
-  if (parsing.messages().AnyFatalError()) {
+  const auto *sourceFile{fatalError ? nullptr : parsing.Prescan(path, options)};
+  if (fatalError || parsing.messages().AnyFatalError()) {
     if (!silent) {
+      if (notAModule) {
+        // Module is not explicitly INTRINSIC, and there's already a global
+        // symbol of the same name that is not a module.
+        context_.SayWithDecl(
+            *notAModule, name, "'%s' is not a module"_err_en_US, name);
+      } else {
         for (auto &msg : parsing.messages().messages()) {
           std::string str{msg.ToString()};
           Say(name, ancestorName,
               parser::MessageFixedText{str.c_str(), str.size(), msg.severity()},
               path);
         }
       }
+    }
     return nullptr;
   }
   CHECK(sourceFile);
   if (!VerifyHeader(sourceFile->content())) {
     Say(name, ancestorName, "File has invalid checksum: %s"_warn_en_US,
         sourceFile->path());
     return nullptr;
   }

flang/lib/Semantics/resolve-names.cpp

 // If an error occurs, report it and return nullptr.
 Scope *ModuleVisitor::FindModule(const parser::Name &name,
     std::optional<bool> isIntrinsic, Scope *ancestor) {
   ModFileReader reader{context()};
   Scope *scope{reader.Read(name.source, isIntrinsic, ancestor)};
   if (!scope) {
     return nullptr;
   }
-  if (scope->kind() != Scope::Kind::Module) {
-    Say(name, "'%s' is not a module"_err_en_US);
-    return nullptr;
-  }
   if (DoesScopeContain(scope, currScope())) { // 14.2.2(1)
     Say(name, "Module '%s' cannot USE itself"_err_en_US);
   }
   Resolve(name, scope->symbol());
   return scope;
 }
 
 void ModuleVisitor::ApplyDefaultAccess() {

flang/test/Semantics/modfile49.f90

+! RUN: %python %S/test_errors.py %s %flang_fc1
+subroutine foo
+end
+subroutine iso_fortran_env
+end
+subroutine bad1
+  !ERROR: 'foo' is not a module
+  use foo
+end
+subroutine ok1
+  use, intrinsic :: iso_fortran_env
+end
+subroutine ok2
+  use iso_fortran_env
+end
+subroutine bad2
+  !ERROR: 'iso_fortran_env' is not a module
+  use, non_intrinsic :: iso_fortran_env
+end