[ModuleInterface] Print alias for module names in swiftinterface files

Ambiguities are introduced in generated swiftinterfaces when a type
shares a name with a module (i.e. XCTest). This workaround uses the
module-alias feature to avoid these ambiguities. Writing module
references with a distinguishable prefix should allow normal
type-checking to avoid the usual ambiguities.

We should still aim for a proper fully-qualified named syntax, but this
may help in the mean time.

rdar://101969500

Author: xymus

include/swift/AST/ASTPrinter.h

@@ -24,6 +24,10 @@
 #include "llvm/Support/raw_ostream.h"
 #include "swift/AST/PrintOptions.h"
 
+// Prefix to use when printing module names in module interfaces to avoid
+// ambiguities with type names, in AliasModuleNames mode.
+#define MODULE_DISAMBIGUATING_PREFIX "Module___"
+
 namespace swift {
   class Decl;
   class DeclContext;

include/swift/AST/PrintOptions.h

@@ -466,6 +466,10 @@ struct PrintOptions {
   /// of the alias.
   bool PrintTypeAliasUnderlyingType = false;
 
+  /// Use aliases when printing references to modules to avoid ambiguities
+  /// with types sharing a name with a module.
+  bool AliasModuleNames = false;
+
   /// When printing an Optional<T>, rather than printing 'T?', print
   /// 'T!'. Used as a modifier only when we know we're printing
   /// something that was declared as an implicitly unwrapped optional
@@ -601,7 +605,7 @@ struct PrintOptions {
     return result;
   }
 
-  /// Retrieve the set of options suitable for interface generation.
+  /// Retrieve the set of options suitable for IDE interface generation.
   static PrintOptions printInterface(bool printFullConvention) {
     PrintOptions result =
         printForDiagnostics(AccessLevel::Public, printFullConvention);
@@ -636,7 +640,8 @@ struct PrintOptions {
   static PrintOptions printSwiftInterfaceFile(ModuleDecl *ModuleToPrint,
                                               bool preferTypeRepr,
                                               bool printFullConvention,
-                                              bool printSPIs);
+                                              bool printSPIs,
+                                              bool aliasModuleNames);
 
   /// Retrieve the set of options suitable for "Generated Interfaces", which
   /// are a prettified representation of the public API of a module, to be

include/swift/Frontend/ModuleInterfaceSupport.h

@@ -33,6 +33,10 @@ struct ModuleInterfaceOptions {
   /// interface, or should we fully-qualify them?
   bool PreserveTypesAsWritten = false;
 
+  /// Use aliases when printing references to modules to avoid ambiguities
+  /// with types sharing a name with a module.
+  bool AliasModuleNames = false;
+
   /// See \ref FrontendOptions.PrintFullConvention.
   /// [TODO: Clang-type-plumbing] This check should go away.
   bool PrintFullConvention = false;

lib/AST/ASTPrinter.cpp

@@ -131,7 +131,8 @@ static bool contributesToParentTypeStorage(const AbstractStorageDecl *ASD) {
 PrintOptions PrintOptions::printSwiftInterfaceFile(ModuleDecl *ModuleToPrint,
                                                    bool preferTypeRepr,
                                                    bool printFullConvention,
-                                                   bool printSPIs) {
+                                                   bool printSPIs,
+                                                   bool aliasModuleNames) {
   PrintOptions result;
   result.IsForSwiftInterface = true;
   result.PrintLongAttrsOnSeparateLines = true;
@@ -152,6 +153,7 @@ PrintOptions PrintOptions::printSwiftInterfaceFile(ModuleDecl *ModuleToPrint,
   result.OpaqueReturnTypePrinting =
       OpaqueReturnTypePrintingMode::StableReference;
   result.PreferTypeRepr = preferTypeRepr;
+  result.AliasModuleNames = aliasModuleNames;
   if (printFullConvention)
     result.PrintFunctionRepresentationAttrs =
       PrintOptions::FunctionRepresentationMode::Full;
@@ -367,6 +369,9 @@ void ASTPrinter::printTypeRef(Type T, const TypeDecl *RefTo, Identifier Name,
 
 void ASTPrinter::printModuleRef(ModuleEntity Mod, Identifier Name,
                                 const PrintOptions &Options) {
+  if (Options.AliasModuleNames)
+    printTextImpl(MODULE_DISAMBIGUATING_PREFIX);
+
   printName(Name);
 }
 

lib/Frontend/CompilerInvocation.cpp

@@ -368,6 +368,10 @@ static void ParseModuleInterfaceArgs(ModuleInterfaceOptions &Opts,
 
   Opts.PreserveTypesAsWritten |=
     Args.hasArg(OPT_module_interface_preserve_types_as_written);
+  Opts.AliasModuleNames |=
+    Args.hasFlag(OPT_alias_module_names_in_module_interface,
+                 OPT_disable_alias_module_names_in_module_interface,
+                 false);
   Opts.PrintFullConvention |=
     Args.hasArg(OPT_experimental_print_full_convention);
   Opts.ExperimentalSPIImports |=

lib/Frontend/ModuleInterfaceSupport.cpp

@@ -58,7 +58,32 @@ static void printToolVersionAndFlagsComment(raw_ostream &out,
   out << "// " SWIFT_COMPILER_VERSION_KEY ": "
       << ToolsVersion << "\n";
   out << "// " SWIFT_MODULE_FLAGS_KEY ": "
-      << Opts.Flags << "\n";
+      << Opts.Flags;
+
+  // Insert additional -module-alias flags
+  if (Opts.AliasModuleNames) {
+    llvm::SmallSet<StringRef, 2> aliasTargets;
+    StringRef moduleName = M->getNameStr();
+    aliasTargets.insert(M->getNameStr());
+    out << " -module-alias " << MODULE_DISAMBIGUATING_PREFIX <<
+           moduleName << "=" << moduleName;
+
+    SmallVector<ImportedModule> imports;
+    M->getImportedModules(imports,
+                          {ModuleDecl::ImportFilterKind::Default,
+                           ModuleDecl::ImportFilterKind::Exported,
+                           ModuleDecl::ImportFilterKind::SPIOnly,
+                           ModuleDecl::ImportFilterKind::SPIAccessControl});
+    for (ImportedModule import: imports) {
+      StringRef importedName = import.importedModule->getNameStr();
+      if (aliasTargets.insert(importedName).second) {
+        out << " -module-alias " << MODULE_DISAMBIGUATING_PREFIX <<
+               importedName << "=" << importedName;
+      }
+    }
+  }
+  out << "\n";
+
   if (!Opts.IgnorableFlags.empty()) {
     out << "// " SWIFT_MODULE_FLAGS_IGNORABLE_KEY ": "
         << Opts.IgnorableFlags << "\n";
@@ -295,6 +320,8 @@ static void printImports(raw_ostream &out,
     }
 
     out << "import ";
+    if (Opts.AliasModuleNames)
+      out << MODULE_DISAMBIGUATING_PREFIX;
     importedModule->getReverseFullModuleName().printForward(out);
 
     // Write the access path we should be honoring but aren't.
@@ -758,7 +785,8 @@ bool swift::emitSwiftInterface(raw_ostream &out,
   printImports(out, Opts, M);
 
   const PrintOptions printOptions = PrintOptions::printSwiftInterfaceFile(
-      M, Opts.PreserveTypesAsWritten, Opts.PrintFullConvention, Opts.PrintSPIs);
+      M, Opts.PreserveTypesAsWritten, Opts.PrintFullConvention, Opts.PrintSPIs,
+      Opts.AliasModuleNames);
   InheritedProtocolCollector::PerTypeMap inheritedProtocolMap;
 
   SmallVector<Decl *, 16> topLevelDecls;

test/ModuleInterface/ambiguous-aliases-workaround.swift

@@ -0,0 +1,66 @@
+/// Test that the AliasModuleNames mode avoids ambiguities in swiftinterfaces
+
+// RUN: %empty-directory(%t)
+// RUN: split-file %s %t
+
+// RUN: %target-swift-frontend -emit-module -module-name AmbiguousLib \
+// RUN:     -swift-version 5 -enable-library-evolution \
+// RUN:     -o %t/AmbiguousLib.swiftmodule \
+// RUN:     -emit-module-interface-path %t/AmbiguousLib.swiftinterface \
+// RUN:     %t/AmbiguousLib.swift
+// RUN: %target-swift-typecheck-module-from-interface(%t/AmbiguousLib.swiftinterface)
+
+// RUN: %target-swift-frontend -emit-module -module-name AmbiguousClientName \
+// RUN:     -swift-version 5 -enable-library-evolution \
+// RUN:     -o %t/AmbiguousClientName.swiftmodule \
+// RUN:     -emit-module-interface-path %t/AmbiguousClientName.swiftinterface \
+// RUN:     %t/AmbiguousClientName.swift -I%t \
+// RUN:     -alias-module-names-in-module-interface
+// RUN: %target-swift-typecheck-module-from-interface(%t/AmbiguousClientName.swiftinterface) -I%t
+
+//--- module.modulemap
+module AmbiguousClientName {
+    header "AmbiguousClientName.h"
+}
+
+module SomeClangModule {
+    header "SomeClangModule.h"
+}
+
+//--- AmbiguousClientName.h
+struct UnderlyingType {};
+void underlyingFunc() {}
+
+//--- SomeClangModule.h
+struct CType {};
+
+//--- AmbiguousLib.swift
+
+// 1. AmbiguousLib defined a type named AmbiguousLib
+public struct AmbiguousLib {
+    public struct Nested {}
+}
+
+// 2. A lib defines a type of the same name as a client's module
+public struct AmbiguousClientName {
+}
+
+//--- AmbiguousClientName.swift
+
+@_exported import AmbiguousClientName
+import AmbiguousLib
+import SomeClangModule
+
+public struct SomeType {
+    @inlinable
+    public func inlinableFunc() {
+        var x: AmbiguousClientName
+    }
+}
+
+public func refToLocalType(_ a: SomeType) {}
+public func refToNestedInLib(_ a: AmbiguousLib.Nested) {}
+
+public func refToStdlib(_ a: Swift.Int) {}
+public func refToUnderlying(_ a: UnderlyingType) {}
+public func refToC(_ a: CType) {}