Remove source specific build variables from C++ API.

The only use case was for Objective-C rules so that different set of sources specified in the same rule could be compiled with either ARC or no ARC. To replace source specific build variables, we call into CcLibraryHelper twice for each set of sources.

This has led to separating the building of compilation providers and outputs from those related to linking. In the case of Objective-C, the compilation outputs are merged and then passed to a single invocation of linking in CcLibraryHelper.

In a later CL, the distinction between compilation and linking will be refined by separating them in different classes.

RELNOTES:none
PiperOrigin-RevId: 179167102

1 files changed, 162 insertions, 50 deletions

diff --git a/src/main/java/com/google/devtools/build/lib/rules/objc/CompilationSupport.java b/src/main/java/com/google/devtools/build/lib/rules/objc/CompilationSupport.java
index bfca258170..c41c162a17 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/objc/CompilationSupport.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/objc/CompilationSupport.java
@@ -87,6 +87,7 @@ import com.google.devtools.build.lib.rules.apple.ApplePlatform.PlatformType;
 import com.google.devtools.build.lib.rules.apple.AppleToolchain;
 import com.google.devtools.build.lib.rules.apple.XcodeConfig;
 import com.google.devtools.build.lib.rules.apple.XcodeConfigProvider;
+import com.google.devtools.build.lib.rules.cpp.CcCompilationOutputs;
 import com.google.devtools.build.lib.rules.cpp.CcLibraryHelper;
 import com.google.devtools.build.lib.rules.cpp.CcLibraryHelper.Info;
 import com.google.devtools.build.lib.rules.cpp.CcToolchain;
@@ -94,6 +95,7 @@ import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.CollidingProv
 import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.FeatureConfiguration;
 import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.Variables.VariablesExtension;
 import com.google.devtools.build.lib.rules.cpp.CcToolchainProvider;
+import com.google.devtools.build.lib.rules.cpp.CppCompilationContext;
 import com.google.devtools.build.lib.rules.cpp.CppCompileAction;
 import com.google.devtools.build.lib.rules.cpp.CppFileTypes;
 import com.google.devtools.build.lib.rules.cpp.CppHelper;
@@ -117,6 +119,7 @@ import com.google.devtools.build.lib.util.Pair;
 import com.google.devtools.build.lib.vfs.FileSystemUtils;
 import com.google.devtools.build.lib.vfs.PathFragment;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.LinkedHashSet;
 import java.util.List;
@@ -297,27 +300,21 @@ public class CompilationSupport {
     }
   }
 
