[Module aliasing] Serialize SIL and binaries with module real names

include/swift/AST/FileUnit.h

@@ -288,12 +288,14 @@ class FileUnit : public DeclContext, public ASTAllocated<FileUnit> {
     return nullptr;
   }
 
-  /// Returns the name to use when referencing entities in this file.
+  /// Returns the real name of the enclosing module to use when referencing entities in this file.
+  /// The 'real name' is the actual binary name of the module, which can be different from the 'name'
+  /// if module aliasing was used (via -module-alias flag).
   ///
-  /// Usually this is the module name itself, but certain Clang features allow
+  /// Usually this is the module real name itself, but certain Clang features allow
   /// substituting another name instead.
   virtual StringRef getExportedModuleName() const {
-    return getParentModule()->getName().str();
+    return getParentModule()->getRealName().str();
   }
 
   /// Traverse the decls within this file.

include/swift/AST/Module.h

@@ -176,6 +176,9 @@ class ModuleDecl
   ///
   /// For a Swift module, this will only ever have one component, but an
   /// imported Clang module might actually be a submodule.
+  ///
+  /// *Note: see `StringRef operator*()` for details on the returned name for printing
+  /// for a Swift module.
   class ReverseFullNameIterator {
   public:
     // Make this look like a valid STL iterator.
@@ -194,6 +197,9 @@ class ModuleDecl
       current = clangModule;
     }
 
+    /// Returns the name of the current module.
+    /// Note that for a Swift module, it returns the current module's real (binary) name,
+    /// which can be different from the name if module aliasing was used (see `-module-alias`).
     StringRef operator*() const;
     ReverseFullNameIterator &operator++();
 
@@ -208,6 +214,9 @@ class ModuleDecl
 
     /// This is a convenience function that writes the entire name, in forward
     /// order, to \p out.
+    ///
+    /// It calls `StringRef operator*()` under the hood (see for more detail on the
+    /// returned name for a Swift module).
     void printForward(raw_ostream &out, StringRef delim = ".") const;
   };
 
@@ -793,6 +802,9 @@ class ModuleDecl
   ///
   /// For a Swift module, this will only ever have one component, but an
   /// imported Clang module might actually be a submodule.
+  ///
+  /// *Note: see `StringRef operator*()` for details on the returned name for printing
+  /// for a Swift module.
   ReverseFullNameIterator getReverseFullModuleName() const {
     return ReverseFullNameIterator(this);
   }

include/swift/ClangImporter/ClangModule.h

