Add a module alias option to frontend

Validate input and set up the module alias map
rdar://83316886

Author: elsh

include/swift/AST/DiagnosticsFrontend.def

@@ -150,7 +150,8 @@ ERROR(error_stdlib_module_name,none,
       "module name \"%0\" is reserved for the standard library"
       "%select{|; use -module-name flag to specify an alternate name}1",
       (StringRef, bool))
-
+ERROR(error_bad_module_alias,none,
+      "invalid module alias \"%0\" for an imported module; make sure the input format is correct (-module-alias alias=underlying_name), where the alias maps to an imported module, and the names do not contain special characters", (StringRef))
 ERROR(error_stdlib_not_found,Fatal,
       "unable to load standard library for target '%0'", (StringRef))
 

include/swift/Basic/LangOptions.h

@@ -31,6 +31,7 @@
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/VersionTuple.h"
 #include "llvm/Support/raw_ostream.h"
+#include <map>
 #include <string>
 #include <vector>
 
@@ -196,6 +197,9 @@ namespace swift {
     /// Enable features useful for running in the debugger.
     bool DebuggerSupport = false;
 
+    /// A map of aliases and underlying names of imported modules.
+    std::map<StringRef, StringRef> ModuleAliasMap;
+
     /// Enable the MemoryBufferSerializedModuleImporter.
     /// Only used by lldb-moduleimport-test.
     bool EnableMemoryBufferImporter = false;

include/swift/Frontend/Frontend.h

@@ -300,6 +300,14 @@ class CompilerInvocation {
     return FrontendOpts.ParseStdlib;
   }
 
+  void setModuleAliasMap(std::map<StringRef, StringRef> ModAliasMap) {
+      FrontendOpts.ModuleAliasMap = ModAliasMap;
+  }
+
+  std::map<StringRef, StringRef> getModuleAliasMap() const {
+      return FrontendOpts.ModuleAliasMap;
+  }
+
   void setModuleName(StringRef Name) {
     FrontendOpts.ModuleName = Name.str();
     IRGenOpts.ModuleName = Name.str();

include/swift/Frontend/FrontendOptions.h

@@ -19,6 +19,7 @@
 #include "swift/Frontend/InputFile.h"
 #include "llvm/ADT/Hashing.h"
 
+#include <map>
 #include <string>
 #include <vector>
 
@@ -48,6 +49,9 @@ class FrontendOptions {
   /// An Objective-C header to import and make implicitly visible.
   std::string ImplicitObjCHeaderPath;
 
+  /// The map of aliases and underlying names of imported modules.
+  std::map<StringRef, StringRef> ModuleAliasMap;
+
   /// The name of the module that the frontend is building.
   std::string ModuleName;
 

include/swift/Option/Options.td

@@ -430,6 +430,10 @@ def module_name : Separate<["-"], "module-name">,
 def module_name_EQ : Joined<["-"], "module-name=">, Flags<[FrontendOption]>,
   Alias<module_name>;
 
+def module_alias : Separate<["-"], "module-alias">,
+  Flags<[FrontendOption]>,
+  HelpText<"Alias and underlying name 'alias=underlying_name' of the module to be imported">;
+
 def module_link_name : Separate<["-"], "module-link-name">,
   Flags<[FrontendOption, ModuleInterfaceOption]>,
   HelpText<"Library to link against when using this module">;

lib/Frontend/ArgsToFrontendOptionsConverter.cpp

@@ -244,6 +244,11 @@ bool ArgsToFrontendOptionsConverter::convert(
   if (const Arg *A = Args.getLastArg(OPT_module_link_name))
     Opts.ModuleLinkName = A->getValue();
 
+  // This must be called after computing module name, module abi name,
+  // and module link name.
+  if (computeModuleAliases())
+    return true;
+
   if (const Arg *A = Args.getLastArg(OPT_access_notes_path))
     Opts.AccessNotesPath = A->getValue();
 
@@ -498,6 +503,40 @@ bool ArgsToFrontendOptionsConverter::setUpImmediateArgs() {
   return false;
 }
 
+bool ArgsToFrontendOptionsConverter::computeModuleAliases() {
+  auto list = Args.getAllArgValues(options::OPT_module_alias);
+  if (!list.empty()) {
+    for (auto val: list) {
+      auto i = val.find("=");
+      if (i == std::string::npos) {
+          Diags.diagnose(SourceLoc(), diag::error_bad_module_alias, val);
+          return true;
+      }
+
+      std::string *lhs = new std::string(val.substr(0, i));
+      std::string *rhs = new std::string(val.substr(i+1, val.length()));
+      auto modAlias = StringRef(*lhs);
+      auto modValue = StringRef(*rhs);
+
+      if (modAlias.empty() ||
+          modValue.empty() ||
+          modAlias == Opts.ModuleName ||
+          modAlias == Opts.ModuleABIName ||
+          modAlias == Opts.ModuleLinkName ||
+          modValue == Opts.ModuleName ||
+          modValue == Opts.ModuleABIName ||
+          modValue == Opts.ModuleLinkName ||
+          !Lexer::isIdentifier(modAlias) ||
+          !Lexer::isIdentifier(modValue)) {
+          Diags.diagnose(SourceLoc(), diag::error_bad_module_alias, val);
+          return true;
+      }
+      Opts.ModuleAliasMap.insert({ modAlias, modValue });
+    }
+  }
+  return false;
+}
+
 bool ArgsToFrontendOptionsConverter::computeModuleName() {
   const Arg *A = Args.getLastArg(options::OPT_module_name);
   if (A) {

lib/Frontend/ArgsToFrontendOptionsConverter.h

@@ -37,6 +37,7 @@ class ArgsToFrontendOptionsConverter {
   void computeDebugTimeOptions();
   bool computeFallbackModuleName();
   bool computeModuleName();
+  bool computeModuleAliases();
   bool computeMainAndSupplementaryOutputFilenames();
   void computeDumpScopeMapLocations();
   void computeHelpOptions();

lib/Frontend/Frontend.cpp

@@ -211,6 +211,7 @@ bool CompilerInstance::setUpASTContextIfNeeded() {
   // and single file builds.
   Invocation.getLangOptions().RecordRequestReferences
     = !isWholeModuleCompilation();
+  Invocation.getLangOptions().ModuleAliasMap = Invocation.getFrontendOptions().ModuleAliasMap;
 
   Context.reset(ASTContext::get(
       Invocation.getLangOptions(), Invocation.getTypeCheckerOptions(),