[C++20][Modules][7/8] Find the primary interface name for a module.

[iains]

Summary

When we are building modules, there are cases where the only way to determine
validity of access is by comparing primary interface names. This is because we need
to be able to associate a primary interface name with an imported partition, but
before the primary interface module is complete - so that textual comparison is
necessary.

If this turns out to be needed many times, we could cache the result, but it seems
unlikely to be significant (at this time); cases with very many imported partitions
would seem unusual.

[iains]

rebased onto import state machine

[iains]

Rebased onto other modules work.

[iains]

patch 7 of 8 to implement basic C++20 module partition support.

[iains]

rebased onto changes in parent patches.

[urnathan]

clang/include/clang/Basic/Module.h

520–522

stray blank line?

523–524

haven't you added an IsPartition flag to Module? can't you test that before searching? Also, Almost Always Auto?

[urnathan]

clang/include/clang/Basic/Module.h

522

Is it possible to return a StringRef rather than a copy?

[iains]

clang/include/clang/Basic/Module.h

523–524

1. The case we are dealing with is

we're building A{,:B}
we encounter :Part

So we do not have a module for the importer ('cos we didn't build it yet) but we need to know the primary module name for the imported partition (even to be able to find it).

So it's a wee bit icky, but we are reduced to manipulating text (none of the content of Module.h is available - we are looking at parser tokens).

2. auto and StringRefs - yes probably I could do better.

The consolation is that this is not an action we'd reasonably expect to be carried out many times c.f. other parser jobs - of course, I'll be proven wrong and someone will import 10^6 partitions ....

[iains]

clang/include/clang/Basic/Module.h

523–524

(none of the content of Module.h is available - we are looking at parser tokens).

maybe I retract that, at least partially, we do not have a module (built) - but some of the base information is saved in sema when the module decl is built, so we probably do know if we are building A:B or just A.

If we think that this could be a pain point - sema can cache the primary module name and we can then return a StringRef to that.

[ChuanqiXu]

My implementation is

StringRef getPrimaryModuleName() const {
    if (Check Kind)
      return Name;
    return StringRef(Name).split('-').first;
  }

[iains]

address review comments, rebase

[iains]

remove stray blank line

[iains]

clang/include/clang/Basic/Module.h

523–524

I've reworked this to use a StringRef - so that the source string components are owned by the importing module (which we're building) and then we construct a new module name (for the imported module) which we will use to find it. We have enough of the module at this point to do this.

[ChuanqiXu]

clang/include/clang/Basic/Module.h

527

Here we could return Name simply.

[iains]

rebased, addressed review comment.

[iains]

rebased

clang/include/clang/Basic/Module.h

void setParent(Module *M) {
     Parent = M;
     Parent->SubModuleIndex[Name] = Parent->SubModules.size();
     Parent->SubModules.push_back(this);
   }
 
   /// Is this a module partition.
   bool isModulePartition() const { return Name.find(':') != std::string::npos; }
 
+  /// Get the primary module interface name from a partition.
+  StringRef getPrimaryModuleInterfaceName() const {
+    if (Kind == ModulePartitionInterface ||
+        Kind == ModulePartitionImplementation) {
+      auto pos = Name.find(':');
+      return StringRef(Name.data(), pos);
+    }
+    return Name;
+  }
+
   /// Retrieve the full name of this module, including the path from
   /// its top-level module.
   /// \param AllowStringLiterals If \c true, components that might not be
   ///        lexically valid as identifiers will be emitted as string literals.
   std::string getFullModuleName(bool AllowStringLiterals = false) const;
 
   /// Whether the full name of this module is equal to joining
   /// \p nameParts with "."s.

clang/lib/Sema/SemaModule.cpp

DeclResult Sema::ActOnModuleImport(SourceLocation StartLoc,
   // location of the first component.
   std::pair<IdentifierInfo *, SourceLocation> ModuleNameLoc;
 
   std::string ModuleName;
   if (IsPartition) {
     // We already checked that we are in a module purview in the parser.
     assert(!ModuleScopes.empty() && "in a module purview, but no module?");
     Module *NamedMod = ModuleScopes.back().Module;
-    if (ModuleScopes.back().IsPartition) {
-      // We're importing a partition into a partition, find the name of the
-      // owning named module.
-      size_t P = NamedMod->Name.find_first_of(":");
-      ModuleName = NamedMod->Name.substr(0, P + 1);
-    } else {
-      // We're importing a partition into the named module itself (either the
-      // interface or an implementation TU).
-      ModuleName = NamedMod->Name;
-      ModuleName += ":";
-    }
+    // If we are importing into a partition, find the owning named module,
+    // otherwise, the name of the importing named module.
+    ModuleName = NamedMod->getPrimaryModuleInterfaceName().str();
     ModuleName += stringFromPath(Partition);
     ModuleNameLoc = {PP.getIdentifierInfo(ModuleName), Partition[0].second};
     Partition = ModuleIdPath(ModuleNameLoc);
   } else if (Cxx20Mode) {
     ModuleName = stringFromPath(Path);
     ModuleNameLoc = {PP.getIdentifierInfo(ModuleName), Path[0].second};
     Path = ModuleIdPath(ModuleNameLoc);
   }