@@ -59,7 +59,7 @@ class ClangModuleUnit final : public LoadedFile {
   ModuleDecl *getOverlayModule() const override;
 
   /// Retrieve the "exported" name of the module, which is usually the module
-  /// name, but might be the name of the public module through which this
+  /// real name, but might be the name of the public module through which this
   /// (private) module is re-exported.
   StringRef getExportedModuleName() const override;
 

lib/AST/ASTPrinter.cpp

@@ -2337,13 +2337,16 @@ void PrintAST::visitImportDecl(ImportDecl *decl) {
   llvm::interleave(decl->getImportPath(),
                    [&](const ImportPath::Element &Elem) {
                      if (!Mods.empty()) {
-                       Identifier Name = Elem.Item;
+                       // Should print the module real name in case module
+                       // aliasing is used (see -module-alias), since that's
+                       // the actual binary name.
+                       Identifier Name = decl->getASTContext().getRealModuleName(Elem.Item);
                        if (Options.MapCrossImportOverlaysToDeclaringModule) {
                          if (auto *MD = Mods.front().getAsSwiftModule()) {
                            ModuleDecl *Declaring = const_cast<ModuleDecl*>(MD)
                              ->getDeclaringModuleIfCrossImportOverlay();
                            if (Declaring)
-                             Name = Declaring->getName();
+                             Name = Declaring->getRealName();
                          }
                        }
                        Printer.printModuleRef(Mods.front(), Name);
@@ -4321,7 +4324,9 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
         Mod = Declaring;
     }
 
-    Identifier Name = Mod->getName();
+    // Should use the module real (binary) name here and everywhere else the
+    // module is printed in case module aliasing is used (see -module-alias)
+    Identifier Name = Mod->getRealName();
     if (Options.UseExportedModuleNames && !ExportedModuleName.empty()) {
       Name = Mod->getASTContext().getIdentifier(ExportedModuleName);
     }
@@ -4342,7 +4347,7 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
   bool isLLDBExpressionModule(ModuleDecl *M) {
     if (!M)
       return false;
-    return M->getName().str().startswith(LLDB_EXPRESSIONS_MODULE_NAME_PREFIX);
+    return M->getRealName().str().startswith(LLDB_EXPRESSIONS_MODULE_NAME_PREFIX);
   }
 
   bool shouldPrintFullyQualified(TypeBase *T) {
@@ -4373,7 +4378,7 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
 
     // Don't print qualifiers for types from the standard library.
     if (M->isStdlibModule() ||
-        M->getName() == M->getASTContext().Id_ObjectiveC ||
+        M->getRealName() == M->getASTContext().Id_ObjectiveC ||
         M->isSystemModule() ||
         isLLDBExpressionModule(M))
       return false;
@@ -4636,7 +4641,9 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
 
   void visitModuleType(ModuleType *T) {
     Printer << "module<";
-    Printer.printModuleRef(T->getModule(), T->getModule()->getName());
+    // Should print the module real name in case module aliasing is
+    // used (see -module-alias), since that's the actual binary name.
+    Printer.printModuleRef(T->getModule(), T->getModule()->getRealName());
     Printer << ">";
   }
 
@@ -5696,13 +5703,13 @@ void ProtocolConformance::printName(llvm::raw_ostream &os,
   case ProtocolConformanceKind::Normal: {
     auto normal = cast<NormalProtocolConformance>(this);
     os << normal->getProtocol()->getName()
-       << " module " << normal->getDeclContext()->getParentModule()->getName();
+       << " module " << normal->getDeclContext()->getParentModule()->getRealName();
     break;
   }
   case ProtocolConformanceKind::Self: {
     auto self = cast<SelfProtocolConformance>(this);
     os << self->getProtocol()->getName()
-       << " module " << self->getDeclContext()->getParentModule()->getName();
+       << " module " << self->getDeclContext()->getParentModule()->getRealName();
     break;
   }
   case ProtocolConformanceKind::Specialized: {

lib/AST/Module.cpp

@@ -1499,9 +1499,11 @@ ModuleDecl::ReverseFullNameIterator::ReverseFullNameIterator(
 
 StringRef ModuleDecl::ReverseFullNameIterator::operator*() const {
   assert(current && "all name components exhausted");
-
+  // Return the module's real (binary) name, which can be different from
+  // the name if module aliasing was used (-module-alias flag). The real
+  // name is used for serialization and loading.
   if (auto *swiftModule = current.dyn_cast<const ModuleDecl *>())
-    return swiftModule->getName().str();
+    return swiftModule->getRealName().str();
 
   auto *clangModule =
       static_cast<const clang::Module *>(current.get<const void *>());

lib/ClangImporter/ClangImporter.cpp

@@ -3582,7 +3582,8 @@ StringRef ClangModuleUnit::getExportedModuleName() const {
   if (clangModule && !clangModule->ExportAsModule.empty())
     return clangModule->ExportAsModule;
 
-  return getParentModule()->getName().str();
+  // Return module real name (see FileUnit::getExportedModuleName)
+  return getParentModule()->getRealName().str();
 }
 
 ModuleDecl *ClangModuleUnit::getOverlayModule() const {

lib/Serialization/Serialization.cpp

@@ -751,8 +751,10 @@ IdentifierID Serializer::addModuleRef(const ModuleDecl *module) {
     return CURRENT_MODULE_ID;
   if (module == this->M->getASTContext().TheBuiltinModule)
     return BUILTIN_MODULE_ID;
+  // Use module 'real name', which can be different from 'name'
+  // in case module aliasing was used (-module-alias flag)
   auto moduleName =
-      module->getASTContext().getIdentifier(module->getName().str());
+      module->getASTContext().getIdentifier(module->getRealName().str());
   return addDeclBaseNameRef(moduleName);
 }
 
@@ -961,7 +963,9 @@ void Serializer::writeHeader(const SerializationOptions &options) {
     control_block::RevisionLayout Revision(Out);
     control_block::IsOSSALayout IsOSSA(Out);
 
-    ModuleName.emit(ScratchRecord, M->getName().str());
+    // Write module 'real name', which can be different from 'name'
+    // in case module aliasing is used (-module-alias flag)
+    ModuleName.emit(ScratchRecord, M->getRealName().str());
 
     SmallString<32> versionStringBuf;
     llvm::raw_svector_ostream versionString(versionStringBuf);
@@ -1101,6 +1105,8 @@ void Serializer::writeHeader(const SerializationOptions &options) {
 static void flattenImportPath(const ImportedModule &import,
                               SmallVectorImpl<char> &out) {
   llvm::raw_svector_ostream outStream(out);
+  // This will write the module 'real name', which can be different
+  // from the 'name' in case module aliasing was used (see `-module-alias`)
   import.importedModule->getReverseFullModuleName().printForward(
       outStream, StringRef("\0", 1));