[Driver] Switch -print-target-triple to -print-target-info and add more info.

Rather than only emitting the target triple, provide additional
information about that particular target, including the module triple
(i.e., what file names will be used for Swift modules for that
triple), the runtime compatibility version if there is one, and
whether linking with rpaths is required for the standard library and
other libraries shipped with Swift. Encode this as JSON so we can
extend it in the future. For now, it looks like this:

```
{
  "target": {
    "triple": "arm64-apple-ios12.0",
    "moduleTriple": "arm64-apple-ios",
    "swiftRuntimeCompatibilityVersion": "5.0",
    "librariesRequireRPath": true
  }
}
```

Which you can deserialize into a TargetInfo instance as defined below:

```
struct Target: Codable {
  /// The target triple.
  var triple: String
  /// The triple used for module file names.
  var moduleTriple: String
  /// If this platform provides the Swift runtime, the Swift language
  version
  /// with which that runtime is compatible.
  var swiftRuntimeCompatibilityVersion: String?
  /// Whether linking against the Swift libraries requires the use of
  rpaths.
  var librariesRequireRPath: Bool
}

struct TargetInfo: Codable {
  var target: Target
}
```

Implements rdar://problem/47095159.

Author: DougGregor

include/swift/Frontend/FrontendOptions.h

@@ -249,7 +249,7 @@ class FrontendOptions {
 
   /// Indicates that the frontend should print the target triple and then
   /// exit.
-  bool PrintTargetTriple = false;
+  bool PrintTargetInfo = false;
 
   /// Should we sort SIL functions, vtables, witness tables, and global
   /// variables by name when we print it out. This eases diffing of SIL files.

include/swift/Option/Options.td

@@ -884,9 +884,9 @@ def target : Separate<["-"], "target">,
   HelpText<"Generate code for the given target <triple>, such as x86_64-apple-macos10.9">, MetaVarName<"<triple>">;
 def target_legacy_spelling : Joined<["--"], "target=">,
   Flags<[FrontendOption]>, Alias<target>;
-def print_target_triple : Flag<["-"], "print-target-triple">,
+def print_target_info : Flag<["-"], "print-target-info">,
     Flags<[FrontendOption]>,
-    HelpText<"Generate code for the given target <triple>, such as x86_64-apple-macos10.9">, MetaVarName<"<triple>">;
+    HelpText<"Print target information for the given target <triple>, such as x86_64-apple-macos10.9">, MetaVarName<"<triple>">;
 
 def target_cpu : Separate<["-"], "target-cpu">, Flags<[FrontendOption, ModuleInterfaceOption]>,
   HelpText<"Generate code for a particular CPU variant">;

lib/Driver/Driver.cpp

@@ -2122,10 +2122,10 @@ bool Driver::handleImmediateArgs(const ArgList &Args, const ToolChain &TC) {
                                 std::end(commandArgs));
   }
 
