swift/tensorflow merge (2020-06-09)

lldb/include/lldb/Host/HostInfoBase.h

@@ -92,6 +92,9 @@ class HostInfoBase {
   static bool ComputePathRelativeToLibrary(FileSpec &file_spec,
                                            llvm::StringRef dir);
 
+  static FileSpec GetXcodeContentsDirectory() { return {}; }
+  static FileSpec GetXcodeDeveloperDirectory() { return {}; }
+
   /// Return the directory containing a specific Xcode SDK.
   static llvm::StringRef GetXcodeSDKPath(XcodeSDK sdk) { return {}; }
 

lldb/include/lldb/Host/macosx/HostInfoMacOSX.h

@@ -32,7 +32,8 @@ class HostInfoMacOSX : public HostInfoPosix {
   static bool GetOSBuildString(std::string &s);
   static bool GetOSKernelDescription(std::string &s);
   static FileSpec GetProgramFileSpec();
-  static std::string FindXcodeContentsDirectoryInPath(llvm::StringRef path);
+  static FileSpec GetXcodeContentsDirectory();
+  static FileSpec GetXcodeDeveloperDirectory();
 
   /// Query xcrun to find an Xcode SDK directory.
   static llvm::StringRef GetXcodeSDKPath(XcodeSDK sdk);

lldb/include/lldb/Utility/XcodeSDK.h

@@ -87,6 +87,8 @@ class XcodeSDK {
   static std::string GetCanonicalName(Info info);
   /// Return the best-matching SDK type for a specific triple.
   static XcodeSDK::Type GetSDKTypeForTriple(const llvm::Triple &triple);
+
+  static std::string FindXcodeContentsDirectoryInPath(llvm::StringRef path);
 };
 
 } // namespace lldb_private

lldb/source/Host/macosx/objcxx/HostInfoMacOSX.mm

@@ -297,11 +297,82 @@ static void ParseOSVersion(llvm::VersionTuple &version, NSString *Key) {
   }
 }
 
