Add flags for disabling legacy crosstool fields

This cl adds following flags:
* --experimental_disable_legacy_cc_compilation_api
* --experimental_disable_legacy_cc_linking_api
* --experimental_disable_linking_mode_flags
* --experimental_disable_compilation_mode_flags
* --experimental_disable_legacy_crosstool_fields

RELNOTES: None
PiperOrigin-RevId: 204924599

1 files changed, 233 insertions, 0 deletions

diff --git a/src/test/java/com/google/devtools/build/lib/rules/cpp/CcToolchainProviderTest.java b/src/test/java/com/google/devtools/build/lib/rules/cpp/CcToolchainProviderTest.java
index ce099c9628..9264059f08 100644
--- a/src/test/java/com/google/devtools/build/lib/rules/cpp/CcToolchainProviderTest.java
+++ b/src/test/java/com/google/devtools/build/lib/rules/cpp/CcToolchainProviderTest.java
@@ -15,12 +15,15 @@
 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.assertThrows;
 
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.testing.EqualsTester;
 import com.google.devtools.build.lib.actions.Artifact;
 import com.google.devtools.build.lib.analysis.ConfiguredTarget;
+import com.google.devtools.build.lib.analysis.RuleContext;
+import com.google.devtools.build.lib.analysis.config.CompilationMode;
 import com.google.devtools.build.lib.analysis.util.AnalysisMock;
 import com.google.devtools.build.lib.analysis.util.BuildViewTestCase;
 import com.google.devtools.build.lib.collect.nestedset.NestedSetBuilder;
@@ -182,4 +185,234 @@ public class CcToolchainProviderTest extends BuildViewTestCase {
     List<String> unfilteredCompilerOptions = (List<String>) ct.get("unfiltered_compiler_options");
     assertThat(unfilteredCompilerOptions).contains("--sysroot=/usr/local/custom-sysroot");
   }
