Make creating a CcToolchainConfigInfo from Skylark possible
Work towards issue #5380.
//tools/cpp/cc_toolchain_config_lib.bzl contains all the necessary functionality for
one to be able to create a CcToolchainConfigInfo provider from Skylark. CcToolchainConfigInfo currently encapsulates the info read from the CROSSTOOL file. We are moving away from using the CROSSTOOL files, in the future we will reroute the logic
through an attribute of cc_toolchain that will point to a Skylark rule.
A CcToolchainConfigInfo provider can be created with the cc_common.create_cc_toolchain_config_info()
method.
e.g:
crosstool_rule = rule{
implementation = _impl,
provides = [CcToolchainConfigInfo],
)
def _impl(ctx):
feature1 = feature(
name = "feature_one",
flag_sets = [
flag_set(actions = ["action1"]),
flag_set(
actions = ["action1"],
flag_groups = [
flag_group(
flags = ["flag1"],
),
flag_group(
flag_groups = [
flag_group(
flags = ["flag1"],
),
],
expand_if_equal = variable_with_value(
name = "variable1",
value = "value",
),
),
],
expand_if_all_available = ["sysroot"],
),
],
)
action_config1 = action_config(action_name = "action_one", enabled = True)
action_config2 = action_config(
action_name = "action_two",
enabled = True,
tools = [tool(path = "/a/b/c")],
)
artifact_name_pattern1 = artifact_name_pattern(
category_name = "static_library",
prefix = "prefix",
extension = ".a",
)
cc_target_os = "os"
return cc_common.create_cc_toolchain_config_info(
features = [feature1],
action_configs = [action_config1, action_config2],
artifact_name_patterns = [artifact_name_pattern1],
cc_target_os = cc_target_os,
make_variables = [make_variable(name = "v1", value = "val")],
)
RELNOTES: None.
PiperOrigin-RevId: 209648136
diff --git a/src/main/java/com/google/devtools/build/lib/bazel/rules/CcRules.java b/src/main/java/com/google/devtools/build/lib/bazel/rules/CcRules.java
index 620d810..015b9cd 100644
--- a/src/main/java/com/google/devtools/build/lib/bazel/rules/CcRules.java
+++ b/src/main/java/com/google/devtools/build/lib/bazel/rules/CcRules.java
@@ -29,6 +29,7 @@
import com.google.devtools.build.lib.rules.cpp.CcLibcTopAlias;
import com.google.devtools.build.lib.rules.cpp.CcLinkingInfo;
import com.google.devtools.build.lib.rules.cpp.CcToolchainAliasRule;
+import com.google.devtools.build.lib.rules.cpp.CcToolchainConfigInfo;
import com.google.devtools.build.lib.rules.cpp.CcToolchainRule;
import com.google.devtools.build.lib.rules.cpp.CcToolchainSuiteRule;
import com.google.devtools.build.lib.rules.cpp.CppBuildInfo;
@@ -80,6 +81,7 @@
builder.addSkylarkBootstrap(new CcBootstrap(new BazelCcModule()));
builder.addSkylarkAccessibleTopLevels("CcCompilationInfo", CcCompilationInfo.PROVIDER);
builder.addSkylarkAccessibleTopLevels("CcLinkingInfo", CcLinkingInfo.PROVIDER);
+ builder.addSkylarkAccessibleTopLevels("CcToolchainConfigInfo", CcToolchainConfigInfo.PROVIDER);
}
@Override
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/BUILD b/src/main/java/com/google/devtools/build/lib/rules/cpp/BUILD
index b1bb9ca..0b10038 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/BUILD
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/BUILD
@@ -40,6 +40,7 @@
"//src/main/java/com/google/devtools/build/lib/rules/apple",
"//src/main/java/com/google/devtools/build/lib/shell",
"//src/main/java/com/google/devtools/build/lib/skyframe/serialization/autocodec",
+ "//src/main/java/com/google/devtools/build/lib/skylarkbuildapi",
"//src/main/java/com/google/devtools/build/lib/skylarkbuildapi/cpp",
"//src/main/java/com/google/devtools/build/lib/vfs",
"//src/main/java/com/google/devtools/build/skyframe",
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcModule.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcModule.java
index ff0a6e3..f37e897 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcModule.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcModule.java
@@ -14,12 +14,15 @@
package com.google.devtools.build.lib.rules.cpp;
+import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Joiner;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.devtools.build.lib.actions.Artifact;
import com.google.devtools.build.lib.analysis.RuleContext;
+import com.google.devtools.build.lib.analysis.config.CompilationMode;
+import com.google.devtools.build.lib.analysis.config.InvalidConfigurationException;
import com.google.devtools.build.lib.analysis.platform.ToolchainInfo;
import com.google.devtools.build.lib.analysis.skylark.SkylarkRuleContext;
import com.google.devtools.build.lib.collect.nestedset.NestedSet;
@@ -31,28 +34,47 @@
import com.google.devtools.build.lib.packages.NativeProvider;
import com.google.devtools.build.lib.packages.Provider;
import com.google.devtools.build.lib.packages.RuleClass.ConfiguredTargetFactory.RuleErrorException;
+import com.google.devtools.build.lib.packages.SkylarkInfo;
import com.google.devtools.build.lib.rules.cpp.CcCompilationHelper.CompilationInfo;
import com.google.devtools.build.lib.rules.cpp.CcLinkingHelper.LinkingInfo;
import com.google.devtools.build.lib.rules.cpp.CcModule.CcSkylarkInfo;
+import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.ActionConfig;
+import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.ArtifactNamePattern;
+import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.EnvEntry;
+import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.EnvSet;
+import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.Feature;
import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.FeatureConfiguration;
+import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.Flag;
+import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.FlagGroup;
+import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.FlagSet;
+import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.VariableWithValue;
+import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.WithFeatureSet;
+import com.google.devtools.build.lib.rules.cpp.CcToolchainVariables.Expandable;
+import com.google.devtools.build.lib.rules.cpp.CcToolchainVariables.StringValueParser;
import com.google.devtools.build.lib.rules.cpp.LinkerInputs.LibraryToLink;
import com.google.devtools.build.lib.skyframe.serialization.ObjectCodec;
import com.google.devtools.build.lib.skyframe.serialization.autocodec.AutoCodec;
import com.google.devtools.build.lib.skyframe.serialization.autocodec.AutoCodec.VisibleForSerialization;
+import com.google.devtools.build.lib.skylarkbuildapi.SkylarkRuleContextApi;
import com.google.devtools.build.lib.skylarkbuildapi.cpp.CcModuleApi;
import com.google.devtools.build.lib.skylarkbuildapi.cpp.CcSkylarkInfoApi;
import com.google.devtools.build.lib.skylarkinterface.Param;
+import com.google.devtools.build.lib.skylarkinterface.ParamType;
import com.google.devtools.build.lib.skylarkinterface.SkylarkCallable;
import com.google.devtools.build.lib.syntax.EvalException;
import com.google.devtools.build.lib.syntax.EvalUtils;
+import com.google.devtools.build.lib.syntax.Runtime.NoneType;
import com.google.devtools.build.lib.syntax.SkylarkDict;
import com.google.devtools.build.lib.syntax.SkylarkList;
import com.google.devtools.build.lib.syntax.SkylarkNestedSet;
import com.google.devtools.build.lib.util.Pair;
+import com.google.devtools.build.lib.util.StringUtil;
import com.google.devtools.build.lib.vfs.PathFragment;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
import javax.annotation.Nullable;
/** A module that contains Skylark utilities for C++ support. */
@@ -546,4 +568,876 @@
? ((SkylarkNestedSet) o).getSet(type)
: NestedSetBuilder.wrap(Order.COMPILE_ORDER, (SkylarkList<T>) o);
}
+
+ @SkylarkCallable(
+ name = "create_cc_toolchain_config_info",
+ documented = false,
+ parameters = {
+ @Param(
+ name = "ctx",
+ positional = false,
+ named = true,
+ type = SkylarkRuleContextApi.class,
+ doc = "The rule context."),
+ @Param(
+ name = "features",
+ positional = false,
+ named = true,
+ defaultValue = "[]",
+ type = SkylarkList.class),
+ @Param(
+ name = "action_configs",
+ positional = false,
+ named = true,
+ defaultValue = "[]",
+ type = SkylarkList.class),
+ @Param(
+ name = "artifact_name_patterns",
+ positional = false,
+ named = true,
+ defaultValue = "[]",
+ type = SkylarkList.class),
+ @Param(
+ name = "cxx_builtin_include_directories",
+ positional = false,
+ named = true,
+ defaultValue = "[]",
+ type = SkylarkList.class),
+ @Param(
+ name = "toolchain_identifier",
+ positional = false,
+ noneable = true,
+ defaultValue = "None",
+ allowedTypes = {@ParamType(type = String.class), @ParamType(type = NoneType.class)},
+ named = true),
+ @Param(
+ name = "host_system_name",
+ positional = false,
+ noneable = true,
+ defaultValue = "None",
+ allowedTypes = {@ParamType(type = String.class), @ParamType(type = NoneType.class)},
+ named = true),
+ @Param(
+ name = "target_system_name",
+ positional = false,
+ noneable = true,
+ defaultValue = "None",
+ allowedTypes = {@ParamType(type = String.class), @ParamType(type = NoneType.class)},
+ named = true),
+ @Param(
+ name = "target_cpu",
+ positional = false,
+ noneable = true,
+ defaultValue = "None",
+ allowedTypes = {@ParamType(type = String.class), @ParamType(type = NoneType.class)},
+ named = true),
+ @Param(
+ name = "target_libc",
+ positional = false,
+ noneable = true,
+ defaultValue = "None",
+ allowedTypes = {@ParamType(type = String.class), @ParamType(type = NoneType.class)},
+ named = true),
+ @Param(
+ name = "compiler",
+ positional = false,
+ noneable = true,
+ defaultValue = "None",
+ allowedTypes = {@ParamType(type = String.class), @ParamType(type = NoneType.class)},
+ named = true),
+ @Param(
+ name = "abi_version",
+ positional = false,
+ noneable = true,
+ defaultValue = "None",
+ allowedTypes = {@ParamType(type = String.class), @ParamType(type = NoneType.class)},
+ named = true),
+ @Param(
+ name = "abi_libc_version",
+ positional = false,
+ noneable = true,
+ defaultValue = "None",
+ allowedTypes = {@ParamType(type = String.class), @ParamType(type = NoneType.class)},
+ named = true),
+ @Param(
+ name = "supports_gold_linker",
+ positional = false,
+ defaultValue = "False",
+ type = Boolean.class,
+ named = true),
+ @Param(
+ name = "supports_start_end_lib",
+ positional = false,
+ type = Boolean.class,
+ defaultValue = "False",
+ named = true),
+ @Param(
+ name = "supports_interface_shared_objects",
+ positional = false,
+ type = Boolean.class,
+ defaultValue = "False",
+ named = true),
+ @Param(
+ name = "supports_embedded_filegroup",
+ positional = false,
+ type = Boolean.class,
+ defaultValue = "False",
+ named = true),
+ @Param(
+ name = "static_runtime_filegroup",
+ positional = false,
+ noneable = true,
+ defaultValue = "None",
+ allowedTypes = {@ParamType(type = String.class), @ParamType(type = NoneType.class)},
+ named = true),
+ @Param(
+ name = "dynamic_runtime_filegroup",
+ positional = false,
+ noneable = true,
+ defaultValue = "None",
+ allowedTypes = {@ParamType(type = String.class), @ParamType(type = NoneType.class)},
+ named = true),
+ @Param(
+ name = "supports_fission",
+ positional = false,
+ type = Boolean.class,
+ defaultValue = "False",
+ named = true),
+ @Param(
+ name = "supports_dsym",
+ positional = false,
+ type = Boolean.class,
+ defaultValue = "False",
+ named = true),
+ @Param(
+ name = "needs_pic",
+ positional = false,
+ type = Boolean.class,
+ defaultValue = "False",
+ named = true),
+ @Param(
+ name = "tool_paths",
+ positional = false,
+ named = true,
+ defaultValue = "[]",
+ type = SkylarkList.class),
+ @Param(
+ name = "compiler_flags",
+ positional = false,
+ named = true,
+ defaultValue = "[]",
+ type = SkylarkList.class),
+ @Param(
+ name = "cxx_flags",
+ positional = false,
+ named = true,
+ defaultValue = "[]",
+ type = SkylarkList.class),
+ @Param(
+ name = "unfiltered_cxx_flags",
+ positional = false,
+ named = true,
+ defaultValue = "[]",
+ type = SkylarkList.class),
+ @Param(
+ name = "linker_flags",
+ positional = false,
+ named = true,
+ defaultValue = "[]",
+ type = SkylarkList.class),
+ @Param(
+ name = "dynamic_library_linker_flags",
+ positional = false,
+ named = true,
+ defaultValue = "[]",
+ type = SkylarkList.class),
+ @Param(
+ name = "test_only_linker_flags",
+ positional = false,
+ named = true,
+ defaultValue = "[]",
+ type = SkylarkList.class),
+ @Param(
+ name = "objcopy_embed_flags",
+ positional = false,
+ named = true,
+ defaultValue = "[]",
+ type = SkylarkList.class),
+ @Param(
+ name = "ld_embed_flags",
+ positional = false,
+ named = true,
+ defaultValue = "[]",
+ type = SkylarkList.class),
+ @Param(
+ name = "compilation_mode_compiler_flags",
+ positional = false,
+ named = true,
+ defaultValue = "{}",
+ type = SkylarkDict.class),
+ @Param(
+ name = "compilation_mode_cxx_flags",
+ positional = false,
+ named = true,
+ defaultValue = "{}",
+ type = SkylarkDict.class),
+ @Param(
+ name = "compilation_mode_linker_flags",
+ positional = false,
+ named = true,
+ defaultValue = "{}",
+ type = SkylarkDict.class),
+ @Param(
+ name = "mostly_static_linking_mode_flags",
+ positional = false,
+ named = true,
+ defaultValue = "[]",
+ type = SkylarkList.class),
+ @Param(
+ name = "dynamic_linking_mode_flags",
+ positional = false,
+ named = true,
+ defaultValue = "None",
+ noneable = true,
+ allowedTypes = {
+ @ParamType(type = SkylarkList.class),
+ @ParamType(type = NoneType.class)
+ }),
+ @Param(
+ name = "fully_static_linking_mode_flags",
+ positional = false,
+ named = true,
+ defaultValue = "[]",
+ type = SkylarkList.class),
+ @Param(
+ name = "mostly_static_libraries_linking_mode_flags",
+ positional = false,
+ named = true,
+ defaultValue = "[]",
+ type = SkylarkList.class),
+ @Param(
+ name = "make_variables",
+ positional = false,
+ named = true,
+ defaultValue = "[]",
+ type = SkylarkList.class),
+ @Param(
+ name = "builtin_sysroot",
+ positional = false,
+ noneable = true,
+ defaultValue = "None",
+ allowedTypes = {@ParamType(type = String.class), @ParamType(type = NoneType.class)},
+ named = true),
+ @Param(
+ name = "default_libc_top",
+ positional = false,
+ noneable = true,
+ defaultValue = "None",
+ allowedTypes = {@ParamType(type = String.class), @ParamType(type = NoneType.class)},
+ named = true),
+ @Param(
+ name = "cc_target_os",
+ positional = false,
+ noneable = true,
+ defaultValue = "None",
+ allowedTypes = {@ParamType(type = String.class), @ParamType(type = NoneType.class)},
+ named = true),
+ })
+ public CcToolchainConfigInfo ccToolchainConfigInfoFromSkylark(
+ SkylarkRuleContext skylarkRuleContext,
+ SkylarkList<Object> features,
+ SkylarkList<Object> actionConfigs,
+ SkylarkList<Object> artifactNamePatterns,
+ SkylarkList<String> cxxBuiltInIncludeDirectories,
+ Object toolchhainIdentifier,
+ Object hostSystemName,
+ Object targetSystemName,
+ Object targetCpu,
+ Object targetLibc,
+ Object compiler,
+ Object abiVersion,
+ Object abiLibcVersion,
+ Boolean supportsGoldLinker,
+ Boolean supportsStartEndLib,
+ Boolean supportsInterfaceSharedObjects,
+ Boolean supportsEmbeddedRuntimes,
+ Object staticRuntimesFilegroup,
+ Object dynamicRuntimesFilegroup,
+ Boolean supportsFission,
+ Boolean supportsDsym,
+ Boolean needsPic,
+ SkylarkList<Object> toolPaths,
+ SkylarkList<String> compilerFlags,
+ SkylarkList<String> cxxFlags,
+ SkylarkList<String> unfilteredCxxFlags,
+ SkylarkList<String> linkerFlags,
+ SkylarkList<String> dynamicLibraryLinkerFlags,
+ SkylarkList<String> testOnlyLinkerFlags,
+ SkylarkList<String> objcopyEmbedFlags,
+ SkylarkList<String> ldEmbedFlags,
+ Object compilationModeCompilerFlagsUnchecked,
+ Object compilationModeCxxFlagsUnchecked,
+ Object compilationModeLinkerFlagsUnchecked,
+ SkylarkList<String> mostlyStaticLinkingModeFlags,
+ Object dynamicLinkingModeFlags,
+ SkylarkList<String> fullyStaticLinkingModeFlags,
+ SkylarkList<String> mostlyStaticLibrariesLinkingModeFlags,
+ SkylarkList<Object> makeVariables,
+ Object builtinSysroot,
+ Object defaultLibcTop,
+ Object ccTargetOs)
+ throws InvalidConfigurationException, EvalException {
+
+ CppConfiguration config =
+ skylarkRuleContext.getConfiguration().getFragment(CppConfiguration.class);
+ if (!config.enableCcToolchainConfigInfoFromSkylark()) {
+ throw new InvalidConfigurationException("Creating a CcToolchainConfigInfo is not enabled.");
+ }
+
+ ImmutableList.Builder<Feature> featureBuilder = ImmutableList.builder();
+ for (Object feature : features) {
+ featureBuilder.add(featureFromSkylark((SkylarkInfo) feature));
+ }
+
+ ImmutableList.Builder<ActionConfig> actionConfigBuilder = ImmutableList.builder();
+ for (Object actionConfig : actionConfigs) {
+ actionConfigBuilder.add(actionConfigFromSkylark((SkylarkInfo) actionConfig));
+ }
+
+ ImmutableList.Builder<ArtifactNamePattern> artifactNamePatternBuilder = ImmutableList.builder();
+ for (Object artifactNamePattern : artifactNamePatterns) {
+ artifactNamePatternBuilder.add(
+ artifactNamePatternFromSkylark((SkylarkInfo) artifactNamePattern));
+ }
+
+ ImmutableList.Builder<Pair<String, String>> toolPathPairs = ImmutableList.builder();
+ for (Object toolPath : toolPaths) {
+ toolPathPairs.add(toolPathFromSkylark((SkylarkInfo) toolPath));
+ }
+
+ ImmutableList.Builder<Pair<String, String>> makeVariablePairs = ImmutableList.builder();
+ for (Object makeVariable : makeVariables) {
+ makeVariablePairs.add(makeVariableFromSkylark((SkylarkInfo) makeVariable));
+ }
+
+ SkylarkList<String> dynamicModeFlags =
+ convertFromNoneable(dynamicLinkingModeFlags, /* defaultValue= */ null);
+ boolean hasDynamicLinkingModeFlags = dynamicModeFlags != null;
+
+ return new CcToolchainConfigInfo(
+ actionConfigBuilder.build(),
+ featureBuilder.build(),
+ artifactNamePatternBuilder.build(),
+ ImmutableList.copyOf(cxxBuiltInIncludeDirectories),
+ convertFromNoneable(toolchhainIdentifier, /* defaultValue= */ null),
+ convertFromNoneable(hostSystemName, /* defaultValue= */ null),
+ convertFromNoneable(targetSystemName, /* defaultValue= */ null),
+ convertFromNoneable(targetCpu, /* defaultValue= */ null),
+ convertFromNoneable(targetLibc, /* defaultValue= */ null),
+ convertFromNoneable(compiler, /* defaultValue= */ null),
+ convertFromNoneable(abiVersion, /* defaultValue= */ null),
+ convertFromNoneable(abiLibcVersion, /* defaultValue= */ null),
+ supportsGoldLinker,
+ supportsStartEndLib,
+ supportsInterfaceSharedObjects,
+ supportsEmbeddedRuntimes,
+ convertFromNoneable(staticRuntimesFilegroup, /* defaultValue= */ null),
+ convertFromNoneable(dynamicRuntimesFilegroup, /* defaultValue= */ null),
+ supportsFission,
+ supportsDsym,
+ needsPic,
+ toolPathPairs.build(),
+ ImmutableList.copyOf(compilerFlags),
+ ImmutableList.copyOf(cxxFlags),
+ ImmutableList.copyOf(unfilteredCxxFlags),
+ ImmutableList.copyOf(linkerFlags),
+ ImmutableList.copyOf(dynamicLibraryLinkerFlags),
+ ImmutableList.copyOf(testOnlyLinkerFlags),
+ ImmutableList.copyOf(objcopyEmbedFlags),
+ ImmutableList.copyOf(ldEmbedFlags),
+ getCompilationModeFlagsFromSkylark(
+ compilationModeCompilerFlagsUnchecked, "compilation_mode_compiler_flags"),
+ getCompilationModeFlagsFromSkylark(
+ compilationModeCxxFlagsUnchecked, "compilation_mode_cxx_flags"),
+ getCompilationModeFlagsFromSkylark(
+ compilationModeLinkerFlagsUnchecked, "compilation_mode_linker_flags"),
+ ImmutableList.copyOf(mostlyStaticLinkingModeFlags),
+ hasDynamicLinkingModeFlags ? ImmutableList.copyOf(dynamicModeFlags) : ImmutableList.of(),
+ ImmutableList.copyOf(fullyStaticLinkingModeFlags),
+ ImmutableList.copyOf(mostlyStaticLibrariesLinkingModeFlags),
+ makeVariablePairs.build(),
+ convertFromNoneable(builtinSysroot, /* defaultValue= */ null),
+ convertFromNoneable(defaultLibcTop, /* defaultValue= */ null),
+ convertFromNoneable(ccTargetOs, /* defaultValue= */ null),
+ hasDynamicLinkingModeFlags);
+ }
+
+ /** Checks whether the {@link SkylarkInfo} is of the required type. */
+ private static void checkRightProviderType(SkylarkInfo provider, String type)
+ throws EvalException {
+ String providerType = (String) provider.getValueOrNull("type_name");
+ if (providerType == null) {
+ providerType = provider.getProvider().getPrintableName();
+ }
+ if (!provider.hasField("type_name") || !provider.getValue("type_name").equals(type)) {
+ throw new EvalException(
+ provider.getCreationLoc(),
+ String.format("Expected object of type '%s', received '%s'.", type, providerType));
+ }
+ }
+
+ /** Creates a {@link Feature} from a {@link SkylarkInfo}. */
+ @VisibleForTesting
+ static Feature featureFromSkylark(SkylarkInfo featureStruct)
+ throws InvalidConfigurationException, EvalException {
+ checkRightProviderType(featureStruct, "feature");
+ String name = getFieldFromSkylarkProvider(featureStruct, "name", String.class);
+ Boolean enabled = getFieldFromSkylarkProvider(featureStruct, "enabled", Boolean.class);
+ if (name == null || (name.isEmpty() && !enabled)) {
+ throw new EvalException(
+ featureStruct.getCreationLoc(),
+ "A feature must either have a nonempty 'name' field or be enabled.");
+ }
+
+ if (!name.matches("^[_a-z]*$")) {
+ throw new EvalException(
+ featureStruct.getCreationLoc(),
+ String.format(
+ "A feature's name must consist solely of lowercase letters and '_', got '%s'", name));
+ }
+
+ ImmutableList.Builder<FlagSet> flagSetBuilder = ImmutableList.builder();
+ ImmutableList<SkylarkInfo> flagSets =
+ getSkylarkProviderListFromSkylarkField(featureStruct, "flag_sets");
+ for (SkylarkInfo flagSet : flagSets) {
+ flagSetBuilder.add(flagSetFromSkylark(flagSet));
+ }
+
+ ImmutableList.Builder<EnvSet> envSetBuilder = ImmutableList.builder();
+ ImmutableList<SkylarkInfo> envSets =
+ getSkylarkProviderListFromSkylarkField(featureStruct, "env_sets");
+ for (SkylarkInfo envSet : envSets) {
+ envSetBuilder.add(envSetFromSkylark(envSet));
+ }
+
+ ImmutableList.Builder<ImmutableSet<String>> requiresBuilder = ImmutableList.builder();
+
+ ImmutableList<SkylarkInfo> requires =
+ getSkylarkProviderListFromSkylarkField(featureStruct, "requires");
+ for (SkylarkInfo featureSetStruct : requires) {
+ if (!featureSetStruct.hasField("type_name")
+ || !featureSetStruct.getValue("type_name").equals("feature_set")) {
+ throw new EvalException(
+ featureStruct.getCreationLoc(), "expected object of type 'feature_set'.");
+ }
+ ImmutableSet<String> featureSet =
+ getStringSetFromSkylarkProviderField(featureSetStruct, "features");
+ requiresBuilder.add(featureSet);
+ }
+
+ ImmutableList<String> implies = getStringListFromSkylarkProviderField(featureStruct, "implies");
+
+ ImmutableList<String> provides =
+ getStringListFromSkylarkProviderField(featureStruct, "provides");
+
+ return new Feature(
+ name,
+ flagSetBuilder.build(),
+ envSetBuilder.build(),
+ enabled,
+ requiresBuilder.build(),
+ implies,
+ provides);
+ }
+
+ /**
+ * Creates a Pair(name, value) that represents a {@link
+ * com.google.devtools.build.lib.view.config.crosstool.CrosstoolConfig.MakeVariable} from a {@link
+ * SkylarkInfo}.
+ */
+ @VisibleForTesting
+ static Pair<String, String> makeVariableFromSkylark(SkylarkInfo makeVariableStruct)
+ throws EvalException {
+ checkRightProviderType(makeVariableStruct, "make_variable");
+ String name = getFieldFromSkylarkProvider(makeVariableStruct, "name", String.class);
+ String value = getFieldFromSkylarkProvider(makeVariableStruct, "value", String.class);
+ if (name == null || name.isEmpty()) {
+ throw new EvalException(
+ makeVariableStruct.getCreationLoc(),
+ "'name' parameter of make_variable must be a nonempty string.");
+ }
+ if (value == null || value.isEmpty()) {
+ throw new EvalException(
+ makeVariableStruct.getCreationLoc(),
+ "'value' parameter of make_variable must be a nonempty string.");
+ }
+ return Pair.of(name, value);
+ }
+
+ /**
+ * Creates a Pair(name, path) that represents a {@link
+ * com.google.devtools.build.lib.view.config.crosstool.CrosstoolConfig.ToolPath} from a {@link
+ * SkylarkInfo}.
+ */
+ @VisibleForTesting
+ static Pair<String, String> toolPathFromSkylark(SkylarkInfo toolPathStruct) throws EvalException {
+ checkRightProviderType(toolPathStruct, "tool_path");
+ String name = getFieldFromSkylarkProvider(toolPathStruct, "name", String.class);
+ String path = getFieldFromSkylarkProvider(toolPathStruct, "path", String.class);
+ if (name == null || name.isEmpty()) {
+ throw new EvalException(
+ toolPathStruct.getCreationLoc(),
+ "'name' parameter of tool_path must be a nonempty string.");
+ }
+ if (path == null || path.isEmpty()) {
+ throw new EvalException(
+ toolPathStruct.getCreationLoc(),
+ "'path' parameter of tool_path must be a nonempty string.");
+ }
+ return Pair.of(name, path);
+ }
+
+ /** Creates a {@link VariableWithValue} from a {@link SkylarkInfo}. */
+ @VisibleForTesting
+ static VariableWithValue variableWithValueFromSkylark(SkylarkInfo variableWithValueStruct)
+ throws EvalException {
+ checkRightProviderType(variableWithValueStruct, "variable_with_value");
+ String name = getFieldFromSkylarkProvider(variableWithValueStruct, "name", String.class);
+ String value = getFieldFromSkylarkProvider(variableWithValueStruct, "value", String.class);
+ if (name == null || name.isEmpty()) {
+ throw new EvalException(
+ variableWithValueStruct.getCreationLoc(),
+ "'name' parameter of variable_with_value must be a nonempty string.");
+ }
+ if (value == null || value.isEmpty()) {
+ throw new EvalException(
+ variableWithValueStruct.getCreationLoc(),
+ "'value' parameter of variable_with_value must be a nonempty string.");
+ }
+ return new VariableWithValue(name, value);
+ }
+
+ /** Creates an {@link EnvEntry} from a {@link SkylarkInfo}. */
+ @VisibleForTesting
+ static EnvEntry envEntryFromSkylark(SkylarkInfo envEntryStruct)
+ throws InvalidConfigurationException, EvalException {
+ checkRightProviderType(envEntryStruct, "env_entry");
+ String key = getFieldFromSkylarkProvider(envEntryStruct, "key", String.class);
+ String value = getFieldFromSkylarkProvider(envEntryStruct, "value", String.class);
+ if (key == null || key.isEmpty()) {
+ throw new EvalException(
+ envEntryStruct.getCreationLoc(),
+ "'key' parameter of env_entry must be a nonempty string.");
+ }
+ if (value == null || value.isEmpty()) {
+ throw new EvalException(
+ envEntryStruct.getCreationLoc(),
+ "'value' parameter of env_entry must be a nonempty string.");
+ }
+ StringValueParser parser = new StringValueParser(value);
+ return new EnvEntry(key, parser.getChunks());
+ }
+
+ /** Creates a {@link WithFeatureSet} from a {@link SkylarkInfo}. */
+ @VisibleForTesting
+ static WithFeatureSet withFeatureSetFromSkylark(SkylarkInfo withFeatureSetStruct)
+ throws EvalException {
+ checkRightProviderType(withFeatureSetStruct, "with_feature_set");
+ ImmutableSet<String> features =
+ getStringSetFromSkylarkProviderField(withFeatureSetStruct, "features");
+ ImmutableSet<String> notFeatures =
+ getStringSetFromSkylarkProviderField(withFeatureSetStruct, "not_features");
+ return new WithFeatureSet(features, notFeatures);
+ }
+
+ /** Creates an {@link EnvSet} from a {@link SkylarkInfo}. */
+ @VisibleForTesting
+ static EnvSet envSetFromSkylark(SkylarkInfo envSetStruct)
+ throws InvalidConfigurationException, EvalException {
+ checkRightProviderType(envSetStruct, "env_set");
+ ImmutableSet<String> actions = getStringSetFromSkylarkProviderField(envSetStruct, "actions");
+ if (actions.isEmpty()) {
+ throw new EvalException(
+ envSetStruct.getCreationLoc(), "actions parameter of env_set must be a nonempty list.");
+ }
+ ImmutableList.Builder<EnvEntry> envEntryBuilder = ImmutableList.builder();
+ ImmutableList<SkylarkInfo> envEntryStructs =
+ getSkylarkProviderListFromSkylarkField(envSetStruct, "env_entries");
+ for (SkylarkInfo envEntryStruct : envEntryStructs) {
+ envEntryBuilder.add(envEntryFromSkylark(envEntryStruct));
+ }
+
+ ImmutableSet.Builder<WithFeatureSet> withFeatureSetBuilder = ImmutableSet.builder();
+ ImmutableList<SkylarkInfo> withFeatureSetStructs =
+ getSkylarkProviderListFromSkylarkField(envSetStruct, "with_features");
+ for (SkylarkInfo withFeatureSetStruct : withFeatureSetStructs) {
+ withFeatureSetBuilder.add(withFeatureSetFromSkylark(withFeatureSetStruct));
+ }
+ return new EnvSet(actions, envEntryBuilder.build(), withFeatureSetBuilder.build());
+ }
+
+ /** Creates a {@link FlagGroup} from a {@link SkylarkInfo}. */
+ @VisibleForTesting
+ static FlagGroup flagGroupFromSkylark(SkylarkInfo flagGroupStruct)
+ throws InvalidConfigurationException, EvalException {
+ checkRightProviderType(flagGroupStruct, "flag_group");
+
+ ImmutableList.Builder<Expandable> expandableBuilder = ImmutableList.builder();
+ ImmutableList<String> flags = getStringListFromSkylarkProviderField(flagGroupStruct, "flags");
+ for (String flag : flags) {
+ StringValueParser parser = new StringValueParser(flag);
+ expandableBuilder.add(new Flag(parser.getChunks()));
+ }
+
+ ImmutableList<SkylarkInfo> flagGroups =
+ getSkylarkProviderListFromSkylarkField(flagGroupStruct, "flag_groups");
+ for (SkylarkInfo flagGroup : flagGroups) {
+ expandableBuilder.add(flagGroupFromSkylark(flagGroup));
+ }
+
+ if (flagGroups.size() > 0 && flags.size() > 0) {
+ throw new EvalException(
+ flagGroupStruct.getCreationLoc(),
+ "flag_group must contain either a list of flags or a list of flag_groups.");
+ }
+
+ if (flagGroups.size() == 0 && flags.size() == 0) {
+ throw new EvalException(
+ flagGroupStruct.getCreationLoc(), "Both 'flags' and 'flag_groups' are empty.");
+ }
+
+ String iterateOver = getFieldFromSkylarkProvider(flagGroupStruct, "iterate_over", String.class);
+ String expandIfAvailable =
+ getFieldFromSkylarkProvider(flagGroupStruct, "expand_if_available", String.class);
+ String expandIfNotAvailable =
+ getFieldFromSkylarkProvider(flagGroupStruct, "expand_if_not_available", String.class);
+ String expandIfTrue =
+ getFieldFromSkylarkProvider(flagGroupStruct, "expand_if_true", String.class);
+ String expandIfFalse =
+ getFieldFromSkylarkProvider(flagGroupStruct, "expand_if_false", String.class);
+ SkylarkInfo expandIfEqualStruct =
+ getFieldFromSkylarkProvider(flagGroupStruct, "expand_if_equal", SkylarkInfo.class);
+ VariableWithValue expandIfEqual =
+ expandIfEqualStruct == null ? null : variableWithValueFromSkylark(expandIfEqualStruct);
+
+ return new FlagGroup(
+ expandableBuilder.build(),
+ iterateOver,
+ expandIfAvailable == null ? ImmutableSet.of() : ImmutableSet.of(expandIfAvailable),
+ expandIfNotAvailable == null ? ImmutableSet.of() : ImmutableSet.of(expandIfNotAvailable),
+ expandIfTrue,
+ expandIfFalse,
+ expandIfEqual);
+ }
+
+ /** Creates a {@link FlagSet} from a {@link SkylarkInfo}. */
+ @VisibleForTesting
+ static FlagSet flagSetFromSkylark(SkylarkInfo flagSetStruct)
+ throws InvalidConfigurationException, EvalException {
+ checkRightProviderType(flagSetStruct, "flag_set");
+ ImmutableSet<String> actions = getStringSetFromSkylarkProviderField(flagSetStruct, "actions");
+ if (actions.isEmpty()) {
+ throw new EvalException(
+ flagSetStruct.getCreationLoc(), "'actions' field of flag_set must be a nonempty list.");
+ }
+ ImmutableList.Builder<FlagGroup> flagGroupsBuilder = ImmutableList.builder();
+ ImmutableList<SkylarkInfo> flagGroups =
+ getSkylarkProviderListFromSkylarkField(flagSetStruct, "flag_groups");
+ for (SkylarkInfo flagGroup : flagGroups) {
+ flagGroupsBuilder.add(flagGroupFromSkylark(flagGroup));
+ }
+
+ ImmutableSet.Builder<WithFeatureSet> withFeatureSetBuilder = ImmutableSet.builder();
+ ImmutableList<SkylarkInfo> withFeatureSetStructs =
+ getSkylarkProviderListFromSkylarkField(flagSetStruct, "with_features");
+ for (SkylarkInfo withFeatureSetStruct : withFeatureSetStructs) {
+ withFeatureSetBuilder.add(withFeatureSetFromSkylark(withFeatureSetStruct));
+ }
+
+ return new FlagSet(
+ actions, ImmutableSet.of(), withFeatureSetBuilder.build(), flagGroupsBuilder.build());
+ }
+
+ /**
+ * Creates a {@link com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.Tool} from a
+ * {@link SkylarkInfo}.
+ */
+ @VisibleForTesting
+ static CcToolchainFeatures.Tool toolFromSkylark(SkylarkInfo toolStruct) throws EvalException {
+ checkRightProviderType(toolStruct, "tool");
+ String toolPathString = getFieldFromSkylarkProvider(toolStruct, "path", String.class);
+ PathFragment toolPath = toolPathString == null ? null : PathFragment.create(toolPathString);
+ if (toolPath != null && toolPath.isEmpty()) {
+ throw new EvalException(
+ toolStruct.getCreationLoc(), "The 'path' field of tool must be a nonempty string.");
+ }
+ ImmutableSet.Builder<WithFeatureSet> withFeatureSetBuilder = ImmutableSet.builder();
+ ImmutableList<SkylarkInfo> withFeatureSetStructs =
+ getSkylarkProviderListFromSkylarkField(toolStruct, "with_features");
+ for (SkylarkInfo withFeatureSetStruct : withFeatureSetStructs) {
+ withFeatureSetBuilder.add(withFeatureSetFromSkylark(withFeatureSetStruct));
+ }
+
+ ImmutableSet<String> executionRequirements =
+ getStringSetFromSkylarkProviderField(toolStruct, "execution_requirements");
+ return new CcToolchainFeatures.Tool(
+ toolPath, executionRequirements, withFeatureSetBuilder.build());
+ }
+
+ /** Creates an {@link ActionConfig} from a {@link SkylarkInfo}. */
+ @VisibleForTesting
+ static ActionConfig actionConfigFromSkylark(SkylarkInfo actionConfigStruct)
+ throws InvalidConfigurationException, EvalException {
+ checkRightProviderType(actionConfigStruct, "action_config");
+ String actionName =
+ getFieldFromSkylarkProvider(actionConfigStruct, "action_name", String.class);
+ if (actionName == null || actionName.isEmpty()) {
+ throw new EvalException(
+ actionConfigStruct.getCreationLoc(),
+ "The 'action_name' field of action_config must be a nonempty string.");
+ }
+ if (!actionName.matches("^[_a-z]*$")) {
+ throw new EvalException(
+ actionConfigStruct.getCreationLoc(),
+ String.format(
+ "An action_config's name must consist solely of lowercase letters and '_', got '%s'",
+ actionName));
+ }
+
+ Boolean enabled = getFieldFromSkylarkProvider(actionConfigStruct, "enabled", Boolean.class);
+
+ ImmutableList.Builder<CcToolchainFeatures.Tool> toolBuilder = ImmutableList.builder();
+ ImmutableList<SkylarkInfo> toolStructs =
+ getSkylarkProviderListFromSkylarkField(actionConfigStruct, "tools");
+ for (SkylarkInfo toolStruct : toolStructs) {
+ toolBuilder.add(toolFromSkylark(toolStruct));
+ }
+
+ ImmutableList.Builder<FlagSet> flagSetBuilder = ImmutableList.builder();
+ ImmutableList<SkylarkInfo> flagSets =
+ getSkylarkProviderListFromSkylarkField(actionConfigStruct, "flag_sets");
+ for (SkylarkInfo flagSet : flagSets) {
+ flagSetBuilder.add(flagSetFromSkylark(flagSet));
+ }
+
+ ImmutableList<String> implies =
+ getStringListFromSkylarkProviderField(actionConfigStruct, "implies");
+
+ return new ActionConfig(
+ actionName, actionName, toolBuilder.build(), flagSetBuilder.build(), enabled, implies);
+ }
+
+ /** Creates an {@link ArtifactNamePattern} from a {@link SkylarkInfo}. */
+ @VisibleForTesting
+ static ArtifactNamePattern artifactNamePatternFromSkylark(SkylarkInfo artifactNamePatternStruct)
+ throws EvalException {
+ checkRightProviderType(artifactNamePatternStruct, "artifact_name_pattern");
+ String categoryName =
+ getFieldFromSkylarkProvider(artifactNamePatternStruct, "category_name", String.class);
+ if (categoryName == null || categoryName.isEmpty()) {
+ throw new EvalException(
+ artifactNamePatternStruct.getCreationLoc(),
+ "The 'category_name' field of artifact_name_pattern must be a nonempty string.");
+ }
+ ArtifactCategory foundCategory = null;
+ for (ArtifactCategory artifactCategory : ArtifactCategory.values()) {
+ if (categoryName.equals(artifactCategory.getCategoryName())) {
+ foundCategory = artifactCategory;
+ }
+ }
+
+ if (foundCategory == null) {
+ throw new EvalException(
+ artifactNamePatternStruct.getCreationLoc(),
+ String.format("Artifact category %s not recognized.", categoryName));
+ }
+
+ String extension =
+ getFieldFromSkylarkProvider(artifactNamePatternStruct, "extension", String.class);
+ if (extension == null || extension.isEmpty()) {
+ throw new EvalException(
+ artifactNamePatternStruct.getCreationLoc(),
+ "The 'extension' field of artifact_name_pattern must be a nonempty string.");
+ }
+ if (!foundCategory.getAllowedExtensions().contains(extension)) {
+ throw new EvalException(
+ artifactNamePatternStruct.getCreationLoc(),
+ String.format(
+ "Unrecognized file extension '%s', allowed extensions are %s,"
+ + " please check artifact_name_pattern configuration for %s in your rule.",
+ extension,
+ StringUtil.joinEnglishList(foundCategory.getAllowedExtensions(), "or", "'"),
+ foundCategory.getCategoryName()));
+ }
+
+ String prefix = getFieldFromSkylarkProvider(artifactNamePatternStruct, "prefix", String.class);
+ if (prefix == null || prefix.isEmpty()) {
+ throw new EvalException(
+ artifactNamePatternStruct.getCreationLoc(),
+ "The 'prefix' field of artifact_name_pattern must be a nonempty string.");
+ }
+ return new ArtifactNamePattern(foundCategory, prefix, extension);
+ }
+
+ private static <T> T getFieldFromSkylarkProvider(
+ SkylarkInfo provider, String fieldName, Class<T> clazz) throws EvalException {
+ Object obj = provider.getValueOrNull(fieldName);
+ if (obj == null) {
+ throw new EvalException(
+ provider.getCreationLoc(), String.format("Missing mandatory field '%s'", fieldName));
+ }
+ if (clazz.isInstance(obj)) {
+ return clazz.cast(obj);
+ }
+ if (NoneType.class.isInstance(obj)) {
+ return null;
+ }
+ throw new EvalException(
+ provider.getCreationLoc(),
+ String.format("Field '%s' is not of '%s' type.", fieldName, clazz.getName()));
+ }
+
+ /** Returns a list of strings from a field of a {@link SkylarkInfo}. */
+ private static ImmutableList<String> getStringListFromSkylarkProviderField(
+ SkylarkInfo provider, String fieldName) throws EvalException {
+ return SkylarkList.castSkylarkListOrNoneToList(
+ provider.getValueOrNull(fieldName), String.class, fieldName)
+ .stream()
+ .collect(ImmutableList.toImmutableList());
+ }
+
+ /** Returns a set of strings from a field of a {@link SkylarkInfo}. */
+ private static ImmutableSet<String> getStringSetFromSkylarkProviderField(
+ SkylarkInfo provider, String fieldName) throws EvalException {
+ return SkylarkList.castSkylarkListOrNoneToList(
+ provider.getValueOrNull(fieldName), String.class, fieldName)
+ .stream()
+ .collect(ImmutableSet.toImmutableSet());
+ }
+
+ /** Returns a list of SkylarkInfo providers from a field of a {@link SkylarkInfo}. */
+ private static ImmutableList<SkylarkInfo> getSkylarkProviderListFromSkylarkField(
+ SkylarkInfo provider, String fieldName) throws EvalException {
+ return SkylarkList.castSkylarkListOrNoneToList(
+ provider.getValueOrNull(fieldName), SkylarkInfo.class, fieldName)
+ .stream()
+ .collect(ImmutableList.toImmutableList());
+ }
+
+ private static ImmutableMap<CompilationMode, ImmutableList<String>>
+ getCompilationModeFlagsFromSkylark(Object compilationModeFlags, String field)
+ throws EvalException {
+ Map<String, SkylarkList> compilationModeLinkerFlagsMap =
+ SkylarkDict.castSkylarkDictOrNoneToDict(
+ compilationModeFlags, String.class, SkylarkList.class, field);
+ ImmutableMap.Builder<CompilationMode, ImmutableList<String>> compilationModeFlagsBuilder =
+ ImmutableMap.builder();
+ for (Entry<String, SkylarkList> entry : compilationModeLinkerFlagsMap.entrySet()) {
+ compilationModeFlagsBuilder.put(
+ CompilationMode.valueOf(entry.getKey()),
+ ImmutableList.copyOf(
+ convertSkylarkListOrNestedSetToList(entry.getValue(), String.class)));
+ }
+ return compilationModeFlagsBuilder.build();
+ }
}
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcToolchainConfigInfo.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcToolchainConfigInfo.java
index 032bae9..71f9bec 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcToolchainConfigInfo.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcToolchainConfigInfo.java
@@ -15,6 +15,8 @@
package com.google.devtools.build.lib.rules.cpp;
import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.devtools.build.lib.analysis.config.CompilationMode;
import com.google.devtools.build.lib.analysis.config.InvalidConfigurationException;
import com.google.devtools.build.lib.concurrent.ThreadSafety.Immutable;
import com.google.devtools.build.lib.packages.NativeInfo;
@@ -23,6 +25,7 @@
import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.ArtifactNamePattern;
import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.Feature;
import com.google.devtools.build.lib.skyframe.serialization.autocodec.AutoCodec;
+import com.google.devtools.build.lib.skylarkbuildapi.cpp.CcToolchainConfigInfoApi;
import com.google.devtools.build.lib.util.Pair;
import com.google.devtools.build.lib.view.config.crosstool.CrosstoolConfig.CToolchain;
import com.google.devtools.build.lib.view.config.crosstool.CrosstoolConfig.CompilationModeFlags;
@@ -31,7 +34,7 @@
/** Information describing C++ toolchain derived from CROSSTOOL file. */
@Immutable
-public class CcToolchainConfigInfo extends NativeInfo {
+public class CcToolchainConfigInfo extends NativeInfo implements CcToolchainConfigInfoApi {
public static final NativeProvider<CcToolchainConfigInfo> PROVIDER =
new NativeProvider<CcToolchainConfigInfo>(
CcToolchainConfigInfo.class, "CcToolchainConfigInfo") {};
@@ -67,27 +70,21 @@
private final ImmutableList<String> testOnlyLinkerFlags;
private final ImmutableList<String> objcopyEmbedFlags;
private final ImmutableList<String> ldEmbedFlags;
- private final ImmutableList<String> optCompilationModeCompilerFlags;
- private final ImmutableList<String> optCompilationModeCxxFlags;
- private final ImmutableList<String> optCompilationModeLinkerFlags;
- private final ImmutableList<String> dbgCompilationModeCompilerFlags;
- private final ImmutableList<String> dbgCompilationModeCxxFlags;
- private final ImmutableList<String> dbgCompilationModeLinkerFlags;
- private final ImmutableList<String> fastbuildCompilationModeCompilerFlags;
- private final ImmutableList<String> fastbuildCompilationModeCxxFlags;
- private final ImmutableList<String> fastbuildCompilationModeLinkerFlags;
+ private final ImmutableMap<CompilationMode, ImmutableList<String>> compilationModeCompilerFlags;
+ private final ImmutableMap<CompilationMode, ImmutableList<String>> compilationModeCxxFlags;
+ private final ImmutableMap<CompilationMode, ImmutableList<String>> compilationModeLinkerFlags;
private final ImmutableList<String> mostlyStaticLinkingModeFlags;
private final ImmutableList<String> dynamicLinkingModeFlags;
private final ImmutableList<String> fullyStaticLinkingModeFlags;
private final ImmutableList<String> mostlyStaticLibrariesLinkingModeFlags;
private final ImmutableList<Pair<String, String>> makeVariables;
private final String builtinSysroot;
- private final String defaultGrteTop;
+ private final String defaultLibcTop;
private final String ccTargetOs;
private final boolean hasDynamicLinkingModeFlags;
@AutoCodec.Instantiator
- protected CcToolchainConfigInfo(
+ public CcToolchainConfigInfo(
ImmutableList<ActionConfig> actionConfigs,
ImmutableList<Feature> features,
ImmutableList<ArtifactNamePattern> artifactNamePatterns,
@@ -118,22 +115,16 @@
ImmutableList<String> testOnlyLinkerFlags,
ImmutableList<String> objcopyEmbedFlags,
ImmutableList<String> ldEmbedFlags,
- ImmutableList<String> optCompilationModeCompilerFlags,
- ImmutableList<String> optCompilationModeCxxFlags,
- ImmutableList<String> optCompilationModeLinkerFlags,
- ImmutableList<String> dbgCompilationModeCompilerFlags,
- ImmutableList<String> dbgCompilationModeCxxFlags,
- ImmutableList<String> dbgCompilationModeLinkerFlags,
- ImmutableList<String> fastbuildCompilationModeCompilerFlags,
- ImmutableList<String> fastbuildCompilationModeCxxFlags,
- ImmutableList<String> fastbuildCompilationModeLinkerFlags,
+ ImmutableMap<CompilationMode, ImmutableList<String>> compilationModeCompilerFlags,
+ ImmutableMap<CompilationMode, ImmutableList<String>> compilationModeCxxFlags,
+ ImmutableMap<CompilationMode, ImmutableList<String>> compilationModeLinkerFlags,
ImmutableList<String> mostlyStaticLinkingModeFlags,
ImmutableList<String> dynamicLinkingModeFlags,
ImmutableList<String> fullyStaticLinkingModeFlags,
ImmutableList<String> mostlyStaticLibrariesLinkingModeFlags,
ImmutableList<Pair<String, String>> makeVariables,
String builtinSysroot,
- String defaultGrteTop,
+ String defaultLibcTop,
String ccTargetOs,
boolean hasDynamicLinkingModeFlags) {
super(PROVIDER);
@@ -167,22 +158,16 @@
this.testOnlyLinkerFlags = testOnlyLinkerFlags;
this.objcopyEmbedFlags = objcopyEmbedFlags;
this.ldEmbedFlags = ldEmbedFlags;
- this.optCompilationModeCompilerFlags = optCompilationModeCompilerFlags;
- this.optCompilationModeCxxFlags = optCompilationModeCxxFlags;
- this.optCompilationModeLinkerFlags = optCompilationModeLinkerFlags;
- this.dbgCompilationModeCompilerFlags = dbgCompilationModeCompilerFlags;
- this.dbgCompilationModeCxxFlags = dbgCompilationModeCxxFlags;
- this.dbgCompilationModeLinkerFlags = dbgCompilationModeLinkerFlags;
- this.fastbuildCompilationModeCompilerFlags = fastbuildCompilationModeCompilerFlags;
- this.fastbuildCompilationModeCxxFlags = fastbuildCompilationModeCxxFlags;
- this.fastbuildCompilationModeLinkerFlags = fastbuildCompilationModeLinkerFlags;
+ this.compilationModeCompilerFlags = compilationModeCompilerFlags;
+ this.compilationModeCxxFlags = compilationModeCxxFlags;
+ this.compilationModeLinkerFlags = compilationModeLinkerFlags;
this.mostlyStaticLinkingModeFlags = mostlyStaticLinkingModeFlags;
this.dynamicLinkingModeFlags = dynamicLinkingModeFlags;
this.fullyStaticLinkingModeFlags = fullyStaticLinkingModeFlags;
this.mostlyStaticLibrariesLinkingModeFlags = mostlyStaticLibrariesLinkingModeFlags;
this.makeVariables = makeVariables;
this.builtinSysroot = builtinSysroot;
- this.defaultGrteTop = defaultGrteTop;
+ this.defaultLibcTop = defaultLibcTop;
this.ccTargetOs = ccTargetOs;
this.hasDynamicLinkingModeFlags = hasDynamicLinkingModeFlags;
}
@@ -243,6 +228,27 @@
}
}
+ ImmutableMap.Builder<CompilationMode, ImmutableList<String>> compilationModeCompilerFlags =
+ ImmutableMap.builder();
+ compilationModeCompilerFlags.put(CompilationMode.OPT, optCompilationModeCompilerFlags.build());
+ compilationModeCompilerFlags.put(CompilationMode.DBG, dbgCompilationModeCompilerFlags.build());
+ compilationModeCompilerFlags.put(
+ CompilationMode.FASTBUILD, fastbuildCompilationModeCompilerFlags.build());
+
+ ImmutableMap.Builder<CompilationMode, ImmutableList<String>> compilationModeCxxFlags =
+ ImmutableMap.builder();
+ compilationModeCxxFlags.put(CompilationMode.OPT, optCompilationModeCxxFlags.build());
+ compilationModeCxxFlags.put(CompilationMode.DBG, dbgCompilationModeCxxFlags.build());
+ compilationModeCxxFlags.put(
+ CompilationMode.FASTBUILD, fastbuildCompilationModeCxxFlags.build());
+
+ ImmutableMap.Builder<CompilationMode, ImmutableList<String>> compilationModeLinkerFlags =
+ ImmutableMap.builder();
+ compilationModeLinkerFlags.put(CompilationMode.OPT, optCompilationModeLinkerFlags.build());
+ compilationModeLinkerFlags.put(CompilationMode.DBG, dbgCompilationModeLinkerFlags.build());
+ compilationModeLinkerFlags.put(
+ CompilationMode.FASTBUILD, fastbuildCompilationModeLinkerFlags.build());
+
boolean hasDynamicLinkingModeFlags = false;
for (LinkingModeFlags flag : toolchain.getLinkingModeFlagsList()) {
switch (flag.getMode()) {
@@ -284,9 +290,7 @@
toolchain.getSupportsFission(),
toolchain.getSupportsDsym(),
toolchain.getNeedsPic(),
- toolchain
- .getToolPathList()
- .stream()
+ toolchain.getToolPathList().stream()
.map(a -> Pair.of(a.getName(), a.getPath()))
.collect(ImmutableList.toImmutableList()),
ImmutableList.copyOf(toolchain.getCompilerFlagList()),
@@ -297,22 +301,14 @@
ImmutableList.copyOf(toolchain.getTestOnlyLinkerFlagList()),
ImmutableList.copyOf(toolchain.getObjcopyEmbedFlagList()),
ImmutableList.copyOf(toolchain.getLdEmbedFlagList()),
- optCompilationModeCompilerFlags.build(),
- optCompilationModeCxxFlags.build(),
- optCompilationModeLinkerFlags.build(),
- dbgCompilationModeCompilerFlags.build(),
- dbgCompilationModeCxxFlags.build(),
- dbgCompilationModeLinkerFlags.build(),
- fastbuildCompilationModeCompilerFlags.build(),
- fastbuildCompilationModeCxxFlags.build(),
- fastbuildCompilationModeLinkerFlags.build(),
+ compilationModeCompilerFlags.build(),
+ compilationModeCxxFlags.build(),
+ compilationModeLinkerFlags.build(),
mostlyStaticLinkerFlags.build(),
dynamicLinkerFlags.build(),
fullyStaticLinkerFlags.build(),
mostlyStaticLibrariesLinkerFlags.build(),
- toolchain
- .getMakeVariableList()
- .stream()
+ toolchain.getMakeVariableList().stream()
.map(makeVariable -> Pair.of(makeVariable.getName(), makeVariable.getValue()))
.collect(ImmutableList.toImmutableList()),
toolchain.getBuiltinSysroot(),
@@ -533,62 +529,62 @@
// TODO(b/65151735): Remove once this field is migrated to features.
@Deprecated
- public String getDefaultGrteTop() {
- return defaultGrteTop;
+ public String getDefaultLibcTop() {
+ return defaultLibcTop;
}
// TODO(b/65151735): Remove once this field is migrated to features.
@Deprecated
public ImmutableList<String> getOptCompilationModeCompilerFlags() {
- return optCompilationModeCompilerFlags;
+ return compilationModeCompilerFlags.get(CompilationMode.OPT);
}
// TODO(b/65151735): Remove once this field is migrated to features.
@Deprecated
public ImmutableList<String> getOptCompilationModeCxxFlags() {
- return optCompilationModeCxxFlags;
+ return compilationModeCxxFlags.get(CompilationMode.OPT);
}
// TODO(b/65151735): Remove once this field is migrated to features.
@Deprecated
public ImmutableList<String> getOptCompilationModeLinkerFlags() {
- return optCompilationModeLinkerFlags;
+ return compilationModeLinkerFlags.get(CompilationMode.OPT);
}
// TODO(b/65151735): Remove once this field is migrated to features.
@Deprecated
public ImmutableList<String> getDbgCompilationModeCompilerFlags() {
- return dbgCompilationModeCompilerFlags;
+ return compilationModeCompilerFlags.get(CompilationMode.DBG);
}
// TODO(b/65151735): Remove once this field is migrated to features.
@Deprecated
public ImmutableList<String> getDbgCompilationModeCxxFlags() {
- return dbgCompilationModeCxxFlags;
+ return compilationModeCxxFlags.get(CompilationMode.DBG);
}
// TODO(b/65151735): Remove once this field is migrated to features.
@Deprecated
public ImmutableList<String> getDbgCompilationModeLinkerFlags() {
- return dbgCompilationModeLinkerFlags;
+ return compilationModeLinkerFlags.get(CompilationMode.DBG);
}
// TODO(b/65151735): Remove once this field is migrated to features.
@Deprecated
public ImmutableList<String> getFastbuildCompilationModeCompilerFlags() {
- return fastbuildCompilationModeCompilerFlags;
+ return compilationModeCompilerFlags.get(CompilationMode.FASTBUILD);
}
// TODO(b/65151735): Remove once this field is migrated to features.
@Deprecated
public ImmutableList<String> getFastbuildCompilationModeCxxFlags() {
- return fastbuildCompilationModeCxxFlags;
+ return compilationModeCxxFlags.get(CompilationMode.FASTBUILD);
}
// TODO(b/65151735): Remove once this field is migrated to features.
@Deprecated
public ImmutableList<String> getFastbuildCompilationModeLinkerFlags() {
- return fastbuildCompilationModeLinkerFlags;
+ return compilationModeLinkerFlags.get(CompilationMode.FASTBUILD);
}
// TODO(b/65151735): Remove once this field is migrated to features.
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcToolchainFeatures.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcToolchainFeatures.java
index 610867d..5fca15a 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcToolchainFeatures.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcToolchainFeatures.java
@@ -102,17 +102,14 @@
public static final String COLLIDING_PROVIDES_ERROR =
"Symbol %s is provided by all of the following features: %s";
- /**
- * A single flag to be expanded under a set of variables.
- */
+ /** A single flag to be expanded under a set of variables. */
@Immutable
@AutoCodec
@VisibleForSerialization
- static class Flag implements Serializable, Expandable {
+ public static class Flag implements Serializable, Expandable {
private final ImmutableList<StringChunk> chunks;
- @VisibleForSerialization
- Flag(ImmutableList<StringChunk> chunks) {
+ public Flag(ImmutableList<StringChunk> chunks) {
this.chunks = chunks;
}
@@ -196,8 +193,7 @@
/** A single environment key/value pair to be expanded under a set of variables. */
@Immutable
@AutoCodec
- @VisibleForSerialization
- static class EnvEntry implements Serializable {
+ public static class EnvEntry implements Serializable {
private final String key;
private final ImmutableList<StringChunk> valueChunks;
@@ -208,8 +204,7 @@
}
@AutoCodec.Instantiator
- @VisibleForSerialization
- EnvEntry(String key, ImmutableList<StringChunk> valueChunks) {
+ public EnvEntry(String key, ImmutableList<StringChunk> valueChunks) {
this.key = key;
this.valueChunks = valueChunks;
}
@@ -246,10 +241,10 @@
}
}
+ /** Used for equality check between a variable and a specific value. */
@Immutable
@AutoCodec
- @VisibleForSerialization
- static class VariableWithValue {
+ public static class VariableWithValue {
public final String variable;
public final String value;
@@ -266,7 +261,7 @@
@Immutable
@AutoCodec
@VisibleForSerialization
- static class FlagGroup implements Serializable, Expandable {
+ public static class FlagGroup implements Serializable, Expandable {
private final ImmutableList<Expandable> expandables;
private String iterateOverVariable;
private final ImmutableSet<String> expandIfAllAvailable;
@@ -463,7 +458,7 @@
@Immutable
@AutoCodec
@VisibleForSerialization
- static class FlagSet implements Serializable {
+ public static class FlagSet implements Serializable {
private final ImmutableSet<String> actions;
private final ImmutableSet<String> expandIfAllAvailable;
private final ImmutableSet<WithFeatureSet> withFeatureSets;
@@ -493,8 +488,7 @@
}
@AutoCodec.Instantiator
- @VisibleForSerialization
- FlagSet(
+ public FlagSet(
ImmutableSet<String> actions,
ImmutableSet<String> expandIfAllAvailable,
ImmutableSet<WithFeatureSet> withFeatureSets,
@@ -546,10 +540,14 @@
}
}
+ /**
+ * A set of positive and negative features. This stanza will evaluate to true when every 'feature'
+ * is enabled, and every 'not_feature' is not enabled.
+ */
@Immutable
@AutoCodec
@VisibleForSerialization
- static class WithFeatureSet implements Serializable {
+ public static class WithFeatureSet implements Serializable {
private final ImmutableSet<String> features;
private final ImmutableSet<String> notFeatures;
@@ -559,8 +557,7 @@
}
@AutoCodec.Instantiator
- @VisibleForSerialization
- WithFeatureSet(ImmutableSet<String> features, ImmutableSet<String> notFeatures) {
+ public WithFeatureSet(ImmutableSet<String> features, ImmutableSet<String> notFeatures) {
this.features = features;
this.notFeatures = notFeatures;
}
@@ -596,7 +593,7 @@
@Immutable
@AutoCodec
@VisibleForSerialization
- static class EnvSet implements Serializable {
+ public static class EnvSet implements Serializable {
private final ImmutableSet<String> actions;
private final ImmutableList<EnvEntry> envEntries;
private final ImmutableSet<WithFeatureSet> withFeatureSets;
@@ -617,8 +614,7 @@
}
@AutoCodec.Instantiator
- @VisibleForSerialization
- EnvSet(
+ public EnvSet(
ImmutableSet<String> actions,
ImmutableList<EnvEntry> envEntries,
ImmutableSet<WithFeatureSet> withFeatureSets) {
@@ -685,7 +681,7 @@
@Immutable
@AutoCodec
@VisibleForSerialization
- static class Feature implements Serializable, CrosstoolSelectable {
+ public static class Feature implements Serializable, CrosstoolSelectable {
private static final Interner<Feature> FEATURE_INTERNER = BlazeInterners.newWeakInterner();
private final String name;
@@ -721,7 +717,7 @@
this.provides = ImmutableList.copyOf(feature.getProvidesList());
}
- private Feature(
+ public Feature(
String name,
ImmutableList<FlagSet> flagSets,
ImmutableList<EnvSet> envSets,
@@ -890,7 +886,7 @@
*/
@Immutable
@AutoCodec
- static class ActionConfig implements Serializable, CrosstoolSelectable {
+ public static class ActionConfig implements Serializable, CrosstoolSelectable {
public static final String FLAG_SET_WITH_ACTION_ERROR =
"action_config %s specifies actions. An action_config's flag sets automatically apply "
+ "to the configured action. Thus, you must not specify action lists in an "
@@ -938,7 +934,7 @@
this.implies = ImmutableList.copyOf(actionConfig.getImpliesList());
}
- private ActionConfig(
+ public ActionConfig(
String configName,
String actionName,
ImmutableList<Tool> tools,
@@ -1045,7 +1041,7 @@
/** A description of how artifacts of a certain type are named. */
@Immutable
- static class ArtifactNamePattern {
+ public static class ArtifactNamePattern {
private final ArtifactCategory artifactCategory;
private final String prefix;
@@ -1082,6 +1078,12 @@
this.extension = artifactNamePattern.getExtension();
}
+ public ArtifactNamePattern(ArtifactCategory artifactCategory, String prefix, String extension) {
+ this.artifactCategory = artifactCategory;
+ this.prefix = prefix;
+ this.extension = extension;
+ }
+
/** Returns the ArtifactCategory for this ArtifactNamePattern. */
ArtifactCategory getArtifactCategory() {
return this.artifactCategory;
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcToolchainVariables.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcToolchainVariables.java
index 1ac3b5f..d19004f 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CcToolchainVariables.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CcToolchainVariables.java
@@ -156,7 +156,7 @@
*
* <p>To get a literal percent character, "%%" can be used in the string.
*/
- static class StringValueParser {
+ public static class StringValueParser {
private final String value;
@@ -168,13 +168,13 @@
private final ImmutableList.Builder<StringChunk> chunks = ImmutableList.builder();
private final ImmutableSet.Builder<String> usedVariables = ImmutableSet.builder();
- StringValueParser(String value) throws InvalidConfigurationException {
+ public StringValueParser(String value) throws InvalidConfigurationException {
this.value = value;
parse();
}
/** @return the parsed chunks for this string. */
- ImmutableList<StringChunk> getChunks() {
+ public ImmutableList<StringChunk> getChunks() {
return chunks.build();
}
@@ -262,7 +262,7 @@
}
/** A flag or flag group that can be expanded under a set of variables. */
- interface Expandable {
+ public interface Expandable {
/**
* Expands the current expandable under the given {@code view}, adding new flags to {@code
* commandLine}.
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CppConfiguration.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CppConfiguration.java
index 49a3c06..22786d1 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CppConfiguration.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CppConfiguration.java
@@ -1221,4 +1221,8 @@
}
return PathFragment.create(builtInSysroot);
}
+
+ boolean enableCcToolchainConfigInfoFromSkylark() {
+ return cppOptions.enableCcToolchainConfigInfoFromSkylark;
+ }
}
diff --git a/src/main/java/com/google/devtools/build/lib/rules/cpp/CppOptions.java b/src/main/java/com/google/devtools/build/lib/rules/cpp/CppOptions.java
index 7b70235..6c6dd00 100644
--- a/src/main/java/com/google/devtools/build/lib/rules/cpp/CppOptions.java
+++ b/src/main/java/com/google/devtools/build/lib/rules/cpp/CppOptions.java
@@ -841,6 +841,15 @@
public boolean enableCcToolchainFromCrosstool;
@Option(
+ name = "experimental_enable_cc_toolchain_config_info",
+ defaultValue = "false",
+ documentationCategory = OptionDocumentationCategory.TOOLCHAIN,
+ effectTags = {OptionEffectTag.LOADING_AND_ANALYSIS},
+ metadataTags = {OptionMetadataTag.EXPERIMENTAL},
+ help = "If true, Bazel will allow creating a CcToolchainConfigInfo.")
+ public boolean enableCcToolchainConfigInfoFromSkylark;
+
+ @Option(
name = "experimental_includes_attribute_subpackage_traversal",
defaultValue = "true",
documentationCategory = OptionDocumentationCategory.UNDOCUMENTED,
diff --git a/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/cpp/CcToolchainConfigInfoApi.java b/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/cpp/CcToolchainConfigInfoApi.java
new file mode 100644
index 0000000..deaaeab
--- /dev/null
+++ b/src/main/java/com/google/devtools/build/lib/skylarkbuildapi/cpp/CcToolchainConfigInfoApi.java
@@ -0,0 +1,31 @@
+// Copyright 2018 The Bazel Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.google.devtools.build.lib.skylarkbuildapi.cpp;
+
+import com.google.devtools.build.lib.skylarkbuildapi.StructApi;
+import com.google.devtools.build.lib.skylarkinterface.SkylarkModule;
+import com.google.devtools.build.lib.skylarkinterface.SkylarkModuleCategory;
+
+/** Additional layer of configurability for c++ rules through features and actions. */
+@SkylarkModule(
+ name = "CcToolchainConfigInfo",
+ namespace = true,
+ category = SkylarkModuleCategory.BUILTIN,
+ doc =
+ "Additional layer of configurability for C++ rules. Encapsulates platform-dependent "
+ + "specifics of C++ actions through features and action configs. It is used to "
+ + "configure the C++ toolchain, and later on for command line construction. "
+ + "Replaces the functionality of CROSSTOOL file.")
+public interface CcToolchainConfigInfoApi extends StructApi {}
diff --git a/src/test/java/com/google/devtools/build/lib/rules/cpp/BUILD b/src/test/java/com/google/devtools/build/lib/rules/cpp/BUILD
index 71cfffb..bbce0d8 100644
--- a/src/test/java/com/google/devtools/build/lib/rules/cpp/BUILD
+++ b/src/test/java/com/google/devtools/build/lib/rules/cpp/BUILD
@@ -21,6 +21,7 @@
) + ["proto/CcProtoLibraryTest.java"],
resources = [
"//tools/build_defs/cc:action_names.bzl",
+ "//tools/cpp:cc_toolchain_config_lib.bzl",
"//tools/cpp:crosstool_utils",
"//tools/cpp:lib_cc_configure",
],
diff --git a/src/test/java/com/google/devtools/build/lib/rules/cpp/SkylarkCcCommonTest.java b/src/test/java/com/google/devtools/build/lib/rules/cpp/SkylarkCcCommonTest.java
index 7f688bf..4f1600e 100644
--- a/src/test/java/com/google/devtools/build/lib/rules/cpp/SkylarkCcCommonTest.java
+++ b/src/test/java/com/google/devtools/build/lib/rules/cpp/SkylarkCcCommonTest.java
@@ -14,6 +14,8 @@
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 static org.junit.Assert.fail;
import com.google.common.base.Joiner;
import com.google.common.collect.ImmutableList;
@@ -24,14 +26,29 @@
import com.google.devtools.build.lib.analysis.configuredtargets.RuleConfiguredTarget.Mode;
import com.google.devtools.build.lib.analysis.util.AnalysisMock;
import com.google.devtools.build.lib.analysis.util.BuildViewTestCase;
+import com.google.devtools.build.lib.packages.SkylarkInfo;
import com.google.devtools.build.lib.packages.util.ResourceLoader;
+import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.ActionConfig;
+import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.EnvEntry;
+import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.EnvSet;
+import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.Feature;
import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.FeatureConfiguration;
+import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.FlagGroup;
+import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.FlagSet;
+import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.Tool;
+import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.VariableWithValue;
+import com.google.devtools.build.lib.rules.cpp.CcToolchainFeatures.WithFeatureSet;
+import com.google.devtools.build.lib.rules.cpp.CcToolchainVariables.StringValueParser;
import com.google.devtools.build.lib.rules.cpp.LinkerInputs.LibraryToLink;
import com.google.devtools.build.lib.skylarkbuildapi.cpp.LibraryToLinkApi;
+import com.google.devtools.build.lib.syntax.EvalException;
import com.google.devtools.build.lib.syntax.SkylarkDict;
import com.google.devtools.build.lib.syntax.SkylarkList;
import com.google.devtools.build.lib.syntax.SkylarkNestedSet;
import com.google.devtools.build.lib.testutil.TestConstants;
+import com.google.devtools.build.lib.util.Pair;
+import com.google.devtools.build.lib.vfs.PathFragment;
+import java.io.IOException;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
@@ -1357,4 +1374,2612 @@
ConfiguredTarget target = getConfiguredTarget("//foo:bin");
return (CppLinkAction) getGeneratingAction(artifactByPath(getFilesToBuild(target), "bin"));
}
+
+ private void loadCcToolchainConfigLib() throws IOException {
+ scratch.appendFile("tools/cpp/BUILD", "");
+ scratch.file(
+ "tools/cpp/cc_toolchain_config_lib.bzl",
+ ResourceLoader.readFromResources(
+ TestConstants.BAZEL_REPO_PATH + "tools/cpp/cc_toolchain_config_lib.bzl"));
+ }
+
+ @Test
+ public void testVariableWithValue() throws Exception {
+ loadCcToolchainConfigLib();
+ createVariableWithValueRule("one", /* name= */ "None", /* value= */ "None");
+
+ AssertionError e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//one:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("name parameter of variable_with_value should be a string, found NoneType");
+
+ createVariableWithValueRule("two", /* name= */ "'abc'", /* value= */ "None");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//two:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("value parameter of variable_with_value should be a string, found NoneType");
+
+ createVariableWithValueRule("three", /* name= */ "''", /* value= */ "None");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//three:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("name parameter of variable_with_value must be a nonempty string");
+
+ createVariableWithValueRule("four", /* name= */ "'abc'", /* value= */ "''");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//four:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("value parameter of variable_with_value must be a nonempty string");
+
+ createVariableWithValueRule("five", /* name= */ "'abc'", /* value= */ "'def'");
+
+ ConfiguredTarget t = getConfiguredTarget("//five:a");
+ SkylarkInfo variable = (SkylarkInfo) t.get("variable");
+ assertThat(variable).isNotNull();
+ VariableWithValue v = CcModule.variableWithValueFromSkylark(variable);
+ assertThat(v).isNotNull();
+ assertThat(v.variable).isEqualTo("abc");
+ assertThat(v.value).isEqualTo("def");
+
+ createEnvEntryRule("six", /* key= */ "'abc'", /* value= */ "'def'");
+ t = getConfiguredTarget("//six:a");
+ SkylarkInfo envEntry = (SkylarkInfo) t.get("entry");
+ try {
+ CcModule.variableWithValueFromSkylark(envEntry);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Expected object of type 'variable_with_value', received 'env_entry");
+ }
+ }
+
+ private void createVariableWithValueRule(String pkg, String name, String value)
+ throws IOException {
+ scratch.file(
+ pkg + "/foo.bzl",
+ "load('//tools/cpp:cc_toolchain_config_lib.bzl', 'variable_with_value')",
+ "def _impl(ctx):",
+ " return struct(variable = variable_with_value(",
+ " name = " + name + ",",
+ " value = " + value + "))",
+ "crule = rule(implementation = _impl)");
+ scratch.file(pkg + "/BUILD", "load(':foo.bzl', 'crule')", "crule(name = 'a')");
+ }
+
+ @Test
+ public void testCustomVariableWithValue() throws Exception {
+ loadCcToolchainConfigLib();
+ createCustomVariableWithValueRule("one", /* name= */ "None", /* value= */ "None");
+ ConfiguredTarget t = getConfiguredTarget("//one:a");
+ SkylarkInfo variable = (SkylarkInfo) t.get("variable");
+ try {
+ CcModule.variableWithValueFromSkylark(variable);
+ fail("Should have failed because of empty string.");
+ } catch (EvalException e) {
+ assertThat(e)
+ .hasMessageThat()
+ .contains("'name' parameter of variable_with_value must be a nonempty string.");
+ }
+
+ createCustomVariableWithValueRule("two", /* name= */ "'abc'", /* value= */ "None");
+
+ t = getConfiguredTarget("//two:a");
+ variable = (SkylarkInfo) t.get("variable");
+ try {
+ CcModule.variableWithValueFromSkylark(variable);
+ fail("Should have failed because of empty string.");
+ } catch (EvalException e) {
+ assertThat(e)
+ .hasMessageThat()
+ .contains("'value' parameter of variable_with_value must be a nonempty string.");
+ }
+
+ createCustomVariableWithValueRule("three", /* name= */ "'abc'", /* value= */ "struct()");
+
+ t = getConfiguredTarget("//three:a");
+ variable = (SkylarkInfo) t.get("variable");
+ try {
+ CcModule.variableWithValueFromSkylark(variable);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException e) {
+ assertThat(e).hasMessageThat().contains("Field 'value' is not of 'java.lang.String' type.");
+ }
+
+ createCustomVariableWithValueRule("four", /* name= */ "True", /* value= */ "'abc'");
+
+ t = getConfiguredTarget("//four:a");
+ variable = (SkylarkInfo) t.get("variable");
+ try {
+ CcModule.variableWithValueFromSkylark(variable);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException e) {
+ assertThat(e).hasMessageThat().contains("Field 'name' is not of 'java.lang.String' type.");
+ }
+ }
+
+ private void createCustomVariableWithValueRule(String pkg, String name, String value)
+ throws IOException {
+ scratch.file(
+ pkg + "/foo.bzl",
+ "def _impl(ctx):",
+ " return struct(variable = struct(",
+ " name = " + name + ",",
+ " value = " + value + ",",
+ " type_name = 'variable_with_value'))",
+ "crule = rule(implementation = _impl)");
+ scratch.file(pkg + "/BUILD", "load(':foo.bzl', 'crule')", "crule(name = 'a')");
+ }
+
+ @Test
+ public void testEnvEntry() throws Exception {
+ loadCcToolchainConfigLib();
+ createEnvEntryRule("one", "None", /* value= */ "None");
+
+ AssertionError e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//one:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("key parameter of env_entry should be a string, found NoneType");
+
+ createEnvEntryRule("two", "'abc'", /* value= */ "None");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//two:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("value parameter of env_entry should be a string, found NoneType");
+
+ createEnvEntryRule("three", "''", /* value= */ "None");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//three:a"));
+ assertThat(e).hasMessageThat().contains("key parameter of env_entry must be a nonempty string");
+
+ createEnvEntryRule("four", "'abc'", /* value= */ "''");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//four:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("value parameter of env_entry must be a nonempty string");
+
+ createEnvEntryRule("five", "'abc'", /* value= */ "'def'");
+
+ ConfiguredTarget t = getConfiguredTarget("//five:a");
+ SkylarkInfo entryProvider = (SkylarkInfo) t.get("entry");
+ assertThat(entryProvider).isNotNull();
+ EnvEntry entry = CcModule.envEntryFromSkylark(entryProvider);
+ assertThat(entry).isNotNull();
+ StringValueParser parser = new StringValueParser("def");
+ assertThat(entry).isEqualTo(new EnvEntry("abc", parser.getChunks()));
+
+ createVariableWithValueRule("six", /* name= */ "'abc'", /* value= */ "'def'");
+ t = getConfiguredTarget("//six:a");
+ SkylarkInfo variable = (SkylarkInfo) t.get("variable");
+ try {
+ CcModule.envEntryFromSkylark(variable);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Expected object of type 'env_entry', received 'variable_with_value");
+ }
+ }
+
+ private void createEnvEntryRule(String pkg, String key, String value) throws Exception {
+ scratch.file(
+ pkg + "/foo.bzl",
+ "load('//tools/cpp:cc_toolchain_config_lib.bzl', 'env_entry')",
+ "def _impl(ctx):",
+ " return struct(entry = env_entry(",
+ " key = " + key + ",",
+ " value = " + value + "))",
+ "crule = rule(implementation = _impl)");
+ scratch.file(pkg + "/BUILD", "load(':foo.bzl', 'crule')", "crule(name = 'a')");
+ }
+
+ @Test
+ public void testCustomEnvEntry() throws Exception {
+ loadCcToolchainConfigLib();
+
+ createCustomEnvEntryRule("one", /* key= */ "None", /* value= */ "None");
+
+ ConfiguredTarget t = getConfiguredTarget("//one:a");
+ SkylarkInfo entry = (SkylarkInfo) t.get("entry");
+ try {
+ CcModule.envEntryFromSkylark(entry);
+ fail("Should have failed because of empty string.");
+ } catch (EvalException e) {
+ assertThat(e)
+ .hasMessageThat()
+ .contains("'key' parameter of env_entry must be a nonempty string.");
+ }
+
+ createCustomEnvEntryRule("two", /* key= */ "'abc'", /* value= */ "None");
+
+ t = getConfiguredTarget("//two:a");
+ entry = (SkylarkInfo) t.get("entry");
+ try {
+ CcModule.envEntryFromSkylark(entry);
+ fail("Should have failed because of empty string.");
+ ;
+ } catch (EvalException e) {
+ assertThat(e)
+ .hasMessageThat()
+ .contains("'value' parameter of env_entry must be a nonempty string.");
+ }
+
+ createCustomEnvEntryRule("three", /* key= */ "'abc'", /* value= */ "struct()");
+
+ t = getConfiguredTarget("//three:a");
+ entry = (SkylarkInfo) t.get("entry");
+ try {
+ CcModule.envEntryFromSkylark(entry);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException e) {
+ assertThat(e).hasMessageThat().contains("Field 'value' is not of 'java.lang.String' type.");
+ }
+
+ createCustomEnvEntryRule("four", /* key= */ "True", /* value= */ "'abc'");
+
+ t = getConfiguredTarget("//four:a");
+ entry = (SkylarkInfo) t.get("entry");
+ try {
+ CcModule.envEntryFromSkylark(entry);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException e) {
+ assertThat(e).hasMessageThat().contains("Field 'key' is not of 'java.lang.String' type.");
+ }
+ }
+
+ private void createCustomEnvEntryRule(String pkg, String key, String value) throws Exception {
+ scratch.file(
+ pkg + "/foo.bzl",
+ "def _impl(ctx):",
+ " return struct(entry = struct(",
+ " key = " + key + ",",
+ " value = " + value + ",",
+ " type_name = 'env_entry'))",
+ "crule = rule(implementation = _impl)");
+ scratch.file(pkg + "/BUILD", "load(':foo.bzl', 'crule')", "crule(name = 'a')");
+ }
+
+ @Test
+ public void testToolPath() throws Exception {
+ loadCcToolchainConfigLib();
+ createToolPathRule("one", /* name= */ "None", "None");
+
+ AssertionError e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//one:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("name parameter of tool_path should be a string, found NoneType");
+
+ createToolPathRule("two", /* name= */ "'abc'", "None");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//two:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("path parameter of tool_path should be a string, found NoneType");
+
+ createToolPathRule("three", /* name= */ "''", "None");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//three:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("name parameter of tool_path must be a nonempty string");
+
+ createToolPathRule("four", /* name= */ "'abc'", "''");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//four:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("path parameter of tool_path must be a nonempty string");
+
+ createToolPathRule("five", /* name= */ "'abc'", "'/d/e/f'");
+
+ ConfiguredTarget t = getConfiguredTarget("//five:a");
+ SkylarkInfo toolPathProvider = (SkylarkInfo) t.get("toolpath");
+ assertThat(toolPathProvider).isNotNull();
+ Pair<String, String> toolPath = CcModule.toolPathFromSkylark(toolPathProvider);
+ assertThat(toolPath).isNotNull();
+ assertThat(toolPath.first).isEqualTo("abc");
+ assertThat(toolPath.second).isEqualTo("/d/e/f");
+
+ createVariableWithValueRule("six", /* name= */ "'abc'", /* value= */ "'def'");
+ t = getConfiguredTarget("//six:a");
+ SkylarkInfo variable = (SkylarkInfo) t.get("variable");
+ try {
+ CcModule.toolPathFromSkylark(variable);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Expected object of type 'tool_path', received 'variable_with_value");
+ }
+ }
+
+ private void createToolPathRule(String pkg, String name, String path) throws IOException {
+ scratch.file(
+ pkg + "/foo.bzl",
+ "load('//tools/cpp:cc_toolchain_config_lib.bzl', 'tool_path')",
+ "def _impl(ctx):",
+ " return struct(toolpath = tool_path(",
+ " name = " + name + ",",
+ " path = " + path + "))",
+ "crule = rule(implementation = _impl)");
+ scratch.file(pkg + "/BUILD", "load(':foo.bzl', 'crule')", "crule(name = 'a')");
+ }
+
+ @Test
+ public void testCustomToolPath() throws Exception {
+ loadCcToolchainConfigLib();
+
+ createCustomToolPathRule("one", /* name= */ "None", /* path= */ "None");
+
+ ConfiguredTarget t = getConfiguredTarget("//one:a");
+ SkylarkInfo toolPath = (SkylarkInfo) t.get("toolpath");
+ try {
+ CcModule.toolPathFromSkylark(toolPath);
+ fail("Should have failed because of empty string.");
+ } catch (EvalException e) {
+ assertThat(e)
+ .hasMessageThat()
+ .contains("'name' parameter of tool_path must be a nonempty string.");
+ }
+
+ createCustomToolPathRule("two", /* name= */ "'abc'", /* path= */ "None");
+
+ t = getConfiguredTarget("//two:a");
+ toolPath = (SkylarkInfo) t.get("toolpath");
+ try {
+ CcModule.toolPathFromSkylark(toolPath);
+ fail("Should have failed because of empty string.");
+ } catch (EvalException e) {
+ assertThat(e)
+ .hasMessageThat()
+ .contains("'path' parameter of tool_path must be a nonempty string.");
+ }
+
+ createCustomToolPathRule("three", /* name= */ "'abc'", /* path= */ "struct()");
+
+ t = getConfiguredTarget("//three:a");
+ toolPath = (SkylarkInfo) t.get("toolpath");
+ try {
+ CcModule.toolPathFromSkylark(toolPath);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException e) {
+ assertThat(e).hasMessageThat().contains("Field 'path' is not of 'java.lang.String' type.");
+ }
+
+ createCustomToolPathRule("four", /* name= */ "True", /* path= */ "'abc'");
+
+ t = getConfiguredTarget("//four:a");
+ toolPath = (SkylarkInfo) t.get("toolpath");
+ try {
+ CcModule.toolPathFromSkylark(toolPath);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException e) {
+ assertThat(e).hasMessageThat().contains("Field 'name' is not of 'java.lang.String' type.");
+ }
+ }
+
+ private void createCustomToolPathRule(String pkg, String name, String path) throws IOException {
+ scratch.file(
+ pkg + "/foo.bzl",
+ "load('//tools/cpp:cc_toolchain_config_lib.bzl', 'tool_path')",
+ "def _impl(ctx):",
+ " return struct(toolpath = struct(",
+ " name = " + name + ",",
+ " path = " + path + ",",
+ " type_name = 'tool_path'))",
+ "crule = rule(implementation = _impl)");
+ scratch.file(pkg + "/BUILD", "load(':foo.bzl', 'crule')", "crule(name = 'a')");
+ }
+
+ @Test
+ public void testMakeVariable() throws Exception {
+ loadCcToolchainConfigLib();
+ createMakeVariablerule("one", /* name= */ "None", /* value= */ "None");
+
+ AssertionError e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//one:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("name parameter of make_variable should be a string, found NoneType");
+
+ createMakeVariablerule("two", /* name= */ "'abc'", /* value= */ "None");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//two:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("value parameter of make_variable should be a string, found NoneType");
+
+ createMakeVariablerule("three", /* name= */ "''", /* value= */ "None");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//three:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("name parameter of make_variable must be a nonempty string");
+
+ createMakeVariablerule("four", /* name= */ "'abc'", /* value= */ "''");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//four:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("value parameter of make_variable must be a nonempty string");
+
+ createMakeVariablerule("five", /* name= */ "'abc'", /* value= */ "'val'");
+
+ ConfiguredTarget t = getConfiguredTarget("//five:a");
+ SkylarkInfo makeVariableProvider = (SkylarkInfo) t.get("variable");
+ assertThat(makeVariableProvider).isNotNull();
+ Pair<String, String> makeVariable = CcModule.makeVariableFromSkylark(makeVariableProvider);
+ assertThat(makeVariable).isNotNull();
+ assertThat(makeVariable.first).isEqualTo("abc");
+ assertThat(makeVariable.second).isEqualTo("val");
+
+ createVariableWithValueRule("six", /* name= */ "'abc'", /* value= */ "'def'");
+ t = getConfiguredTarget("//six:a");
+ SkylarkInfo variable = (SkylarkInfo) t.get("variable");
+ try {
+ CcModule.makeVariableFromSkylark(variable);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Expected object of type 'make_variable', received 'variable_with_value");
+ }
+ }
+
+ private void createMakeVariablerule(String pkg, String name, String value) throws IOException {
+ scratch.file(
+ pkg + "/foo.bzl",
+ "load('//tools/cpp:cc_toolchain_config_lib.bzl', 'make_variable')",
+ "def _impl(ctx):",
+ " return struct(variable = make_variable(",
+ " name = " + name + ",",
+ " value = " + value + "))",
+ "crule = rule(implementation = _impl)");
+ scratch.file(pkg + "/BUILD", "load(':foo.bzl', 'crule')", "crule(name = 'a')");
+ }
+
+ @Test
+ public void testCustomMakeVariable() throws Exception {
+ createCustomMakeVariablerule("one", /* name= */ "None", /* value= */ "None");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//one:a");
+ SkylarkInfo makeVariableProvider = (SkylarkInfo) t.get("variable");
+ CcModule.makeVariableFromSkylark(makeVariableProvider);
+ fail("Should have failed because of empty string.");
+ } catch (EvalException e) {
+ assertThat(e)
+ .hasMessageThat()
+ .contains("'name' parameter of make_variable must be a nonempty string.");
+ }
+
+ createCustomMakeVariablerule("two", /* name= */ "'abc'", /* value= */ "None");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//two:a");
+ SkylarkInfo makeVariableProvider = (SkylarkInfo) t.get("variable");
+ CcModule.makeVariableFromSkylark(makeVariableProvider);
+ fail("Should have failed because of empty string.");
+ } catch (EvalException e) {
+ assertThat(e)
+ .hasMessageThat()
+ .contains("'value' parameter of make_variable must be a nonempty string.");
+ }
+
+ createCustomMakeVariablerule("three", /* name= */ "[]", /* value= */ "None");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//three:a");
+ SkylarkInfo makeVariableProvider = (SkylarkInfo) t.get("variable");
+ CcModule.makeVariableFromSkylark(makeVariableProvider);
+ fail("Should have failed because of empty string.");
+ } catch (EvalException e) {
+ assertThat(e).hasMessageThat().contains("Field 'name' is not of 'java.lang.String' type.");
+ }
+
+ createCustomMakeVariablerule("four", /* name= */ "'abc'", /* value= */ "True");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//four:a");
+ SkylarkInfo makeVariableProvider = (SkylarkInfo) t.get("variable");
+ CcModule.makeVariableFromSkylark(makeVariableProvider);
+ fail("Should have failed because of empty string.");
+ } catch (EvalException e) {
+ assertThat(e).hasMessageThat().contains("Field 'value' is not of 'java.lang.String' type.");
+ }
+ }
+
+ private void createCustomMakeVariablerule(String pkg, String name, String value)
+ throws Exception {
+ scratch.file(
+ pkg + "/foo.bzl",
+ "def _impl(ctx):",
+ " return struct(variable = struct(",
+ " name = " + name + ",",
+ " value = " + value + ",",
+ " type_name = 'make_variable'))",
+ "crule = rule(implementation = _impl)");
+ scratch.file(pkg + "/BUILD", "load(':foo.bzl', 'crule')", "crule(name = 'a')");
+ }
+
+ @Test
+ public void testWithFeatureSet() throws Exception {
+ loadCcToolchainConfigLib();
+ createWithFeatureSetRule("one", /* features= */ "None", /* notFeatures= */ "None");
+
+ AssertionError e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//one:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("features parameter of with_feature_set should be a list, found NoneType");
+
+ createWithFeatureSetRule("two", /* features= */ "['abc']", /* notFeatures= */ "None");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//two:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("not_features parameter of with_feature_set should be a list, found NoneType");
+
+ createWithFeatureSetRule("three", /* features= */ "'asdf'", /* notFeatures= */ "None");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//three:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("features parameter of with_feature_set should be a list, found string");
+
+ createWithFeatureSetRule("four", /* features= */ "['abc']", /* notFeatures= */ "'def'");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//four:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("not_features parameter of with_feature_set should be a list, found string");
+
+ createWithFeatureSetRule(
+ "five", /* features= */ "['f1', 'f2']", /* notFeatures= */ "['nf1', 'nf2']");
+
+ ConfiguredTarget t = getConfiguredTarget("//five:a");
+ SkylarkInfo withFeatureSetProvider = (SkylarkInfo) t.get("wfs");
+ assertThat(withFeatureSetProvider).isNotNull();
+ WithFeatureSet withFeatureSet = CcModule.withFeatureSetFromSkylark(withFeatureSetProvider);
+ assertThat(withFeatureSet).isNotNull();
+ assertThat(withFeatureSet.getFeatures()).containsExactly("f1", "f2");
+ assertThat(withFeatureSet.getNotFeatures()).containsExactly("nf1", "nf2");
+
+ createVariableWithValueRule("six", /* name= */ "'abc'", /* value= */ "'def'");
+ t = getConfiguredTarget("//six:a");
+ SkylarkInfo variable = (SkylarkInfo) t.get("variable");
+ try {
+ CcModule.withFeatureSetFromSkylark(variable);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Expected object of type 'with_feature_set', received 'variable_with_value");
+ }
+ }
+
+ private void createWithFeatureSetRule(String pkg, String features, String notFeatures)
+ throws Exception {
+ scratch.file(
+ pkg + "/foo.bzl",
+ "load('//tools/cpp:cc_toolchain_config_lib.bzl', 'with_feature_set')",
+ "def _impl(ctx):",
+ " return struct(wfs = with_feature_set(",
+ " features = " + features + ",",
+ " not_features = " + notFeatures + "))",
+ "crule = rule(implementation = _impl)");
+ scratch.file(pkg + "/BUILD", "load(':foo.bzl', 'crule')", "crule(name = 'a')");
+ }
+
+ @Test
+ public void testCustomWithFeatureSet() throws Exception {
+ createCustomWithFeatureSetRule("one", /* features= */ "struct()", /* notFeatures= */ "None");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//one:a");
+ SkylarkInfo withFeatureSetProvider = (SkylarkInfo) t.get("wfs");
+ assertThat(withFeatureSetProvider).isNotNull();
+ CcModule.withFeatureSetFromSkylark(withFeatureSetProvider);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException e) {
+ assertThat(e)
+ .hasMessageThat()
+ .contains("Illegal argument: 'features' is not of expected type list or NoneType");
+ }
+
+ createCustomWithFeatureSetRule("two", /* features= */ "['abc']", /* notFeatures= */ "struct()");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//two:a");
+ SkylarkInfo withFeatureSetProvider = (SkylarkInfo) t.get("wfs");
+ assertThat(withFeatureSetProvider).isNotNull();
+ CcModule.withFeatureSetFromSkylark(withFeatureSetProvider);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException e) {
+ assertThat(e)
+ .hasMessageThat()
+ .contains("Illegal argument: 'not_features' is not of expected type list or NoneType");
+ }
+
+ createCustomWithFeatureSetRule("three", /* features= */ "[struct()]", /* notFeatures= */ "[]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//three:a");
+ SkylarkInfo withFeatureSetProvider = (SkylarkInfo) t.get("wfs");
+ assertThat(withFeatureSetProvider).isNotNull();
+ CcModule.withFeatureSetFromSkylark(withFeatureSetProvider);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException e) {
+ assertThat(e)
+ .hasMessageThat()
+ .contains("expected type 'string' for 'features' element but got type 'struct' instead");
+ }
+
+ createCustomWithFeatureSetRule("four", /* features= */ "[]", /* notFeatures= */ "[struct()]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//four:a");
+ SkylarkInfo withFeatureSetProvider = (SkylarkInfo) t.get("wfs");
+ assertThat(withFeatureSetProvider).isNotNull();
+ CcModule.withFeatureSetFromSkylark(withFeatureSetProvider);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException e) {
+ assertThat(e)
+ .hasMessageThat()
+ .contains(
+ "expected type 'string' for 'not_features' element but got type 'struct' instead");
+ }
+ }
+
+ private void createCustomWithFeatureSetRule(String pkg, String features, String notFeatures)
+ throws Exception {
+ scratch.file(
+ pkg + "/foo.bzl",
+ "def _impl(ctx):",
+ " return struct(wfs = struct(",
+ " features = " + features + ",",
+ " not_features = " + notFeatures + ",",
+ " type_name = 'with_feature_set'))",
+ "crule = rule(implementation = _impl)");
+ scratch.file(pkg + "/BUILD", "load(':foo.bzl', 'crule')", "crule(name = 'a')");
+ }
+
+ @Test
+ public void testEnvSet() throws Exception {
+ loadCcToolchainConfigLib();
+ createEnvSetRule(
+ "one", /* actions= */ "['a1']", /* envEntries= */ "None", /* withFeatures= */ "None");
+
+ AssertionError e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//one:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("env_entries parameter of env_set should be a list, found NoneType");
+
+ createEnvSetRule(
+ "two", /* actions= */ "['a1']", /* envEntries= */ "['abc']", /* withFeatures= */ "None");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//two:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("with_features parameter of env_set should be a list, found NoneType");
+
+ createEnvSetRule(
+ "three", /* actions= */ "['a1']", /* envEntries= */ "'asdf'", /* withFeatures= */ "None");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//three:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("env_entries parameter of env_set should be a list, found string");
+
+ createEnvSetRule(
+ "four", /* actions= */ "['a1']", /* envEntries= */ "['abc']", /* withFeatures= */ "'def'");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//four:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("with_features parameter of env_set should be a list, found string");
+
+ createEnvSetRule(
+ "five",
+ /* actions= */ "['a1']",
+ /* envEntries= */ "[env_entry(key = 'a', value = 'b'),"
+ + "variable_with_value(name = 'a', value = 'b')]",
+ /* withFeatures= */ "[]");
+
+ ConfiguredTarget t = getConfiguredTarget("//five:a");
+ SkylarkInfo envSetProvider = (SkylarkInfo) t.get("envset");
+ assertThat(envSetProvider).isNotNull();
+ try {
+ CcModule.envSetFromSkylark(envSetProvider);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Expected object of type 'env_entry', received 'variable_with_value'");
+ }
+
+ createEnvSetRule("six", /* actions= */ "[]", /* envEntries= */ "[]", /* withFeatures= */ "[]");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//six:a"));
+ assertThat(e).hasMessageThat().contains("actions parameter of env_set must be a nonempty list");
+
+ createEnvSetRule(
+ "seven",
+ /* actions= */ "['a1']",
+ /* envEntries= */ "[env_entry(key = 'a', value = 'b')]",
+ /* withFeatures= */ "[with_feature_set(features = ['a'])]");
+
+ t = getConfiguredTarget("//seven:a");
+ envSetProvider = (SkylarkInfo) t.get("envset");
+ assertThat(envSetProvider).isNotNull();
+ EnvSet envSet = CcModule.envSetFromSkylark(envSetProvider);
+ assertThat(envSet).isNotNull();
+
+ createVariableWithValueRule("eight", /* name= */ "'abc'", /* value= */ "'def'");
+ t = getConfiguredTarget("//eight:a");
+ SkylarkInfo variable = (SkylarkInfo) t.get("variable");
+ try {
+ CcModule.envSetFromSkylark(variable);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Expected object of type 'env_set', received 'variable_with_value");
+ }
+ }
+
+ private void createEnvSetRule(String pkg, String actions, String envEntries, String withFeatures)
+ throws Exception {
+ scratch.file(
+ pkg + "/foo.bzl",
+ "load('//tools/cpp:cc_toolchain_config_lib.bzl',",
+ " 'env_set', 'env_entry', 'with_feature_set', 'variable_with_value')",
+ "def _impl(ctx):",
+ " return struct(envset = env_set(",
+ " actions = " + actions + ",",
+ " env_entries = " + envEntries + ",",
+ " with_features = " + withFeatures + "))",
+ "crule = rule(implementation = _impl)");
+ scratch.file(pkg + "/BUILD", "load(':foo.bzl', 'crule')", "crule(name = 'a')");
+ }
+
+ @Test
+ public void testCustomEnvSet() throws Exception {
+ loadCcToolchainConfigLib();
+ createCustomEnvSetRule(
+ "one", /* actions= */ "[]", /* envEntries= */ "None", /* withFeatures= */ "None");
+ ConfiguredTarget t = getConfiguredTarget("//one:a");
+ SkylarkInfo envSetProvider = (SkylarkInfo) t.get("envset");
+ assertThat(envSetProvider).isNotNull();
+ try {
+ CcModule.envSetFromSkylark(envSetProvider);
+ fail("Should have failed because of empty action list.");
+ } catch (EvalException e) {
+ assertThat(e)
+ .hasMessageThat()
+ .contains("actions parameter of env_set must be a nonempty list");
+ }
+
+ createCustomEnvSetRule(
+ "two", /* actions= */ "['a1']", /* envEntries= */ "struct()", /* withFeatures= */ "None");
+ t = getConfiguredTarget("//two:a");
+ envSetProvider = (SkylarkInfo) t.get("envset");
+ assertThat(envSetProvider).isNotNull();
+ try {
+ CcModule.envSetFromSkylark(envSetProvider);
+ fail("Should have failed because of wrong envEntries type.");
+ } catch (EvalException e) {
+ assertThat(e)
+ .hasMessageThat()
+ .contains("'env_entries' is not of expected type list or NoneType");
+ }
+
+ createCustomEnvSetRule(
+ "three",
+ /* actions= */ "['a1']",
+ /* envEntries= */ "[struct()]",
+ /* withFeatures= */ "None");
+ t = getConfiguredTarget("//three:a");
+ envSetProvider = (SkylarkInfo) t.get("envset");
+ assertThat(envSetProvider).isNotNull();
+ try {
+ CcModule.envSetFromSkylark(envSetProvider);
+ fail("Should have failed because of wrong envEntry type.");
+ } catch (EvalException e) {
+ assertThat(e)
+ .hasMessageThat()
+ .contains("Expected object of type 'env_entry', received 'struct'");
+ }
+
+ createCustomEnvSetRule(
+ "four",
+ /* actions= */ "['a1']",
+ /* envEntries= */ "[env_entry(key = 'a', value = 'b')]",
+ /* withFeatures= */ "'a'");
+ t = getConfiguredTarget("//four:a");
+ envSetProvider = (SkylarkInfo) t.get("envset");
+ assertThat(envSetProvider).isNotNull();
+ try {
+ CcModule.envSetFromSkylark(envSetProvider);
+ fail("Should have failed because of wrong withFeatures type.");
+ } catch (EvalException e) {
+ assertThat(e)
+ .hasMessageThat()
+ .contains("'with_features' is not of expected type list or NoneType");
+ }
+
+ createCustomEnvSetRule(
+ "five",
+ /* actions= */ "['a1']",
+ /* envEntries= */ "[env_entry(key = 'a', value = 'b')]",
+ /* withFeatures= */ "[env_entry(key = 'a', value = 'b')]");
+ t = getConfiguredTarget("//five:a");
+ envSetProvider = (SkylarkInfo) t.get("envset");
+ assertThat(envSetProvider).isNotNull();
+ try {
+ CcModule.envSetFromSkylark(envSetProvider);
+ fail("Should have failed because of wrong withFeatures type.");
+ } catch (EvalException e) {
+ assertThat(e)
+ .hasMessageThat()
+ .contains("Expected object of type 'with_feature_set', received 'env_entry'.");
+ }
+ }
+
+ private void createCustomEnvSetRule(
+ String pkg, String actions, String envEntries, String withFeatures) throws Exception {
+ scratch.file(
+ pkg + "/foo.bzl",
+ "load('//tools/cpp:cc_toolchain_config_lib.bzl',",
+ " 'env_entry', 'with_feature_set', 'variable_with_value')",
+ "def _impl(ctx):",
+ " return struct(envset = struct(",
+ " actions = " + actions + ",",
+ " env_entries = " + envEntries + ",",
+ " with_features = " + withFeatures + ",",
+ " type_name = 'env_set'))",
+ "crule = rule(implementation = _impl)");
+ scratch.file(pkg + "/BUILD", "load(':foo.bzl', 'crule')", "crule(name = 'a')");
+ }
+
+ @Test
+ public void testFlagGroup() throws Exception {
+ loadCcToolchainConfigLib();
+ createFlagGroupRule(
+ "one",
+ /* flags= */ "[]",
+ /* flagGroups= */ "[]",
+ /* iterateOver= */ "None",
+ /* expandIfTrue= */ "None",
+ /* expandIfFalse= */ "None",
+ /* expandIfAvailable= */ "None",
+ /* expandIfNotAvailable= */ "None",
+ /* expandIfEqual= */ "None");
+
+ AssertionError e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//one:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("flag_group must contain either a list of flags or a list of flag_groups");
+
+ createFlagGroupRule(
+ "two",
+ /* flags= */ "['a']",
+ /* flagGroups= */ "[]",
+ /* iterateOver= */ "struct(val = 'a')",
+ /* expandIfTrue= */ "None",
+ /* expandIfFalse= */ "None",
+ /* expandIfAvailable= */ "None",
+ /* expandIfNotAvailable= */ "None",
+ /* expandIfEqual= */ "None");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//two:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("iterate_over parameter of flag_group should be a string, found struct");
+
+ createFlagGroupRule(
+ "three",
+ /* flags= */ "['a']",
+ /* flagGroups= */ "[]",
+ /* iterateOver= */ "None",
+ /* expandIfTrue= */ "struct(val = 'a')",
+ /* expandIfFalse= */ "None",
+ /* expandIfAvailable= */ "None",
+ /* expandIfNotAvailable= */ "None",
+ /* expandIfEqual= */ "None");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//three:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("expand_if_true parameter of flag_group should be a string, found struct");
+
+ createFlagGroupRule(
+ "four",
+ /* flags= */ "['a']",
+ /* flagGroups= */ "[]",
+ /* iterateOver= */ "None",
+ /* expandIfTrue= */ "None",
+ /* expandIfFalse= */ "struct(val = 'a')",
+ /* expandIfAvailable= */ "None",
+ /* expandIfNotAvailable= */ "None",
+ /* expandIfEqual= */ "None");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//four:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("expand_if_false parameter of flag_group should be a string, found struct");
+
+ createFlagGroupRule(
+ "five",
+ /* flags= */ "['a']",
+ /* flagGroups= */ "[]",
+ /* iterateOver= */ "None",
+ /* expandIfTrue= */ "None",
+ /* expandIfFalse= */ "None",
+ /* expandIfAvailable= */ "struct(val = 'a')",
+ /* expandIfNotAvailable= */ "None",
+ /* expandIfEqual= */ "None");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//five:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("expand_if_available parameter of flag_group should be a string, found struct");
+
+ createFlagGroupRule(
+ "six",
+ /* flags= */ "['a']",
+ /* flagGroups= */ "[]",
+ /* iterateOver= */ "None",
+ /* expandIfTrue= */ "None",
+ /* expandIfFalse= */ "None",
+ /* expandIfAvailable= */ "None",
+ /* expandIfNotAvailable= */ "struct(val = 'a')",
+ /* expandIfEqual= */ "None");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//six:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains(
+ "expand_if_not_available parameter of flag_group should be a string, found struct");
+
+ createFlagGroupRule(
+ "seven",
+ /* flags= */ "['a']",
+ /* flagGroups= */ "['b']",
+ /* iterateOver= */ "None",
+ /* expandIfTrue= */ "None",
+ /* expandIfFalse= */ "None",
+ /* expandIfAvailable= */ "None",
+ /* expandIfNotAvailable= */ "struct(val = 'a')",
+ /* expandIfEqual= */ "None");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//seven:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("flag_group must not contain both a flag and another flag_group");
+
+ createFlagGroupRule(
+ "eight",
+ /* flags= */ "['a']",
+ /* flagGroups= */ "[]",
+ /* iterateOver= */ "'a'",
+ /* expandIfTrue= */ "'b'",
+ /* expandIfFalse= */ "''",
+ /* expandIfAvailable= */ "''",
+ /* expandIfNotAvailable= */ "''",
+ /* expandIfEqual= */ "'a'");
+
+ ConfiguredTarget t = getConfiguredTarget("//eight:a");
+ SkylarkInfo flagGroupProvider = (SkylarkInfo) t.get("flaggroup");
+ assertThat(flagGroupProvider).isNotNull();
+ try {
+ CcModule.flagGroupFromSkylark(flagGroupProvider);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains(
+ "Field 'expand_if_equal' is not of "
+ + "'com.google.devtools.build.lib.packages.SkylarkInfo' type.");
+ }
+
+ createFlagGroupRule(
+ "nine",
+ /* flags= */ "[]",
+ /* flagGroups= */ "[flag_group(flags = ['a']), flag_group(flags = ['b'])]",
+ /* iterateOver= */ "''",
+ /* expandIfTrue= */ "''",
+ /* expandIfFalse= */ "''",
+ /* expandIfAvailable= */ "''",
+ /* expandIfNotAvailable= */ "''",
+ /* expandIfEqual= */ "variable_with_value(name = 'a', value = 'b')");
+
+ t = getConfiguredTarget("//nine:a");
+ flagGroupProvider = (SkylarkInfo) t.get("flaggroup");
+ assertThat(flagGroupProvider).isNotNull();
+ FlagGroup f = CcModule.flagGroupFromSkylark(flagGroupProvider);
+ assertThat(f).isNotNull();
+
+ createFlagGroupRule(
+ "ten",
+ /* flags= */ "[]",
+ /* flagGroups= */ "[flag_group(flags = ['a']), struct(value = 'a')]",
+ /* iterateOver= */ "''",
+ /* expandIfTrue= */ "''",
+ /* expandIfFalse= */ "''",
+ /* expandIfAvailable= */ "''",
+ /* expandIfNotAvailable= */ "''",
+ /* expandIfEqual= */ "variable_with_value(name = 'a', value = 'b')");
+
+ t = getConfiguredTarget("//ten:a");
+ flagGroupProvider = (SkylarkInfo) t.get("flaggroup");
+ assertThat(flagGroupProvider).isNotNull();
+ try {
+ CcModule.flagGroupFromSkylark(flagGroupProvider);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Expected object of type 'flag_group', received 'struct'");
+ }
+ }
+
+ private void createFlagGroupRule(
+ String pkg,
+ String flags,
+ String flagGroups,
+ String iterateOver,
+ String expandIfTrue,
+ String expandIfFalse,
+ String expandIfAvailable,
+ String expandIfNotAvailable,
+ String expandIfEqual)
+ throws Exception {
+ scratch.file(
+ pkg + "/foo.bzl",
+ "load('//tools/cpp:cc_toolchain_config_lib.bzl',",
+ " 'env_set', 'env_entry', 'with_feature_set', 'variable_with_value', 'flag_group')",
+ "def _impl(ctx):",
+ " return struct(flaggroup = flag_group(",
+ " flags = " + flags + ",",
+ " flag_groups = " + flagGroups + ",",
+ " expand_if_true = " + expandIfTrue + ",",
+ " expand_if_false = " + expandIfFalse + ",",
+ " expand_if_available = " + expandIfAvailable + ",",
+ " expand_if_not_available = " + expandIfNotAvailable + ",",
+ " expand_if_equal = " + expandIfEqual + ",",
+ " iterate_over = " + iterateOver + "))",
+ "crule = rule(implementation = _impl)");
+ scratch.file(pkg + "/BUILD", "load(':foo.bzl', 'crule')", "crule(name = 'a')");
+ }
+
+ @Test
+ public void testCustomFlagGroup() throws Exception {
+ loadCcToolchainConfigLib();
+
+ createCustomFlagGroupRule(
+ "one",
+ /* flags= */ "['a']",
+ /* flagGroups= */ "[]",
+ /* iterateOver= */ "struct()",
+ /* expandIfTrue= */ "'b'",
+ /* expandIfFalse= */ "''",
+ /* expandIfAvailable= */ "''",
+ /* expandIfNotAvailable= */ "''",
+ /* expandIfEqual= */ "None");
+
+ ConfiguredTarget t = getConfiguredTarget("//one:a");
+ SkylarkInfo flagGroupProvider = (SkylarkInfo) t.get("flaggroup");
+ assertThat(flagGroupProvider).isNotNull();
+ try {
+ CcModule.flagGroupFromSkylark(flagGroupProvider);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Field 'iterate_over' is not of 'java.lang.String' type.");
+ }
+
+ createCustomFlagGroupRule(
+ "two",
+ /* flags= */ "[]",
+ /* flagGroups= */ "[flag_group(flags = ['a']), flag_group(flags = ['b'])]",
+ /* iterateOver= */ "''",
+ /* expandIfTrue= */ "struct()",
+ /* expandIfFalse= */ "''",
+ /* expandIfAvailable= */ "''",
+ /* expandIfNotAvailable= */ "''",
+ /* expandIfEqual= */ "variable_with_value(name = 'a', value = 'b')");
+
+ t = getConfiguredTarget("//two:a");
+ flagGroupProvider = (SkylarkInfo) t.get("flaggroup");
+ assertThat(flagGroupProvider).isNotNull();
+ try {
+ CcModule.flagGroupFromSkylark(flagGroupProvider);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Field 'expand_if_true' is not of 'java.lang.String' type.");
+ }
+
+ createCustomFlagGroupRule(
+ "three",
+ /* flags= */ "[]",
+ /* flagGroups= */ "[flag_group(flags = ['a'])]",
+ /* iterateOver= */ "''",
+ /* expandIfTrue= */ "''",
+ /* expandIfFalse= */ "True",
+ /* expandIfAvailable= */ "''",
+ /* expandIfNotAvailable= */ "''",
+ /* expandIfEqual= */ "variable_with_value(name = 'a', value = 'b')");
+
+ t = getConfiguredTarget("//three:a");
+ flagGroupProvider = (SkylarkInfo) t.get("flaggroup");
+ assertThat(flagGroupProvider).isNotNull();
+ try {
+ CcModule.flagGroupFromSkylark(flagGroupProvider);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Field 'expand_if_false' is not of 'java.lang.String' type.");
+ }
+
+ createCustomFlagGroupRule(
+ "four",
+ /* flags= */ "[]",
+ /* flagGroups= */ "[flag_group(flags = ['a'])]",
+ /* iterateOver= */ "''",
+ /* expandIfTrue= */ "''",
+ /* expandIfFalse= */ "''",
+ /* expandIfAvailable= */ "struct()",
+ /* expandIfNotAvailable= */ "''",
+ /* expandIfEqual= */ "variable_with_value(name = 'a', value = 'b')");
+
+ t = getConfiguredTarget("//four:a");
+ flagGroupProvider = (SkylarkInfo) t.get("flaggroup");
+ assertThat(flagGroupProvider).isNotNull();
+ try {
+ CcModule.flagGroupFromSkylark(flagGroupProvider);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Field 'expand_if_available' is not of 'java.lang.String' type.");
+ }
+
+ createCustomFlagGroupRule(
+ "five",
+ /* flags= */ "[]",
+ /* flagGroups= */ "[flag_group(flags = ['a'])]",
+ /* iterateOver= */ "''",
+ /* expandIfTrue= */ "''",
+ /* expandIfFalse= */ "''",
+ /* expandIfAvailable= */ "''",
+ /* expandIfNotAvailable= */ "3",
+ /* expandIfEqual= */ "variable_with_value(name = 'a', value = 'b')");
+
+ t = getConfiguredTarget("//five:a");
+ flagGroupProvider = (SkylarkInfo) t.get("flaggroup");
+ assertThat(flagGroupProvider).isNotNull();
+ try {
+ CcModule.flagGroupFromSkylark(flagGroupProvider);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Field 'expand_if_not_available' is not of 'java.lang.String' type.");
+ }
+
+ createCustomFlagGroupRule(
+ "six",
+ /* flags= */ "[]",
+ /* flagGroups= */ "[flag_group(flags = ['a'])]",
+ /* iterateOver= */ "''",
+ /* expandIfTrue= */ "''",
+ /* expandIfFalse= */ "''",
+ /* expandIfAvailable= */ "''",
+ /* expandIfNotAvailable= */ "''",
+ /* expandIfEqual= */ "struct(name = 'a', value = 'b')");
+
+ t = getConfiguredTarget("//six:a");
+ flagGroupProvider = (SkylarkInfo) t.get("flaggroup");
+ assertThat(flagGroupProvider).isNotNull();
+ try {
+ CcModule.flagGroupFromSkylark(flagGroupProvider);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Expected object of type 'variable_with_value', received 'struct'.");
+ }
+ }
+
+ private void createCustomFlagGroupRule(
+ String pkg,
+ String flags,
+ String flagGroups,
+ String iterateOver,
+ String expandIfTrue,
+ String expandIfFalse,
+ String expandIfAvailable,
+ String expandIfNotAvailable,
+ String expandIfEqual)
+ throws Exception {
+ scratch.file(
+ pkg + "/foo.bzl",
+ "load('//tools/cpp:cc_toolchain_config_lib.bzl',",
+ " 'env_set', 'env_entry', 'with_feature_set', 'variable_with_value', 'flag_group')",
+ "def _impl(ctx):",
+ " return struct(flaggroup = struct(",
+ " flags = " + flags + ",",
+ " flag_groups = " + flagGroups + ",",
+ " expand_if_true = " + expandIfTrue + ",",
+ " expand_if_false = " + expandIfFalse + ",",
+ " expand_if_available = " + expandIfAvailable + ",",
+ " expand_if_not_available = " + expandIfNotAvailable + ",",
+ " expand_if_equal = " + expandIfEqual + ",",
+ " iterate_over = " + iterateOver + ",",
+ " type_name = 'flag_group'))",
+ "crule = rule(implementation = _impl)");
+ scratch.file(pkg + "/BUILD", "load(':foo.bzl', 'crule')", "crule(name = 'a')");
+ }
+
+ @Test
+ public void testTool() throws Exception {
+ loadCcToolchainConfigLib();
+ createToolRule("one", /* path= */ "''", /* withFeatures= */ "[]", /* requirements= */ "[]");
+
+ AssertionError e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//one:a"));
+ assertThat(e).hasMessageThat().contains("path parameter of tool must be a nonempty string");
+
+ createToolRule("two", /* path= */ "'a'", /* withFeatures= */ "None", /* requirements= */ "[]");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//two:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("with_features parameter of tool should be a list, found NoneType");
+
+ createToolRule(
+ "three", /* path= */ "'a'", /* withFeatures= */ "[]", /* requirements= */ "None");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//three:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("execution_requirements parameter of tool should be a list, found NoneType");
+
+ createToolRule(
+ "four",
+ /* path= */ "'a'",
+ /* withFeatures= */ "[struct(val = 'a')]",
+ /* requirements= */ "[]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//four:a");
+ SkylarkInfo toolStruct = (SkylarkInfo) t.getValue("tool");
+ assertThat(toolStruct).isNotNull();
+ CcModule.toolFromSkylark(toolStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Expected object of type 'with_feature_set', received 'struct'");
+ }
+
+ createToolRule(
+ "five",
+ /* path= */ "'a'",
+ /* withFeatures= */ "[]",
+ /* requirements= */ "[struct(val = 'a')]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//five:a");
+ SkylarkInfo toolStruct = (SkylarkInfo) t.getValue("tool");
+ assertThat(toolStruct).isNotNull();
+ CcModule.toolFromSkylark(toolStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains(
+ "expected type 'string' for 'execution_requirements' "
+ + "element but got type 'struct' instead");
+ }
+
+ createToolRule(
+ "six",
+ /* path= */ "'/a/b/c'",
+ /* withFeatures= */ "[with_feature_set(features = ['a'])]",
+ /* requirements= */ "['a', 'b']");
+
+ ConfiguredTarget t = getConfiguredTarget("//six:a");
+ SkylarkInfo toolStruct = (SkylarkInfo) t.getValue("tool");
+ assertThat(toolStruct).isNotNull();
+ Tool tool = CcModule.toolFromSkylark(toolStruct);
+ assertThat(tool.getExecutionRequirements()).containsExactly("a", "b");
+ assertThat(tool.getToolPathString(PathFragment.EMPTY_FRAGMENT)).isEqualTo("/a/b/c");
+ assertThat(tool.getWithFeatureSetSets())
+ .contains(new WithFeatureSet(ImmutableSet.of("a"), ImmutableSet.of()));
+ }
+
+ private void createToolRule(String pkg, String path, String withFeatures, String requirements)
+ throws Exception {
+ scratch.file(
+ pkg + "/foo.bzl",
+ "load('//tools/cpp:cc_toolchain_config_lib.bzl', 'with_feature_set', 'tool')",
+ "def _impl(ctx):",
+ " return struct(tool = tool(",
+ " path = " + path + ",",
+ " with_features = " + withFeatures + ",",
+ " execution_requirements = " + requirements + "))",
+ "crule = rule(implementation = _impl)");
+ scratch.file(pkg + "/BUILD", "load(':foo.bzl', 'crule')", "crule(name = 'a')");
+ }
+
+ @Test
+ public void testCustomTool() throws Exception {
+ loadCcToolchainConfigLib();
+ createCustomToolRule(
+ "one", /* path= */ "''", /* withFeatures= */ "[]", /* requirements= */ "[]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//one:a");
+ SkylarkInfo toolStruct = (SkylarkInfo) t.getValue("tool");
+ assertThat(toolStruct).isNotNull();
+ CcModule.toolFromSkylark(toolStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("The 'path' field of tool must be a nonempty string.");
+ }
+
+ createCustomToolRule(
+ "two", /* path= */ "struct()", /* withFeatures= */ "[]", /* requirements= */ "[]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//two:a");
+ SkylarkInfo toolStruct = (SkylarkInfo) t.getValue("tool");
+ assertThat(toolStruct).isNotNull();
+ CcModule.toolFromSkylark(toolStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee).hasMessageThat().contains("Field 'path' is not of 'java.lang.String' type.");
+ }
+
+ createCustomToolRule(
+ "three", /* path= */ "'a'", /* withFeatures= */ "struct()", /* requirements= */ "[]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//three:a");
+ SkylarkInfo toolStruct = (SkylarkInfo) t.getValue("tool");
+ assertThat(toolStruct).isNotNull();
+ CcModule.toolFromSkylark(toolStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Illegal argument: 'with_features' is not of expected type list or NoneType");
+ }
+
+ createCustomToolRule(
+ "four",
+ /* path= */ "'a'",
+ /* withFeatures= */ "[struct(val = 'a')]",
+ /* requirements= */ "[]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//four:a");
+ SkylarkInfo toolStruct = (SkylarkInfo) t.getValue("tool");
+ assertThat(toolStruct).isNotNull();
+ CcModule.toolFromSkylark(toolStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Expected object of type 'with_feature_set', received 'struct'");
+ }
+
+ createCustomToolRule(
+ "five", /* path= */ "'a'", /* withFeatures= */ "[]", /* requirements= */ "'a'");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//five:a");
+ SkylarkInfo toolStruct = (SkylarkInfo) t.getValue("tool");
+ assertThat(toolStruct).isNotNull();
+ CcModule.toolFromSkylark(toolStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains(
+ "llegal argument: 'execution_requirements' is not of expected type list or NoneType");
+ }
+
+ createCustomToolRule(
+ "six", /* path= */ "'a'", /* withFeatures= */ "[]", /* requirements= */ "[struct()]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//six:a");
+ SkylarkInfo toolStruct = (SkylarkInfo) t.getValue("tool");
+ assertThat(toolStruct).isNotNull();
+ CcModule.toolFromSkylark(toolStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains(
+ "expected type 'string' for 'execution_requirements' "
+ + "element but got type 'struct' instead");
+ }
+ }
+
+ private void createCustomToolRule(
+ String pkg, String path, String withFeatures, String requirements) throws Exception {
+ scratch.file(
+ pkg + "/foo.bzl",
+ "load('//tools/cpp:cc_toolchain_config_lib.bzl', 'with_feature_set')",
+ "def _impl(ctx):",
+ " return struct(tool = struct(",
+ " path = " + path + ",",
+ " with_features = " + withFeatures + ",",
+ " execution_requirements = " + requirements + ",",
+ " type_name = 'tool'))",
+ "crule = rule(implementation = _impl)");
+ scratch.file(pkg + "/BUILD", "load(':foo.bzl', 'crule')", "crule(name = 'a')");
+ }
+
+ @Test
+ public void testFlagSet() throws Exception {
+ loadCcToolchainConfigLib();
+ createFlagSetRule("one", /* actions= */ "[]", /* flagGroups= */ "[]", /* withFeatures= */ "[]");
+
+ AssertionError e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//one:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("actions parameter of flag_set must be a nonempty list");
+
+ createFlagSetRule(
+ "two", /* actions= */ "['a']", /* flagGroups= */ "[]", /* withFeatures= */ "None");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//two:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("with_features parameter of flag_set should be a list, found NoneType");
+
+ createFlagSetRule(
+ "three", /* actions= */ "['a']", /* flagGroups= */ "None", /* withFeatures= */ "[]");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//three:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("flag_groups parameter of flag_set should be a list, found NoneType");
+
+ createFlagSetRule(
+ "four",
+ /* actions= */ "['a', struct(val = 'a')]",
+ /* flagGroups= */ "[]",
+ /* withFeatures= */ "[]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//four:a");
+ SkylarkInfo flagSetStruct = (SkylarkInfo) t.getValue("flagset");
+ assertThat(flagSetStruct).isNotNull();
+ CcModule.flagSetFromSkylark(flagSetStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("expected type 'string' for 'actions' element but got type 'struct' instead");
+ }
+
+ createFlagSetRule(
+ "five",
+ /* actions= */ "['a']",
+ /* flagGroups= */ "[flag_group(flags = ['a']), struct(value = 'a')]",
+ /* withFeatures= */ "[]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//five:a");
+ SkylarkInfo flagSetStruct = (SkylarkInfo) t.getValue("flagset");
+ assertThat(flagSetStruct).isNotNull();
+ CcModule.flagSetFromSkylark(flagSetStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Expected object of type 'flag_group', received 'struct'");
+ }
+
+ createFlagSetRule(
+ "six",
+ /* actions= */ "['a']",
+ /* flagGroups= */ "[flag_group(flags = ['a'])]",
+ /* withFeatures= */ "[struct(val = 'a')]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//six:a");
+ SkylarkInfo flagSetStruct = (SkylarkInfo) t.getValue("flagset");
+ assertThat(flagSetStruct).isNotNull();
+ CcModule.flagSetFromSkylark(flagSetStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Expected object of type 'with_feature_set', received 'struct'");
+ }
+
+ createFlagSetRule(
+ "seven",
+ /* actions= */ "['a']",
+ /* flagGroups= */ "[flag_group(flags = ['a'])]",
+ /* withFeatures= */ "[with_feature_set(features = ['a'])]");
+ ConfiguredTarget t = getConfiguredTarget("//seven:a");
+ SkylarkInfo flagSetStruct = (SkylarkInfo) t.getValue("flagset");
+ assertThat(flagSetStruct).isNotNull();
+ FlagSet f = CcModule.flagSetFromSkylark(flagSetStruct);
+ assertThat(f).isNotNull();
+ }
+
+ private void createFlagSetRule(String pkg, String actions, String flagGroups, String withFeatures)
+ throws Exception {
+ scratch.file(
+ pkg + "/foo.bzl",
+ "load('//tools/cpp:cc_toolchain_config_lib.bzl',",
+ " 'env_set', 'env_entry', 'with_feature_set', 'variable_with_value', 'flag_group',",
+ " 'flag_set')",
+ "def _impl(ctx):",
+ " return struct(flagset = flag_set(",
+ " flag_groups = " + flagGroups + ",",
+ " actions = " + actions + ",",
+ " with_features = " + withFeatures + "))",
+ "crule = rule(implementation = _impl)");
+ scratch.file(pkg + "/BUILD", "load(':foo.bzl', 'crule')", "crule(name = 'a')");
+ }
+
+ @Test
+ public void testCustomFlagSet() throws Exception {
+ loadCcToolchainConfigLib();
+ createCustomFlagSetRule(
+ "one", /* actions= */ "[]", /* flagGroups= */ "[]", /* withFeatures= */ "[]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//one:a");
+ SkylarkInfo flagSetStruct = (SkylarkInfo) t.getValue("flagset");
+ assertThat(flagSetStruct).isNotNull();
+ CcModule.flagSetFromSkylark(flagSetStruct);
+ fail("Should have failed because 'actions' field is empty.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("'actions' field of flag_set must be a nonempty list");
+ }
+
+ createCustomFlagSetRule(
+ "two", /* actions= */ "['a']", /* flagGroups= */ "struct()", /* withFeatures= */ "[]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//two:a");
+ SkylarkInfo flagSetStruct = (SkylarkInfo) t.getValue("flagset");
+ assertThat(flagSetStruct).isNotNull();
+ CcModule.flagSetFromSkylark(flagSetStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Illegal argument: 'flag_groups' is not of expected type list or NoneType");
+ }
+
+ createCustomFlagSetRule(
+ "three", /* actions= */ "['a']", /* flagGroups= */ "[]", /* withFeatures= */ "struct()");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//three:a");
+ SkylarkInfo flagSetStruct = (SkylarkInfo) t.getValue("flagset");
+ assertThat(flagSetStruct).isNotNull();
+ CcModule.flagSetFromSkylark(flagSetStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Illegal argument: 'with_features' is not of expected type list or NoneType");
+ }
+
+ createCustomFlagSetRule(
+ "four", /* actions= */ "struct()", /* flagGroups= */ "[]", /* withFeatures= */ "[]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//four:a");
+ SkylarkInfo flagSetStruct = (SkylarkInfo) t.getValue("flagset");
+ assertThat(flagSetStruct).isNotNull();
+ CcModule.flagSetFromSkylark(flagSetStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Illegal argument: 'actions' is not of expected type list or NoneType");
+ }
+ }
+
+ private void createCustomFlagSetRule(
+ String pkg, String actions, String flagGroups, String withFeatures) throws Exception {
+ scratch.file(
+ pkg + "/foo.bzl",
+ "load('//tools/cpp:cc_toolchain_config_lib.bzl',",
+ " 'env_set', 'env_entry', 'with_feature_set', 'variable_with_value', 'flag_group',",
+ " 'flag_set')",
+ "def _impl(ctx):",
+ " return struct(flagset = struct(",
+ " flag_groups = " + flagGroups + ",",
+ " actions = " + actions + ",",
+ " with_features = " + withFeatures + ",",
+ " type_name = 'flag_set'))",
+ "crule = rule(implementation = _impl)");
+ scratch.file(pkg + "/BUILD", "load(':foo.bzl', 'crule')", "crule(name = 'a')");
+ }
+
+ @Test
+ public void testActionConfig() throws Exception {
+ loadCcToolchainConfigLib();
+ createActionConfigRule(
+ "one",
+ /* actionName= */ "''",
+ /* enabled= */ "True",
+ /* tools= */ "[]",
+ /* flagSets= */ "[]",
+ /* implies= */ "[]");
+
+ AssertionError e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//one:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("name parameter of action_config must be a nonempty string");
+
+ createActionConfigRule(
+ "two",
+ /* actionName= */ "'actionname'",
+ /* enabled= */ "['asd']",
+ /* tools= */ "[]",
+ /* flagSets= */ "[]",
+ /* implies= */ "[]");
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//two:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("enabled parameter of action_config should be a bool, found list");
+
+ createActionConfigRule(
+ "three",
+ /* actionName= */ "'actionname'",
+ /* enabled= */ "True",
+ /* tools= */ "[with_feature_set(features = ['a'])]",
+ /* flagSets= */ "[]",
+ /* implies= */ "[]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//three:a");
+ SkylarkInfo actionConfigStruct = (SkylarkInfo) t.getValue("config");
+ assertThat(actionConfigStruct).isNotNull();
+ CcModule.actionConfigFromSkylark(actionConfigStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Expected object of type 'tool', received 'with_feature_set'");
+ }
+
+ createActionConfigRule(
+ "four",
+ /* actionName= */ "'actionname'",
+ /* enabled= */ "True",
+ /* tools= */ "[tool(path = 'a/b/c')]",
+ /* flagSets= */ "[tool(path = 'a/b/c')]",
+ /* implies= */ "[]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//four:a");
+ SkylarkInfo actionConfigStruct = (SkylarkInfo) t.getValue("config");
+ assertThat(actionConfigStruct).isNotNull();
+ CcModule.actionConfigFromSkylark(actionConfigStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Expected object of type 'flag_set', received 'tool'");
+ }
+
+ createActionConfigRule(
+ "five",
+ /* actionName= */ "'actionname'",
+ /* enabled= */ "True",
+ /* tools= */ "[tool(path = 'a/b/c')]",
+ /* flagSets= */ "[flag_set(actions = ['a', 'b'])]",
+ /* implies= */ "flag_set(actions = ['a', 'b'])");
+
+ e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//five:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("implies parameter of action_config should be a list, found struct");
+
+ createActionConfigRule(
+ "six",
+ /* actionName= */ "'actionname'",
+ /* enabled= */ "True",
+ /* tools= */ "[tool(path = 'a/b/c')]",
+ /* flagSets= */ "[flag_set(actions = ['a', 'b'])]",
+ /* implies= */ "[flag_set(actions = ['a', 'b'])]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//six:a");
+ SkylarkInfo actionConfigStruct = (SkylarkInfo) t.getValue("config");
+ assertThat(actionConfigStruct).isNotNull();
+ CcModule.actionConfigFromSkylark(actionConfigStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("expected type 'string' for 'implies' element but got type 'struct' instead");
+ }
+
+ createActionConfigRule(
+ "seven",
+ /* actionName= */ "'actionname'",
+ /* enabled= */ "True",
+ /* tools= */ "[tool(path = 'a/b/c')]",
+ /* flagSets= */ "[flag_set(actions = ['a', 'b'])]",
+ /* implies= */ "[flag_set(actions = ['a', 'b'])]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//seven:a");
+ SkylarkInfo actionConfigStruct = (SkylarkInfo) t.getValue("config");
+ assertThat(actionConfigStruct).isNotNull();
+ CcModule.actionConfigFromSkylark(actionConfigStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("expected type 'string' for 'implies' element but got type 'struct' instead");
+ }
+
+ createActionConfigRule(
+ "eight",
+ /* actionName= */ "'actionname'",
+ /* enabled= */ "True",
+ /* tools= */ "[tool(path = 'a/b/c')]",
+ /* flagSets= */ "[flag_set(actions = ['a', 'b'])]",
+ /* implies= */ "['a', 'b']");
+
+ ConfiguredTarget t = getConfiguredTarget("//eight:a");
+ SkylarkInfo actionConfigStruct = (SkylarkInfo) t.getValue("config");
+ assertThat(actionConfigStruct).isNotNull();
+ ActionConfig a = CcModule.actionConfigFromSkylark(actionConfigStruct);
+ assertThat(a).isNotNull();
+ assertThat(a.getActionName()).isEqualTo("actionname");
+ assertThat(a.getImplies()).containsExactly("a", "b").inOrder();
+
+ createActionConfigRule(
+ "nine",
+ /* actionName= */ "'Upper'",
+ /* enabled= */ "True",
+ /* tools= */ "[tool(path = 'a/b/c')]",
+ /* flagSets= */ "[flag_set(actions = ['a', 'b'])]",
+ /* implies= */ "[flag_set(actions = ['a', 'b'])]");
+
+ try {
+ t = getConfiguredTarget("//nine:a");
+ actionConfigStruct = (SkylarkInfo) t.getValue("config");
+ assertThat(actionConfigStruct).isNotNull();
+ CcModule.actionConfigFromSkylark(actionConfigStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains(
+ "An action_config's name must consist solely "
+ + "of lowercase letters and '_', got 'Upper'");
+ }
+
+ createActionConfigRule(
+ "ten",
+ /* actionName= */ "'white\tspace'",
+ /* enabled= */ "True",
+ /* tools= */ "[tool(path = 'a/b/c')]",
+ /* flagSets= */ "[flag_set(actions = ['a', 'b'])]",
+ /* implies= */ "[flag_set(actions = ['a', 'b'])]");
+
+ try {
+ t = getConfiguredTarget("//ten:a");
+ actionConfigStruct = (SkylarkInfo) t.getValue("config");
+ assertThat(actionConfigStruct).isNotNull();
+ CcModule.actionConfigFromSkylark(actionConfigStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains(
+ "An action_config's name must consist solely "
+ + "of lowercase letters and '_', got 'white\tspace'");
+ }
+ }
+
+ private void createActionConfigRule(
+ String pkg, String actionName, String enabled, String tools, String flagSets, String implies)
+ throws Exception {
+ scratch.file(
+ pkg + "/foo.bzl",
+ "load('//tools/cpp:cc_toolchain_config_lib.bzl', 'with_feature_set',",
+ " 'tool', 'flag_set', 'action_config', )",
+ "def _impl(ctx):",
+ " return struct(config = action_config(",
+ " action_name = " + actionName + ",",
+ " enabled = " + enabled + ",",
+ " tools = " + tools + ",",
+ " flag_sets = " + flagSets + ",",
+ " implies = " + implies + "))",
+ "crule = rule(implementation = _impl)");
+ scratch.file(pkg + "/BUILD", "load(':foo.bzl', 'crule')", "crule(name = 'a')");
+ }
+
+ @Test
+ public void testCustomActionConfig() throws Exception {
+ loadCcToolchainConfigLib();
+ createCustomActionConfigRule(
+ "one",
+ /* actionName= */ "struct()",
+ /* enabled= */ "True",
+ /* tools= */ "[]",
+ /* flagSets= */ "[]",
+ /* implies= */ "[]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//one:a");
+ SkylarkInfo actionConfigStruct = (SkylarkInfo) t.getValue("config");
+ assertThat(actionConfigStruct).isNotNull();
+ CcModule.actionConfigFromSkylark(actionConfigStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Field 'action_name' is not of 'java.lang.String' type.");
+ }
+
+ createCustomActionConfigRule(
+ "two",
+ /* actionName= */ "'actionname'",
+ /* enabled= */ "['asd']",
+ /* tools= */ "[]",
+ /* flagSets= */ "[]",
+ /* implies= */ "[]");
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//two:a");
+ SkylarkInfo actionConfigStruct = (SkylarkInfo) t.getValue("config");
+ assertThat(actionConfigStruct).isNotNull();
+ CcModule.actionConfigFromSkylark(actionConfigStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Field 'enabled' is not of 'java.lang.Boolean' type.");
+ }
+
+ createCustomActionConfigRule(
+ "three",
+ /* actionName= */ "'actionname'",
+ /* enabled= */ "True",
+ /* tools= */ "struct()",
+ /* flagSets= */ "[]",
+ /* implies= */ "[]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//three:a");
+ SkylarkInfo actionConfigStruct = (SkylarkInfo) t.getValue("config");
+ assertThat(actionConfigStruct).isNotNull();
+ CcModule.actionConfigFromSkylark(actionConfigStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Illegal argument: 'tools' is not of expected type list or NoneType");
+ }
+
+ createCustomActionConfigRule(
+ "four",
+ /* actionName= */ "'actionname'",
+ /* enabled= */ "True",
+ /* tools= */ "[tool(path = 'a/b/c')]",
+ /* flagSets= */ "True",
+ /* implies= */ "[]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//four:a");
+ SkylarkInfo actionConfigStruct = (SkylarkInfo) t.getValue("config");
+ assertThat(actionConfigStruct).isNotNull();
+ CcModule.actionConfigFromSkylark(actionConfigStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Illegal argument: 'flag_sets' is not of expected type list or NoneType");
+ }
+
+ createCustomActionConfigRule(
+ "five",
+ /* actionName= */ "'actionname'",
+ /* enabled= */ "True",
+ /* tools= */ "[tool(path = 'a/b/c')]",
+ /* flagSets= */ "[]",
+ /* implies= */ "flag_set(actions = ['a', 'b'])");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//five:a");
+ SkylarkInfo actionConfigStruct = (SkylarkInfo) t.getValue("config");
+ assertThat(actionConfigStruct).isNotNull();
+ CcModule.actionConfigFromSkylark(actionConfigStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Illegal argument: 'implies' is not of expected type list or NoneType");
+ }
+ }
+
+ private void createCustomActionConfigRule(
+ String pkg, String actionName, String enabled, String tools, String flagSets, String implies)
+ throws Exception {
+ scratch.file(
+ pkg + "/foo.bzl",
+ "load('//tools/cpp:cc_toolchain_config_lib.bzl', 'with_feature_set',",
+ " 'tool', 'flag_set', 'action_config', )",
+ "def _impl(ctx):",
+ " return struct(config = struct(",
+ " action_name = " + actionName + ",",
+ " enabled = " + enabled + ",",
+ " tools = " + tools + ",",
+ " flag_sets = " + flagSets + ",",
+ " implies = " + implies + ",",
+ " type_name = 'action_config'))",
+ "crule = rule(implementation = _impl)");
+ scratch.file(pkg + "/BUILD", "load(':foo.bzl', 'crule')", "crule(name = 'a')");
+ }
+
+ @Test
+ public void testFeature() throws Exception {
+ loadCcToolchainConfigLib();
+ createFeatureRule(
+ "one",
+ /* name= */ "''",
+ /* enabled= */ "False",
+ /* flagSets= */ "[]",
+ /* envSets= */ "[]",
+ /* requires= */ "[]",
+ /* implies= */ "[]",
+ /* provides= */ "[]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//one:a");
+ SkylarkInfo featureStruct = (SkylarkInfo) t.getValue("f");
+ assertThat(featureStruct).isNotNull();
+ CcModule.featureFromSkylark(featureStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("A feature must either have a nonempty 'name' field or be enabled.");
+ }
+
+ createFeatureRule(
+ "two",
+ /* name= */ "'featurename'",
+ /* enabled= */ "None",
+ /* flagSets= */ "[]",
+ /* envSets= */ "[]",
+ /* requires= */ "[]",
+ /* implies= */ "[]",
+ /* provides= */ "[]");
+ AssertionError e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//two:a"));
+ assertThat(e)
+ .hasMessageThat()
+ .contains("enabled parameter of feature should be a bool, found NoneType");
+
+ createFeatureRule(
+ "three",
+ /* name= */ "'featurename'",
+ /* enabled= */ "True",
+ /* flagSets= */ "[struct()]",
+ /* envSets= */ "[]",
+ /* requires= */ "[]",
+ /* implies= */ "[]",
+ /* provides= */ "[]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//three:a");
+ SkylarkInfo featureStruct = (SkylarkInfo) t.getValue("f");
+ assertThat(featureStruct).isNotNull();
+ CcModule.featureFromSkylark(featureStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Expected object of type 'flag_set', received 'struct'");
+ }
+
+ createFeatureRule(
+ "four",
+ /* name= */ "'featurename'",
+ /* enabled= */ "True",
+ /* flagSets= */ "[flag_set(actions = ['a'], flag_groups = [flag_group(flags = ['a'])])]",
+ /* envSets= */ "[tool(path = 'a/b/c')]",
+ /* requires= */ "[]",
+ /* implies= */ "[]",
+ /* provides= */ "[]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//four:a");
+ SkylarkInfo featureStruct = (SkylarkInfo) t.getValue("f");
+ assertThat(featureStruct).isNotNull();
+ CcModule.featureFromSkylark(featureStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Expected object of type 'env_set', received 'tool'");
+ }
+
+ createFeatureRule(
+ "five",
+ /* name= */ "'featurename'",
+ /* enabled= */ "True",
+ /* flagSets= */ "[flag_set(actions = ['a'], flag_groups = [flag_group(flags = ['a'])])]",
+ /* envSets= */ "[env_set(actions = ['a1'], "
+ + "env_entries = [env_entry(key = 'a', value = 'b')])]",
+ /* requires= */ "[tool(path = 'a/b/c')]",
+ /* implies= */ "[]",
+ /* provides= */ "[]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//five:a");
+ SkylarkInfo featureStruct = (SkylarkInfo) t.getValue("f");
+ assertThat(featureStruct).isNotNull();
+ CcModule.featureFromSkylark(featureStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee).hasMessageThat().contains("expected object of type 'feature_set'");
+ }
+
+ createFeatureRule(
+ "six",
+ /* name= */ "'featurename'",
+ /* enabled= */ "True",
+ /* flagSets= */ "[flag_set(actions = ['a'], flag_groups = [flag_group(flags = ['a'])])]",
+ /* envSets= */ "[env_set(actions = ['a1'], "
+ + "env_entries = [env_entry(key = 'a', value = 'b')])]",
+ /* requires= */ "[feature_set(features = ['f1', 'f2'])]",
+ /* implies= */ "[tool(path = 'a/b/c')]",
+ /* provides= */ "[]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//six:a");
+ SkylarkInfo featureStruct = (SkylarkInfo) t.getValue("f");
+ assertThat(featureStruct).isNotNull();
+ CcModule.featureFromSkylark(featureStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("expected type 'string' for 'implies' element but got type 'struct' instead");
+ }
+
+ createFeatureRule(
+ "seven",
+ /* name= */ "'featurename'",
+ /* enabled= */ "True",
+ /* flagSets= */ "[flag_set(actions = ['a'], flag_groups = [flag_group(flags = ['a'])])]",
+ /* envSets= */ "[env_set(actions = ['a1'], "
+ + "env_entries = [env_entry(key = 'a', value = 'b')])]",
+ /* requires= */ "[feature_set(features = ['f1', 'f2'])]",
+ /* implies= */ "['a', 'b', 'c']",
+ /* provides= */ "[struct()]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//seven:a");
+ SkylarkInfo featureStruct = (SkylarkInfo) t.getValue("f");
+ assertThat(featureStruct).isNotNull();
+ CcModule.featureFromSkylark(featureStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("expected type 'string' for 'provides' element but got type 'struct' instead");
+ }
+
+ createFeatureRule(
+ "eight",
+ /* name= */ "'featurename'",
+ /* enabled= */ "True",
+ /* flagSets= */ "[flag_set(actions = ['a'], flag_groups = [flag_group(flags = ['a'])])]",
+ /* envSets= */ "[env_set(actions = ['a1'], "
+ + "env_entries = [env_entry(key = 'a', value = 'b')])]",
+ /* requires= */ "[feature_set(features = ['f1', 'f2'])]",
+ /* implies= */ "['a', 'b', 'c']",
+ /* provides= */ "['a', 'b', 'c']");
+
+ ConfiguredTarget t = getConfiguredTarget("//eight:a");
+ SkylarkInfo featureStruct = (SkylarkInfo) t.getValue("f");
+ assertThat(featureStruct).isNotNull();
+ Feature a = CcModule.featureFromSkylark(featureStruct);
+ assertThat(a).isNotNull();
+
+ createFeatureRule(
+ "nine",
+ /* name= */ "'UpperCase'",
+ /* enabled= */ "False",
+ /* flagSets= */ "[]",
+ /* envSets= */ "[]",
+ /* requires= */ "[]",
+ /* implies= */ "[]",
+ /* provides= */ "[]");
+
+ try {
+ t = getConfiguredTarget("//nine:a");
+ featureStruct = (SkylarkInfo) t.getValue("f");
+ assertThat(featureStruct).isNotNull();
+ CcModule.featureFromSkylark(featureStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains(
+ "A feature's name must consist solely of lowercase letters and '_', got 'UpperCase");
+ }
+
+ createFeatureRule(
+ "ten",
+ /* name= */ "'white space'",
+ /* enabled= */ "False",
+ /* flagSets= */ "[]",
+ /* envSets= */ "[]",
+ /* requires= */ "[]",
+ /* implies= */ "[]",
+ /* provides= */ "[]");
+
+ try {
+ t = getConfiguredTarget("//ten:a");
+ featureStruct = (SkylarkInfo) t.getValue("f");
+ assertThat(featureStruct).isNotNull();
+ CcModule.featureFromSkylark(featureStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains(
+ "A feature's name must consist solely of "
+ + "lowercase letters and '_', got 'white space");
+ }
+ }
+
+ private void createFeatureRule(
+ String pkg,
+ String name,
+ String enabled,
+ String flagSets,
+ String envSets,
+ String requires,
+ String implies,
+ String provides)
+ throws Exception {
+ scratch.file(
+ pkg + "/foo.bzl",
+ "load('//tools/cpp:cc_toolchain_config_lib.bzl', 'with_feature_set', 'feature_set',",
+ " 'flag_set', 'flag_group', 'tool', 'env_set', 'env_entry', 'feature')",
+ "def _impl(ctx):",
+ " return struct(f = feature(",
+ " name = " + name + ",",
+ " enabled = " + enabled + ",",
+ " flag_sets = " + flagSets + ",",
+ " env_sets = " + envSets + ",",
+ " requires = " + requires + ",",
+ " implies = " + implies + ",",
+ " provides = " + provides + "))",
+ "crule = rule(implementation = _impl)");
+ scratch.file(pkg + "/BUILD", "load(':foo.bzl', 'crule')", "crule(name = 'a')");
+ }
+
+ @Test
+ public void testCustomFeature() throws Exception {
+ loadCcToolchainConfigLib();
+ createCustomFeatureRule(
+ "one",
+ /* name= */ "struct()",
+ /* enabled= */ "False",
+ /* flagSets= */ "[]",
+ /* envSets= */ "[]",
+ /* requires= */ "[]",
+ /* implies= */ "[]",
+ /* provides= */ "[]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//one:a");
+ SkylarkInfo featureStruct = (SkylarkInfo) t.getValue("f");
+ assertThat(featureStruct).isNotNull();
+ CcModule.featureFromSkylark(featureStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee).hasMessageThat().contains("Field 'name' is not of 'java.lang.String' type.");
+ }
+
+ createCustomFeatureRule(
+ "two",
+ /* name= */ "'featurename'",
+ /* enabled= */ "struct()",
+ /* flagSets= */ "[]",
+ /* envSets= */ "[]",
+ /* requires= */ "[]",
+ /* implies= */ "[]",
+ /* provides= */ "[]");
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//two:a");
+ SkylarkInfo featureStruct = (SkylarkInfo) t.getValue("f");
+ assertThat(featureStruct).isNotNull();
+ CcModule.featureFromSkylark(featureStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Field 'enabled' is not of 'java.lang.Boolean' type.");
+ }
+
+ createCustomFeatureRule(
+ "three",
+ /* name= */ "'featurename'",
+ /* enabled= */ "True",
+ /* flagSets= */ "struct()",
+ /* envSets= */ "[]",
+ /* requires= */ "[]",
+ /* implies= */ "[]",
+ /* provides= */ "[]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//three:a");
+ SkylarkInfo featureStruct = (SkylarkInfo) t.getValue("f");
+ assertThat(featureStruct).isNotNull();
+ CcModule.featureFromSkylark(featureStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Illegal argument: 'flag_sets' is not of expected type list or NoneType");
+ }
+
+ createCustomFeatureRule(
+ "four",
+ /* name= */ "'featurename'",
+ /* enabled= */ "True",
+ /* flagSets= */ "[]",
+ /* envSets= */ "struct()",
+ /* requires= */ "[]",
+ /* implies= */ "[]",
+ /* provides= */ "[]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//four:a");
+ SkylarkInfo featureStruct = (SkylarkInfo) t.getValue("f");
+ assertThat(featureStruct).isNotNull();
+ CcModule.featureFromSkylark(featureStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Illegal argument: 'env_sets' is not of expected type list or NoneType");
+ }
+
+ createCustomFeatureRule(
+ "five",
+ /* name= */ "'featurename'",
+ /* enabled= */ "True",
+ /* flagSets= */ "[]",
+ /* envSets= */ "[]",
+ /* requires= */ "struct()",
+ /* implies= */ "[]",
+ /* provides= */ "[]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//five:a");
+ SkylarkInfo featureStruct = (SkylarkInfo) t.getValue("f");
+ assertThat(featureStruct).isNotNull();
+ CcModule.featureFromSkylark(featureStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Illegal argument: 'requires' is not of expected type list or NoneType");
+ }
+
+ createCustomFeatureRule(
+ "six",
+ /* name= */ "'featurename'",
+ /* enabled= */ "True",
+ /* flagSets= */ "[]",
+ /* envSets= */ "[]",
+ /* requires= */ "[]",
+ /* implies= */ "struct()",
+ /* provides= */ "[]");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//six:a");
+ SkylarkInfo featureStruct = (SkylarkInfo) t.getValue("f");
+ assertThat(featureStruct).isNotNull();
+ CcModule.featureFromSkylark(featureStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Illegal argument: 'implies' is not of expected type list or NoneType");
+ }
+
+ createCustomFeatureRule(
+ "seven",
+ /* name= */ "'featurename'",
+ /* enabled= */ "True",
+ /* flagSets= */ "[]",
+ /* envSets= */ "[]",
+ /* requires= */ "[]",
+ /* implies= */ "[]",
+ /* provides= */ "struct()");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//seven:a");
+ SkylarkInfo featureStruct = (SkylarkInfo) t.getValue("f");
+ assertThat(featureStruct).isNotNull();
+ CcModule.featureFromSkylark(featureStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Illegal argument: 'provides' is not of expected type list or NoneType");
+ }
+ }
+
+ private void createCustomFeatureRule(
+ String pkg,
+ String name,
+ String enabled,
+ String flagSets,
+ String envSets,
+ String requires,
+ String implies,
+ String provides)
+ throws Exception {
+ scratch.file(
+ pkg + "/foo.bzl",
+ "load('//tools/cpp:cc_toolchain_config_lib.bzl', 'with_feature_set', 'feature_set',",
+ " 'flag_set', 'flag_group', 'tool', 'env_set', 'env_entry', 'feature')",
+ "def _impl(ctx):",
+ " return struct(f = struct(",
+ " name = " + name + ",",
+ " enabled = " + enabled + ",",
+ " flag_sets = " + flagSets + ",",
+ " env_sets = " + envSets + ",",
+ " requires = " + requires + ",",
+ " implies = " + implies + ",",
+ " provides = " + provides + ",",
+ " type_name = 'feature'))",
+ "crule = rule(implementation = _impl)");
+ scratch.file(pkg + "/BUILD", "load(':foo.bzl', 'crule')", "crule(name = 'a')");
+ }
+
+ @Test
+ public void testCustomArtifactNamePattern() throws Exception {
+ loadCcToolchainConfigLib();
+ createCustomArtifactNamePatternRule(
+ "one", /* categoryName= */ "struct()", /* extension= */ "'a'", /* prefix= */ "'a'");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//one:a");
+ SkylarkInfo artifactNamePatternStruct = (SkylarkInfo) t.getValue("namepattern");
+ assertThat(artifactNamePatternStruct).isNotNull();
+ CcModule.artifactNamePatternFromSkylark(artifactNamePatternStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Field 'category_name' is not of 'java.lang.String' type.");
+ }
+
+ createCustomArtifactNamePatternRule(
+ "two",
+ /* categoryName= */ "'static_library'",
+ /* extension= */ "struct()",
+ /* prefix= */ "'a'");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//two:a");
+ SkylarkInfo artifactNamePatternStruct = (SkylarkInfo) t.getValue("namepattern");
+ assertThat(artifactNamePatternStruct).isNotNull();
+ CcModule.artifactNamePatternFromSkylark(artifactNamePatternStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("Field 'extension' is not of 'java.lang.String' type.");
+ }
+
+ createCustomArtifactNamePatternRule(
+ "three",
+ /* categoryName= */ "'static_library'",
+ /* extension= */ "'.a'",
+ /* prefix= */ "struct()");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//three:a");
+ SkylarkInfo artifactNamePatternStruct = (SkylarkInfo) t.getValue("namepattern");
+ assertThat(artifactNamePatternStruct).isNotNull();
+ CcModule.artifactNamePatternFromSkylark(artifactNamePatternStruct);
+ fail("Should have failed because of wrong object type.");
+ } catch (EvalException ee) {
+ assertThat(ee).hasMessageThat().contains("Field 'prefix' is not of 'java.lang.String' type.");
+ }
+
+ createCustomArtifactNamePatternRule(
+ "four", /* categoryName= */ "''", /* extension= */ "'.a'", /* prefix= */ "'a'");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//four:a");
+ SkylarkInfo artifactNamePatternStruct = (SkylarkInfo) t.getValue("namepattern");
+ assertThat(artifactNamePatternStruct).isNotNull();
+ CcModule.artifactNamePatternFromSkylark(artifactNamePatternStruct);
+ fail("Should have failed because of empty string.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains(
+ "The 'category_name' field of artifact_name_pattern must be a nonempty string.");
+ }
+
+ createCustomArtifactNamePatternRule(
+ "five", /* categoryName= */ "'static_library'", /* extension= */ "''", /* prefix= */ "'a'");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//five:a");
+ SkylarkInfo artifactNamePatternStruct = (SkylarkInfo) t.getValue("namepattern");
+ assertThat(artifactNamePatternStruct).isNotNull();
+ CcModule.artifactNamePatternFromSkylark(artifactNamePatternStruct);
+ fail("Should have failed because of empty string.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("The 'extension' field of artifact_name_pattern must be a nonempty string.");
+ }
+
+ createCustomArtifactNamePatternRule(
+ "six", /* categoryName= */ "'static_library'", /* extension= */ "'.a'", /* prefix= */ "''");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//six:a");
+ SkylarkInfo artifactNamePatternStruct = (SkylarkInfo) t.getValue("namepattern");
+ assertThat(artifactNamePatternStruct).isNotNull();
+ CcModule.artifactNamePatternFromSkylark(artifactNamePatternStruct);
+ fail("Should have failed because of empty string.");
+ } catch (EvalException ee) {
+ assertThat(ee)
+ .hasMessageThat()
+ .contains("The 'prefix' field of artifact_name_pattern must be a nonempty string.");
+ }
+
+ createCustomArtifactNamePatternRule(
+ "seven", /* categoryName= */ "'unknown'", /* extension= */ "'.a'", /* prefix= */ "'a'");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//seven:a");
+ SkylarkInfo artifactNamePatternStruct = (SkylarkInfo) t.getValue("namepattern");
+ assertThat(artifactNamePatternStruct).isNotNull();
+ CcModule.artifactNamePatternFromSkylark(artifactNamePatternStruct);
+ fail("Should have failed because of unrecognized category.");
+ } catch (EvalException ee) {
+ assertThat(ee).hasMessageThat().contains("Artifact category unknown not recognized");
+ }
+
+ createCustomArtifactNamePatternRule(
+ "eight",
+ /* categoryName= */ "'static_library'",
+ /* extension= */ "'a'",
+ /* prefix= */ "'a'");
+
+ try {
+ ConfiguredTarget t = getConfiguredTarget("//eight:a");
+ SkylarkInfo artifactNamePatternStruct = (SkylarkInfo) t.getValue("namepattern");
+ assertThat(artifactNamePatternStruct).isNotNull();
+ CcModule.artifactNamePatternFromSkylark(artifactNamePatternStruct);
+ fail("Should have failed because of unrecognized extension.");
+ } catch (EvalException ee) {
+ assertThat(ee).hasMessageThat().contains("Unrecognized file extension 'a'");
+ }
+ }
+
+ private void createCustomArtifactNamePatternRule(
+ String pkg, String categoryName, String extension, String prefix) throws Exception {
+ scratch.file(
+ pkg + "/foo.bzl",
+ "def _impl(ctx):",
+ " return struct(namepattern = struct(",
+ " category_name = " + categoryName + ",",
+ " extension = " + extension + ",",
+ " prefix = " + prefix + ",",
+ " type_name = 'artifact_name_pattern'))",
+ "crule = rule(implementation = _impl)");
+ scratch.file(pkg + "/BUILD", "load(':foo.bzl', 'crule')", "crule(name = 'a')");
+ }
+
+ @Test
+ public void testCcToolchainInfoFromSkylark() throws Exception {
+ loadCcToolchainConfigLib();
+ scratch.file(
+ "foo/crosstool.bzl",
+ "load('//tools/cpp:cc_toolchain_config_lib.bzl',",
+ " 'feature',",
+ " 'action_config',",
+ " 'artifact_name_pattern',",
+ " 'env_entry',",
+ " 'variable_with_value',",
+ " 'make_variable',",
+ " 'feature_set',",
+ " 'with_feature_set',",
+ " 'env_set',",
+ " 'flag_group',",
+ " 'flag_set',",
+ " 'tool_path',",
+ " 'tool')",
+ "",
+ "def _impl(ctx):",
+ " return cc_common.create_cc_toolchain_config_info(",
+ " ctx = ctx,",
+ " features = [feature(name = 'featureone')],",
+ " action_configs = [action_config(action_name = 'action', enabled=True)],",
+ " artifact_name_patterns = [artifact_name_pattern(",
+ " category_name = 'static_library',",
+ " prefix = 'prefix',",
+ " extension = '.a')],",
+ " cxx_builtin_include_directories = ['dir1', 'dir2', 'dir3'],",
+ " toolchain_identifier = 'toolchain',",
+ " host_system_name = 'host',",
+ " target_system_name = 'target',",
+ " target_cpu = 'cpu',",
+ " target_libc = 'libc',",
+ " default_libc_top = 'libc_top',",
+ " compiler = 'compiler',",
+ " abi_libc_version = 'abi_libc',",
+ " abi_version = 'abi',",
+ " supports_gold_linker = True,",
+ " supports_start_end_lib = True,",
+ " tool_paths = [tool_path(name = 'name1', path = 'path1')],",
+ " cc_target_os = 'os',",
+ " compiler_flags = ['flag1', 'flag2', 'flag3'],",
+ " linker_flags = ['flag1'],",
+ " objcopy_embed_flags = ['flag1'],",
+ " needs_pic = True,",
+ " builtin_sysroot = 'sysroot',",
+ " make_variables = [make_variable(name = 'acs', value = 'asd')])",
+ "cc_toolchain_config_rule = rule(",
+ " implementation = _impl,",
+ " attrs = {},",
+ " provides = [CcToolchainConfigInfo], ",
+ ")");
+
+ scratch.file(
+ "foo/BUILD",
+ "load(':crosstool.bzl', 'cc_toolchain_config_rule')",
+ "cc_toolchain_alias(name='alias')",
+ "cc_toolchain_config_rule(name='r')");
+ useConfiguration("--experimental_enable_cc_toolchain_config_info");
+ ConfiguredTarget target = getConfiguredTarget("//foo:r");
+ assertThat(target).isNotNull();
+ CcToolchainConfigInfo ccToolchainConfigInfo =
+ (CcToolchainConfigInfo) target.get(CcToolchainConfigInfo.PROVIDER.getKey());
+ assertThat(ccToolchainConfigInfo).isNotNull();
+
+ useConfiguration();
+ AssertionError e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//foo:r"));
+ assertThat(e).hasMessageThat().contains("Creating a CcToolchainConfigInfo is not enabled.");
+ }
}
diff --git a/tools/cpp/cc_toolchain_config_lib.bzl b/tools/cpp/cc_toolchain_config_lib.bzl
new file mode 100644
index 0000000..5130e79
--- /dev/null
+++ b/tools/cpp/cc_toolchain_config_lib.bzl
@@ -0,0 +1,542 @@
+# Copyright 2018 The Bazel Authors. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+""" A library of functions creating structs for CcToolchainConfigInfo."""
+
+def _check_is_none_or_right_type(obj, obj_of_right_type, parameter_name, method_name):
+ if obj != None:
+ _check_right_type(obj, obj_of_right_type, parameter_name, method_name)
+
+def _check_right_type(obj, obj_of_right_type, parameter_name, method_name):
+ if type(obj) != type(obj_of_right_type):
+ fail("{} parameter of {} should be a {}, found {}."
+ .format(parameter_name, method_name, type(obj_of_right_type), type(obj)))
+
+def _check_is_nonempty_string(obj, parameter_name, method_name):
+ _check_right_type(obj, "", parameter_name, method_name)
+ if obj == "":
+ fail("{} parameter of {} must be a nonempty string."
+ .format(parameter_name, method_name))
+
+def _check_is_nonempty_list(obj, parameter_name, method_name):
+ _check_right_type(obj, [], parameter_name, method_name)
+ if len(obj) == 0:
+ fail("{} parameter of {} must be a nonempty list."
+ .format(parameter_name, method_name))
+
+EnvEntryInfo = provider(fields = ["key", "value", "type_name"])
+
+def env_entry(key, value):
+ """ A key/value pair to be added as an environment variable.
+
+ The returned EnvEntry provider finds its use in EnvSet creation through
+ the env_entries parameter of env_set(); EnvSet groups environment variables
+ that need to be expanded for specific actions.
+ The value of this pair is expanded in the same way as is described in
+ flag_group. The key remains an unexpanded string literal.
+
+ Args:
+ key: a string literal representing the name of the variable.
+ value: the value to be expanded.
+
+ Returns:
+ An EnvEntryInfo provider.
+ """
+ _check_is_nonempty_string(key, "key", "env_entry")
+ _check_is_nonempty_string(value, "value", "env_entry")
+ return EnvEntryInfo(key = key, value = value, type_name = "env_entry")
+
+VariableWithValueInfo = provider(fields = ["name", "value", "type_name"])
+
+def variable_with_value(name, value):
+ """ Represents equality check between a variable and a certain value.
+
+ The returned provider finds its use through flag_group.expand_if_equal,
+ making the expansion of the flag_group conditional on the value of the
+ variable.
+
+ Args:
+ name: name of the variable.
+ value: the value the variable should be compared against.
+
+ Returns:
+ A VariableWithValueInfo provider.
+ """
+ _check_is_nonempty_string(name, "name", "variable_with_value")
+ _check_is_nonempty_string(value, "value", "variable_with_value")
+ return VariableWithValueInfo(
+ name = name,
+ value = value,
+ type_name = "variable_with_value",
+ )
+
+MakeVariableInfo = provider(fields = ["name", "value", "type_name"])
+
+def make_variable(name, value):
+ """ A make variable that is made accessible to rules."""
+ _check_is_nonempty_string(name, "name", "make_variable")
+ _check_is_nonempty_string(value, "value", "make_variable")
+ return MakeVariableInfo(
+ name = name,
+ value = value,
+ type_name = "make_variable",
+ )
+
+FeatureSetInfo = provider(fields = ["features", "type_name"])
+
+def feature_set(features = []):
+ """ A set of features.
+
+ Used to support logical 'and' when specifying feature requirements in a
+ feature.
+
+ Args:
+ features: A list of unordered feature names.
+
+ Returns:
+ A FeatureSetInfo provider.
+ """
+ _check_right_type(features, [], "features", "feature_set")
+ return FeatureSetInfo(features = features, type_name = "feature_set")
+
+WithFeatureSetInfo = provider(fields = ["features", "not_features", "type_name"])
+
+def with_feature_set(features = [], not_features = []):
+ """ A set of positive and negative features.
+
+ This stanza will evaluate to true when every 'feature' is enabled, and
+ every 'not_feature' is not enabled.
+
+ Args:
+ features: A list of feature names that need to be enabled.
+ not_features: A list of feature names that need to not be enabled.
+
+ Returns:
+ A WithFeatureSetInfo provider.
+ """
+ _check_right_type(features, [], "features", "with_feature_set")
+ _check_right_type(not_features, [], "not_features", "with_feature_set")
+ return WithFeatureSetInfo(
+ features = features,
+ not_features = not_features,
+ type_name = "with_feature_set",
+ )
+
+EnvSetInfo = provider(fields = ["actions", "env_entries", "with_features", "type_name"])
+
+def env_set(actions, env_entries = [], with_features = []):
+ """ Groups a set of environment variables to apply for certain actions.
+
+ EnvSet providers are passed to feature() and action_config(), to be applied to
+ the actions they are specified for.
+
+ Args:
+ actions: A list of actions this env set applies to; each env set must
+ specify at least one action.
+ env_entries: A list of EnvEntry - the environment variables applied
+ via this env set.
+ with_features: A list of feature sets defining when this env set gets
+ applied. The env set will be applied when any one of the feature
+ sets evaluate to true. (That is, when when every 'feature' is
+ enabled, and every 'not_feature' is not enabled.)
+ If 'with_features' is omitted, the env set will be applied
+ unconditionally for every action specified.
+
+ Returns:
+ An EnvSetInfo provider.
+ """
+ _check_is_nonempty_list(actions, "actions", "env_set")
+ _check_right_type(env_entries, [], "env_entries", "env_set")
+ _check_right_type(with_features, [], "with_features", "env_set")
+ return EnvSetInfo(
+ actions = actions,
+ env_entries = env_entries,
+ with_features = with_features,
+ type_name = "env_set",
+ )
+
+FlagGroupInfo = provider(fields = [
+ "flags",
+ "flag_groups",
+ "iterate_over",
+ "expand_if_available",
+ "expand_if_not_available",
+ "expand_if_true",
+ "expand_if_false",
+ "expand_if_equal",
+ "type_name",
+])
+
+def flag_group(
+ flags = [],
+ flag_groups = [],
+ iterate_over = None,
+ expand_if_available = None,
+ expand_if_not_available = None,
+ expand_if_true = None,
+ expand_if_false = None,
+ expand_if_equal = None):
+ """ A group of flags. Supports parametrization via variable expansion.
+
+ To expand a variable of list type, flag_group has to be annotated with
+ `iterate_over` message. Then all nested flags or flag_groups will be
+ expanded repeatedly for each element of the list.
+ For example:
+ flag_group(
+ iterate_over = 'include_path',
+ flags = ['-I', '%{include_path}'],
+ )
+ ... will get expanded to -I /to/path1 -I /to/path2 ... for each
+ include_path /to/pathN.
+
+ To expand a variable of structure type, use dot-notation, e.g.:
+ flag_group(
+ iterate_over = "libraries_to_link",
+ flag_groups = [
+ flag_group(
+ iterate_over = "libraries_to_link.libraries",
+ flags = ["-L%{libraries_to_link.libraries.directory}"],
+ )
+ ]
+ )
+
+ Flag groups can be nested; if they are, the flag group must only contain
+ other flag groups (no flags) so the order is unambiguously specified.
+ In order to expand a variable of nested lists, 'iterate_over' can be used.
+ For example:
+ flag_group (
+ iterate_over = 'object_files',
+ flag_groups = [
+ flag_group (
+ flags = ['--start-lib'],
+ ),
+ flag_group (
+ iterate_over = 'object_files',
+ flags = ['%{object_files}'],
+ ),
+ flag_group (
+ flags = ['--end-lib'],
+ )
+ ]
+ )
+ ... will get expanded to
+ --start-lib a1.o a2.o ... --end-lib --start-lib b1.o b2.o .. --end-lib
+ with %{object_files} being a variable of nested list type
+ [['a1.o', 'a2.o', ...], ['b1.o', 'b2.o', ...], ...].
+
+ Args:
+ flags: a string list, representing flags. Only one of flags and
+ flag_groups can be set, as to avoid ambiguity.
+ flag_groups: a list of FlagGroup entries. Only one of flags and
+ flag_groups can be set, as to avoid ambiguity.
+ iterate_over: a string, representing a variable of list type.
+ expand_if_available: A build variable that needs to be available
+ in order to expand the flag_group.
+ expand_if_not_available: A build variable that needs to be
+ unavailable in order for this flag_group to be expanded.
+ expand_if_true: if set, this variable needs to evaluate to True in
+ order for the flag_group to be expanded.
+ expand_if_false: if set, this variable needs to evalate to False in
+ order for the flag_group to be expanded.
+ expand_if_equal: a VariableWithValue, the flag_group is expanded in
+ case of equality.
+
+ Returns:
+ A FlagGroupInfo provider.
+ """
+
+ _check_right_type(flags, [], "flags", "flag_group")
+ _check_right_type(flag_groups, [], "flag_groups", "flag_group")
+ if len(flags) > 0 and len(flag_groups) > 0:
+ fail("flag_group must not contain both a flag and another flag_group.")
+ if len(flags) == 0 and len(flag_groups) == 0:
+ fail("flag_group must contain either a list of flags or a list of flag_groups.")
+ _check_is_none_or_right_type(expand_if_true, "string", "expand_if_true", "flag_group")
+ _check_is_none_or_right_type(expand_if_false, "string", "expand_if_false", "flag_group")
+ _check_is_none_or_right_type(expand_if_available, "string", "expand_if_available", "flag_group")
+ _check_is_none_or_right_type(
+ expand_if_not_available,
+ "string",
+ "expand_if_not_available",
+ "flag_group",
+ )
+ _check_is_none_or_right_type(iterate_over, "string", "iterate_over", "flag_group")
+
+ return FlagGroupInfo(
+ flags = flags,
+ flag_groups = flag_groups,
+ iterate_over = iterate_over,
+ expand_if_available = expand_if_available,
+ expand_if_not_available = expand_if_not_available,
+ expand_if_true = expand_if_true,
+ expand_if_false = expand_if_false,
+ expand_if_equal = expand_if_equal,
+ type_name = "flag_group",
+ )
+
+FlagSetInfo = provider(fields = [
+ "actions",
+ "with_features",
+ "flag_groups",
+ "type_name",
+])
+
+def flag_set(
+ actions,
+ with_features = [],
+ flag_groups = []):
+ """ A set of flags to be expanded in the command line for specific actions.
+
+ Args:
+ actions: The actions this flag set applies to; each flag set must
+ specify at least one action.
+ with_features: A list of feature sets defining when this flag set gets
+ applied. The flag set will be applied when any one of the feature
+ sets evaluate to true. (That is, when when every 'feature' is
+ enabled, and every 'not_feature' is not enabled.)
+ If 'with_feature' is omitted, the flag set will be applied
+ unconditionally for every action specified.
+ flag_groups: A FlagGroup list - the flags applied via this flag set.
+
+ Returns:
+ A FlagSetInfo provider.
+ """
+ _check_is_nonempty_list(actions, "actions", "flag_set")
+ _check_right_type(with_features, [], "with_features", "flag_set")
+ _check_right_type(flag_groups, [], "flag_groups", "flag_set")
+ return FlagSetInfo(
+ actions = actions,
+ with_features = with_features,
+ flag_groups = flag_groups,
+ type_name = "flag_set",
+ )
+
+FeatureInfo = provider(fields = [
+ "name",
+ "enabled",
+ "flag_sets",
+ "env_sets",
+ "requires",
+ "implies",
+ "provides",
+ "type_name",
+])
+
+def feature(
+ name,
+ enabled = False,
+ flag_sets = [],
+ env_sets = [],
+ requires = [],
+ implies = [],
+ provides = []):
+ """ Contains all flag specifications for one feature.
+
+ Args:
+ name: The feature's name. It is possible to introduce a feature without
+ a change to Bazel by adding a 'feature' section to the toolchain
+ and adding the corresponding string as feature in the BUILD file.
+ enabled: If 'True', this feature is enabled unless a rule type
+ explicitly marks it as unsupported.
+ flag_sets: A FlagSet list - If the given feature is enabled, the flag
+ sets will be applied for the actions are specified for.
+ env_sets: an EnvSet list - If the given feature is enabled, the env
+ sets will be applied for the actions they are specified for.
+ requires: A list of feature sets defining when this feature is
+ supported by the toolchain. The feature is supported if any of the
+ feature sets fully apply, that is, when all features of a feature
+ set are enabled.
+ If 'requires' is omitted, the feature is supported independently of
+ which other features are enabled.
+ Use this for example to filter flags depending on the build mode
+ enabled (opt / fastbuild / dbg).
+ implies: A string list of features or action configs that are
+ automatically enabled when this feature is enabled. If any of the
+ implied features or action configs cannot be enabled, this feature
+ will (silently) not be enabled either.
+ provides: A list of names this feature conflicts with.
+ A feature cannot be enabled if:
+ - 'provides' contains the name of a different feature or action
+ config that we want to enable.
+ - 'provides' contains the same value as a 'provides' in a
+ different feature or action config that we want to enable.
+ Use this in order to ensure that incompatible features cannot be
+ accidentally activated at the same time, leading to hard to
+ diagnose compiler errors.
+
+ Returns:
+ A FeatureInfo provider.
+ """
+ _check_right_type(enabled, True, "enabled", "feature")
+ _check_right_type(flag_sets, [], "flag_sets", "feature")
+ _check_right_type(env_sets, [], "env_sets", "feature")
+ _check_right_type(requires, [], "requires", "feature")
+ _check_right_type(provides, [], "provides", "feature")
+ _check_right_type(implies, [], "implies", "feature")
+ return FeatureInfo(
+ name = name,
+ enabled = enabled,
+ flag_sets = flag_sets,
+ env_sets = env_sets,
+ requires = requires,
+ implies = implies,
+ provides = provides,
+ type_name = "feature",
+ )
+
+ToolPathInfo = provider(fields = ["name", "path", "type_name"])
+
+def tool_path(name, path):
+ """ Tool locations.
+
+ Args:
+ name: Name of the tool.
+ path: Location of the tool; Can be absolute path (in case of non hermetic
+ toolchain), or path relative to the cc_toolchain's package.
+
+ Returns:
+ A ToolPathInfo provider.
+
+ Deprecated:
+ Prefer specifying an ActionConfig for the action that needs the tool.
+ TODO(b/27903698) migrate to ActionConfig.
+ """
+ _check_is_nonempty_string(name, "name", "tool_path")
+ _check_is_nonempty_string(path, "path", "tool_path")
+ return ToolPathInfo(name = name, path = path, type_name = "tool_path")
+
+ToolInfo = provider(fields = ["path", "with_features", "execution_requirements", "type_name"])
+
+def tool(path, with_features = [], execution_requirements = []):
+ """ Describes a tool associated with a crosstool action config.
+
+ Args:
+ path: Location of the tool; Can be absolute path (in case of non hermetic
+ toolchain), or path relative to the cc_toolchain's package.
+ with_features: A list of feature sets defining when this tool is
+ applicable. The tool will used when any one of the feature sets
+ evaluate to true. (That is, when when every 'feature' is enabled,
+ and every 'not_feature' is not enabled.)
+ If 'with_feature' is omitted, the tool will apply for any feature
+ configuration.
+ execution_requirements: Requirements on the execution environment for
+ the execution of this tool, to be passed as out-of-band "hints" to
+ the execution backend.
+ Ex. "requires-darwin"
+
+ Returns:
+ A ToolInfo provider.
+ """
+ _check_is_nonempty_string(path, "path", "tool")
+ _check_right_type(with_features, [], "with_features", "tool")
+ _check_right_type(execution_requirements, [], "execution_requirements", "tool")
+ return ToolInfo(
+ path = path,
+ with_features = with_features,
+ execution_requirements = execution_requirements,
+ type_name = "tool",
+ )
+
+ActionConfigInfo = provider(fields = [
+ "config_name",
+ "action_name",
+ "enabled",
+ "tools",
+ "flag_sets",
+ "implies",
+ "type_name",
+])
+
+def action_config(
+ action_name,
+ enabled = True,
+ tools = [],
+ flag_sets = [],
+ implies = []):
+ """ Configuration of a Bazel action.
+
+ An action config corresponds to a Bazel action, and allows selection of
+ a tool based on activated features.
+ Action config activation occurs by the same semantics as features: a
+ feature can 'require' or 'imply' an action config in the same way that it
+ would another feature.
+
+ Args:
+ action_name: The name of the Bazel action that this config applies to,
+ ex. 'c-compile' or 'c-module-compile'.
+ enabled: If 'True', this action is enabled unless a rule type
+ explicitly marks it as unsupported.
+ tools: The tool applied to the action will be the first Tool with a
+ feature set that matches the feature configuration. An error will
+ be thrown if no tool matches a provided feature configuration - for
+ that reason, it's a good idea to provide a default tool with an
+ empty feature set.
+ flag_sets: If the given action config is enabled, the flag sets will be
+ applied to the corresponding action.
+ implies: A list of features or action configs that are automatically
+ enabled when this action config is enabled. If any of the implied
+ features or action configs cannot be enabled, this action config
+ will (silently) not be enabled either.
+
+ Returns:
+ An ActionConfigInfo provider.
+ """
+ _check_is_nonempty_string(action_name, "name", "action_config")
+ _check_right_type(enabled, True, "enabled", "action_config")
+ _check_right_type(tools, [], "tools", "action_config")
+ _check_right_type(flag_sets, [], "flag_sets", "action_config")
+ _check_right_type(implies, [], "implies", "action_config")
+ return ActionConfigInfo(
+ action_name = action_name,
+ enabled = enabled,
+ tools = tools,
+ flag_sets = flag_sets,
+ implies = implies,
+ type_name = "action_config",
+ )
+
+ArtifactNamePatternInfo = provider(fields = [
+ "category_name",
+ "prefix",
+ "extension",
+ "type_name",
+])
+
+def artifact_name_pattern(category_name, prefix, extension):
+ """ The name for an artifact of a given category of input or output artifacts to an action.
+
+ Args:
+ category_name: The category of artifacts that this selection applies
+ to. This field is compared against a list of categories defined
+ in bazel. Example categories include "linked_output" or
+ "debug_symbols". An error is thrown if no category is matched.
+ prefix: The prefix for creating the artifact for this selection.
+ Together with the extension it is used to create an artifact name
+ based on the target name.
+ extension: The extension for creating the artifact for this selection.
+ Together with the prefix it is used to create an artifact name
+ based on the target name.
+
+ Returns:
+ An ArtifactNamePatternInfo provider
+ """
+ _check_is_nonempty_string(category_name, "category_name", "artifact_name_pattern")
+ _check_is_nonempty_string(prefix, "prefix", "artifact_name_pattern")
+ _check_is_nonempty_string(extension, "extension", "artifact_name_pattern")
+ return ArtifactNamePatternInfo(
+ category_name = category_name,
+ prefix = prefix,
+ extension = extension,
+ type_name = "artifact_name_pattern",
+ )
