Merge pull request swiftlang#39929 from apple/es-src

Module Aliasing: do not allow module real names to appear in source files (only allow module aliases).
Resolves rdar://83592084

Author: elsh

include/swift/AST/ASTContext.h

@@ -350,8 +350,14 @@ class ASTContext final {
   /// Cache of module names that fail the 'canImport' test in this context.
   mutable llvm::SmallPtrSet<Identifier, 8> FailedModuleImportNames;
 
-  /// Mapping between aliases and real (physical) names of imported or referenced modules.
-  mutable llvm::DenseMap<Identifier, Identifier> ModuleAliasMap;
+  /// Set if a `-module-alias` was passed. Used to store mapping between module aliases and
+  /// their corresponding real names, and vice versa for a reverse lookup, which is needed to check
+  /// if the module names appearing in source files are aliases or real names.
+  /// \see ASTContext::getRealModuleName.
+  ///
+  /// The boolean in the value indicates whether or not the entry is keyed by an alias vs real name,
+  /// i.e. true if the entry is [key: alias_name, value: (real_name, true)].
+  mutable llvm::DenseMap<Identifier, std::pair<Identifier, bool>> ModuleAliasMap;
 
   /// Retrieve the allocator for the given arena.
   llvm::BumpPtrAllocator &
@@ -483,9 +489,23 @@ class ASTContext final {
   /// are the real (physical) module names on disk.
   void setModuleAliases(const llvm::StringMap<StringRef> &aliasMap);
 
-  /// Retrieve the actual module name if a module alias is used via '-module-alias Foo=X', where Foo is
-  /// a module alias and X is the real (physical) name. Returns \p key if no aliasing is used.
-  Identifier getRealModuleName(Identifier key) const;
+  /// Look up the module alias map by the given \p key.
+  ///
+  /// \param key A module alias or real name to look up the map by
+  /// \param alwaysReturnRealName Indicates whether it should always retrieve the real module name
+  ///        given \p key. Defaults to true. This takes a higher precedence than
+  ///        \p lookupAliasFromReal.
+  /// \param lookupAliasFromReal Indicates whether to look up an alias by treating \p key
+  ///        as a real name. Defaults to false.
+  /// \return The real name or alias mapped to the key.
+  ///         If \p alwaysReturnRealName is true, return the real module name if \p key is an alias
+  ///         or the key itself since that's the real name.
+  ///         If \p lookupAliasFromReal is true, and \p alwaysReturnRealName is false, return
+  ///         only if \p key is a real name, else an empty Identifier.
+  ///         If no aliasing is used, return \p key.
+  Identifier getRealModuleName(Identifier key,
+                               bool alwaysReturnRealName = true,
+                               bool lookupAliasFromReal = false) const;
 
   /// Decide how to interpret two precedence groups.
   Associativity associateInfixOperators(PrecedenceGroupDecl *left,

include/swift/AST/DiagnosticsParse.def

@@ -302,6 +302,9 @@ ERROR(getset_cannot_be_implied,none,
 // Import
 ERROR(decl_expected_module_name,none,
       "expected module name in import declaration", ())
+ERROR(expected_module_alias,none,
+      "cannot refer to module as %0 because it has been aliased; use %1 "
+      "instead", (Identifier, Identifier))
 
 // Extension
 ERROR(expected_lbrace_extension,PointsToFirstBadToken,

lib/AST/ASTContext.cpp

@@ -1637,20 +1637,42 @@ void ASTContext::addModuleInterfaceChecker(
 }
 
 void ASTContext::setModuleAliases(const llvm::StringMap<StringRef> &aliasMap) {
+  // This setter should be called only once after ASTContext has been initialized
+  assert(ModuleAliasMap.empty());
+  
   for (auto k: aliasMap.keys()) {
-    auto val = aliasMap.lookup(k);
-    if (!val.empty()) {
-      ModuleAliasMap[getIdentifier(k)] = getIdentifier(val);
+    auto v = aliasMap.lookup(k);
+    if (!v.empty()) {
+      auto key = getIdentifier(k);
+      auto val = getIdentifier(v);
+      // key is a module alias, val is its corresponding real name
+      ModuleAliasMap[key] = std::make_pair(val, true);
+      // add an entry with an alias as key for an easier lookup later
+      ModuleAliasMap[val] = std::make_pair(key, false);
     }
   }
 }
 
-Identifier ASTContext::getRealModuleName(Identifier key) const {
+Identifier ASTContext::getRealModuleName(Identifier key, bool alwaysReturnRealName, bool lookupAliasFromReal) const {
   auto found = ModuleAliasMap.find(key);
-  if (found != ModuleAliasMap.end()) {
-    return found->second;
+  if (found == ModuleAliasMap.end())
+    return key;
+
+  // Found an entry
+  auto realOrAlias = found->second;
+
+  // If alwaysReturnRealName, return the real name if the key is an
+  // alias or the key itself since that's the real name
+  if (alwaysReturnRealName) {
+     return realOrAlias.second ? realOrAlias.first : key;
   }
-  return key;
+
+  // If lookupAliasFromReal, and the found entry should be keyed by a real
+  // name, return the entry value, otherwise, return an empty Identifier.
+  if (lookupAliasFromReal == realOrAlias.second)
+      return Identifier();
+
+  return realOrAlias.first;
 }
 
 Optional<ModuleDependencies> ASTContext::getModuleDependencies(

lib/AST/UnqualifiedLookup.cpp

@@ -431,7 +431,20 @@ void UnqualifiedLookupFactory::lookForAModuleWithTheGivenName(
 #endif
     return;
   }
-  ModuleDecl *desiredModule = Ctx.getLoadedModule(Name.getBaseIdentifier());
+
+  ModuleDecl *desiredModule = nullptr;
+  auto givenName = Name.getBaseIdentifier();
+  // Check if the given name appearing in the source file is a module
+  // real name or alias; for example, if `-module-alias Foo=Bar` was
+  // passed, the alias 'Foo' should appear in source files, not 'Bar'.
+  // If the real name 'Bar' was used, looking up getRealModuleName will
+  // return an empty Identifier.
+  if (!Ctx.getRealModuleName(givenName, /*alwaysReturnRealName=*/false).empty()) {
+    // Only load the module if the lookup value is not empty, i.e. given
+    // name is a module alias, not a real module name.
+    desiredModule = Ctx.getLoadedModule(givenName);
+  }
+
   if (!desiredModule && Name.getFullName() == Ctx.TheBuiltinModule->getName())
     desiredModule = Ctx.TheBuiltinModule;
   if (desiredModule) {

lib/Parse/ParseDecl.cpp

@@ -4822,6 +4822,20 @@ ParserResult<ImportDecl> Parser::parseDeclImport(ParseDeclOptions Flags,
     return nullptr;
   }
 
+  // Look up if the imported module is being aliased via -module-alias,
+  // and check that the module alias appeared in source files instead of
+  // its corresponding real name
+  auto parsedModuleID = importPath.get().front().Item;
+  if (Context.getRealModuleName(parsedModuleID, /*alwaysReturnRealName=*/false).empty()) {
+    // If reached here, it means the parsed module name is a real module name
+    // which appeared in the source file; only a module alias should be allowed
+    auto aliasName = Context.getRealModuleName(parsedModuleID, /*alwaysReturnRealName=*/false, /*lookupAliasFromReal=*/true);
+    diagnose(importPath.front().Loc, diag::expected_module_alias,
+                     parsedModuleID, aliasName)
+      .fixItReplace(importPath.front().Loc, aliasName.str());
+    return nullptr;
+  }
+
   auto *ID = ImportDecl::create(Context, CurDeclContext, ImportLoc, Kind,
                                 KindLoc, importPath.get());
   ID->getAttrs() = Attributes;

test/Frontend/module-alias-diags.swift

@@ -0,0 +1,121 @@
+/// Test diagnostics with module aliasing.
+///
+/// Module 'Lib' imports module 'XLogging', and 'XLogging' is aliased 'AppleLogging'.
+
+// 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
+
+/// 1. Pass: load and reference a module with module aliasing
+/// Create module Lib that imports XLogging WITH -module-alias XLogging=AppleLogging
+// RUN: %target-swift-frontend -module-name LibA %t/FileLib.swift -module-alias XLogging=AppleLogging -I %t -emit-module -emit-module-path %t/LibA.swiftmodule -Rmodule-loading 2> %t/result-LibA.output
+// RUN: test -f %t/LibA.swiftmodule
+// RUN: %FileCheck %s -input-file %t/result-LibA.output -check-prefix CHECK-LOAD
+// CHECK-LOAD: remark: loaded module at {{.*}}AppleLogging.swiftmodule
+
+/// 2. Fail: trying to access a non-member of a module (with module aliasing) should fail with the module alias in the diags
+/// Try building module Lib that imports XLogging WITH -module-alias XLogging=AppleLogging
+// RUN: not %target-swift-frontend -module-name LibB %t/FileLibNoSuchMember.swift -module-alias XLogging=AppleLogging -I %t -emit-module -emit-module-path %t/LibB.swiftmodule 2> %t/result-LibB.output
+// RUN: %FileCheck %s -input-file %t/result-LibB.output -check-prefix CHECK-NO-MEMBER
+// CHECK-NO-MEMBER: error: module 'XLogging' has no member named 'setupErr'
+
+/// 3. Fail: importing the real module name that's being aliased should fail
+/// Create module Lib that imports XLogging WITH -module-alias XLogging=AppleLogging
+// RUN: not %target-swift-frontend -module-name LibC %t/FileLibImportRealName.swift -module-alias XLogging=AppleLogging -I %t -emit-module -emit-module-path %t/LibC.swiftmodule 2> %t/result-LibC.output
+// RUN: %FileCheck %s -input-file %t/result-LibC.output -check-prefix CHECK-NOT-IMPORT
+// CHECK-NOT-IMPORT: error: cannot refer to module as 'AppleLogging' because it has been aliased; use 'XLogging' instead
+
+/// 4-1. Fail: referencing the real module name that's aliased should fail
+/// Create module Lib that imports XLogging WITH -module-alias XLogging=AppleLogging
+// RUN: not %target-swift-frontend -module-name LibD %t/FileLibRefRealName1.swift -module-alias XLogging=AppleLogging -I %t -emit-module -emit-module-path %t/LibD.swiftmodule 2> %t/result-LibD.output
+// RUN: %FileCheck %s -input-file %t/result-LibD.output -check-prefix CHECK-NOT-REF1
+// CHECK-NOT-REF1: error: cannot find 'AppleLogging' in scope
+
+/// 4-2. Fail: referencing the real module name that's aliased should fail
+/// Create module Lib that imports XLogging WITH -module-alias XLogging=AppleLogging
+// RUN: not %target-swift-frontend -module-name LibE %t/FileLibRefRealName2.swift -module-alias XLogging=AppleLogging -I %t -emit-module -emit-module-path %t/LibE.swiftmodule 2> %t/result-LibE.output
+// RUN: %FileCheck %s -input-file %t/result-LibE.output -check-prefix CHECK-NOT-REF2
+// CHECK-NOT-REF2: error: cannot find type 'AppleLogging' in scope
+
+/// 4-3. Fail: referencing the real module name that's aliased should fail
+/// Create module Lib that imports XLogging WITH -module-alias XLogging=AppleLogging
+// RUN: not %target-swift-frontend -module-name LibF %t/FileLibRefRealName3.swift -module-alias XLogging=AppleLogging -I %t -emit-module -emit-module-path %t/LibF.swiftmodule 2> %t/result-LibF.output
+// RUN: %FileCheck %s -input-file %t/result-LibF.output -check-prefix CHECK-NOT-REF3
+// CHECK-NOT-REF3: error: cannot find type 'AppleLogging' in scope
+
+/// 4-4. Fail: referencing the real module name that's aliased should fail
+/// Create module Lib that imports XLogging WITH -module-alias XLogging=AppleLogging
+// RUN: not %target-swift-frontend -module-name LibG %t/FileLibRefRealName4.swift -module-alias XLogging=AppleLogging -I %t -emit-module -emit-module-path %t/LibG.swiftmodule 2> %t/result-LibG.output
+// RUN: %FileCheck %s -input-file %t/result-LibG.output -check-prefix CHECK-NOT-REF4
+// CHECK-NOT-REF4: error: cannot find type 'AppleLogging' in scope
+
+
+// BEGIN FileLogging.swift
+public protocol Loggable {
+  var verbosity: Int { get }
+}
+
+public struct Logger {
+  public init() {}
+}
+
+public func setup() -> XLogging.Logger? {
+  return Logger()
+}
+
+// BEGIN FileLib.swift
+import XLogging
+
+public func start() {
+  _ = XLogging.setup()
+}
+
+// BEGIN FileLibNoSuchMember.swift
+import XLogging
+
+public func start() {
+  _ = XLogging.setupErr()
+}
+
+// BEGIN FileLibImportRealName.swift
+import XLogging
+import AppleLogging
+
+public func start() {
+  _ = XLogging.setup()
+}
+
+// BEGIN FileLibRefRealName1.swift
+import XLogging
+
+public func start() {
+  _ = AppleLogging.setup()
+}
+
+// BEGIN FileLibRefRealName2.swift
+import XLogging
+
+public struct MyStruct: AppleLogging.Loggable {
+  public var verbosity: Int {
+    return 3
+  }
+}
+
+// BEGIN FileLibRefRealName3.swift
+import XLogging
+
+public struct MyStruct<T> where T: AppleLogging.Loggable {
+  func log<T>(_ arg: T) {
+  }
+}
+
+// BEGIN FileLibRefRealName4.swift
+import XLogging
+
+public struct MyStruct {
+  func log<T: AppleLogging.Loggable>(_ arg: T) {
+  }
+}