+
+  @Test
+  public void testDisablingMostlyStaticLinkOptions() throws Exception {
+    testDisablingLinkingApiMethod("provider.mostly_static_link_options(False)");
+  }
+
+  @Test
+  public void testDisablingFullyStaticLinkOptions() throws Exception {
+    testDisablingLinkingApiMethod("provider.fully_static_link_options(True)");
+  }
+
+  @Test
+  public void testDisablingDynamicLinkOptions() throws Exception {
+    testDisablingLinkingApiMethod("provider.dynamic_link_options(False)");
+  }
+
+  @Test
+  public void testDisablingLinkOptions() throws Exception {
+    testDisablingLinkingApiMethod("provider.link_options_do_not_use");
+  }
+
+  @Test
+  public void testDisablingMostlyStaticLinkOptionsFromConfiguration() throws Exception {
+    testDisablingLinkingApiMethod("ctx.fragments.cpp.mostly_static_link_options([], False)");
+  }
+
+  @Test
+  public void testDisablingFullyStaticLinkOptionsFromConfiguration() throws Exception {
+    testDisablingLinkingApiMethod("ctx.fragments.cpp.fully_static_link_options([], True)");
+  }
+
+  @Test
+  public void testDisablingDynamicLinkOptionsFromConfiguration() throws Exception {
+    testDisablingLinkingApiMethod("ctx.fragments.cpp.dynamic_link_options([], False)");
+  }
+
+  @Test
+  public void testDisablingLinkOptionsFromConfiguration() throws Exception {
+    testDisablingLinkingApiMethod("ctx.fragments.cpp.link_options");
+  }
+
+  private void testDisablingLinkingApiMethod(String method) throws Exception {
+    useConfiguration("--experimental_disable_legacy_cc_linking_api");
+    scratch.file(
+        "test/rule.bzl",
+        "def _impl(ctx):",
+        "  provider = ctx.attr._cc_toolchain[cc_common.CcToolchainInfo]",
+        "  return struct(",
+        "    link_options = " + method + ",",
+        "  )",
+        "",
+        "my_rule = rule(",
+        "  _impl,",
+        "  fragments = [ 'cpp' ],",
+        "  attrs = {'_cc_toolchain': attr.label(default=Label('//test:toolchain')) }",
+        ")");
+    scratch.file(
+        "test/BUILD",
+        "load(':rule.bzl', 'my_rule')",
+        "cc_toolchain_alias(name = 'toolchain')",
+        "my_rule(name = 'target')");
+    AssertionError e =
+        assertThrows(AssertionError.class, () -> getConfiguredTarget("//test:target"));
+    assertThat(e)
+        .hasMessageThat()
+        .contains(
+            "Skylark APIs accessing linking flags has been removed. "
+                + "Use the new API on cc_common.");
+  }
+
+  @Test
+  public void testDisablingCompilerOptions() throws Exception {
+    testDisablingCompilationApiMethod("provider.compiler_options()");
+  }
+
+  @Test
+  public void testDisablingCxxOptions() throws Exception {
+    testDisablingCompilationApiMethod("provider.cxx_options()");
+  }
+
+  @Test
+  public void testDisablingCOptions() throws Exception {
+    testDisablingCompilationApiMethod("provider.c_options()");
+  }
+
+  @Test
+  public void testDisablingUnfilteredOptions() throws Exception {
+    testDisablingCompilationApiMethod("provider.unfiltered_compiler_options([])");
+  }
+
+  @Test
+  public void testDisablingCompilerOptionsFromConfiguration() throws Exception {
+    testDisablingCompilationApiMethod("ctx.fragments.cpp.compiler_options([])");
+  }
+
+  @Test
+  public void testDisablingCxxOptionsFromConfiguration() throws Exception {
+    testDisablingCompilationApiMethod("ctx.fragments.cpp.cxx_options([])");
+  }
+
+  @Test
+  public void testDisablingCOptionsFromConfiguration() throws Exception {
+    testDisablingCompilationApiMethod("ctx.fragments.cpp.c_options");
+  }
+
+  @Test
+  public void testDisablingUnfilteredOptionsFromConfiguration() throws Exception {
+    testDisablingCompilationApiMethod("ctx.fragments.cpp.unfiltered_compiler_options([])");
+  }
+
+  private void testDisablingCompilationApiMethod(String method) throws Exception {
+    useConfiguration("--experimental_disable_legacy_cc_compilation_api");
+    scratch.file(
+        "test/rule.bzl",
+        "def _impl(ctx):",
+        "  provider = ctx.attr._cc_toolchain[cc_common.CcToolchainInfo]",
+        "  return struct(",
+        "    compile_options = " + method + ",",
+        "  )",
+        "",
+        "my_rule = rule(",
+        "  _impl,",
+        "  fragments = [ 'cpp' ],",
+        "  attrs = {'_cc_toolchain': attr.label(default=Label('//test:toolchain')) }",
+        ")");
+    scratch.file(
+        "test/BUILD",
+        "load(':rule.bzl', 'my_rule')",
+        "cc_toolchain_alias(name = 'toolchain')",
+        "my_rule(name = 'target')");
+    AssertionError e =
+        assertThrows(AssertionError.class, () -> getConfiguredTarget("//test:target"));
+    assertThat(e)
+        .hasMessageThat()
+        .contains(
+            "Skylark APIs accessing compilation flags has been removed. "
+                + "Use the new API on cc_common.");
+  }
+
+  @Test
+  public void testDisablingCompilationModeFlags() throws Exception {
+    AnalysisMock.get()
+        .ccSupport()
+        .setupCrosstool(
+            mockToolsConfig,
+            "compilation_mode_flags { mode: OPT compiler_flag: '-foo_from_compilation_mode' }",
+            "compilation_mode_flags { mode: OPT cxx_flag: '-bar_from_compilation_mode' }",
+            "compilation_mode_flags { mode: OPT linker_flag: '-baz_from_compilation_mode' }");
+    scratch.file("a/BUILD", "cc_library(name='a', srcs=['a.cc'])");
+
+    useConfiguration("-c", "opt");
+    CcToolchainProvider ccToolchainProvider = getCcToolchainProvider();
+    assertThat(ccToolchainProvider.getCompilerOptions()).contains("-foo_from_compilation_mode");
+    assertThat(ccToolchainProvider.getLegacyCxxOptions()).contains("-bar_from_compilation_mode");
+    assertThat(ccToolchainProvider.getLegacyMostlyStaticLinkFlags(CompilationMode.OPT))
+        .contains("-baz_from_compilation_mode");
+
+    useConfiguration("-c", "opt", "--experimental_disable_compilation_mode_flags");
+    ccToolchainProvider = getCcToolchainProvider();
+    assertThat(ccToolchainProvider.getCompilerOptions())
+        .doesNotContain("-foo_from_compilation_mode");
+    assertThat(ccToolchainProvider.getLegacyCxxOptions())
+        .doesNotContain("-bar_from_compilation_mode");
+    assertThat(ccToolchainProvider.getLegacyMostlyStaticLinkFlags(CompilationMode.OPT))
+        .doesNotContain("-baz_from_compilation_mode");
+  }
+
+  private CcToolchainProvider getCcToolchainProvider() throws Exception {
+    ConfiguredTarget target = getConfiguredTarget("//a");
+    RuleContext ruleContext = getRuleContext(target);
+    return CppHelper.getToolchainUsingDefaultCcToolchainAttribute(ruleContext);
+  }
+
+  @Test
+  public void testDisablingLinkingModeFlags() throws Exception {
+    AnalysisMock.get()
+        .ccSupport()
+        .setupCrosstool(
+            mockToolsConfig,
+            "linking_mode_flags { mode: MOSTLY_STATIC linker_flag: '-foo_from_linking_mode' }");
+    scratch.file("a/BUILD", "cc_library(name='a', srcs=['a.cc'])");
+
+    useConfiguration();
+    CcToolchainProvider ccToolchainProvider = getCcToolchainProvider();
+    assertThat(ccToolchainProvider.getLegacyMostlyStaticLinkFlags(CompilationMode.OPT))
+        .contains("-foo_from_linking_mode");
+
+    useConfiguration("--experimental_disable_linking_mode_flags");
+    ccToolchainProvider = getCcToolchainProvider();
+    assertThat(ccToolchainProvider.getLegacyMostlyStaticLinkFlags(CompilationMode.OPT))
+        .doesNotContain("-foo_from_linking_mode");
+  }
+
+  @Test
+  public void testDisablingLegacyCrosstoolFields() throws Exception {
+    AnalysisMock.get()
+        .ccSupport()
+        .setupCrosstool(
+            mockToolsConfig,
+            "compiler_flag: '-foo_compiler_flag'",
+            "cxx_flag: '-foo_cxx_flag'",
+            "unfiltered_cxx_flag: '-foo_unfiltered_cxx_flag'",
+            "linker_flag: '-foo_linker_flag'",
+            "dynamic_library_linker_flag: '-foo_dynamic_library_linker_flag'",
+            "test_only_linker_flag: '-foo_test_only_linker_flag'");
+    scratch.file("a/BUILD", "cc_library(name='a', srcs=['a.cc'])");
+
+    useConfiguration();
+    CcToolchainProvider ccToolchainProvider = getCcToolchainProvider();
+    assertThat(ccToolchainProvider.getLegacyCompileOptions()).contains("-foo_compiler_flag");
+    assertThat(ccToolchainProvider.getLegacyCxxOptions()).contains("-foo_cxx_flag");
+    assertThat(ccToolchainProvider.getUnfilteredCompilerOptions())
+        .contains("-foo_unfiltered_cxx_flag");
+    assertThat(ccToolchainProvider.getLegacyLinkOptions()).contains("-foo_linker_flag");
+    assertThat(ccToolchainProvider.getSharedLibraryLinkOptions(/* flags= */ ImmutableList.of()))
+        .contains("-foo_dynamic_library_linker_flag");
+    assertThat(ccToolchainProvider.getTestOnlyLinkOptions()).contains("-foo_test_only_linker_flag");
+
+    useConfiguration("--experimental_disable_legacy_crosstool_fields");
+    ccToolchainProvider = getCcToolchainProvider();
+    assertThat(ccToolchainProvider.getLegacyCompileOptions()).doesNotContain("-foo_compiler_flag");
+    assertThat(ccToolchainProvider.getLegacyCxxOptions()).doesNotContain("-foo_cxx_flag");
+    assertThat(ccToolchainProvider.getUnfilteredCompilerOptions())
+        .doesNotContain("-foo_unfiltered_cxx_flag");
+    assertThat(ccToolchainProvider.getLegacyLinkOptions()).doesNotContain("-foo_linker_flag");
+    assertThat(ccToolchainProvider.getSharedLibraryLinkOptions(/* flags= */ ImmutableList.of()))
+        .doesNotContain("-foo_dynamic_library_linker_flag");
+    assertThat(ccToolchainProvider.getTestOnlyLinkOptions())
+        .doesNotContain("-foo_test_only_linker_flag");
+  }
 }