Updates params to ASTContext::getRealModuleName

Author: elsh

include/swift/AST/ASTContext.h

@@ -491,13 +491,21 @@ class ASTContext final {
 
   /// 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 reverseLookup Default to false, but if true, it will treat the \p key as a real name and
-  ///        look up the alias, which can be used to guard against real names appearing in source files.
-  /// \returns The real name or alias mapped to the key.
-  ///          If \p reverseLookup is true but the \p key is an alias, it will return an empty Identifier.
-  ///          If no aliasing is used, \p key will be returned.
-  Identifier getRealModuleName(Identifier key, bool reverseLookup = false) const;
+  /// \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,

lib/AST/ASTContext.cpp

@@ -1653,19 +1653,25 @@ void ASTContext::setModuleAliases(const llvm::StringMap<StringRef> &aliasMap) {
   }
 }
 
-Identifier ASTContext::getRealModuleName(Identifier key, bool reverseLookup) const {
+Identifier ASTContext::getRealModuleName(Identifier key, bool alwaysReturnRealName, bool lookupAliasFromReal) const {
   auto found = ModuleAliasMap.find(key);
   if (found == ModuleAliasMap.end())
     return key;
 
   // Found an entry
   auto realOrAlias = found->second;
-  // If reverseLookup, i.e. look up an alias by real name, but the found
-  // entry is keyed by an alias, return an empty Identifier
-  if (reverseLookup && realOrAlias.second)
-    return Identifier();
 
-  // Return a real name or an alias (if reverseLookup) mapped to the given key
+  // 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;
+  }
+
+  // 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;
 }
 

lib/AST/UnqualifiedLookup.cpp

@@ -437,9 +437,11 @@ void UnqualifiedLookupFactory::lookForAModuleWithTheGivenName(
   // 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 no module aliasing is used, this will simply return the given
-  // name and 'true' indicating the check passed.
-  if (!Ctx.getRealModuleName(givenName).empty()) {
+  // 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);
   }
 

lib/Parse/ParseDecl.cpp

@@ -4823,10 +4823,10 @@ ParserResult<ImportDecl> Parser::parseDeclImport(ParseDeclOptions Flags,
   // 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).empty()) {
+  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, /*reverseLookup=*/true);
+    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());

test/Frontend/module-alias-diags.swift

@@ -26,7 +26,7 @@
 /// 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: module real name should not appear in source files; only the module alias is allowed
+// 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