blob: eb2a5374f20d2f7f4bef64b7e3159fa7b25da9f3 [file] [log] [blame]
// Copyright 2014 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.analysis;
import static com.google.devtools.build.lib.analysis.test.ExecutionInfo.DEFAULT_TEST_RUNNER_EXEC_GROUP;
import static com.google.devtools.build.lib.packages.Attribute.attr;
import static com.google.devtools.build.lib.packages.BuildType.DISTRIBUTIONS;
import static com.google.devtools.build.lib.packages.BuildType.LABEL;
import static com.google.devtools.build.lib.packages.BuildType.LABEL_LIST;
import static com.google.devtools.build.lib.packages.BuildType.LICENSE;
import static com.google.devtools.build.lib.packages.BuildType.NODEP_LABEL_LIST;
import static com.google.devtools.build.lib.packages.Type.BOOLEAN;
import static com.google.devtools.build.lib.packages.Type.INTEGER;
import static com.google.devtools.build.lib.packages.Type.STRING;
import static com.google.devtools.build.lib.packages.Types.STRING_DICT;
import static com.google.devtools.build.lib.packages.Types.STRING_LIST;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.devtools.build.lib.analysis.config.BuildConfigurationValue;
import com.google.devtools.build.lib.analysis.config.ExecutionTransitionFactory;
import com.google.devtools.build.lib.analysis.config.RunUnder;
import com.google.devtools.build.lib.analysis.constraints.ConstraintConstants;
import com.google.devtools.build.lib.analysis.platform.ConstraintValueInfo;
import com.google.devtools.build.lib.analysis.test.CoverageConfiguration;
import com.google.devtools.build.lib.analysis.test.TestConfiguration;
import com.google.devtools.build.lib.cmdline.Label;
import com.google.devtools.build.lib.packages.Attribute;
import com.google.devtools.build.lib.packages.Attribute.LabelLateBoundDefault;
import com.google.devtools.build.lib.packages.Attribute.LabelListLateBoundDefault;
import com.google.devtools.build.lib.packages.Attribute.LateBoundDefault.Resolver;
import com.google.devtools.build.lib.packages.AttributeMap;
import com.google.devtools.build.lib.packages.BuildType;
import com.google.devtools.build.lib.packages.ConfigurationFragmentPolicy.MissingFragmentPolicy;
import com.google.devtools.build.lib.packages.RuleClass;
import com.google.devtools.build.lib.packages.RuleClass.Builder.RuleClassType;
import com.google.devtools.build.lib.packages.TargetUtils;
import com.google.devtools.build.lib.packages.TestSize;
import com.google.devtools.build.lib.packages.Type;
import com.google.devtools.build.lib.packages.Type.ConversionException;
import com.google.devtools.build.lib.packages.Types;
import com.google.devtools.build.lib.skyframe.serialization.VisibleForSerialization;
import com.google.devtools.build.lib.skyframe.serialization.autocodec.SerializationConstant;
import com.google.devtools.build.lib.util.FileTypeSet;
import javax.annotation.Nullable;
import net.starlark.java.eval.StarlarkInt;
/**
* Rule class definitions used by (almost) every rule.
*/
public class BaseRuleClasses {
private BaseRuleClasses() {}
@SerializationConstant @VisibleForSerialization
static final Attribute.ComputedDefault testonlyDefault =
new Attribute.ComputedDefault() {
@Override
public Object getDefault(AttributeMap rule) {
return rule.getPackageArgs().defaultTestOnly();
}
};
@SerializationConstant @VisibleForSerialization
static final Attribute.ComputedDefault deprecationDefault =
new Attribute.ComputedDefault() {
@Override
public Object getDefault(AttributeMap rule) {
return rule.getPackageArgs().defaultDeprecation();
}
};
@SerializationConstant @VisibleForSerialization
public static final Attribute.ComputedDefault TIMEOUT_DEFAULT =
new Attribute.ComputedDefault() {
@Override
public Object getDefault(AttributeMap rule) {
TestSize size = TestSize.getTestSize(rule.get("size", Type.STRING));
if (size != null) {
String timeout = size.getDefaultTimeout().toString();
if (timeout != null) {
return timeout;
}
}
return "illegal";
}
};
@SerializationConstant @VisibleForSerialization
public static final Attribute.ComputedDefault packageMetadataDefault =
new Attribute.ComputedDefault() {
@Override
public Object getDefault(AttributeMap rule) {
return rule.getPackageArgs().defaultPackageMetadata();
}
};
// TODO(b/65746853): provide a way to do this without passing the entire configuration
/**
* Implementation for the :action_listener attribute.
*
* <p>action_listeners are special rules; they tell the build system to add extra_actions to
* existing rules. As such they need an edge to every ConfiguredTarget with the limitation that
* they only run on the target configuration and should not operate on action_listeners and
* extra_actions themselves (to avoid cycles).
*/
@SerializationConstant @VisibleForSerialization @VisibleForTesting
static final LabelListLateBoundDefault<?> ACTION_LISTENER =
LabelListLateBoundDefault.fromTargetConfiguration(
BuildConfigurationValue.class,
(rule, attributes, configuration) -> configuration.getActionListeners());
public static final String DEFAULT_COVERAGE_SUPPORT_VALUE = "//tools/test:coverage_support";
@SerializationConstant @VisibleForSerialization
static final Resolver<TestConfiguration, Label> COVERAGE_SUPPORT_CONFIGURATION_RESOLVER =
(rule, attributes, configuration) -> configuration.getCoverageSupport();
public static LabelLateBoundDefault<TestConfiguration> coverageSupportAttribute(
Label defaultValue) {
return LabelLateBoundDefault.fromTargetConfiguration(
TestConfiguration.class, defaultValue, COVERAGE_SUPPORT_CONFIGURATION_RESOLVER);
}
public static final String DEFAULT_COVERAGE_REPORT_GENERATOR_VALUE =
"//tools/test:coverage_report_generator";
@SerializationConstant @VisibleForSerialization
static final Resolver<CoverageConfiguration, Label>
COVERAGE_REPORT_GENERATOR_CONFIGURATION_RESOLVER =
(rule, attributes, configuration) -> configuration.reportGenerator();
public static LabelLateBoundDefault<CoverageConfiguration> coverageReportGeneratorAttribute(
Label defaultValue) {
return LabelLateBoundDefault.fromTargetConfiguration(
CoverageConfiguration.class,
defaultValue,
COVERAGE_REPORT_GENERATOR_CONFIGURATION_RESOLVER);
}
public static LabelLateBoundDefault<CoverageConfiguration> getCoverageOutputGeneratorLabel() {
return LabelLateBoundDefault.fromTargetConfiguration(
CoverageConfiguration.class, null, COVERAGE_OUTPUT_GENERATOR_RESOLVER);
}
@SerializationConstant @VisibleForSerialization
static final Resolver<CoverageConfiguration, Label> COVERAGE_OUTPUT_GENERATOR_RESOLVER =
(rule, attributes, configuration) -> configuration.outputGenerator();
// TODO(b/65746853): provide a way to do this without passing the entire configuration
/** Implementation for the :run_under attribute. */
@SerializationConstant @VisibleForSerialization
public static final LabelLateBoundDefault<?> RUN_UNDER =
LabelLateBoundDefault.fromTargetConfiguration(
BuildConfigurationValue.class,
null,
(rule, attributes, configuration) -> {
RunUnder runUnder = configuration.getRunUnder();
return runUnder != null ? runUnder.getLabel() : null;
});
/**
* A base rule for all test rules.
*/
public static final class TestBaseRule implements RuleDefinition {
@Override
public RuleClass build(RuleClass.Builder builder, RuleDefinitionEnvironment env) {
builder
.addExecGroup(DEFAULT_TEST_RUNNER_EXEC_GROUP)
.requiresConfigurationFragments(TestConfiguration.class)
// TestConfiguration only needed to create TestAction and TestProvider
// Only necessary at top-level and can be skipped if trimmed.
.setMissingFragmentPolicy(TestConfiguration.class, MissingFragmentPolicy.IGNORE)
.add(
attr("size", STRING)
.value("medium")
.taggable()
.nonconfigurable("policy decision: should be consistent across configurations"))
.add(
attr("timeout", STRING)
.taggable()
.nonconfigurable("policy decision: should be consistent across configurations")
.value(TIMEOUT_DEFAULT))
.add(
attr("flaky", BOOLEAN)
.value(false)
.taggable()
.nonconfigurable("policy decision: should be consistent across configurations"))
.add(attr("shard_count", INTEGER).value(StarlarkInt.of(-1)))
.add(
attr("local", BOOLEAN)
.value(false)
.taggable()
.nonconfigurable("policy decision: should be consistent across configurations"))
.add(attr("args", STRING_LIST))
.add(attr("env", STRING_DICT))
.add(attr("env_inherit", STRING_LIST))
// Input files for every test action
.add(
attr("$test_wrapper", LABEL)
.cfg(ExecutionTransitionFactory.createFactory())
.singleArtifact()
.value(env.getToolsLabel("//tools/test:test_wrapper")))
.add(
attr("$xml_writer", LABEL)
.cfg(ExecutionTransitionFactory.createFactory())
.singleArtifact()
.value(env.getToolsLabel("//tools/test:xml_writer")))
.add(
attr("$test_runtime", LABEL_LIST)
.cfg(ExecutionTransitionFactory.createFactory())
.value(getTestRuntimeLabelList(env)))
.add(
attr("$test_setup_script", LABEL)
.cfg(ExecutionTransitionFactory.createFactory())
.singleArtifact()
.value(env.getToolsLabel("//tools/test:test_setup")))
.add(
attr("$xml_generator_script", LABEL)
.cfg(ExecutionTransitionFactory.createFactory())
.singleArtifact()
.value(env.getToolsLabel("//tools/test:test_xml_generator")))
.add(
attr("$collect_coverage_script", LABEL)
.cfg(ExecutionTransitionFactory.createFactory())
.singleArtifact()
.value(env.getToolsLabel("//tools/test:collect_coverage")))
// Input files for test actions collecting code coverage
.add(
attr(":coverage_support", LABEL)
.value(
coverageSupportAttribute(env.getToolsLabel(DEFAULT_COVERAGE_SUPPORT_VALUE))))
// Used in the one-per-build coverage report generation action.
.add(
attr(":coverage_report_generator", LABEL)
.cfg(ExecutionTransitionFactory.createFactory())
.value(
coverageReportGeneratorAttribute(
env.getToolsLabel(DEFAULT_COVERAGE_REPORT_GENERATOR_VALUE))))
// The target itself and run_under both run on the same machine.
.add(attr(":run_under", LABEL).value(RUN_UNDER).skipPrereqValidatorCheck());
env.getNetworkAllowlistForTests()
.ifPresent(
label ->
builder.add(
Allowlist.getAttributeFromAllowlistName("external_network").value(label)));
return builder.build();
}
@Override
public Metadata getMetadata() {
return RuleDefinition.Metadata.builder()
.name("$test_base_rule")
.type(RuleClassType.ABSTRACT)
.ancestors(MakeVariableExpandingRule.class)
.build();
}
}
private static final String TOOLS_TEST_RUNTIME_TARGET_PATTERN = "//tools/test:runtime";
private static ImmutableList<Label> testRuntimeLabelList = null;
// Always return the same ImmutableList<Label> for every $test_runtime attribute's default value.
public static synchronized ImmutableList<Label> getTestRuntimeLabelList(
RuleDefinitionEnvironment env) {
if (testRuntimeLabelList == null) {
testRuntimeLabelList =
ImmutableList.of(
Label.parseCanonicalUnchecked(
env.getToolsRepository() + TOOLS_TEST_RUNTIME_TARGET_PATTERN));
}
return testRuntimeLabelList;
}
/**
* The attribute used to list the configuration properties used by a target and its transitive
* dependencies. Currently only supports config_feature_flag.
*
* <p>A special value of "//command_line_option/fragments:test" instructs
* TestTrimmingTransitionFactory to skip trimming for this rule.
*/
public static final String TAGGED_TRIMMING_ATTR = "transitive_configs";
/** Share common attributes across both base and Starlark base rules. */
// TODO(bazel-team): replace this with a common RuleDefinition ancestor of NativeBuildRule
// and StarlarkRuleClassFunctions.baseRule. This requires refactoring StarlarkRuleClassFunctions
// to instantiate its RuleClasses through RuleDefinition.
public static RuleClass.Builder commonCoreAndStarlarkAttributes(RuleClass.Builder builder) {
return builder
// The visibility attribute is special: it is a nodep label, and loading the
// necessary package groups is handled by {@link LabelVisitor#visitTargetVisibility}.
// Package groups always have the null configuration so that they are not duplicated
// needlessly.
.add(
attr("visibility", NODEP_LABEL_LIST)
.orderIndependent()
.cfg(ExecutionTransitionFactory.createFactory())
.nonconfigurable(
"special attribute integrated more deeply into Bazel's core logic"))
.add(
attr(TAGGED_TRIMMING_ATTR, NODEP_LABEL_LIST)
.orderIndependent()
.nonconfigurable("Used in determining configuration"))
.add(
attr("deprecation", STRING)
.value(deprecationDefault)
.nonconfigurable("Used in core loading phase logic with no access to configs"))
.add(
attr("tags", STRING_LIST)
.orderIndependent()
.taggable()
.nonconfigurable("low-level attribute, used in TargetUtils without configurations"))
.add(
attr("generator_name", STRING)
.undocumented("internal")
.nonconfigurable("static structure of a rule"))
.add(
attr("generator_function", STRING)
.undocumented("internal")
.nonconfigurable("static structure of a rule"))
.add(
attr("generator_location", STRING)
.undocumented("internal")
.nonconfigurable("static structure of a rule"))
.add(
attr("testonly", BOOLEAN)
.value(testonlyDefault)
.nonconfigurable("policy decision: rules testability should be consistent"))
.add(attr("features", STRING_LIST).orderIndependent())
.add(
attr(":action_listener", LABEL_LIST)
.cfg(ExecutionTransitionFactory.createFactory())
.value(ACTION_LISTENER))
.add(
attr(RuleClass.COMPATIBLE_ENVIRONMENT_ATTR, LABEL_LIST)
.allowedRuleClasses(ConstraintConstants.ENVIRONMENT_RULE)
.cfg(ExecutionTransitionFactory.createFactory())
.allowedFileTypes(FileTypeSet.NO_FILE)
.dontCheckConstraints()
.nonconfigurable(
"special logic for constraints and select: see ConstraintSemantics"))
.add(
attr(RuleClass.RESTRICTED_ENVIRONMENT_ATTR, LABEL_LIST)
.allowedRuleClasses(ConstraintConstants.ENVIRONMENT_RULE)
.cfg(ExecutionTransitionFactory.createFactory())
.allowedFileTypes(FileTypeSet.NO_FILE)
.dontCheckConstraints()
.nonconfigurable(
"special logic for constraints and select: see ConstraintSemantics"))
.add(
attr(RuleClass.CONFIG_SETTING_DEPS_ATTRIBUTE, LABEL_LIST)
.nonconfigurable("stores configurability keys"))
.add(
attr(RuleClass.APPLICABLE_METADATA_ATTR, LABEL_LIST)
.value(packageMetadataDefault)
.cfg(ExecutionTransitionFactory.createFactory())
.allowedFileTypes(FileTypeSet.NO_FILE)
.dontCheckConstraints()
.nonconfigurable("applicable_metadata is not configurable"))
.add(
attr("aspect_hints", LABEL_LIST)
.allowedFileTypes(FileTypeSet.NO_FILE)
.undocumented("experimental attribute"));
}
public static RuleClass.Builder execPropertiesAttribute(RuleClass.Builder builder)
throws ConversionException {
return builder.add(
attr(RuleClass.EXEC_PROPERTIES_ATTR, STRING_DICT).defaultValue(ImmutableMap.of()));
}
/**
* Ancestor of every native rule in BUILD files (not WORKSPACE files).
*
* <p>This includes:
*
* <ul>
* <li>rules that create actions ({@link NativeActionCreatingRule})
* <li>rules that encapsulate toolchain and build environment context
* <li>rules that aggregate other rules (like file groups, test suites, or aliases)
* </ul>
*/
public static final class NativeBuildRule implements RuleDefinition {
@Override
public RuleClass build(RuleClass.Builder builder, RuleDefinitionEnvironment env) {
return commonCoreAndStarlarkAttributes(builder)
.add(
attr("licenses", LICENSE)
.nonconfigurable("Used in core loading phase logic with no access to configs"))
.add(
attr("distribs", DISTRIBUTIONS)
.nonconfigurable("Used in core loading phase logic with no access to configs"))
// Any rule that provides its own meaning for the "target_compatible_with" attribute
// has to be excluded in `IncompatibleTargetChecker`.
.add(
attr(RuleClass.TARGET_COMPATIBLE_WITH_ATTR, LABEL_LIST)
.mandatoryProviders(ConstraintValueInfo.PROVIDER.id())
// This should be configurable to allow for complex types of restrictions.
.tool(
"target_compatible_with exists for constraint checking, not to create an"
+ " actual dependency")
.allowedFileTypes(FileTypeSet.NO_FILE))
.build();
}
@Override
public Metadata getMetadata() {
return RuleDefinition.Metadata.builder()
.name("$native_build_rule")
.type(RuleClassType.ABSTRACT)
.build();
}
}
/**
* A rule that contains a {@code variables=} attribute to allow referencing Make variables.
*/
public static final class MakeVariableExpandingRule implements RuleDefinition {
@Override
public RuleClass build(RuleClass.Builder builder, RuleDefinitionEnvironment env) {
return builder
// Documented in
// com/google/devtools/build/docgen/templates/attributes/common/toolchains.html.
.add(
attr("toolchains", LABEL_LIST)
.allowedFileTypes(FileTypeSet.NO_FILE)
.mandatoryProviders(ImmutableList.of(TemplateVariableInfo.PROVIDER.id()))
.dontCheckConstraints())
.build();
}
@Override
public Metadata getMetadata() {
return RuleDefinition.Metadata.builder()
.name("$make_variable_expanding_rule")
.type(RuleClassType.ABSTRACT)
.build();
}
}
/**
* Ancestor of every native BUILD rule that creates actions.
*
* <p>This is a subset of all BUILD rules. Filegroups and aliases, for example, simply encapsulate
* other rules. Toolchain rules provide metadata for actions of other rules. See {@link
* NativeBuildRule} for these.
*/
public static final class NativeActionCreatingRule implements RuleDefinition {
@Override
public RuleClass build(RuleClass.Builder builder, RuleDefinitionEnvironment env) {
return builder
.add(attr("deps", LABEL_LIST).legacyAllowAnyFileType())
.add(
attr("data", LABEL_LIST)
.allowedFileTypes(FileTypeSet.ANY_FILE)
.dontCheckConstraints())
.add(attr(RuleClass.EXEC_PROPERTIES_ATTR, Types.STRING_DICT).value(ImmutableMap.of()))
.add(
attr(RuleClass.EXEC_COMPATIBLE_WITH_ATTR, BuildType.LABEL_LIST)
.allowedFileTypes()
.nonconfigurable("Used in toolchain resolution")
.tool(
"exec_compatible_with exists for constraint checking, not to create an"
+ " actual dependency")
.value(ImmutableList.of()))
.build();
}
@Override
public Metadata getMetadata() {
return RuleDefinition.Metadata.builder()
.name("$native_buildable_rule")
.type(RuleClassType.ABSTRACT)
.ancestors(BaseRuleClasses.NativeBuildRule.class)
.build();
}
}
/** A base rule for all binary rules. */
public static final class BinaryBaseRule implements RuleDefinition {
@Override
public RuleClass build(RuleClass.Builder builder, RuleDefinitionEnvironment env) {
return builder
.add(attr("args", STRING_LIST))
.add(attr("env", STRING_DICT))
.add(attr("output_licenses", LICENSE))
.add(
attr("$is_executable", BOOLEAN)
.value(true)
.nonconfigurable("Called from RunCommand.isExecutable, which takes a Target"))
.build();
}
@Override
public Metadata getMetadata() {
return RuleDefinition.Metadata.builder()
.name("$binary_base_rule")
.type(RuleClassType.ABSTRACT)
.ancestors(MakeVariableExpandingRule.class)
.build();
}
}
/**
* An empty rule that exists for the sole purpose to completely remove a native rule while it's
* still defined as a Starlark rule in builtins.
*
* <p>Use it like <code>builder.addRuleDefinition(new BaseRuleClasses.EmptyRule("name") {});
* </code>. The <code>{}</code> create a new class for each rule. That's needed because {@link
* ConfiguredRuleClassProvider.Builder} assumes each rule class has a different Java class.
*/
public abstract static class EmptyRule implements RuleDefinition {
private final String name;
public EmptyRule(String name) {
this.name = name;
}
@Override
public RuleClass build(RuleClass.Builder builder, RuleDefinitionEnvironment env) {
return builder.removeAttribute("deps").removeAttribute("data").build();
}
@Override
public Metadata getMetadata() {
Metadata.Builder metadata =
Metadata.builder()
.name(name)
.type(TargetUtils.isTestRuleName(name) ? RuleClassType.TEST : RuleClassType.NORMAL)
.ancestors(BaseRuleClasses.NativeActionCreatingRule.class)
.factoryClass(EmptyRuleConfiguredTargetFactory.class);
if (TargetUtils.isTestRuleName(name)) {
metadata.ancestors(
BaseRuleClasses.TestBaseRule.class, BaseRuleClasses.NativeActionCreatingRule.class);
}
return metadata.build();
}
}
/**
* Factory used by rules' definitions that exist for the sole purpose of providing documentation.
* For most of these rules, the actual rule is implemented in Starlark but the documentation
* generation mechanism does not work yet for Starlark rules. TODO(bazel-team): Delete once
* documentation tools work for Starlark.
*/
public static class EmptyRuleConfiguredTargetFactory implements RuleConfiguredTargetFactory {
@Override
@Nullable
public ConfiguredTarget create(RuleContext ruleContext) {
ruleContext.ruleError("Rule is unimplemented.");
return null;
}
}
}