Move CppConfiguration#getCompilerFlags and #getCxxFlags to CcToolchainProvider.

This is required to migrate the c++ rules to use platform based toolchain selection.

PiperOrigin-RevId: 179552579

2 files changed, 119 insertions, 16 deletions

diff --git a/src/test/java/com/google/devtools/build/lib/rules/cpp/CcToolchainTest.java b/src/test/java/com/google/devtools/build/lib/rules/cpp/CcToolchainTest.java
index 757c97d57f..86414b8cfe 100644
--- a/src/test/java/com/google/devtools/build/lib/rules/cpp/CcToolchainTest.java
+++ b/src/test/java/com/google/devtools/build/lib/rules/cpp/CcToolchainTest.java
@@ -15,15 +15,22 @@
 package com.google.devtools.build.lib.rules.cpp;
 
 import static com.google.common.truth.Truth.assertThat;
+import static com.google.devtools.build.lib.testutil.MoreAsserts.assertDoesNotContainSublist;
 import static org.junit.Assert.fail;
 
+import com.google.common.collect.ImmutableList;
 import com.google.devtools.build.lib.actions.util.ActionsTestUtil;
 import com.google.devtools.build.lib.analysis.ConfiguredTarget;
 import com.google.devtools.build.lib.analysis.platform.ToolchainInfo;
 import com.google.devtools.build.lib.analysis.util.BuildViewTestCase;
+import com.google.devtools.build.lib.packages.util.MockCcSupport;
 import com.google.devtools.build.lib.rules.cpp.CppConfiguration.DynamicMode;
 import com.google.devtools.build.lib.view.config.crosstool.CrosstoolConfig;
 import com.google.devtools.common.options.OptionsParsingException;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;
@@ -446,10 +453,7 @@ public class CcToolchainTest extends BuildViewTestCase {
     }
   }
 