+FileSpec HostInfoMacOSX::GetXcodeContentsDirectory() {
+  static FileSpec g_xcode_contents_path;
+  static std::once_flag g_once_flag;
+  std::call_once(g_once_flag, [&]() {
+    // Try the shlib dir first.
+    if (FileSpec fspec = HostInfo::GetShlibDir()) {
+      if (FileSystem::Instance().Exists(fspec)) {
+        std::string xcode_contents_dir =
+            XcodeSDK::FindXcodeContentsDirectoryInPath(fspec.GetPath());
+        if (!xcode_contents_dir.empty()) {
+          g_xcode_contents_path = FileSpec(xcode_contents_dir);
+          return;
+        }
+      }
+    }
+
+    if (const char *developer_dir_env_var = getenv("DEVELOPER_DIR")) {
+      FileSpec fspec(developer_dir_env_var);
+      if (FileSystem::Instance().Exists(fspec)) {
+        // FIXME: This looks like it couldn't possibly work!
+        std::string xcode_contents_dir =
+            XcodeSDK::FindXcodeContentsDirectoryInPath(fspec.GetPath());
+        if (!xcode_contents_dir.empty()) {
+          g_xcode_contents_path = FileSpec(xcode_contents_dir);
+          return;
+        }
+      }
+    }
+
+    FileSpec fspec(HostInfo::GetXcodeSDKPath(XcodeSDK::GetAnyMacOS()));
+    if (fspec) {
+      if (FileSystem::Instance().Exists(fspec)) {
+        std::string xcode_contents_dir =
+            XcodeSDK::FindXcodeContentsDirectoryInPath(fspec.GetPath());
+        if (!xcode_contents_dir.empty()) {
+          g_xcode_contents_path = FileSpec(xcode_contents_dir);
+          return;
+        }
+      }
+    }
+  });
+  return g_xcode_contents_path;
+}
+
+lldb_private::FileSpec HostInfoMacOSX::GetXcodeDeveloperDirectory() {
+  static lldb_private::FileSpec g_developer_directory;
+  static llvm::once_flag g_once_flag;
+  llvm::call_once(g_once_flag, []() {
+    if (FileSpec fspec = GetXcodeContentsDirectory()) {
+      fspec.AppendPathComponent("Developer");
+      if (FileSystem::Instance().Exists(fspec))
+        g_developer_directory = fspec;
+    }
+  });
+  return g_developer_directory;
+}
+
 static std::string GetXcodeSDK(XcodeSDK sdk) {
   XcodeSDK::Info info = sdk.Parse();
   std::string sdk_name = XcodeSDK::GetCanonicalName(info);
   auto find_sdk = [](std::string sdk_name) -> std::string {
-    std::string xcrun_cmd = "xcrun --show-sdk-path --sdk " + sdk_name;
+    std::string xcrun_cmd;
+    Environment env = Host::GetEnvironment();
+    std::string developer_dir = env.lookup("DEVELOPER_DIR");
+    if (developer_dir.empty())
+      if (FileSpec fspec = HostInfo::GetShlibDir())
+        if (FileSystem::Instance().Exists(fspec)) {
+          FileSpec path(
+              XcodeSDK::FindXcodeContentsDirectoryInPath(fspec.GetPath()));
+          if (path.RemoveLastPathComponent())
+            developer_dir = path.GetPath();
+        }
+    if (!developer_dir.empty())
+      xcrun_cmd = "/usr/bin/env DEVELOPER_DIR=\"" + developer_dir + "\" ";
+    xcrun_cmd += "xcrun --show-sdk-path --sdk " + sdk_name;
+
     int status = 0;
     int signo = 0;
     std::string output_str;

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp

@@ -684,15 +684,8 @@ bool DynamicLoaderDarwin::AddModulesUsingImageInfos(
       // Update the module's platform with the DYLD info.
       ArchSpec dyld_spec = image_infos[idx].GetArchitecture();
       if (dyld_spec.GetTriple().getOS() == llvm::Triple::IOS &&
-          dyld_spec.GetTriple().getEnvironment() == llvm::Triple::MacABI) {
+          dyld_spec.GetTriple().getEnvironment() == llvm::Triple::MacABI)
         image_module_sp->MergeArchitecture(dyld_spec);
-        const auto &target_triple = target.GetArchitecture().GetTriple();
-        // If dyld reports the process as being loaded as MACCATALYST,
-        // force-update the target's architecture to MACCATALYST.
-        if (!(target_triple.getOS() == llvm::Triple::IOS &&
-              target_triple.getEnvironment() == llvm::Triple::MacABI))
-          target.SetArchitecture(dyld_spec);
-      }
     }
   }
 

lldb/source/Plugins/ExpressionParser/Swift/SwiftASTManipulator.cpp

@@ -90,27 +90,41 @@ void SwiftASTManipulator::WrapExpression(
 __builtin_logger_initialize()
 )";
 
-    // The debug function declarations need only be declared once per session - on the first REPL call.
-    // This code assumes that the first call is the first REPL call; don't call playground once then playground || repl again
+    // The debug function declarations need only be declared once per session -
+    // on the first REPL call.  This code assumes that the first call is the
+    // first REPL call; don't call playground once then playground || repl
+    // again
     bool first_expression = options.GetPreparePlaygroundStubFunctions();
 
