Introduce module aliasing to Driver

Parse input and store aliases in ModuleOutputInfo
Validate input aliases and emit diagnostics
Resolves rdar://85523248

Author: elsh

Sources/SwiftDriver/Driver/Driver.swift

@@ -2144,9 +2144,12 @@ extension Driver {
       fallbackOrDiagnose(.error_stdlib_module_name(moduleName: moduleName, explicitModuleName: parsedOptions.contains(.moduleName)))
     }
 
+    // Retrieve and validate module aliases if passed in
+    let moduleAliases = moduleAliasesFromInput(parsedOptions.arguments(for: [.moduleAlias]), with: moduleName, onError: diagnosticsEngine)
+
     // If we're not emiting a module, we're done.
     if moduleOutputKind == nil {
-      return ModuleOutputInfo(output: nil, name: moduleName, nameIsFallback: moduleNameIsFallback)
+      return ModuleOutputInfo(output: nil, name: moduleName, nameIsFallback: moduleNameIsFallback, aliases: moduleAliases)
     }
 
     // Determine the module file to output.
@@ -2180,10 +2183,60 @@ extension Driver {
 
     switch moduleOutputKind! {
     case .topLevel:
-      return ModuleOutputInfo(output: .topLevel(moduleOutputPath.intern()), name: moduleName, nameIsFallback: moduleNameIsFallback)
+      return ModuleOutputInfo(output: .topLevel(moduleOutputPath.intern()), name: moduleName, nameIsFallback: moduleNameIsFallback, aliases: moduleAliases)
     case .auxiliary:
-      return ModuleOutputInfo(output: .auxiliary(moduleOutputPath.intern()), name: moduleName, nameIsFallback: moduleNameIsFallback)
+      return ModuleOutputInfo(output: .auxiliary(moduleOutputPath.intern()), name: moduleName, nameIsFallback: moduleNameIsFallback, aliases: moduleAliases)
+    }
+  }
+
+  // Validate and return module aliases passed via -module-alias
+  static func moduleAliasesFromInput(_ aliasArgs: [ParsedOption],
+                                     with moduleName: String,
+                                     onError diagnosticsEngine: DiagnosticsEngine) -> [String: String]? {
+    var moduleAliases: [String: String]? = nil
+    let validate = { (_ arg: String, allowModuleName: Bool) -> Bool in
+      if !arg.sd_isSwiftIdentifier {
+        diagnosticsEngine.emit(.error_bad_module_name(moduleName: arg, explicitModuleName: true))
+        return false
+      }
+      if arg == "Swift" {
+        diagnosticsEngine.emit(.error_stdlib_module_name(moduleName: arg, explicitModuleName: true))
+        return false
+      }
+      if !allowModuleName, arg == moduleName {
+        diagnosticsEngine.emit(.error_bad_module_alias(arg, moduleName: moduleName))
+        return false
+      }
+      return true
+    }
+    
+    var used = [""]
+    for item in aliasArgs {
+      let arg = item.argument.asSingle
+      let pair = arg.components(separatedBy: "=")
+      guard pair.count == 2 else {
+        diagnosticsEngine.emit(.error_bad_module_alias(arg, moduleName: moduleName, formatted: false))
+        continue
+      }
+      guard let lhs = pair.first, validate(lhs, false) else { continue }
+      guard let rhs = pair.last, validate(rhs, true) else { continue }
+
+      if moduleAliases == nil {
+        moduleAliases = [String: String]()
+      }
+      if let _ = moduleAliases?[lhs] {
+        diagnosticsEngine.emit(.error_bad_module_alias(lhs, moduleName: moduleName, isDuplicate: true))
+        continue
+      }
+      if used.contains(rhs)  {
+        diagnosticsEngine.emit(.error_bad_module_alias(rhs, moduleName: moduleName, isDuplicate: true))
+        continue
+      }
+      moduleAliases?[lhs] = rhs
+      used.append(lhs)
+      used.append(rhs)
     }
+    return moduleAliases
   }
 }
 

Sources/SwiftDriver/Driver/ModuleOutputInfo.swift

@@ -48,4 +48,7 @@
 
   /// Whether `name` was picked by the driver instead of the user.
   public let nameIsFallback: Bool
+
+  /// Map of aliases and real names of modules referenced by source files in the current module
+  public let aliases: [String: String]?
 }

Sources/SwiftDriver/Jobs/FrontendJobHelpers.swift

