Merge pull request #40102 from apple/es-param

[NFC] Add module alias lookup option enum / use the option to look up in ASTContext::getRealModuleName

Author: elsh

include/swift/AST/ASTContext.h

@@ -489,23 +489,27 @@ class ASTContext final {
   /// are the real (physical) module names on disk.
   void setModuleAliases(const llvm::StringMap<StringRef> &aliasMap);
 
-  /// Look up the module alias map by the given \p key.
+  /// Look up option used in \c getRealModuleName when module aliasing is applied.
+  enum class ModuleAliasLookupOption {
+    alwaysRealName,
+    realNameFromAlias,
+    aliasFromRealName
+  };
+
+  /// Look up the module alias map by the given \p key and a lookup \p option.
+  ///
+  /// \param key A module alias or real name to look up the map by.
+  /// \param option A look up option \c ModuleAliasLookupOption. Defaults to alwaysRealName.
   ///
-  /// \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.
+  ///         If no aliasing is used, return \p key regardless of \p option.
+  ///         If \p option is alwaysRealName, return the real module name whether the \p key is an alias
+  ///         or a real name.
+  ///         If \p option is realNameFromAlias, only return a real name if \p key is an alias.
+  ///         If \p option is aliasFromRealName, only return an alias if \p key is a real name.
+  ///         Else return a real name or an alias mapped to the \p key.
   Identifier getRealModuleName(Identifier key,
-                               bool alwaysReturnRealName = true,
-                               bool lookupAliasFromReal = false) const;
+                               ModuleAliasLookupOption option = ModuleAliasLookupOption::alwaysRealName) const;
 
   /// Decide how to interpret two precedence groups.
   Associativity associateInfixOperators(PrecedenceGroupDecl *left,

lib/AST/ASTContext.cpp

@@ -1653,26 +1653,31 @@ void ASTContext::setModuleAliases(const llvm::StringMap<StringRef> &aliasMap) {
   }
 }
 
-Identifier ASTContext::getRealModuleName(Identifier key, bool alwaysReturnRealName, bool lookupAliasFromReal) const {
+Identifier ASTContext::getRealModuleName(Identifier key, ModuleAliasLookupOption option) const {
   auto found = ModuleAliasMap.find(key);
   if (found == ModuleAliasMap.end())
-    return key;
+    return key; // No module aliasing was used, so just return the given key
 
   // Found an entry
-  auto realOrAlias = found->second;
+  auto value = 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;
+  // With the alwaysRealName option, look up the real name by treating
+  // the given key as an alias; if the key's not an alias, return the key
+  // itself since that's the real name.
+  if (option == ModuleAliasLookupOption::alwaysRealName) {
+     return value.second ? value.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)
+  // With realNameFromAlias or aliasFromRealName option, only return the value
+  // if the given key matches the description (whether it's an alias or real name)
+  // by looking up the value.second (true if keyed by an alias). If not matched,
+  // return an empty Identifier.
+  if ((option == ModuleAliasLookupOption::realNameFromAlias && !value.second) ||
+      (option == ModuleAliasLookupOption::aliasFromRealName && value.second))
       return Identifier();
 
-  return realOrAlias.first;
+  // Otherwise return the value found (whether the key is an alias or real name)
+  return value.first;
 }
 
 Optional<ModuleDependencies> ASTContext::getModuleDependencies(

lib/AST/UnqualifiedLookup.cpp

@@ -441,9 +441,10 @@ 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 the real name 'Bar' was used, looking up getRealModuleName will
-  // return an empty Identifier.
-  if (!Ctx.getRealModuleName(givenName, /*alwaysReturnRealName=*/false).empty()) {
+  // If the real name 'Bar' was used, looking up getRealModuleName with
+  // the real name 'Bar' and realNameFromAlias option should return
+  // an empty Identifier.
+  if (!Ctx.getRealModuleName(givenName, ASTContext::ModuleAliasLookupOption::realNameFromAlias).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

@@ -4831,10 +4831,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, /*alwaysReturnRealName=*/false).empty()) {
+  if (Context.getRealModuleName(parsedModuleID, ASTContext::ModuleAliasLookupOption::realNameFromAlias).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);
+    auto aliasName = Context.getRealModuleName(parsedModuleID, ASTContext::ModuleAliasLookupOption::aliasFromRealName);
     diagnose(importPath.front().Loc, diag::expected_module_alias,
                      parsedModuleID, aliasName)
       .fixItReplace(importPath.front().Loc, aliasName.str());