Implement preliminary support for deserializing cc1 flags in Swift modules.

There is no functional change on all other code paths.  Support for
cc1 flags isn't complete.  Since cc1 flags are not stable it's not
feasible to keep a list of all multi-arg flags, for example. It also
makes it difficult to correctly identify where working directories and
path remappings should applied. For all these reasons, using cc1 flags
for anything but a local build with explicit modules and precise
compiler invocations isn't supported yet.

rdar://133249595

Author: adrian-prantl

lldb/source/Plugins/TypeSystem/Swift/SwiftASTContext.cpp

@@ -1573,7 +1573,21 @@ bool ShouldUnique(StringRef arg) {
 
 // static
 void SwiftASTContext::AddExtraClangArgs(const std::vector<std::string> &source,
-                                        std::vector<std::string> &dest) {
+                                        std::vector<std::string> &dest,
+                                        bool cc1) {
+  // FIXME: Support for cc1 flags isn't complete.  The uniquing
+  // algortihm below does not work for cc1 flags. Since cc1 flags are
+  // not stable it's not feasible to keep a list of all multi-arg
+  // flags, for example. It also makes it difficult to correctly
+  // identify where workng directories and path remappings should
+  // applied. For all these reasons, using cc1 flags for anything but
+  // a local build with explicit modules and precise compiler
+  // invocations isn't supported yet.
+  if (cc1) {
+    dest.insert(dest.end(), source.begin(), source.end());
+    return;
+  }
+
   llvm::StringSet<> unique_flags;
   for (auto &arg : dest)
     unique_flags.insert(arg);
@@ -1751,11 +1765,27 @@ static void applyOverrideOptions(std::vector<std::string> &args,
 void SwiftASTContext::AddExtraClangArgs(
     const std::vector<std::string> &ExtraArgs, StringRef overrideOpts) {
   swift::ClangImporterOptions &importer_options = GetClangImporterOptions();
-  AddExtraClangArgs(ExtraArgs, importer_options.ExtraArgs);
+
+  // Detect cc1 flags.  When DirectClangCC1ModuleBuild is on then the
+  // clang arguments in the serialized invocation are clang cc1 flags,
+  // which are very specific to one compiler version and cannot
+  // be merged with driver options.
+  bool fresh_invocation = importer_options.ExtraArgs.empty();
+  if (fresh_invocation && !ExtraArgs.empty() && ExtraArgs.front() == "-cc1")
+    importer_options.DirectClangCC1ModuleBuild = true;
+  if (!importer_options.DirectClangCC1ModuleBuild && !ExtraArgs.empty() &&
+      ExtraArgs.front() == "-cc1")
+    AddDiagnostic(
+        eSeverityWarning,
+        "Mixing and matching of driver and cc1 Clang options detected");
+
+  AddExtraClangArgs(ExtraArgs, importer_options.ExtraArgs,
+                    importer_options.DirectClangCC1ModuleBuild);
   applyOverrideOptions(importer_options.ExtraArgs, overrideOpts);
   if (HasNonexistentExplicitModule(importer_options.ExtraArgs))
     RemoveExplicitModules(importer_options.ExtraArgs);
 
+  // Detect explicitly-built modules.
   m_has_explicit_modules =
       llvm::any_of(importer_options.ExtraArgs, [](const std::string &arg) {
         return StringRef(arg).starts_with("-fmodule-file=");
@@ -1864,6 +1894,11 @@ void SwiftASTContext::FilterClangImporterOptions(
         arg_sr == "-fno-implicit-module-maps")
       continue;
 
+    // This is not a cc1 option.
+    if (arg_sr.starts_with("--target=") && ctx &&
+        ctx->GetClangImporterOptions().DirectClangCC1ModuleBuild)
+      continue;
+
     // The VFS options turn into fatal errors when the referenced file
     // is not found. Since the Xcode build system tends to create a
     // lot of VFS overlays by default, stat them and emit a warning if
@@ -1889,6 +1924,7 @@ void SwiftASTContext::FilterClangImporterOptions(
       // Keep it.
       extra_args.push_back(ivfs_arg);
     }
+
     extra_args.push_back(std::move(arg));
   }
 }

lldb/source/Plugins/TypeSystem/Swift/SwiftASTContext.h

@@ -279,7 +279,7 @@ class SwiftASTContext : public TypeSystemSwift {
   void AddExtraClangArgs(const std::vector<std::string> &ExtraArgs,
                          llvm::StringRef overrideOpts = "");
   static void AddExtraClangArgs(const std::vector<std::string>& source,
-                                std::vector<std::string>& dest);
+                                std::vector<std::string>& dest, bool cc1);
   static std::string GetPluginServer(llvm::StringRef plugin_library_path);
   /// Removes nonexisting VFS overlay options.
   static void FilterClangImporterOptions(std::vector<std::string> &extra_args,

lldb/test/API/lang/swift/clangimporter/explicit_cc1/Makefile

@@ -0,0 +1,5 @@
+SWIFT_SOURCES := main.swift
+SWIFT_ENABLE_EXPLICIT_MODULES := YES
+SWIFTFLAGS_EXTRAS = -I$(SRCDIR) -Xfrontend -experimental-clang-importer-direct-cc1-scan
+
+include Makefile.rules

lldb/test/API/lang/swift/clangimporter/explicit_cc1/TestSwiftClangImporterExplicitCC1.py

@@ -0,0 +1,29 @@
+import lldb
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.decorators import *
+import lldbsuite.test.lldbutil as lldbutil
+import unittest2
+
+class TestSwiftClangImporterExplicitCC1(TestBase):
+
+    NO_DEBUG_INFO_TESTCASE = True
+
+    # Don't run ClangImporter tests if Clangimporter is disabled.
+    @skipIf(setting=('symbols.use-swift-clangimporter', 'false'))
+    @skipIf(setting=('symbols.swift-precise-compiler-invocation', 'false'))
+    @skipIf(setting=('plugin.typesystem.clang.experimental-redecl-completion', 'true'), bugnumber='rdar://128094135')
+    @skipUnlessDarwin
+    @swiftTest
+    def test(self):
+        """
+        Test flipping on/off implicit modules.
+        """
+        self.build()
+        lldbutil.run_to_source_breakpoint(self, "break here",
+                                          lldb.SBFileSpec('main.swift'))
+        log = self.getBuildArtifact("types.log")
+        self.expect('log enable lldb types -f "%s"' % log)
+        self.expect("expression obj", DATA_TYPES_DISPLAYED_CORRECTLY,
+                    substrs=["b ="])
+        self.filecheck('platform shell cat "%s"' % log, __file__)
+#       CHECK:  SwiftASTContextForExpressions(module: "a", cu: "main.swift")::LogConfiguration() --     -cc1

lldb/test/API/lang/swift/clangimporter/explicit_cc1/a.h

@@ -0,0 +1,5 @@
+#include "b.h"
+
+struct A {
+  struct B b;
+};

lldb/test/API/lang/swift/clangimporter/explicit_cc1/b.h

@@ -0,0 +1 @@
+struct B {};

lldb/test/API/lang/swift/clangimporter/explicit_cc1/main.swift

@@ -0,0 +1,3 @@
+import ClangA
+let obj = A()
+print("break here \(obj)")

lldb/test/API/lang/swift/clangimporter/explicit_cc1/module.modulemap

@@ -0,0 +1,7 @@
+module ClangA {
+  header "a.h"
+}
+
+module ClangB {
+  header "b.h"
+}

lldb/unittests/Symbol/TestSwiftASTContext.cpp

@@ -234,15 +234,15 @@ const std::vector<std::string> uniqued_flags = {
 TEST_F(ClangArgs, UniquingCollisionWithExistingFlags) {
   const std::vector<std::string> source = duplicated_flags;
   std::vector<std::string> dest = uniqued_flags;
-  SwiftASTContext::AddExtraClangArgs(source, dest);
+  SwiftASTContext::AddExtraClangArgs(source, dest, false);
 
   EXPECT_EQ(dest, uniqued_flags);
 }
 
 TEST_F(ClangArgs, UniquingCollisionWithAddedFlags) {
   const std::vector<std::string> source = duplicated_flags;
   std::vector<std::string> dest;
-  SwiftASTContext::AddExtraClangArgs(source, dest);
+  SwiftASTContext::AddExtraClangArgs(source, dest, false);
 
   EXPECT_EQ(dest, uniqued_flags);
 }
@@ -251,7 +251,7 @@ TEST_F(ClangArgs, DoubleDash) {
   // -v with all currently ignored arguments following.
   const std::vector<std::string> source{"-v", "--", "-Werror", ""};
   std::vector<std::string> dest;
-  SwiftASTContext::AddExtraClangArgs(source, dest);
+  SwiftASTContext::AddExtraClangArgs(source, dest, false);
 
   // Check that all ignored arguments got removed.
   EXPECT_EQ(dest, std::vector<std::string>({"-v"}));