fix(clion): Add Xcode information to Cpp compiler wrapper

base/src/com/google/idea/blaze/base/command/BlazeCommandName.java

@@ -37,6 +37,7 @@ public final class BlazeCommandName {
   public static final BlazeCommandName RUN = fromString("run");
   public static final BlazeCommandName BUILD = fromString("build");
   public static final BlazeCommandName QUERY = fromString("query");
+  public static final BlazeCommandName CQUERY = fromString("cquery");
   public static final BlazeCommandName INFO = fromString("info");
   public static final BlazeCommandName MOBILE_INSTALL = fromString("mobile-install");
   public static final BlazeCommandName COVERAGE = fromString("coverage");

cpp/BUILD

@@ -65,6 +65,18 @@ java_library(
     ],
 )
 
+java_library(
+    name = "mock_xcode_settings_provider",
+    testonly = 1,
+    srcs = ["tests/utils/com/google/idea/blaze/cpp/MockXcodeSettingsProvider.java"],
+    visibility = PLUGIN_PACKAGES_VISIBILITY,
+    deps = [
+        ":cpp",
+        "//base",
+        "//intellij_platform_sdk:plugin_api",
+    ],
+)
+
 # exposed so plugins can optionally depend on it
 java_library(
     name = "compiler_version_checker",
@@ -96,6 +108,7 @@ intellij_unit_test_suite(
     runtime_deps = ["//intellij_platform_sdk:test_libs"],
     deps = [
         ":cpp",
+        ":mock_xcode_settings_provider",
         "//base",
         "//base:unit_test_utils",
         "//common/experiments",

cpp/src/META-INF/blaze-cpp.xml

@@ -46,6 +46,8 @@
   </extensions>
   <extensions defaultExtensionNs="com.intellij">
     <projectService serviceImplementation="com.google.idea.blaze.cpp.BlazeCompilerInfoMapService"/>
+    <projectService serviceInterface="com.google.idea.blaze.cpp.XcodeCompilerSettingsProvider"
+                    serviceImplementation="com.google.idea.blaze.cpp.XcodeCompilerSettingsProviderImpl"/>
     <registryKey defaultValue="false" description="Disable absolute path trimming in debug clang builds" key="bazel.trim.absolute.path.disabled"/>
     <applicationService serviceInterface="com.google.idea.blaze.cpp.CompilerVersionChecker"
                         serviceImplementation="com.google.idea.blaze.cpp.CompilerVersionCheckerImpl"/>

cpp/src/com/google/idea/blaze/cpp/BlazeCompilerSettings.java

@@ -16,6 +16,7 @@
 package com.google.idea.blaze.cpp;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.jetbrains.cidr.lang.CLanguageKind;
@@ -32,19 +33,22 @@ final class BlazeCompilerSettings {
   private final ImmutableList<String> cCompilerSwitches;
   private final ImmutableList<String> cppCompilerSwitches;
   private final String compilerVersion;
+  private final ImmutableMap<String, String> compilerEnvironment;
 
   BlazeCompilerSettings(
       Project project,
       @Nullable File cCompiler,
       @Nullable File cppCompiler,
       ImmutableList<String> cFlags,
       ImmutableList<String> cppFlags,
-      String compilerVersion) {
+      String compilerVersion,
+      ImmutableMap<String, String> compilerEnvironment) {
     this.cCompiler = cCompiler;
     this.cppCompiler = cppCompiler;
     this.cCompilerSwitches = ImmutableList.copyOf(getCompilerSwitches(project, cFlags));
     this.cppCompilerSwitches = ImmutableList.copyOf(getCompilerSwitches(project, cppFlags));
     this.compilerVersion = compilerVersion;
+    this.compilerEnvironment = compilerEnvironment;
   }
 
   OCCompilerKind getCompiler(OCLanguageKind languageKind) {
@@ -81,4 +85,8 @@ private static List<String> getCompilerSwitches(Project project, List<String> al
   String getCompilerVersion() {
     return compilerVersion;
   }
+
+  String getCompilerEnvironment(String variable) {
+    return compilerEnvironment.get(variable);
+  }
 }

cpp/src/com/google/idea/blaze/cpp/BlazeConfigurationResolver.java

@@ -45,6 +45,7 @@
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.io.FileUtilRt;
+import java.util.Optional;
 import org.jetbrains.annotations.NotNull;
 
 import javax.annotation.Nullable;
@@ -84,13 +85,19 @@ public BlazeConfigurationResolverResult update(
     ImmutableMap<TargetKey, CToolchainIdeInfo> toolchainLookupMap =
         BlazeConfigurationToolchainResolver.buildToolchainLookupMap(
             context, blazeProjectData.getTargetMap());
+
+    Optional<XcodeCompilerSettings> xcodeSettings =
+            BlazeConfigurationToolchainResolver.resolveXcodeCompilerSettings(context, project);
+
     ImmutableMap<CToolchainIdeInfo, BlazeCompilerSettings> compilerSettings =
         BlazeConfigurationToolchainResolver.buildCompilerSettingsMap(
             context,
             project,
             toolchainLookupMap,
             executionRootPathResolver,
-            oldResult.getCompilerSettings());
+            oldResult.getCompilerSettings(),
+            xcodeSettings
+        );
 
     ImmutableMap<String, String> targetToVersion = getTargetToVersionMap(toolchainLookupMap, compilerSettings);
     ProjectViewTargetImportFilter projectViewFilter =
@@ -106,6 +113,8 @@ public BlazeConfigurationResolverResult update(
             context, blazeProjectData, toolchainLookupMap, targetFilter, executionRootPathResolver);
     builder.setValidHeaderRoots(validHeaderRoots);
     builder.setTargetToVersionMap(targetToVersion);
+    builder.setXcodeSettings(xcodeSettings);
+
     return builder.build();
   }
 

cpp/src/com/google/idea/blaze/cpp/BlazeConfigurationResolverResult.java

@@ -20,6 +20,7 @@
 import com.google.common.collect.ImmutableSet;
 import com.google.idea.blaze.base.ideinfo.CToolchainIdeInfo;
 
+import java.util.Optional;
 import javax.annotation.concurrent.Immutable;
 import java.io.File;
 import java.util.Map;
@@ -35,16 +36,19 @@ final class BlazeConfigurationResolverResult {
   private final ImmutableMap<CToolchainIdeInfo, BlazeCompilerSettings> compilerSettings;
   private final ImmutableSet<File> validHeaderRoots;
   private final ImmutableMap<String, String> targetToCompilerVersion;
+  private final Optional<XcodeCompilerSettings> xcodeProperties;
 
   private BlazeConfigurationResolverResult(
       ImmutableMap<BlazeResolveConfigurationData, BlazeResolveConfiguration> uniqueResolveConfigurations,
       ImmutableMap<CToolchainIdeInfo, BlazeCompilerSettings> compilerSettings,
       ImmutableSet<File> validHeaderRoots,
-      ImmutableMap<String, String> targetToCompilerVersion) {
+      ImmutableMap<String, String> targetToCompilerVersion,
+      Optional<XcodeCompilerSettings> xcodeProperties) {
     this.uniqueResolveConfigurations = uniqueResolveConfigurations;
     this.compilerSettings = compilerSettings;
     this.validHeaderRoots = validHeaderRoots;
     this.targetToCompilerVersion = targetToCompilerVersion;
+    this.xcodeProperties = xcodeProperties;
   }
 
   static Builder builder() {
@@ -67,6 +71,10 @@ ImmutableMap<CToolchainIdeInfo, BlazeCompilerSettings> getCompilerSettings() {
     return compilerSettings;
   }
 
+  public Optional<XcodeCompilerSettings> getXcodeProperties() {
+    return xcodeProperties;
+  }
+
   boolean isValidHeaderRoot(File absolutePath) {
     return validHeaderRoots.contains(absolutePath);
   }
@@ -84,7 +92,8 @@ boolean isEquivalentConfigurations(BlazeConfigurationResolverResult other) {
         return false;
       }
     }
-    return validHeaderRoots.equals(other.validHeaderRoots);
+    return validHeaderRoots.equals(other.validHeaderRoots) &&
+        xcodeProperties.equals(other.xcodeProperties);
   }
 
   public ImmutableMap<String, String> getTargetToCompilerVersion() {
@@ -96,13 +105,15 @@ static class Builder {
         ImmutableMap.of();
     ImmutableMap<CToolchainIdeInfo, BlazeCompilerSettings> compilerSettings = ImmutableMap.of();
     ImmutableSet<File> validHeaderRoots = ImmutableSet.of();
+    Optional<XcodeCompilerSettings> xcodeSettings;
     private ImmutableMap<String, String> setTargetToVersionMap;
 
     public Builder() {}
 
     BlazeConfigurationResolverResult build() {
       return new BlazeConfigurationResolverResult(
-          uniqueConfigurations, compilerSettings, validHeaderRoots, setTargetToVersionMap);
+          uniqueConfigurations, compilerSettings, validHeaderRoots, setTargetToVersionMap,
+          xcodeSettings);
     }
 
     void setUniqueConfigurations(
@@ -123,5 +134,10 @@ void setValidHeaderRoots(ImmutableSet<File> validHeaderRoots) {
     public void setTargetToVersionMap(ImmutableMap<String, String> targetToVersionMap) {
       this.setTargetToVersionMap = targetToVersionMap;
     }
+
+    public void setXcodeSettings(
+        Optional<XcodeCompilerSettings> xcodeSettings) {
+      this.xcodeSettings = xcodeSettings;
+    }
   }
 }

cpp/src/com/google/idea/blaze/cpp/BlazeConfigurationToolchainResolver.java

@@ -45,6 +45,7 @@
 import com.google.idea.blaze.base.sync.BlazeSyncManager;
 import com.google.idea.blaze.base.sync.workspace.ExecutionRootPathResolver;
 import com.google.idea.blaze.cpp.CompilerVersionChecker.VersionCheckException;
+import com.google.idea.blaze.cpp.XcodeCompilerSettingsProvider.XcodeCompilerSettingsException;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.project.Project;
 import com.intellij.pom.NavigatableAdapter;
@@ -55,6 +56,7 @@
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutionException;
@@ -187,19 +189,24 @@ private static boolean usesAppleCcToolchain(TargetIdeInfo target) {
         .anyMatch(s -> s.startsWith("//tools/osx/crosstool"));
   }
 
-  /** Returns the compiler settings for each toolchain. */
+  /**
+   * Returns the compiler settings for each toolchain.
+   */
   static ImmutableMap<CToolchainIdeInfo, BlazeCompilerSettings> buildCompilerSettingsMap(
       BlazeContext context,
       Project project,
       ImmutableMap<TargetKey, CToolchainIdeInfo> toolchainLookupMap,
       ExecutionRootPathResolver executionRootPathResolver,
-      ImmutableMap<CToolchainIdeInfo, BlazeCompilerSettings> oldCompilerSettings) {
+      ImmutableMap<CToolchainIdeInfo, BlazeCompilerSettings> oldCompilerSettings,
+      Optional<XcodeCompilerSettings> xcodeCompilerSettings
+  ) {
     return Scope.push(
         context,
         childContext -> {
           childContext.push(new TimingScope("Build compiler settings map", EventType.Other));
           return doBuildCompilerSettingsMap(
-              context, project, toolchainLookupMap, executionRootPathResolver, oldCompilerSettings);
+              context, project, toolchainLookupMap, executionRootPathResolver,
+              xcodeCompilerSettings, oldCompilerSettings);
         });
   }
 
@@ -208,6 +215,7 @@ private static ImmutableMap<CToolchainIdeInfo, BlazeCompilerSettings> doBuildCom
       Project project,
       ImmutableMap<TargetKey, CToolchainIdeInfo> toolchainLookupMap,
       ExecutionRootPathResolver executionRootPathResolver,
+      Optional<XcodeCompilerSettings> xcodeCompilerSettings,
       ImmutableMap<CToolchainIdeInfo, BlazeCompilerSettings> oldCompilerSettings) {
     Set<CToolchainIdeInfo> toolchains = new HashSet<>(toolchainLookupMap.values());
     List<ListenableFuture<Map.Entry<CToolchainIdeInfo, BlazeCompilerSettings>>>
@@ -226,7 +234,7 @@ private static ImmutableMap<CToolchainIdeInfo, BlazeCompilerSettings> doBuildCom
                   return null;
                 }
                 String compilerVersion =
-                    getCompilerVersion(project, context, executionRootPathResolver, cppExecutable);
+                    getCompilerVersion(project, context, executionRootPathResolver, xcodeCompilerSettings, cppExecutable);
                 if (compilerVersion == null) {
                   return null;
                 }
@@ -239,6 +247,7 @@ private static ImmutableMap<CToolchainIdeInfo, BlazeCompilerSettings> doBuildCom
                     createBlazeCompilerSettings(
                         project,
                         toolchain,
+                        xcodeCompilerSettings,
                         executionRootPathResolver.getExecutionRoot(),
                         cppExecutable,
                         compilerVersion);
@@ -274,11 +283,13 @@ private static String getCompilerVersion(
       Project project,
       BlazeContext context,
       ExecutionRootPathResolver executionRootPathResolver,
+      Optional<XcodeCompilerSettings> xcodeCompilerSettings,
       File cppExecutable) {
     File executionRoot = executionRootPathResolver.getExecutionRoot();
+    ImmutableMap<String, String> compilerEnvFlags = XcodeCompilerSettingsProvider.getInstance(project).asEnvironmentVariables(xcodeCompilerSettings);
     try {
       return CompilerVersionChecker.getInstance()
-          .checkCompilerVersion(executionRoot, cppExecutable);
+          .checkCompilerVersion(executionRoot, cppExecutable, compilerEnvFlags);
     } catch (VersionCheckException e) {
       switch (e.kind) {
         case MISSING_EXEC_ROOT:
@@ -323,12 +334,15 @@ public void navigate(boolean requestFocus) {
   private static BlazeCompilerSettings createBlazeCompilerSettings(
       Project project,
       CToolchainIdeInfo toolchainIdeInfo,
+      Optional<XcodeCompilerSettings> xcodeCompilerSettings,
       File executionRoot,
       File cppExecutable,
       String compilerVersion) {
+    ImmutableMap<String, String> compilerWrapperEnvVars =
+        XcodeCompilerSettingsProvider.getInstance(project).asEnvironmentVariables(xcodeCompilerSettings);
     File compilerWrapper =
         CompilerWrapperProvider.getInstance()
-            .createCompilerExecutableWrapper(executionRoot, cppExecutable);
+            .createCompilerExecutableWrapper(executionRoot, cppExecutable, compilerWrapperEnvVars);
     if (compilerWrapper == null) {
       return null;
     }
@@ -337,16 +351,35 @@ private static BlazeCompilerSettings createBlazeCompilerSettings(
 
     ImmutableList.Builder<String> cppFlagsBuilder = ImmutableList.builder();
     cppFlagsBuilder.addAll(toolchainIdeInfo.getCppCompilerOptions());
+
+    ImmutableMap.Builder<String, String> compilerEnv = ImmutableMap.builder();
+    compilerEnv.putAll(compilerWrapperEnvVars);
     return new BlazeCompilerSettings(
         project,
         compilerWrapper,
         compilerWrapper,
         cFlagsBuilder.build(),
         cppFlagsBuilder.build(),
-        compilerVersion);
+        compilerVersion,
+        compilerEnv.build());
   }
 
   private static <T> ListenableFuture<T> submit(Callable<T> callable) {
     return BlazeExecutor.getInstance().submit(callable);
   }
+
+  public static Optional<XcodeCompilerSettings> resolveXcodeCompilerSettings(BlazeContext context,
+      Project project) {
+    return Scope.push(
+        context,
+        childContext -> {
+          childContext.push(new TimingScope("Resolve Xcode information", EventType.Other));
+          try {
+            return XcodeCompilerSettingsProvider.getInstance(project).fromContext(context, project);
+          } catch (XcodeCompilerSettingsException e) {
+            IssueOutput.warn(String.format("There was an error fetching the Xcode information from the build: %s\n\nSome C++ functionality may not be available.", e.toString()));
+            return Optional.empty();
+          }
+        });
+  }
 }

cpp/src/com/google/idea/blaze/cpp/CompilerVersionChecker.java

@@ -15,6 +15,7 @@
  */
 package com.google.idea.blaze.cpp;
 
+import com.google.common.collect.ImmutableMap;
 import com.intellij.openapi.components.ServiceManager;
 import java.io.File;
 
@@ -44,5 +45,6 @@ public VersionCheckException(IssueKind kind, String message) {
   }
 
   /** Returns the compiler's version string */
-  String checkCompilerVersion(File executionRoot, File cppExecutable) throws VersionCheckException;
+  String checkCompilerVersion(
+      File executionRoot, File cppExecutable, ImmutableMap<String, String> checkerEnv) throws VersionCheckException;
 }

cpp/src/com/google/idea/blaze/cpp/CompilerVersionCheckerImpl.java

@@ -15,6 +15,7 @@
  */
 package com.google.idea.blaze.cpp;
 
+import com.google.common.collect.ImmutableMap;
 import com.google.idea.blaze.base.async.process.ExternalTask;
 import com.google.idea.blaze.cpp.CompilerVersionChecker.VersionCheckException.IssueKind;
 import java.io.ByteArrayOutputStream;
@@ -24,8 +25,9 @@
 public class CompilerVersionCheckerImpl implements CompilerVersionChecker {
 
   @Override
-  public String checkCompilerVersion(File executionRoot, File cppExecutable)
-      throws VersionCheckException {
+  public String checkCompilerVersion(File executionRoot, File cppExecutable,
+      ImmutableMap<String, String> checkerEnv)
+  throws VersionCheckException {
     if (!executionRoot.exists()) {
       throw new VersionCheckException(IssueKind.MISSING_EXEC_ROOT, "");
     }
@@ -39,6 +41,7 @@ public String checkCompilerVersion(File executionRoot, File cppExecutable)
             .args(cppExecutable.toString())
             // NOTE: this won't work with MSVC if we ever support that (check CToolchainIdeInfo?)
             .args("--version")
+            .environmentVars(checkerEnv)
             .stdout(outputStream)
             .stderr(errStream)
             .build()