Globals

A string or a collection of elements.

dict

A dictionary containing information about configuration settings which should be set by this configuration transition. Keys are build setting labels and values are their new post-transition values. All other settings are unchanged. Use this to declare specific configuration settings that an analysis test requires to be set in order to pass.

A string or a collection of elements.

function

A Starlark function that implements this aspect, with exactly two parameters: Target (the target to which the aspect is applied) and ctx (the rule context which the targetis created from). Attributes of the target are available via the ctx.rule field. This function is evaluated during the analysis phase for each application of an aspect to a target.

sequence of strings

List of attribute names. The aspect propagates along dependencies specified in the attributes of a target with these names. Common values here include deps and exports. The list can also contain a single string "*" to propagate along all dependencies of a target.

dict

A dictionary declaring all the attributes of the aspect. It maps from an attribute name to an attribute object, like `attr.label` or `attr.string` (see attr module). Aspect attributes are available to implementation function as fields of ctx parameter.

Implicit attributes starting with _ must have default values, and have type label or label_list.

Explicit attributes must have type string, and must use the values restriction. Explicit attributes restrict the aspect to only be used with rules that have attributes of the same name, type, and valid values according to the restriction.

sequence

This attribute allows this aspect to inspect other aspects. The value must be a list of providers, or a list of lists of providers. For example, [FooInfo, BarInfo, [BazInfo, QuxInfo]] is a valid value.

A single list of providers will automatically be converted to a list containing one list of providers. That is, [FooInfo, BarInfo] will automatically be converted to [[FooInfo, BarInfo]].

To make another aspect (e.g. other_aspect) visible to this aspect, other_aspect must provide all providers from at least one of the lists. In the example of [FooInfo, BarInfo, [BazInfo, QuxInfo]], this aspect can only see other_aspect if and only if other_aspect provides FooInfo *or* BarInfo *or* both BazInfo *and* QuxInfo.

sequence

A list of providers that the implementation function must return.

It is an error if the implementation function omits any of the types of providers listed here from its return value. However, the implementation function may return additional providers not listed here.

Each element of the list is an *Info object returned by provider(), except that a legacy provider is represented by its string name instead.

sequence of strings

List of names of configuration fragments that the aspect requires in target configuration.

sequence of strings

List of names of configuration fragments that the aspect requires in host configuration.

sequence of strings

If set, the set of toolchains this rule requires. Toolchains will be found by checking the current platform, and provided to the rule implementation via ctx.toolchain.

bool

If set, this aspect will use the toolchain transition for toolchain dependencies. This is ignored if the --incompatible_use_toolchain_transition flag is set.

string

A description of the aspect that can be extracted by documentation generating tools.

bool

If true, the aspect will, when applied to an output file, instead apply to the output file's generating rule.

For example, suppose an aspect propagates transitively through attribute `deps` and it is applied to target `alpha`. Suppose `alpha` has `deps = [':beta_output']`, where `beta_output` is a declared output of a target `beta`. Suppose `beta` has a target `charlie` as one of its `deps`. If `apply_to_generating_rules=True` for the aspect, then the aspect will propagate through `alpha`, `beta`, and `charlie`. If False, then the aspect will propagate only to `alpha`.

False by default.

string

The label under '//external' to serve as the alias name

string

The real label to be aliased

The variable to convert.

string

The name of a configuration fragment which contains the late-bound value.

string

The name of the value to obtain from the configuration fragment.

A positional parameter distinct from other parameters for legacy support.

If --incompatible_disable_depset_items is false, this parameter serves as the value of items.

If --incompatible_disable_depset_items is true, this parameter serves as the value of direct.

See the documentation for these parameters for more details.

string

The traversal strategy for the new depset. See here for the possible values.

A list of direct elements of a depset.

sequence of depsets

A list of depsets whose elements will become indirect elements of the depset.

Deprecated. This parameter is deprecated and will be removed soon. Please do not depend on it. It is disabled with --incompatible_disable_depset_items. Use this flag to verify your code is compatible with its imminent removal.
Deprecated: Either an iterable whose items become the direct elements of the new depset, in left-to-right order, or else a depset that becomes a transitive element of the new depset. In the latter case, transitive cannot be specified.

Either a dictionary or a list of entries. Entries must be tuples or lists with exactly two elements: key, value.

