Globals

A string or a collection of elements.

A string or a collection of elements.

function

the function implementing this aspect. Must have two parameters: Target (the target to which the aspect is applied) and ctx. Attributes of the target are available via ctx.rule field. The function is called 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 by attributes of a target with this name. The list can also contain a single string '*': in that case aspect propagates along all dependencies of a target.

dict

dictionary to declare all the attributes of the aspect. It maps from an attribute name to an attribute object (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. If explicit attributes are present, the aspect can only be used with rules that have attributes of the same name and type, with valid values.

sequence

Allow the aspect to inspect other aspects. If the aspect propagates along a dependency, and the underlying rule sends a different aspect along that dependency, and that aspect provides one of the providers listed here, this aspect will see the providers provided by that aspect.

The value should be either a list of providers, or a list of lists of providers. This aspect will 'see' the underlying aspects that provide ALL providers from at least ONE of these lists. A single list of providers will be automatically converted to a list containing one list of providers.

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

(Experimental)

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.

string

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

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.

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.

string

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

sequence

A list of direct elements of a depset.

sequence of depsets

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

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.

sequence

input list.

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 object to check length of.

The object to convert.

sequence

The elements to be checked.

sequence

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 implementing this rule, has to have exactly one parameter: repository_ctx. The function is called during 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.

The object to convert.

The sequence to be reversed (string, list or tuple).

function

the 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.

dict

Experimental: This API is in the process of being redesigned.

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

(Experimental)

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.

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.

bool

If true, a special attribute named exec_compatible_with of label-list type is added, which must not already exist in attrs. Targets may use this attribute to specify additional constraints on the execution platform beyond those given in the exec_compatible_with argument to rule().

sequence of strings

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

bool; or UnboundMarker

Experimental: This parameter is experimental and subject to change at any time.

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

BuildSetting

Experimental: This parameter is experimental and subject to change at any time.

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 automaticallyadded to this rule, with a type corresponding to the value passed in here.

dict

The parameter to convert.

string

Optional custom error to report if no condition matches.

This collection.

The object to convert.

The object to convert.

The object to check type of.

string

the name of the workspace.

lists to zip.