-  if (Args.hasArg(options::OPT_print_target_triple)) {
+  if (Args.hasArg(options::OPT_print_target_info)) {
     SmallVector<const char *, 5> commandLine;
     commandLine.push_back("-frontend");
-    commandLine.push_back("-print-target-triple");
+    commandLine.push_back("-print-target-info");
     if (const Arg *TargetArg = Args.getLastArg(options::OPT_target)) {
       commandLine.push_back("-target");
       commandLine.push_back(TargetArg->getValue());

lib/Frontend/ArgsToFrontendOptionsConverter.cpp

@@ -104,8 +104,8 @@ bool ArgsToFrontendOptionsConverter::convert(
   Opts.IgnoreSwiftSourceInfo |= Args.hasArg(OPT_ignore_module_source_info);
   computeHelpOptions();
 
-  if (Args.hasArg(OPT_print_target_triple)) {
-    Opts.PrintTargetTriple = true;
+  if (Args.hasArg(OPT_print_target_info)) {
+    Opts.PrintTargetInfo = true;
   }
 
   if (const Arg *A = Args.getLastArg(OPT_verify_generic_signatures)) {

lib/FrontendTool/FrontendTool.cpp

@@ -42,6 +42,7 @@
 #include "swift/Basic/JSONSerialization.h"
 #include "swift/Basic/LLVMContext.h"
 #include "swift/Basic/LLVMInitialize.h"
+#include "swift/Basic/Platform.h"
 #include "swift/Basic/PrettyStackTrace.h"
 #include "swift/Basic/SourceManager.h"
 #include "swift/Basic/Statistic.h"
@@ -1863,6 +1864,38 @@ createJSONFixItDiagnosticConsumerIfNeeded(
   });
 }
 
+/// Print information about the selected target in JSON.
+static void printTargetInfo(CompilerInvocation &invocation,
+                            llvm::raw_ostream &out) {
+  out << "{\n";
+
+  // Target information.
+  auto &langOpts = invocation.getLangOptions();
+  out << "  \"target\": {\n";
+
+  out << "    \"triple\": \"";
+  out.write_escaped(langOpts.Target.getTriple());
+  out << "\",\n";
+
+  out << "    \"moduleTriple\": \"";
+  out.write_escaped(getTargetSpecificModuleTriple(langOpts.Target).getTriple());
+  out << "\",\n";
+
+  if (auto runtimeVersion = getSwiftRuntimeCompatibilityVersionForTarget(
+          langOpts.Target)) {
+    out << "    \"swiftRuntimeCompatibilityVersion\": \"";
+    out.write_escaped(runtimeVersion->getAsString());
+    out << "\",\n";
+  }
+
+  out << "    \"librariesRequireRPath\": "
+      << (tripleRequiresRPathForSwiftInOS(langOpts.Target) ? "true" : "false")
+      << "\n";
+
+  out << "  }\n";
+
+  out << "}\n";
+}
 
 int swift::performFrontend(ArrayRef<const char *> Args,
                            const char *Argv0, void *MainAddr,
@@ -1987,8 +2020,8 @@ int swift::performFrontend(ArrayRef<const char *> Args,
     return finishDiagProcessing(0);
   }
 
-  if (Invocation.getFrontendOptions().PrintTargetTriple) {
-    llvm::outs() << Invocation.getLangOptions().Target.getTriple() << "\n";
+  if (Invocation.getFrontendOptions().PrintTargetInfo) {
+    printTargetInfo(Invocation, llvm::outs());
     return finishDiagProcessing(0);
   }
 

test/Driver/print_target_info.swift

@@ -0,0 +1,18 @@
+// RUN: %swift_driver -print-target-info -target arm64-apple-ios12.0 | %FileCheck -check-prefix CHECK-IOS %s
+// RUN: %target-swift-frontend -print-target-info -target arm64-apple-ios12.0 | %FileCheck -check-prefix CHECK-IOS %s
+
+// RUN: %swift_driver -print-target-info -target x86_64-unknown-linux | %FileCheck -check-prefix CHECK-LINUX %s
+// RUN: %target-swift-frontend -print-target-info -target x86_64-unknown-linux | %FileCheck -check-prefix CHECK-LINUX %s
+
+// CHECK-IOS:   "target": {
+// CHECK-IOS:     "triple": "arm64-apple-ios12.0",
+// CHECK-IOS:     "moduleTriple": "arm64-apple-ios",
+// CHECK-IOS:     "swiftRuntimeCompatibilityVersion": "5.0",
+// CHECK-IOS:     "librariesRequireRPath": true
+// CHECK-IOS:   }
+
+// CHECK-LINUX:   "target": {
+// CHECK-LINUX:     "triple": "x86_64-unknown-linux",
+// CHECK-LINUX:     "moduleTriple": "x86_64-unknown-linux",
+// CHECK-LINUX:     "librariesRequireRPath": false
+// CHECK-LINUX:   }

test/Driver/print_target_info_macos.swift

@@ -0,0 +1,10 @@
+// Test that -print-target-info infers the host OS when that host OS is macOS
+//
+// We could duplicate this test for other host platforms.
+
+// RUN: %swift_driver -print-target-info  | %FileCheck %s
+// RUN: %target-swift-frontend -print-target-info | %FileCheck %s
+
+// REQUIRES: OS=macosx
+
+// CHECK: "triple": "x86_64-apple-macosx