Merge pull request #40064 from apple/es-imports

Author: swift-ci

include/swift/AST/Decl.h

@@ -1132,13 +1132,16 @@ class ImportDecl final : public Decl,
 
   SourceLoc ImportLoc;
   SourceLoc KindLoc;
+  /// Used to store the real module name corresponding to this import decl in
+  /// case module aliasing is used. For example if '-module-alias Foo=Bar' was
+  /// passed and this decl is 'import Foo', the real name 'Bar' will be stored.
+  Identifier RealModuleName;
 
   /// The resolved module.
   ModuleDecl *Mod = nullptr;
 
   ImportDecl(DeclContext *DC, SourceLoc ImportLoc, ImportKind K,
              SourceLoc KindLoc, ImportPath Path);
-
 public:
   static ImportDecl *create(ASTContext &C, DeclContext *DC,
                             SourceLoc ImportLoc, ImportKind Kind,
@@ -1162,15 +1165,57 @@ class ImportDecl final : public Decl,
     return static_cast<ImportKind>(Bits.ImportDecl.ImportKind);
   }
 
+  /// Retrieves the import path as written in the source code.
+  /// 
+  /// \returns An \c ImportPath corresponding to this import decl. If module aliasing
+  ///          was used, this will contain the aliased name of the module; for instance,
+  ///          if you wrote 'import Foo' but passed '-module-alias Foo=Bar', this import
+  ///          path will include 'Foo'. This return value is always owned by \c ImportDecl
+  ///          (which is owned by the AST context), so it can be persisted.
   ImportPath getImportPath() const {
     return ImportPath({ getTrailingObjects<ImportPath::Element>(),
                         static_cast<size_t>(Bits.ImportDecl.NumPathElements) });
   }
 
+  /// Retrieves the import path, replacing any module aliases with real names.
+  /// 
+  /// \param scratch An \c ImportPath::Builder which may, if necessary, be used to
+  ///        construct the return value. It may go unused, so you should not try to
+  ///        read the result from it; use the return value instead.
+  /// \returns An \c ImportPath corresponding to this import decl. If module aliasing
+  ///          was used, this will contain the real name of the module; for instance,
+  ///          if you wrote 'import Foo' but passed '-module-alias Foo=Bar', this import
+  ///          path will include 'Bar'. This return value may be owned by \p scratch,
+  ///          so it should not be used after \p scratch is destroyed.
+  ImportPath getRealImportPath(ImportPath::Builder &scratch) const;
+
+  /// Retrieves the part of the import path that contains the module name,
+  /// as written in the source code.
+  /// 
+  /// \returns A \c ImportPath::Module corresponding to this import decl. If module
+  ///          aliasing was used, this will contain the aliased name of the module; for
+  ///          instance, if you wrote 'import Foo' but passed '-module-alias Foo=Bar',
+  ///          this module path will contain 'Foo'. This return value is always owned by
+  ///          \c ImportDecl (which is owned by the AST context), so it can be persisted.
   ImportPath::Module getModulePath() const {
     return getImportPath().getModulePath(getImportKind());
   }
 
+  /// Retrieves the part of the import path that contains the module name,
+  /// replacing any module aliases with real names.
+  /// 
+  /// \param scratch An \c ImportPath::Builder which may, if necessary, be used to
+  ///        construct the return value. It may go unused, so you should not try to
+  ///        read the result from it; use the return value instead.
+  /// \returns An \c ImportPath::Module corresponding to this import decl. If module
+  ///          aliasing was used, this will contain the real name of the module; for
+  ///          instance, if you wrote 'import Foo' but passed '-module-alias Foo=Bar',
+  ///          the returned path will contain 'Bar'. This return value may be owned
+  ///          by \p scratch, so it should not be used after \p scratch is destroyed.
+  ImportPath::Module getRealModulePath(ImportPath::Builder &scratch) const {
+    return getRealImportPath(scratch).getModulePath(getImportKind());
+  }
+
   ImportPath::Access getAccessPath() const {
     return getImportPath().getAccessPath(getImportKind());
   }

lib/AST/ASTDumper.cpp

@@ -521,7 +521,11 @@ namespace {
         OS << " kind=" << getImportKindString(ID->getImportKind());
 
       OS << " '";
-      ID->getImportPath().print(OS);
+      // Check if module aliasing was used for the given imported module; for
+      // example, if '-module-alias Foo=Bar' was passed and this module has
+      // 'import Foo', its corresponding real module name 'Bar' should be printed.
+      ImportPath::Builder scratch;
+      ID->getRealImportPath(scratch).print(OS);
       OS << "')";
     }
 