-    const char *playground_prefix =  first_expression ? playground_logger_declarations : "";
+    const char *playground_prefix =
+        first_expression ? playground_logger_declarations : "";
 
     if (pound_file && pound_line) {
       wrapped_stream.Printf("%s#sourceLocation(file: \"%s\", line: %u)\n%s\n",
                             playground_prefix, pound_file, pound_line,
                             orig_text);
     } else {
-      // In 2017+, xcode playgrounds send orig_text that starts with a module loading prefix (not the above prefix), then a sourceLocation specifier that indicates the page name, and then the page body text.
-      // The first_body_line mechanism in this function cannot be used to compensate for the playground_prefix added here, since it incorrectly continues to apply even after sourceLocation directives are read frmo the orig_text.
-      // To make sure playgrounds work correctly whether or not they supply their own sourceLocation, create a dummy sourceLocation here with a fake filename that starts counting the first line of orig_text as line 1.
+      // In 2017+, xcode playgrounds send orig_text that starts with a module
+      // loading prefix (not the above prefix), then a sourceLocation specifier
+      // that indicates the page name, and then the page body text.  The
+      // first_body_line mechanism in this function cannot be used to
+      // compensate for the playground_prefix added here, since it incorrectly
+      // continues to apply even after sourceLocation directives are read from
+      // the orig_text.  To make sure playgrounds work correctly whether or not
+      // they supply their own sourceLocation, create a dummy sourceLocation
+      // here with a fake filename that starts counting the first line of
+      // orig_text as line 1.
       wrapped_stream.Printf("%s#sourceLocation(file: \"%s\", line: %u)\n%s\n",
                             playground_prefix, "Playground.swift", 1,
                             orig_text);
     }
     first_body_line = 1;
     return;