Dictionary of additional entries.

The object to check.

input sequence.

int

start index.

sequence of strings

Experimental The set of toolchains this execution group requires.

sequence of strings

Experimental A list of constraints on the execution platform.

Error to display for the user. The object is converted to a string.

string

The name of the attribute that caused the error. This is used only for error reporting.

The struct whose attribute is accessed.

The name of the struct attribute.

The default value to return in case the struct doesn't have an attribute of the given name.

The object to check.

string

The name of the attribute.

string

String value to hash.

The string to convert.

The base used to interpret a string value; defaults to 10. Must be between 2 and 36 (inclusive), or 0 to detect the base as if x were an integer literal. This parameter must not be supplied if the value is not a string.

The value whose length to report.

The object to convert.

The elements to be checked.

The elements to be checked.

string

The separator string between the objects, default is space (" ").

The objects to print.

string

A description of the provider that can be extracted by documentation generating tools.

sequence of strings; or dict

If specified, restricts the set of allowed fields.
Possible values are:

• list of fields:
  

  provider(fields = ['a', 'b'])

• dictionary field name -> documentation:
  

  provider(
         fields = { 'a' : 'Documentation for a', 'b' : 'Documentation for b' })

int

Value of the start element if stop is provided, otherwise value of stop and the actual start is 0

int

optional index of the first item not to be included in the resulting list; generation of the list stops before stop is reached.

int

The increment (default is 1). It may be negative.

sequence of strings

The labels of the platforms to register.

sequence of strings

The labels of the toolchains to register.

function

the function that implements this rule. Must have a single parameter, repository_ctx. The function is called during the loading phase for each instance of the rule.

dict

dictionary to declare all the attributes of the rule. It maps from an attribute name to an attribute object (see attr module). Attributes starting with _ are private, and can be used to add an implicit dependency on a label to a file (a repository rule cannot depend on a generated artifact). The attribute name is implicitly added and must not be specified.

bool

Indicate that this rule fetches everything from the local system and should be reevaluated at every fetch.

sequence of strings

Provides a list of environment variable that this repository rule depends on. If an environment variable in that list change, the repository will be refetched.

bool

Indicate that the repository inspects the system for configuration purpose

bool

Experimental. This parameter is experimental and may change at any time. Please do not depend on it. It may be enabled on an experimental basis by setting --experimental_repo_remote_exec
Compatible with remote execution

string

A description of the repository rule that can be extracted by documentation generating tools.

The object to convert.

sequence

The sequence (list or tuple) to be reversed.

function

the Starlark function implementing this rule, must have exactly one parameter: ctx. The function is called during the analysis phase for each instance of the rule. It can access the attributes provided by the user. It must create actions to generate all the declared outputs.

bool

Whether this rule is a test rule, that is, whether it may be the subject of a bazel test command. All test rules are automatically considered executable; it is unnecessary (and discouraged) to explicitly set executable = True for a test rule. See the Rules page for more information.

dict

dictionary to declare all the attributes of the rule. It maps from an attribute name to an attribute object (see attr module). Attributes starting with _ are private, and can be used to add an implicit dependency on a label. The attribute name is implicitly added and must not be specified. Attributes visibility, deprecation, tags, testonly, and features are implicitly added and cannot be overridden. Most rules need only a handful of attributes. To limit memory usage, the rule function imposes a cap on the size of attrs.

dict; or None; or function

Deprecated. This parameter is deprecated and will be removed soon. Please do not depend on it. It is disabled with --incompatible_no_rule_outputs_param. Use this flag to verify your code is compatible with its imminent removal.
This parameter has been deprecated. Migrate rules to use OutputGroupInfo or attr.output instead.

A schema for defining predeclared outputs. Unlike output and output_list attributes, the user does not specify the labels for these files. See the Rules page for more on predeclared outputs.

The value of this argument is either a dictionary or a callback function that produces a dictionary. The callback works similar to computed dependency attributes: The function's parameter names are matched against the rule's attributes, so for example if you pass outputs = _my_func with the definition def _my_func(srcs, deps): ..., the function has access to the attributes srcs and deps. Whether the dictionary is specified directly or via a function, it is interpreted as follows.