@@ -1223,7 +1227,7 @@ void swift::printContext(raw_ostream &os, DeclContext *dc) {
 
   switch (dc->getContextKind()) {
   case DeclContextKind::Module:
-    printName(os, cast<ModuleDecl>(dc)->getName());
+    printName(os, cast<ModuleDecl>(dc)->getRealName());
     break;
 
   case DeclContextKind::FileUnit:
@@ -1304,11 +1308,13 @@ void ValueDecl::dumpRef(raw_ostream &os) const {
     // Print the context.
     printContext(os, getDeclContext());
     os << ".";
+    // Print name.
+    getName().printPretty(os);
+  } else {
+    auto moduleName = cast<ModuleDecl>(this)->getRealName();
+    os << moduleName;
   }
 
-  // Print name.
-  getName().printPretty(os);
-
   // Print location.
   auto &srcMgr = getASTContext().SourceMgr;
   if (getLoc().isValid()) {

lib/AST/Decl.cpp

@@ -1066,6 +1066,11 @@ ImportDecl *ImportDecl::create(ASTContext &Ctx, DeclContext *DC,
   auto D = new (ptr) ImportDecl(DC, ImportLoc, Kind, KindLoc, Path);
   if (ClangN)
     D->setClangNode(ClangN);
+  auto realNameIfExists = Ctx.getRealModuleName(Path.front().Item,
+                                                ASTContext::ModuleAliasLookupOption::realNameFromAlias);
+  if (!realNameIfExists.empty()) {
+    D->RealModuleName = realNameIfExists;
+  }
   return D;
 }
 
@@ -1158,6 +1163,24 @@ ImportDecl::findBestImportKind(ArrayRef<ValueDecl *> Decls) {
   return FirstKind;
 }
 
+ImportPath ImportDecl::getRealImportPath(ImportPath::Builder &scratch) const {
+  assert(scratch.empty() && "scratch ImportPath::Builder must be initially empty");
+  auto path = getImportPath();
+  if (RealModuleName.empty())
+    return path;
+
+  for (auto elem : path) {
+    if (scratch.empty()) {
+      // Add the real module name instead of its alias
+      scratch.push_back(RealModuleName);
+    } else {
+      // Add the rest if any (access path elements)
+      scratch.push_back(elem.Item);
+    }
+  }
+  return scratch.get();
+}
+
 ArrayRef<ValueDecl *> ImportDecl::getDecls() const {
   // If this isn't a scoped import, there's nothing to do.
   if (getImportKind() == ImportKind::Module)

lib/FrontendTool/ImportedModules.cpp

@@ -66,7 +66,8 @@ bool swift::emitImportedModules(ModuleDecl *mainModule,
     if (!ID)
       continue;
 
-    auto modulePath = ID->getModulePath();
+    ImportPath::Builder scratch;
+    auto modulePath = ID->getRealModulePath(scratch);
     // only the top-level name is needed (i.e. A in A.B.C)
     Modules.insert(modulePath[0].Item.str());
   }

test/Frontend/Inputs/invalid-module-alias.swift

@@ -0,0 +1,16 @@
+public struct Logger {
+  public init() {}
+  @_spi(Usable) public func spiFunc() {}
+  public func regularFunc() {}
+  func internalFunc() {}
+  private func privateFunc() {}
+}
+struct InternalLogger {
+  init() {}
+}
+private struct PrivateLogger {
+  init() {}
+}
+public func setup() -> XLogging.Logger? {
+  return Logger()
+}

test/Frontend/Inputs/module-alias-src.swift

@@ -13,9 +13,12 @@
 // RUN: %target-swift-frontend -dump-ast %t/FileLib.swift -module-alias XLogging=AppleLogging -I %t > %t/result-ast.output
 
 // RUN: %FileCheck %s -input-file %t/result-ast.output -check-prefix CHECK-AST
-// CHECK-AST: XLogging
+// CHECK-AST-NOT: bind=XLogging
+// CHECK-AST-NOT: module<XLogging>
+// CHECK-AST-NOT: decl=XLogging
+// CHECK-AST: component id='XLogging' bind=AppleLogging
 // CHECK-AST: module<AppleLogging>
-
+// CHECK-AST: decl=AppleLogging
 
 // BEGIN FileLogging.swift
 public struct Logger {

test/Frontend/module-alias-dump-ast.swift

@@ -0,0 +1,48 @@
+/// Test -emit-imported-modules with module aliasing.
+///
+
+// RUN: %empty-directory(%t)
+// RUN: %{python} %utils/split_file.py -o %t %s
+
+/// Create AppleLogging.swiftmodule by aliasing XLogging
+// RUN: %target-swift-frontend -module-name AppleLogging -module-alias XLogging=AppleLogging %t/FileLogging.swift -emit-module -emit-module-path %t/AppleLogging.swiftmodule
+// RUN: test -f %t/AppleLogging.swiftmodule
+
+/// Verify emitted imported modules contains AppleLogging as a module name
+// RUN: %target-swift-frontend -emit-imported-modules %t/FileLib1.swift -module-alias XLogging=AppleLogging -I %t > %t/result1.output
+
+// RUN: %FileCheck %s -input-file %t/result1.output -check-prefix CHECK-AST1
+// CHECK-AST1-NOT: XLogging
+// CHECK-AST1: AppleLogging
+
+// RUN: %target-swift-frontend -emit-imported-modules %t/FileLib2.swift -module-alias XLogging=AppleLogging -I %t > %t/result2.output
+
+// RUN: %FileCheck %s -input-file %t/result2.output -check-prefix CHECK-AST2
+// CHECK-AST2-NOT: XLogging
+// CHECK-AST2: AppleLogging
+
+
+// BEGIN FileLogging.swift
+public struct Logger {
+  public init() {}
+}
+public func setup() -> XLogging.Logger? {
+  return Logger()
+}
+
+// BEGIN FileLib1.swift
+import XLogging
+
+public func start() -> XLogging.Logger? {
+  return XLogging.setup()
+}
+
+public func end(_ arg: XLogging.Logger) {
+}
+
+// BEGIN FileLib2.swift
+import struct XLogging.Logger
+
+public func start() -> XLogging.Logger? {
+  return XLogging.Logger()
+}