@@ -204,6 +204,7 @@ extension Driver {
     try commandLine.appendAllArguments(.Xfrontend, from: &parsedOptions)
     try commandLine.appendAll(.coveragePrefixMap, from: &parsedOptions)
     try commandLine.appendLast(.warnConcurrency, from: &parsedOptions)
+    try commandLine.appendAll(.moduleAlias, from: &parsedOptions)
 
     // Expand the -experimental-hermetic-seal-at-link flag
     if parsedOptions.hasArgument(.experimentalHermeticSealAtLink) {

Sources/SwiftDriver/Utilities/Diagnostics.swift

@@ -89,6 +89,22 @@ extension Diagnostic.Message {
     return .error("module name \"\(moduleName)\" is reserved for the standard library\(suffix)")
   }
 
+  static func error_bad_module_alias(_ arg: String,
+                                     moduleName: String,
+                                     formatted: Bool = true,
+                                     isDuplicate: Bool = false) -> Diagnostic.Message {
+    if !formatted {
+      return .error("invalid format \"\(arg)\"; use the format '-module-alias alias_name=underlying_name'")
+    }
+    if arg == moduleName {
+      return .error("module alias \"\(arg)\" should be different from the module name \"\(moduleName)\"")
+    }
+    if isDuplicate {
+      return .error("the name \"\(arg)\" is already used for a module alias or an underlying name")
+    }
+    return .error("bad module alias \"\(arg)\"")
+  }
+
   static var error_hermetic_seal_cannot_have_library_evolution: Diagnostic.Message {
     .error("Cannot use -experimental-hermetic-seal-at-link with -enable-library-evolution")
   }

Tests/SwiftDriverTests/SwiftDriverTests.swift

@@ -2226,6 +2226,55 @@ final class SwiftDriverTests: XCTestCase {
     }
   }
 
+  func testModuleAliasingWithImplicitBuild() throws {
+    var driver = try Driver(args: [
+      "swiftc", "foo.swift", "-module-name", "Foo", "-module-alias", "Car=Bar",
+      "-emit-module", "-emit-module-path", "/tmp/dir/Foo.swiftmodule",
+    ])
+    let plannedJobs = try driver.planBuild()
+    XCTAssertTrue(plannedJobs.contains { job in
+      job.commandLine.contains(.flag("-module-alias")) &&
+      job.commandLine.contains(.flag("Car=Bar")) &&
+      job.outputs[0].file.absolutePath?.pathString == "/tmp/dir/Foo.swiftmodule"
+    })
+    XCTAssertEqual(driver.moduleOutputInfo.name, "Foo")
+    XCTAssertNotNil(driver.moduleOutputInfo.aliases)
+    XCTAssertEqual(driver.moduleOutputInfo.aliases!.count, 1)
+    XCTAssertEqual(driver.moduleOutputInfo.aliases!["Car"], "Bar")
+  }
+
+  func testInvalidModuleAliasing() throws {
+    try assertDriverDiagnostics(
+      args: ["swiftc", "foo.swift", "-module-name", "Foo", "-module-alias", "CarBar", "-emit-module", "-emit-module-path", "/tmp/dir/Foo.swiftmodule"]
+    ) {
+      $1.expect(.error("invalid format \"CarBar\"; use the format '-module-alias alias_name=underlying_name'"))
+    }
+
+    try assertDriverDiagnostics(
+      args: ["swiftc", "foo.swift", "-module-name", "Foo", "-module-alias", "Foo=Bar", "-emit-module", "-emit-module-path", "/tmp/dir/Foo.swiftmodule"]
+    ) {
+      $1.expect(.error("module alias \"Foo\" should be different from the module name \"Foo\""))
+    }
+
+    try assertDriverDiagnostics(
+      args: ["swiftc", "foo.swift", "-module-name", "Foo", "-module-alias", "C-ar=Bar", "-emit-module", "-emit-module-path", "/tmp/dir/Foo.swiftmodule"]
+    ) {
+      $1.expect(.error("module name \"C-ar\" is not a valid identifier"))
+    }
+
+    try assertDriverDiagnostics(
+      args: ["swiftc", "foo.swift", "-module-name", "Foo", "-module-alias", "Car=Bar", "-module-alias", "Train=Car", "-emit-module", "-emit-module-path", "/tmp/dir/Foo.swiftmodule"]
+    ) {
+      $1.expect(.error("the name \"Car\" is already used for a module alias or an underlying name"))
+    }
+
+    try assertDriverDiagnostics(
+      args: ["swiftc", "foo.swift", "-module-name", "Foo", "-module-alias", "Car=Bar", "-module-alias", "Car=Bus", "-emit-module", "-emit-module-path", "/tmp/dir/Foo.swiftmodule"]
+    ) {
+      $1.expect(.error("the name \"Car\" is already used for a module alias or an underlying name"))
+    }
+  }
+
   func testWholeModuleOptimizationUsingSupplementaryOutputFileMap() throws {
     var driver1 = try Driver(args: [
       "swiftc", "-whole-module-optimization", "foo.swift", "bar.swift", "wibble.swift", "-module-name", "Test",