-  // Regression test for bug 2088255:
-  // "StringIndexOutOfBoundsException in BuildConfiguration.<init>()"
-  @Test
-  public void testShortLibcVersion() throws Exception {
+  private void writeDummyCcToolchain() throws IOException {
     scratch.file(
         "a/BUILD",
         "filegroup(",
@@ -468,6 +472,13 @@ public class CcToolchainTest extends BuildViewTestCase {
         "    objcopy_files = ':empty',",
         "    dynamic_runtime_libs = [':empty'],",
         "    static_runtime_libs = [':empty'])");
+  }
+
+  // Regression test for bug 2088255:
+  // "StringIndexOutOfBoundsException in BuildConfiguration.<init>()"
+  @Test
+  public void testShortLibcVersion() throws Exception {
+    writeDummyCcToolchain();
 
     getAnalysisMock()
         .ccSupport()
@@ -484,6 +495,100 @@ public class CcToolchainTest extends BuildViewTestCase {
     assertThat(toolchainProvider.getTargetLibc()).isEqualTo("2.3.6");
   }
 
+  @Test
+  public void testParamDfDoubleQueueThresholdFactor() throws Exception {
+    writeDummyCcToolchain();
+    useConfiguration();
+
+    scratch.file("lib/BUILD", "cc_library(", "   name = 'lib',", "   srcs = ['a.cc'],", ")");
+
+    ConfiguredTarget lib = getConfiguredTarget("//lib");
+    CcToolchainProvider toolchain =
+        CppHelper.getToolchainUsingDefaultCcToolchainAttribute(getRuleContext(lib));
+
+    assertDoesNotContainSublist(
+        CppHelper.getCompilerOptions(
+            lib.getConfiguration().getFragment(CppConfiguration.class),
+            toolchain,
+            Collections.emptyList()),
+        "--param",
+        "df-double-quote-threshold-factor=0");
+  }
+
+  @Test
+  public void testFeatures() throws Exception {
+    writeDummyCcToolchain();
+
+    String originalCrosstool = analysisMock.ccSupport().readCrosstoolFile();
+    getAnalysisMock()
+        .ccSupport()
+        .setupCrosstoolWithRelease(
+            mockToolsConfig, MockCcSupport.addOptionalDefaultCoptsToCrosstool(originalCrosstool));
+
+    scratch.file("lib/BUILD", "cc_library(", "   name = 'lib',", "   srcs = ['a.cc'],", ")");
+
+    useConfiguration();
+    ConfiguredTarget lib = getConfiguredTarget("//lib");
+    CcToolchainProvider toolchain =
+        CppHelper.getToolchainUsingDefaultCcToolchainAttribute(getRuleContext(lib));
+
+    String defaultSettingFalse = "crosstool_default_false";
+    List<String> copts =
+        CppHelper.getCompilerOptions(
+            lib.getConfiguration().getFragment(CppConfiguration.class),
+            toolchain,
+            Collections.emptyList());
+    assertThat(copts).doesNotContain("-DDEFAULT_FALSE");
+    copts =
+        CppHelper.getCompilerOptions(
+            lib.getConfiguration().getFragment(CppConfiguration.class),
+            toolchain,
+            ImmutableList.of(defaultSettingFalse));
+    assertThat(copts).contains("-DDEFAULT_FALSE");
+
+    useConfiguration("--copt", "-DCOPT");
+    lib = getConfiguredTarget("//lib");
+    toolchain = CppHelper.getToolchainUsingDefaultCcToolchainAttribute(getRuleContext(lib));
+
+    copts =
+        CppHelper.getCompilerOptions(
+            lib.getConfiguration().getFragment(CppConfiguration.class),
+            toolchain,
+            ImmutableList.of(defaultSettingFalse));
+    assertThat(copts).contains("-DDEFAULT_FALSE");
+    assertThat(copts).contains("-DCOPT");
+    assertThat(copts.indexOf("-DDEFAULT_FALSE")).isLessThan(copts.indexOf("-DCOPT"));
+  }
+
+  @Test
+  public void testMergesDefaultCoptsWithUserProvidedOnes() throws Exception {
+    writeDummyCcToolchain();
+    scratch.file("lib/BUILD", "cc_library(", "   name = 'lib',", "   srcs = ['a.cc'],", ")");
+
+    ConfiguredTarget lib = getConfiguredTarget("//lib");
+    CcToolchainProvider toolchain =
+        CppHelper.getToolchainUsingDefaultCcToolchainAttribute(getRuleContext(lib));
+
+    List<String> expected = new ArrayList<>();
+    expected.addAll(
+        CppHelper.getCompilerOptions(
+            lib.getConfiguration().getFragment(CppConfiguration.class),
+            toolchain,
+            Collections.emptyList()));
+    expected.add("-Dfoo");
+
+    useConfiguration("--copt", "-Dfoo");
+    lib = getConfiguredTarget("//lib");
+    toolchain = CppHelper.getToolchainUsingDefaultCcToolchainAttribute(getRuleContext(lib));
+    assertThat(
+            ImmutableList.copyOf(
+                CppHelper.getCompilerOptions(
+                    lib.getConfiguration().getFragment(CppConfiguration.class),
+                    toolchain,
+                    Collections.emptyList())))
+        .isEqualTo(ImmutableList.copyOf(expected));
+  }
+
   public void assertInvalidIncludeDirectoryMessage(String entry, String messageRegex)
       throws Exception {
     try {
diff --git a/src/test/java/com/google/devtools/build/lib/rules/cpp/CrosstoolConfigurationLoaderTest.java b/src/test/java/com/google/devtools/build/lib/rules/cpp/CrosstoolConfigurationLoaderTest.java
index 1d25fc914b..1cc7282f44 100644
--- a/src/test/java/com/google/devtools/build/lib/rules/cpp/CrosstoolConfigurationLoaderTest.java
+++ b/src/test/java/com/google/devtools/build/lib/rules/cpp/CrosstoolConfigurationLoaderTest.java
@@ -203,11 +203,11 @@ public class CrosstoolConfigurationLoaderTest extends AnalysisTestCase {
         .containsExactly(getToolPath("/system-include-dir"));
     assertThat(ccProvider.getSysroot()).isNull();
 
-    assertThat(toolchain.getCompilerOptions(NO_FEATURES))
+    assertThat(CppHelper.getCompilerOptions(toolchain, ccProvider, NO_FEATURES))
         .containsExactly("c", "fastbuild")
         .inOrder();
     assertThat(toolchain.getCOptions()).isEmpty();
-    assertThat(toolchain.getCxxOptions(NO_FEATURES))
+    assertThat(CppHelper.getCxxOptions(toolchain, ccProvider, NO_FEATURES))
         .containsExactly("cxx", "cxx-fastbuild")
         .inOrder();
     assertThat(ccProvider.getUnfilteredCompilerOptions(NO_FEATURES))
@@ -526,11 +526,11 @@ public class CrosstoolConfigurationLoaderTest extends AnalysisTestCase {
     assertThat(ccProviderA.supportsEmbeddedRuntimes()).isTrue();
     assertThat(ccProviderA.toolchainNeedsPic()).isTrue();
 
-    assertThat(toolchainA.getCompilerOptions(NO_FEATURES))
+    assertThat(CppHelper.getCompilerOptions(toolchainA, ccProviderA, NO_FEATURES))
         .containsExactly(
             "compiler-flag-A-1", "compiler-flag-A-2", "fastbuild-flag-A-1", "fastbuild-flag-A-2")
         .inOrder();
-    assertThat(toolchainA.getCxxOptions(NO_FEATURES))
+    assertThat(CppHelper.getCxxOptions(toolchainA, ccProviderA, NO_FEATURES))
         .containsExactly(
             "cxx-flag-A-1", "cxx-flag-A-2", "cxx-fastbuild-flag-A-1", "cxx-fastbuild-flag-A-2")
         .inOrder();
@@ -649,9 +649,9 @@ public class CrosstoolConfigurationLoaderTest extends AnalysisTestCase {
     assertThat(ccProviderC.toolchainNeedsPic()).isFalse();
     assertThat(ccProviderC.supportsFission()).isFalse();
 
-    assertThat(toolchainC.getCompilerOptions(NO_FEATURES)).isEmpty();
+    assertThat(CppHelper.getCompilerOptions(toolchainC, ccProviderC, NO_FEATURES)).isEmpty();
     assertThat(toolchainC.getCOptions()).isEmpty();
-    assertThat(toolchainC.getCxxOptions(NO_FEATURES)).isEmpty();
+    assertThat(CppHelper.getCxxOptions(toolchainC, ccProviderC, NO_FEATURES)).isEmpty();
     assertThat(ccProviderC.getUnfilteredCompilerOptions(NO_FEATURES)).isEmpty();
     assertThat(CppHelper.getDynamicLinkOptions(toolchainC, ccProviderC, NO_FEATURES, true))
         .isEmpty();
@@ -715,12 +715,10 @@ public class CrosstoolConfigurationLoaderTest extends AnalysisTestCase {
             "linker-dbg-flag-B-2",
             "linker-lipo_" + lipoSuffix)
         .inOrder();
-    assertThat(toolchainB.getCompilerOptions(ImmutableList.of("crosstool_fig")))
-        .containsAllOf(
-            "compiler-flag-B-1",
-            "compiler-flag-B-2",
-            "lipo_" + lipoSuffix,
-            "-Wfig")
+    assertThat(
+            CppHelper.getCompilerOptions(
+                toolchainB, ccProviderB, ImmutableList.of("crosstool_fig")))
+        .containsAllOf("compiler-flag-B-1", "compiler-flag-B-2", "lipo_" + lipoSuffix, "-Wfig")
         .inOrder();
   }