-  } else if (repl) { // repl but not playground.
+  }
+
+  assert(!playground && "Playground mode not expected");
+
+  if (repl) {
     if (pound_file && pound_line) {
       wrapped_stream.Printf("#sourceLocation(file: \"%s\", line:  %u)\n%s\n",
                             llvm::sys::path::filename(pound_file).str().c_str(),
@@ -122,87 +136,85 @@ __builtin_logger_initialize()
     return;
   }
 
-  std::string expr_source_path;
+  assert(!playground && !repl && "Playground/REPL mode not expected");
 
   if (pound_file && pound_line) {
     fixed_text.Printf("#sourceLocation(file: \"%s\", line: %u)\n%s\n",
                       pound_file, pound_line, orig_text);
     text = fixed_text.GetString().data();
   } else if (generate_debug_info) {
+    std::string expr_source_path;
     if (SwiftASTManipulator::SaveExpressionTextToTempFile(orig_text, options,
-                                                           expr_source_path)) {
+                                                          expr_source_path)) {
       fixed_text.Printf("#sourceLocation(file: \"%s\", line: 1)\n%s\n",
                         expr_source_path.c_str(), orig_text);
       text = fixed_text.GetString().data();
     }
   }
 
   // Note: All the wrapper functions we make are marked with the
-  // @LLDBDebuggerFunction macro so that the compiler
-  // can do whatever special treatment it need to do on them.  If you add new
-  // variants be sure to mark them this way.
-  // Also, any function that might end up being in an extension of swift class
-  // needs to be marked final, since otherwise
-  // the compiler might try to dispatch them dynamically, which it can't do
-  // correctly for these functions.
-
-  llvm::SmallString<32> buffer;
-  llvm::raw_svector_ostream os(buffer);
+  // @LLDBDebuggerFunction macro so that the compiler can do whatever special
+  // treatment it need to do on them.  If you add new variants be sure to mark
+  // them this way.  Also, any function that might end up being in an extension
+  // of swift class needs to be marked final, since otherwise the compiler
+  // might try to dispatch them dynamically, which it can't do correctly for
+  // these functions.
+
+  std::string availability = "";
   if (!os_version.empty())
-    os << "@available(" << os_version << ", *)";
-  std::string availability = os.str();
+    availability = (llvm::Twine("@available(") + os_version + ", *)").str();
 
   StreamString wrapped_expr_text;
-  wrapped_expr_text.Printf("do\n"
-                           "{\n"
-                           "%s%s%s\n" // Don't indent the code so error columns
-                                      // match up with errors from compiler
-                           "}\n"
-                           "catch (let __lldb_tmp_error)\n"
-                           "{\n"
-                           "    var %s = __lldb_tmp_error\n"
-                           "}\n",
+
+  // Avoid indenting user code: this makes column information from compiler
+  // errors match up with what the user typed.
+  wrapped_expr_text.Printf(R"(
+do {
+%s%s%s
+} catch (let __lldb_tmp_error) {
+  var %s = __lldb_tmp_error
+}
+)",
                            GetUserCodeStartMarker(), text,
                            GetUserCodeEndMarker(), GetErrorName());
 
-  if (needs_object_ptr | static_method) {
+  if (needs_object_ptr || static_method) {
     const char *func_decorator = "";
     if (static_method) {
       if (is_class)
         func_decorator = "final class";
       else
         func_decorator = "static";
-    } else if (is_class &&
-               !(weak_self)) {
+    } else if (is_class && !weak_self) {
       func_decorator = "final";
     } else {
       func_decorator = "mutating";
     }
 
     const char *optional_extension =
-        (weak_self)
-            ? "Swift.Optional where Wrapped == "
-            : "";
-
-    wrapped_stream.Printf(
-        "extension %s$__lldb_context {\n"
-        "  @LLDBDebuggerFunction %s\n"
-        "  %s func $__lldb_wrapped_expr_%u(_ $__lldb_arg : "
-        "UnsafeMutablePointer<Any>) {\n"
-        "%s" // This is the expression text (with newlines).
-        "  }\n"
-        "}\n"
-        "%s\n"
-        "func $__lldb_expr(_ $__lldb_arg : UnsafeMutablePointer<Any>) {\n"
-        "  do {\n"
-        "    $__lldb_injected_self.$__lldb_wrapped_expr_%u(\n"
-        "      $__lldb_arg\n"
-        "    )\n"
-        "  }\n"
-        "}\n",
-        optional_extension, availability.c_str(), func_decorator,
-        current_counter, wrapped_expr_text.GetData(), availability.c_str(),
-        current_counter);
+        weak_self ? "Swift.Optional where Wrapped == " : "";
+
+    // The expression text is inserted into the body of $__lldb_wrapped_expr_%u.
+    wrapped_stream.Printf(R"(
+extension %s$__lldb_context {
+  @LLDBDebuggerFunction %s
+  %s func $__lldb_wrapped_expr_%u(_ $__lldb_arg : UnsafeMutablePointer<Any>) {
+    %s
+  }
+}
+%s
+func $__lldb_expr(_ $__lldb_arg : UnsafeMutablePointer<Any>) {
+  do {
+    $__lldb_injected_self.$__lldb_wrapped_expr_%u(
+      $__lldb_arg
+    )
+  }
+}
+)",
+                          optional_extension, availability.c_str(),
+                          func_decorator, current_counter,
+                          wrapped_expr_text.GetData(), availability.c_str(),
+                          current_counter);
 
     first_body_line = 5;
   } else {

lldb/source/Plugins/ExpressionParser/Swift/SwiftExpressionParser.cpp

@@ -1230,10 +1230,9 @@ static llvm::Expected<ParsedExpression> ParseAndImport(
 
   // Create the source file. Note, we disable delayed parsing for the
   // swift expression parser.
-  swift::SourceFile *source_file = new (*ast_context) swift::SourceFile(
-      module, source_file_kind, buffer_id, /*Keep tokens*/ false,
-      /*KeepSyntaxTree*/ false,
-      swift::SourceFile::ParsingFlags::DisableDelayedBodies);
+  swift::SourceFile *source_file = new (*ast_context)
+      swift::SourceFile(module, source_file_kind, buffer_id,
+                        swift::SourceFile::ParsingFlags::DisableDelayedBodies);
   module.addFile(*source_file);
 
   // Swift Modules that rely on shared libraries (not frameworks)

lldb/source/Plugins/ExpressionParser/Swift/SwiftREPL.cpp

@@ -571,9 +571,8 @@ void SwiftREPL::CompleteCode(const std::string &current_code,
       repl_module = swift_ast->CreateModule(completion_module_info, error,
                                             importInfo);
       llvm::Optional<unsigned> bufferID;
-      swift::SourceFile *repl_source_file = new (*ast)
-          swift::SourceFile(*repl_module, swift::SourceFileKind::Main, bufferID,
-                            /*Keep tokens*/false);
+      swift::SourceFile *repl_source_file = new (*ast) swift::SourceFile(
+          *repl_module, swift::SourceFileKind::Main, bufferID);
       repl_module->addFile(*repl_source_file);
       swift::performImportResolution(*repl_source_file);
       m_completion_module_initialized = true;