Each entry in the dictionary creates a predeclared output where the key is an identifier and the value is a string template that determines the output's label. In the rule's implementation function, the identifier becomes the field name used to access the output's File in ctx.outputs. The output's label has the same package as the rule, and the part after the package is produced by substituting each placeholder of the form "%{ATTR}" with a string formed from the value of the attribute ATTR:

• String-typed attributes are substituted verbatim.
• Label-typed attributes become the part of the label after the package, minus the file extension. For example, the label "//pkg:a/b.c" becomes "a/b".
• Output-typed attributes become the part of the label after the package, including the file extension (for the above example, "a/b.c").
• All list-typed attributes (for example, attr.label_list) used in placeholders are required to have exactly one element. Their conversion is the same as their non-list version (attr.label).
• Other attribute types may not appear in placeholders.
• The special non-attribute placeholders %{dirname} and %{basename} expand to those parts of the rule's label, excluding its package. For example, in "//pkg:a/b.c", the dirname is a and the basename is b.c.

In practice, the most common substitution placeholder is "%{name}". For example, for a target named "foo", the outputs dict {"bin": "%{name}.exe"} predeclares an output named foo.exe that is accessible in the implementation function as ctx.outputs.bin.

bool

Whether this rule is considered executable, that is, whether it may be the subject of a bazel run command. See the Rules page for more information.

bool

If true, the files will be generated in the genfiles directory instead of the bin directory. Unless you need it for compatibility with existing rules (e.g. when generating header files for C++), do not set this flag.

sequence of strings

List of names of configuration fragments that the rule requires in target configuration.

sequence of strings

List of names of configuration fragments that the rule requires in host configuration.

bool

(Experimental)

If true, this rule will expose its actions for inspection by rules that depend on it via an Actions provider. The provider is also available to the rule itself by calling ctx.created_actions().

This should only be used for testing the analysis-time behavior of Starlark rules. This flag may be removed in the future.

sequence of strings

If set, the set of toolchains this rule requires. Toolchains will be found by checking the current platform, and provided to the rule implementation via ctx.toolchain.

bool

If set, this rule will use the toolchain transition for toolchain dependencies. This is ignored if the --incompatible_use_toolchain_transition flag is set.

string

A description of the rule that can be extracted by documentation generating tools.

sequence

A list of providers that the implementation function must return.

It is an error if the implementation function omits any of the types of providers listed here from its return value. However, the implementation function may return additional providers not listed here.

Each element of the list is an *Info object returned by provider(), except that a legacy provider is represented by its string name instead.

sequence of strings

A list of constraints on the execution platform that apply to all targets of this rule type.

bool

If true, then this rule is treated as an analysis test.

Note: Analysis test rules are primarily defined using infrastructure provided in core Starlark libraries. See Testing for guidance.

If a rule is defined as an analysis test rule, it becomes allowed to use configuration transitions defined using analysis_test_transition on its attributes, but opts into some restrictions:

• Targets of this rule are limited in the number of transitive dependencies they may have.
• The rule is considered a test rule (as if test=True were set). This supercedes the value of test
• The rule implementation function may not register actions. Instead, it must register a pass/fail result via providing AnalysisTestResultInfo.

BuildSetting

If set, describes what kind of build setting this rule is. See the config module. If this is set, a mandatory attribute named "build_setting_default" is automatically added to this rule, with a type corresponding to the value passed in here.

If set, points to the configuration transition the rule will apply to its own configuration before analysis.

dict

Experimental. This parameter is experimental and may change at any time. Please do not depend on it. It may be enabled on an experimental basis by setting --experimental_exec_groups
Dictionary to declare execution groups. DO NOT USE - not function yet.

dict

A dict that maps configuration conditions to values. Each key is a label string that identifies a config_setting instance.

string

Optional custom error to report if no condition matches.

The iterable sequence to sort.

An optional function applied to each element before comparison.

bool

Return results in descending order.

The object to convert.

The object to convert.

The object to check type of.

string

the name of the workspace. Names must start with a letter and can only contain letters, numbers, and underscores.

dict of strings

Dict (strings to list of strings) for defining the mappings between external repositories and relative (to the workspace root) paths to directories they incrementally update. Managed directories must be excluded from the source tree by listing them (or their parent directories) in the .bazelignore file.

lists to zip.