Pass in out param to ImportPath getters

Modify ASTDumper to print module real names
Add doc comments

Author: elsh

include/swift/AST/Decl.h

@@ -1132,13 +1132,19 @@ 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);
+  // Sets the real module name corresponding to this import decl in
+  // case module aliasing is used. Called in \c ImportDecl::create.
   void setRealModuleName(Identifier name) { RealModuleName = name; };
 public:
   static ImportDecl *create(ASTContext &C, DeclContext *DC,
@@ -1163,27 +1169,33 @@ class ImportDecl final : public Decl,
     return static_cast<ImportKind>(Bits.ImportDecl.ImportKind);
   }
 
-  ImportPath getImportPath(bool withRealModuleName = false) const {
+  /// Retrieves the full import path.
+  /// \param outRealModuleName An ImportPath builder to write the real module name to if module aliasing
+  ///        was used. For example, if '-module-alias Foo=Bar' was passed, the real name 'Bar' will be written
+  ///        to it, which corresponds to 'import Foo' in source file.
+  /// \returns An ImportPath corresponding to this import decl. If module aliasing was used, 'Foo' will be in the
+  ///          returned path instead of 'Bar' using the above example.
+  ImportPath getImportPath(ImportPath::Builder *outRealModuleName = nullptr) const {
     auto path = ImportPath({ getTrailingObjects<ImportPath::Element>(),
-                        static_cast<size_t>(Bits.ImportDecl.NumPathElements) });
-    if (withRealModuleName && !RealModuleName.empty()) {
-      ImportPath::Builder realPath;
+      static_cast<size_t>(Bits.ImportDecl.NumPathElements) });;
+
+    if (outRealModuleName != nullptr && !RealModuleName.empty()) {
       for (auto elem: path) {
-        if (realPath.empty()) {
-          realPath.push_back(RealModuleName);
+        if (outRealModuleName->empty()) {
+          // Add the real module name instead of its alias
+          outRealModuleName->push_back(RealModuleName);
         } else {
-          realPath.push_back(elem.Item);
+          // Add the rest if any (access path elements)
+          outRealModuleName->push_back(elem.Item);
         }
       }
-      path = ImportPath(realPath.get().getRaw());
     }
     return path;
   }
 
-  ImportPath::Module getModulePath(bool withRealName = false) const {
-    if (withRealName && !RealModuleName.empty()) {
-      ImportPath::Module::Builder builder(RealModuleName);
-      return builder.get();
+  ImportPath::Module getModulePath(ImportPath::Module::Builder *outRealModuleName = nullptr) const {
+    if (outRealModuleName != nullptr && !RealModuleName.empty()) {
+      outRealModuleName->push_back(RealModuleName);
     }
     return getImportPath().getModulePath(getImportKind());
   }

lib/AST/ASTDumper.cpp

@@ -521,7 +521,17 @@ namespace {
         OS << " kind=" << getImportKindString(ID->getImportKind());
 
       OS << " '";
-      ID->getImportPath(/*withRealModuleName=*/true).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 builderWithRealModuleName;
+      auto path = ID->getImportPath(/*outRealModuleName=*/&builderWithRealModuleName);
+      if (!builderWithRealModuleName.get().empty()) {
+        // Module aliasing was used, so print its real module name
+        builderWithRealModuleName.get().print(OS);
+      } else {
+        path.print(OS);
+      }
       OS << "')";
     }
 
@@ -1223,7 +1233,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 +1314,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/FrontendTool/ImportedModules.cpp

@@ -65,9 +65,20 @@ bool swift::emitImportedModules(ModuleDecl *mainModule,
     auto ID = dyn_cast<ImportDecl>(D);
     if (!ID)
       continue;
-    auto modulePath = ID->getModulePath(/*withRealModuleName=*/true);
-    // only the top-level name is needed (i.e. A in A.B.C)
-    Modules.insert(modulePath[0].Item.str());
+
+    // Check if module aliasing was used for an 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 emitted.
+    ImportPath::Module::Builder builderWithRealModuleName;
+    auto modulePath = ID->getModulePath(/*outRealModuleName=*/&builderWithRealModuleName);
+
+    if (!builderWithRealModuleName.get().empty()) {
+      // Module aliasing was used, so use its real module name
+     Modules.insert(builderWithRealModuleName.get().front().Item.str());
+    } else {
+      // only the top-level name is needed (i.e. A in A.B.C)
+      Modules.insert(modulePath[0].Item.str());
+    }
   }
 
   // And now look in the C code we're possibly using.

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

@@ -13,16 +13,18 @@
 // 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-NOT: bind=XLogging
+// CHECK-AST-NOT: module<XLogging>
+// CHECK-AST-NOT: decl=XLogging
+// CHECK-AST: component id='XLogging' bind=AppleLogging
 // CHECK-AST: module<AppleLogging>
-// RUN: not %FileCheck %s -input-file %t/result-ast.output -check-prefix CHECK-NOT-AST
-// CHECK-NOT-AST: XLogging
-
+// CHECK-AST: decl=AppleLogging
 
 // BEGIN FileLogging.swift
 public struct Logger {
   public init() {}
 }
-public func setup() -> XLogging.Logger? {
+public func setup() -> Logger? {
   return Logger()
 }