Add symlinks for the legacy driver invocation (for emergency fallback invoked from 'swift-driver')

Author: artemcm

lib/Driver/Driver.cpp

@@ -99,6 +99,8 @@ void Driver::parseDriverKind(ArrayRef<const char *> Args) {
       llvm::StringSwitch<llvm::Optional<DriverKind>>(DriverName)
           .Case("swift", DriverKind::Interactive)
           .Case("swiftc", DriverKind::Batch)
+          .Case("swift-legacy-driver", DriverKind::Interactive)
+          .Case("swiftc-legacy-driver", DriverKind::Batch)
           .Case("sil-opt", DriverKind::SILOpt)
           .Case("sil-func-extractor", DriverKind::SILFuncExtractor)
           .Case("sil-nm", DriverKind::SILNM)

lib/DriverTool/driver.cpp

@@ -133,7 +133,7 @@ static bool shouldRunAsSubcommand(StringRef ExecName,
   // If we are not run as 'swift', don't do anything special. This doesn't work
   // with symlinks with alternate names, but we can't detect 'swift' vs 'swiftc'
   // if we try and resolve using the actual executable path.
-  if (ExecName != "swift")
+  if (ExecName != "swift" && ExecName != "swift-legacy-driver")
     return false;
 
   // If there are no program arguments, always invoke as normal.
@@ -167,14 +167,30 @@ static bool shouldRunAsSubcommand(StringRef ExecName,
 static bool shouldDisallowNewDriver(DiagnosticEngine &diags,
                                     StringRef ExecName,
                                     const ArrayRef<const char *> argv) {
-  // We are not invoking the driver, so don't forward.
-  if (ExecName != "swift" && ExecName != "swiftc") {
-    return true;
+  // We are expected to use the legacy driver to `exec` an overload
+  // for testing purposes.
+  if (llvm::sys::Process::GetEnv("SWIFT_OVERLOAD_DRIVER").has_value()) {
+    return false;
   }
   StringRef disableArg = "-disallow-use-new-driver";
   StringRef disableEnv = "SWIFT_USE_OLD_DRIVER";
   auto shouldWarn = !llvm::sys::Process::
     GetEnv("SWIFT_AVOID_WARNING_USING_OLD_DRIVER").has_value();
+
+  // We explicitly are on the fallback to the legacy driver from the new driver.
+  // Do not forward.
+  if (ExecName == "swift-legacy-driver" ||
+      ExecName == "swiftc-legacy-driver") {
+    if (shouldWarn)
+      diags.diagnose(SourceLoc(), diag::old_driver_deprecated, disableArg);
+    return true;
+  }
+
+  // We are not invoking the driver, so don't forward.
+  if (ExecName != "swift" && ExecName != "swiftc") {
+    return true;
+  }
+
   // If user specified using the old driver, don't forward.
   if (llvm::find_if(argv, [&](const char* arg) {
     return StringRef(arg) == disableArg;
@@ -193,7 +209,7 @@ static bool shouldDisallowNewDriver(DiagnosticEngine &diags,
 
 static bool appendSwiftDriverName(SmallString<256> &buffer) {
   assert(llvm::sys::fs::exists(buffer));
-  if (auto driverNameOp = llvm::sys::Process::GetEnv("SWIFT_USE_NEW_DRIVER")) {
+  if (auto driverNameOp = llvm::sys::Process::GetEnv("SWIFT_OVERLOAD_DRIVER")) {
     llvm::sys::path::append(buffer, *driverNameOp);
     return true;
   }
@@ -344,7 +360,16 @@ static int run_driver(StringRef ExecName,
       return 2;
     }
   }
-
+  
+  // We are in the fallback to legacy driver mode.
+  // Now that we have determined above that we are not going to
+  // forward the invocation to the new driver, ensure the rest of the
+  // downstream driver execution refers to itself by the appropriate name.
+  if (ExecName == "swift-legacy-driver")
+    ExecName = "swift";
+  else if (ExecName == "swiftc-legacy-driver")
+    ExecName = "swiftc";
+  
   Driver TheDriver(Path, ExecName, argv, Diags);
   switch (TheDriver.getDriverKind()) {
   case Driver::DriverKind::SILOpt:

test/Driver/LegacyDriver/legacy-driver-propagates-response-file-to-new-driver.swift

@@ -6,7 +6,7 @@
 // REQUIRES: shell
 // RUN: %{python} -c 'for i in range(500001): print("-DTEST5_" + str(i))' > %t.resp
 // RUN: cp %S/Inputs/print-args.sh %swift-bin-dir/legacy-driver-propagates-response-file.sh
-// RUN: env SWIFT_USE_NEW_DRIVER=legacy-driver-propagates-response-file.sh %swiftc_driver_plain %s @%t.resp | %FileCheck %s
+// RUN: env SWIFT_OVERLOAD_DRIVER=legacy-driver-propagates-response-file.sh %swiftc_driver_plain -disallow-use-new-driver %s @%t.resp | %FileCheck %s
 // RUN: rm %swift-bin-dir/legacy-driver-propagates-response-file.sh
 
 // CHECK:      -Xfrontend

test/Driver/options-repl-darwin.swift

@@ -6,7 +6,7 @@
 
 // RUN: %empty-directory(%t/usr/bin/)
 // RUN: %empty-directory(%t/usr/lib/)
-// RUN: %hardlink-or-copy(from: %swift_driver_plain, to: %t/usr/bin/swift)
+// RUN: %hardlink-or-copy(from: %swift_driver_plain-legacy-driver, to: %t/usr/bin/swift)
 
 // RUN: %host-library-env %t/usr/bin/swift -repl -### | %FileCheck -check-prefix=INTEGRATED %s
 // RUN: %host-library-env %t/usr/bin/swift -### | %FileCheck -check-prefix=INTEGRATED %s

test/Driver/subcommands.swift

@@ -34,5 +34,5 @@
 // RUN: echo "#!/bin/sh" > %t.dir/swift-foo
 // RUN: echo "echo \"exec: \$0\"" >> %t.dir/swift-foo
 // RUN: chmod +x %t.dir/swift-foo
-// RUN: env PATH=%t.dir %swift_driver_plain foo | %FileCheck -check-prefix=CHECK-SWIFT-SUBCOMMAND %s
+// RUN: env PATH=%t.dir SWIFT_USE_OLD_DRIVER=1 %swift_driver_plain foo | %FileCheck -check-prefix=CHECK-SWIFT-SUBCOMMAND %s
 // CHECK-SWIFT-SUBCOMMAND: exec: {{.*}}/swift-foo

tools/driver/CMakeLists.txt

@@ -85,11 +85,20 @@ if(EXISTS "${SWIFT_RUNTIME_OUTPUT_INTDIR}/swift-driver${CMAKE_EXECUTABLE_SUFFIX}
     SOURCE "swift-driver${CMAKE_EXECUTABLE_SUFFIX}"
     DESTINATION "swift${CMAKE_EXECUTABLE_SUFFIX}"
     WORKING_DIRECTORY "${SWIFT_RUNTIME_OUTPUT_INTDIR}")
-
   swift_create_post_build_symlink(swift-frontend
     SOURCE "swift-driver${CMAKE_EXECUTABLE_SUFFIX}"
     DESTINATION "swiftc${CMAKE_EXECUTABLE_SUFFIX}"
     WORKING_DIRECTORY "${SWIFT_RUNTIME_OUTPUT_INTDIR}")
+
+  message(STATUS "Pointing 'swift-legacy-driver' and 'swiftc-legacy-driver' symlinks at 'swift-frontend'.")
+  swift_create_post_build_symlink(swift-frontend
+    SOURCE "swift-frontend${CMAKE_EXECUTABLE_SUFFIX}"
+    DESTINATION "swift-legacy-driver${CMAKE_EXECUTABLE_SUFFIX}"
+    WORKING_DIRECTORY "${SWIFT_RUNTIME_OUTPUT_INTDIR}")
+  swift_create_post_build_symlink(swift-frontend
+    SOURCE "swift-frontend${CMAKE_EXECUTABLE_SUFFIX}"
+    DESTINATION "swiftc-legacy-driver${CMAKE_EXECUTABLE_SUFFIX}"
+    WORKING_DIRECTORY "${SWIFT_RUNTIME_OUTPUT_INTDIR}")
 else()
   message(STATUS "Pointing 'swift' and 'swiftc' symlinks at 'swift-frontend' - no early SwiftDriver build found.")
   swift_create_post_build_symlink(swift-frontend
@@ -207,4 +216,10 @@ if(EXISTS "${SWIFT_RUNTIME_OUTPUT_INTDIR}/swift-driver${CMAKE_EXECUTABLE_SUFFIX}
   swift_install_in_component(PROGRAMS "${SWIFT_RUNTIME_OUTPUT_INTDIR}/swift-help${CMAKE_EXECUTABLE_SUFFIX}"
                              DESTINATION "bin"
                              COMPONENT compiler)
+  swift_install_in_component(FILES "${SWIFT_RUNTIME_OUTPUT_INTDIR}/swiftc-legacy-driver${CMAKE_EXECUTABLE_SUFFIX}"
+                             DESTINATION "bin"
+                             COMPONENT compiler)
+  swift_install_in_component(FILES "${SWIFT_RUNTIME_OUTPUT_INTDIR}/swift-legacy-driver${CMAKE_EXECUTABLE_SUFFIX}"
+                             DESTINATION "bin"
+                             COMPONENT compiler)
 endif()