-  private CcLibraryHelper createCcLibraryHelper(
+  private Info.CompilationInfo compile(
       ObjcProvider objcProvider,
-      CompilationArtifacts compilationArtifacts,
       VariablesExtension extension,
       ExtraCompileArgs extraCompileArgs,
       CcToolchainProvider ccToolchain,
       FdoSupportProvider fdoSupport,
-      Iterable<PathFragment> priorityHeaders) {
-    PrecompiledFiles precompiledFiles = new PrecompiledFiles(ruleContext);
-    Collection<Artifact> arcSources = ImmutableSortedSet.copyOf(compilationArtifacts.getSrcs());
-    Collection<Artifact> nonArcSources =
-        ImmutableSortedSet.copyOf(compilationArtifacts.getNonArcSrcs());
-    Collection<Artifact> privateHdrs =
-        ImmutableSortedSet.copyOf(compilationArtifacts.getPrivateHdrs());
-    Collection<Artifact> publicHdrs =
-        Stream.concat(
-                Streams.stream(attributes.hdrs()),
-                Streams.stream(compilationArtifacts.getAdditionalHdrs()))
-            .collect(toImmutableSortedSet(naturalOrder()));
-    Artifact pchHdr = getPchFile().orNull();
-    ObjcCppSemantics semantics = createObjcCppSemantics(objcProvider, privateHdrs, pchHdr);
+      Iterable<PathFragment> priorityHeaders,
+      PrecompiledFiles precompiledFiles,
+      Collection<Artifact> sources,
+      Collection<Artifact> privateHdrs,
+      Collection<Artifact> publicHdrs,
+      Artifact pchHdr,
+      ObjcCppSemantics semantics,
+      String purpose)
+      throws RuleErrorException, InterruptedException {
     CcLibraryHelper result =
         new CcLibraryHelper(
                 ruleContext,
@@ -327,18 +324,12 @@ public class CompilationSupport {
                 ccToolchain,
                 fdoSupport,
                 buildConfiguration)
-            .addSources(arcSources, ImmutableMap.of("objc_arc", ""))
-            .addSources(nonArcSources, ImmutableMap.of("no_objc_arc", ""))
+            .addSources(sources)
             .addSources(privateHdrs)
             .addDefines(objcProvider.get(DEFINE))
             .enableCompileProviders()
             .addPublicHeaders(publicHdrs)
             .addPrecompiledFiles(precompiledFiles)
-            .addDeps(ruleContext.getPrerequisites("deps", Mode.TARGET))
-            // Not all our dependencies need to export cpp information.
-            // For example, objc_proto_library can depend on a proto_library rule that does not
-            // generate C++ protos.
-            .setCheckDepsGenerateCpp(false)
             .setCopts(
                 ImmutableList.<String>builder()
                     .addAll(getCompileRuleCopts())
@@ -352,10 +343,9 @@ public class CompilationSupport {
             .addIncludeDirs(objcProvider.get(INCLUDE))
             .addSystemIncludeDirs(objcProvider.get(INCLUDE_SYSTEM))
             .setCppModuleMap(intermediateArtifacts.moduleMap())
-            .setLinkedArtifactNameSuffix(intermediateArtifacts.archiveFileNameSuffix())
             .setPropagateModuleMapToCompileAction(false)
-            .setNeverLink(true)
-            .addVariableExtension(extension);
+            .addVariableExtension(extension)
+            .setPurpose(purpose);
 
     if (pchHdr != null) {
       result.addNonModuleMapHeader(pchHdr);
@@ -366,7 +356,126 @@ public class CompilationSupport {
     if (getCustomModuleMap(ruleContext).isPresent()) {
       result.doNotGenerateModuleMap();
     }
-    return result;
+
+    return result.compile();
+  }
+
+  private Pair<CcCompilationOutputs, ImmutableMap<String, NestedSet<Artifact>>>
+  ccCompileAndLink(
+          ObjcProvider objcProvider,
+          CompilationArtifacts compilationArtifacts,
+          ObjcVariablesExtension.Builder extensionBuilder,
+          ExtraCompileArgs extraCompileArgs,
+          CcToolchainProvider ccToolchain,
+          FdoSupportProvider fdoSupport,
+          Iterable<PathFragment> priorityHeaders,
+          LinkTargetType linkType,
+          Artifact linkActionInput)
+          throws RuleErrorException, InterruptedException {
+    PrecompiledFiles precompiledFiles = new PrecompiledFiles(ruleContext);
+    Collection<Artifact> arcSources = ImmutableSortedSet.copyOf(compilationArtifacts.getSrcs());
+    Collection<Artifact> nonArcSources =
+        ImmutableSortedSet.copyOf(compilationArtifacts.getNonArcSrcs());
+    Collection<Artifact> privateHdrs =
+        ImmutableSortedSet.copyOf(compilationArtifacts.getPrivateHdrs());
+    Collection<Artifact> publicHdrs =
+        Stream.concat(
+                Streams.stream(attributes.hdrs()),
+                Streams.stream(compilationArtifacts.getAdditionalHdrs()))
+            .collect(toImmutableSortedSet(naturalOrder()));
+    Artifact pchHdr = getPchFile().orNull();
+    ObjcCppSemantics semantics = createObjcCppSemantics(objcProvider, privateHdrs, pchHdr);
+
+    String purpose = String.format("%s_objc_arc", semantics.getPurpose());
+    extensionBuilder.setArcEnabled(true);
+    Info.CompilationInfo objcArcCompilationInfo =
+        compile(
+            objcProvider,
+            extensionBuilder.build(),
+            extraCompileArgs,
+            ccToolchain,
+            fdoSupport,
+            priorityHeaders,
+            precompiledFiles,
+            arcSources,
+            privateHdrs,
+            publicHdrs,
+            pchHdr,
+            semantics,
+            purpose);
+
+    purpose = String.format("%s_non_objc_arc", semantics.getPurpose());
+    extensionBuilder.setArcEnabled(false);
+    Info.CompilationInfo nonObjcArcCompilationInfo =
+        compile(
+            objcProvider,
+            extensionBuilder.build(),
+            extraCompileArgs,
+            ccToolchain,
+            fdoSupport,
+            priorityHeaders,
+            precompiledFiles,
+            nonArcSources,
+            privateHdrs,
+            publicHdrs,
+            pchHdr,
+            semantics,
+            purpose);
+
+    CcLibraryHelper resultLink =
+        new CcLibraryHelper(
+                ruleContext,
+                semantics,
+                getFeatureConfiguration(ruleContext, ccToolchain, buildConfiguration, objcProvider),
+                CcLibraryHelper.SourceCategory.CC_AND_OBJC,
+                ccToolchain,
+                fdoSupport,
+                buildConfiguration)
+            .addPrecompiledFiles(precompiledFiles)
+            .addDeps(ruleContext.getPrerequisites("deps", Mode.TARGET))
+            // Not all our dependencies need to export cpp information.
+            // For example, objc_proto_library can depend on a proto_library rule that does not
+            // generate C++ protos.
+            .setCheckDepsGenerateCpp(false)
+            .setLinkedArtifactNameSuffix(intermediateArtifacts.archiveFileNameSuffix())
+            .setNeverLink(true)
+            .addVariableExtension(extensionBuilder.build());
+
+    if (linkType != null) {
+      resultLink.setLinkType(linkType);
+    }
+
+    if (linkActionInput != null) {
+      resultLink.addLinkActionInput(linkActionInput);
+    }
+
+    CppCompilationContext.Builder compilationContextBuilder =
+        new CppCompilationContext.Builder(ruleContext);
+    compilationContextBuilder.mergeDependentContexts(
+        Arrays.asList(
+            objcArcCompilationInfo.getCppCompilationContext(),
+            nonObjcArcCompilationInfo.getCppCompilationContext()));
+    compilationContextBuilder.setPurpose(
+        String.format("%s_merged_arc_non_arc_objc", semantics.getPurpose()));
+    semantics.setupCompilationContext(ruleContext, compilationContextBuilder);
+
+    CcCompilationOutputs.Builder compilationOutputsBuilder = new CcCompilationOutputs.Builder();
+    compilationOutputsBuilder.merge(objcArcCompilationInfo.getCcCompilationOutputs());
+    compilationOutputsBuilder.merge(nonObjcArcCompilationInfo.getCcCompilationOutputs());
+
+    Info.LinkingInfo linkingInfo =
+        resultLink.link(
+            compilationOutputsBuilder.build(), compilationContextBuilder.build());
+
+    List<Map<String, NestedSet<Artifact>>> outputGroupsList =
+        Arrays.asList(
+            objcArcCompilationInfo.getOutputGroups(),
+            nonObjcArcCompilationInfo.getOutputGroups(),
+            linkingInfo.getOutputGroups());
+
+    Map<String, NestedSet<Artifact>> mergedOutputGroups = Info.mergeOutputGroups(outputGroupsList);
+
+    return new Pair<>(compilationOutputsBuilder.build(), ImmutableMap.copyOf(mergedOutputGroups));
   }
 
   private ObjcCppSemantics createObjcCppSemantics(
@@ -453,16 +562,17 @@ public class CompilationSupport {
   }
 
   private void registerHeaderScanningActions(
-      Info info, ObjcProvider objcProvider, CompilationArtifacts compilationArtifacts) {
+      CcCompilationOutputs ccCompilationOutputs,
+      ObjcProvider objcProvider,
+      CompilationArtifacts compilationArtifacts) {
     // PIC is not used for Obj-C builds, if that changes this method will need to change
-    if (!isHeaderThinningEnabled()
-        || info.getCcCompilationOutputs().getObjectFiles(false).isEmpty()) {
+    if (!isHeaderThinningEnabled() || ccCompilationOutputs.getObjectFiles(false).isEmpty()) {
       return;
     }
 
     ImmutableList.Builder<ObjcHeaderThinningInfo> headerThinningInfos = ImmutableList.builder();
     AnalysisEnvironment analysisEnvironment = ruleContext.getAnalysisEnvironment();
-    for (Artifact objectFile : info.getCcCompilationOutputs().getObjectFiles(false)) {
+    for (Artifact objectFile : ccCompilationOutputs.getObjectFiles(false)) {
       ActionAnalysisMetadata generatingAction =
           analysisEnvironment.getLocalGeneratingAction(objectFile);
       if (generatingAction instanceof CppCompileAction) {
@@ -947,7 +1057,8 @@ public class CompilationSupport {
             .setCompilationArtifacts(compilationArtifacts)
             .setIntermediateArtifacts(intermediateArtifacts)
             .setConfiguration(buildConfiguration);
-    CcLibraryHelper helper;
+
+    Pair<CcCompilationOutputs, ImmutableMap<String, NestedSet<Artifact>>> compilationInfo;
 
     if (compilationArtifacts.getArchive().isPresent()) {
       Artifact objList = intermediateArtifacts.archiveObjList();
@@ -957,33 +1068,34 @@ public class CompilationSupport {
 
       extension.addVariableCategory(VariableCategory.ARCHIVE_VARIABLES);
 
-      helper =
-          createCcLibraryHelper(
-                  objcProvider,
-                  compilationArtifacts,
-                  extension.build(),
-                  extraCompileArgs,
-                  ccToolchain,
-                  fdoSupport,
-                  priorityHeaders)
-              .setLinkType(LinkTargetType.OBJC_ARCHIVE)
-              .addLinkActionInput(objList);
+      compilationInfo =
+          ccCompileAndLink(
+              objcProvider,
+              compilationArtifacts,
+              extension,
+              extraCompileArgs,
+              ccToolchain,
+              fdoSupport,
+              priorityHeaders,
+              LinkTargetType.OBJC_ARCHIVE,
+              objList);
     } else {
-      helper =
-          createCcLibraryHelper(
+      compilationInfo =
+          ccCompileAndLink(
               objcProvider,
               compilationArtifacts,
-              extension.build(),
+              extension,
               extraCompileArgs,
               ccToolchain,
               fdoSupport,
-              priorityHeaders);
+              priorityHeaders,
+              /* linkType */ null,
+              /* linkActionInput */ null);
     }
 
-    Info info = helper.build();
-    outputGroupCollector.putAll(info.getOutputGroups());
+    outputGroupCollector.putAll(compilationInfo.getSecond());
 
-    registerHeaderScanningActions(info, objcProvider, compilationArtifacts);
+    registerHeaderScanningActions(compilationInfo.getFirst(), objcProvider, compilationArtifacts);
 
     return this;
   }