[flang] Distinguish intrinsic module USE in module files; correct search paths

[klausler]

Summary

In the USE statements that f18 emits to module files, ensure that symbols
from intrinsic modules are marked as such on their USE statements. And
ensure that the current working directory (".") cannot override the intrinsic
module search path when trying to locate an intrinsic module.

flang/lib/Parser/parsing.cpp

if (options.isModuleFile) {
     }
   }
 
   std::string buf;
   llvm::raw_string_ostream fileError{buf};
   const SourceFile *sourceFile;
   if (path == "-") {
     sourceFile = allSources.ReadStandardInput(fileError);
+  } else if (options.isModuleFile) {
+    // Don't mess with intrinsic module search path
+    sourceFile = allSources.Open(path, fileError);
   } else {
-    std::optional<std::string> currentDirectory{"."};
-    sourceFile = allSources.Open(path, fileError, std::move(currentDirectory));
+    sourceFile =
+        allSources.Open(path, fileError, "."s /*prepend to search path*/);
   }
   if (!fileError.str().empty()) {
     ProvenanceRange range{allSources.AddCompilerInsertion(path)};
     messages_.Say(range, "%s"_err_en_US, fileError.str());
     return sourceFile;
   }
   CHECK(sourceFile);
 

flang/lib/Semantics/mod-file.cpp

void ModFileWriter::PutGeneric(const Symbol &symbol) {
   if (symbol.attrs().test(Attr::PRIVATE)) {
     PutGenericName(decls_ << "private::", symbol) << '\n';
   }
 }
 
 void ModFileWriter::PutUse(const Symbol &symbol) {
   auto &details{symbol.get<UseDetails>()};
   auto &use{details.symbol()};
-  uses_ << "use " << GetUsedModule(details).name();
-  PutGenericName(uses_ << ",only:", symbol);
+  const Symbol &module{GetUsedModule(details)};
+  if (use.owner().parent().IsIntrinsicModules()) {
+    uses_ << "use,intrinsic::";
+  } else {
+    uses_ << "use ";
+  }
+  uses_ << module.name() << ",only:";
+  PutGenericName(uses_, symbol);
   // Can have intrinsic op with different local-name and use-name
   // (e.g. `operator(<)` and `operator(.lt.)`) but rename is not allowed
   if (!IsIntrinsicOp(symbol) && use.name() != symbol.name()) {
     PutGenericName(uses_ << "=>", use);
   }
   uses_ << '\n';
   PutUseExtraAttr(Attr::VOLATILE, symbol, use);
   PutUseExtraAttr(Attr::ASYNCHRONOUS, symbol, use);
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);
     }
+    options.searchDirectories.insert(options.searchDirectories.begin(), "."s);
   }
   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{fatalError ? nullptr : parsing.Prescan(path, options)};

flang/test/Semantics/modfile36.f90

 ! RUN: %python %S/test_modfile.py %s %flang_fc1
 
 ! Check modfile that contains import of use-assocation of another use-association.
 
 module m1
   interface
      subroutine s(x)
        use, intrinsic :: iso_c_binding, only: c_ptr
        type(c_ptr) :: x
      end subroutine
   end interface
 end module
 !Expect: m1.mod
 !module m1
 ! interface
 !  subroutine s(x)
-!   use iso_c_binding, only: c_ptr
+!   use,intrinsic::iso_c_binding, only: c_ptr
 !   type(c_ptr) :: x
 !  end
 ! end interface
 !end
 
 module m2
   use, intrinsic :: iso_c_binding, only: c_ptr
   interface
      subroutine s(x)
        import :: c_ptr
        type(c_ptr) :: x
      end subroutine
   end interface
 end module
 !Expect: m2.mod
 !module m2
-! use iso_c_binding,only:c_ptr
+! use,intrinsic::iso_c_binding,only:c_ptr
 ! interface
 !  subroutine s(x)
 !   import::c_ptr
 !   type(c_ptr)::x
 !  end
 ! end interface
 !end