Arquivos .bzl

Atributos implícitos que começam com _ precisam ter valores padrão e o tipo label ou label_list.

Atributos explícitos precisam ter o tipo string e usar a restrição values. Os atributos explícitos restringem o aspecto a ser usado apenas com regras que tenham atributos com o mesmo nome, tipo e valores válidos de acordo com a restrição.

Uma lista não aninhada de provedores será automaticamente convertida em uma lista que contém uma lista de provedores. Ou seja, [FooInfo, BarInfo] será automaticamente convertido em [[FooInfo, BarInfo]].

Para tornar as segmentações de regras (por exemplo, some_rule) visíveis para um aspecto, o some_rule precisa anunciar todos os provedores de pelo menos uma das listas de provedores obrigatórias. Por exemplo, se a required_providers de um aspecto for [[FooInfo], [BarInfo], [BazInfo, QuxInfo]], esse aspecto só vai poder conferir as metas de some_rule se some_rule fornecer FooInfo, ou BarInfo, ou BazInfo e QuxInfo.

Uma lista não aninhada de provedores será automaticamente convertida em uma lista que contém uma lista de provedores. Ou seja, [FooInfo, BarInfo] será automaticamente convertido em [[FooInfo, BarInfo]].

Para que outro aspecto (por exemplo, other_aspect) fique visível para esse aspecto, o other_aspect precisa informar todos os provedores de pelo menos uma das listas. No exemplo de [[FooInfo], [BarInfo], [BazInfo, QuxInfo]], esse aspecto só vai poder ver other_aspect se other_aspect fornecer FooInfo, ou BarInfo, ou BazInfo e QuxInfo.

Se a função de implementação omitir qualquer um dos tipos de provedores listados aqui do valor de retorno, isso constituirá um erro. No entanto, a função de implementação pode retornar outros provedores não listados aqui.

Cada elemento da lista é um objeto *Info retornado por provider(), mas um provedor legado é representado pelo nome da string dele.Quando um destino da regra é usado como dependência para um destino que declara um provedor necessário, não é necessário especificar esse provedor aqui. Basta que a função de implementação o retorne. No entanto, é uma prática recomendada especificá-lo, mesmo que isso não seja necessário. No entanto, o campo required_providers de um aspecto exige que os provedores sejam especificados aqui.

Por exemplo, suponha que um aspecto se propaga de modo transitivo pelo atributo `deps` e ele seja aplicado ao destino `alpha`. Suponha que `alpha` tenha `deps = [':beta_output']`, em que `beta_output` é uma saída declarada de um destino `beta`. Suponha que `beta` tenha um de destino `charlie` como um dos `deps` e ele será aplicado a `alpha`. Se `apply_to_generate_rules=the,'.

Falso por padrão.

• lista de campos:
  

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

• nome do campo do dicionário -> documentação:
  

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

Confira a seguir uma descrição precisa. Consulte Regras (inicialização personalizada de provedores) para conferir uma discussão intuitiva e casos de uso.

Permita que P seja o símbolo do provedor criado chamando provider(). Conceitualmente, uma instância de P é gerada chamando uma função de construtor padrão c(*args, **kwargs), que faz o seguinte:

• Se args não estiver vazio, ocorrerá um erro.
• Se o parâmetro fields foi especificado quando provider() foi chamado e se kwargs contém alguma chave que não estava listada em fields, ocorre um erro.
• Caso contrário, c retorna uma nova instância que tem, para cada entrada k: v em kwargs, um campo chamado k com o valor v.

MyInfo = provider()
m = MyInfo(foo = 1)

Mas, no caso em que init for especificado, a chamada P(*args, **kwargs) realizará as seguintes etapas:

1. O callback é invocado como init(*args, **kwargs), ou seja, com os mesmos argumentos de posição e palavra-chave que foram transmitidos para P.
2. O valor de retorno de init precisa ser um dicionário, d, com chaves que são strings de nome de campo. Se não estiver, ocorrerá um erro.
3. Uma nova instância de P é gerada como se você chamasse o construtor padrão com as entradas de d como argumentos de palavra-chave, como em c(**d).

Observação: as etapas acima implicam que um erro ocorre se *args ou **kwargs não corresponder à assinatura de init, se a avaliação do corpo de init falhar (talvez intencionalmente por uma chamada para fail()) ou se o valor de retorno de init não for um dicionário com o esquema esperado.

Dessa forma, o callback init generaliza a construção normal do provedor, permitindo argumentos posicionais e lógica arbitrária para pré-processamento e validação. Não é possível contornar a lista de fields permitidos.

Quando init é especificado, o valor de retorno de provider() se torna uma tupla (P, r), em que r é o construtor bruto. Na verdade, o comportamento de r é exatamente o mesmo da função de construtor padrão c discutida acima. Normalmente, r está vinculado a uma variável cujo nome é prefixado com um sublinhado, de modo que somente o arquivo .bzl atual tenha acesso direto a ela:

MyInfo, _new_myinfo = provider(init = ...)

Um esquema para definir saídas pré-declaradas. Ao contrário dos atributos output e output_list, o usuário não especifica os marcadores desses arquivos. Consulte a página Regras para saber mais sobre as saídas pré-declaradas.

O valor desse argumento é um dicionário ou uma função de callback que produz um dicionário. O callback funciona de maneira semelhante aos atributos de dependência computados: os nomes de parâmetro da função são comparados aos atributos da regra. Por exemplo, se você transmitir outputs = _my_func com a definição def _my_func(srcs, deps): ..., a função terá acesso aos atributos srcs e deps. Quer o dicionário seja especificado diretamente ou por meio de uma função, ele é interpretado da seguinte maneira:

Cada entrada no dicionário cria uma saída pré-declarada em que a chave é um identificador e o valor é um modelo de string que determina o rótulo da saída. Na função de implementação da regra, o identificador se torna o nome do campo usado para acessar o File da saída no ctx.outputs. O rótulo da saída tem o mesmo pacote que a regra, e a parte após o pacote é produzida substituindo cada marcador de posição do formulário "%{ATTR}" por uma string formada a partir do valor do atributo ATTR:

• Os atributos do tipo string são substituídos na íntegra.
• Os atributos do tipo rótulo se tornam parte do rótulo após o pacote, menos a extensão do arquivo. Por exemplo, o rótulo "//pkg:a/b.c" se torna "a/b".
• Os atributos de saída se tornam parte do rótulo após o pacote, incluindo a extensão do arquivo (para o exemplo acima, "a/b.c").
• Todos os atributos de lista (por exemplo, attr.label_list) usados em marcadores de posição precisam ter exatamente um elemento. A conversão é a mesma que a versão que não é de lista (attr.label).
• Outros tipos de atributo podem não aparecer nos marcadores de posição.
• Os marcadores especiais sem atributos %{dirname} e %{basename} são expandidos para essas partes do rótulo da regra, excluindo o pacote. Por exemplo, em "//pkg:a/b.c", o nome do diretório é a, e o nome de base é b.c.

Na prática, o marcador de substituição de substituição mais comum é "%{name}". Por exemplo, para um destino chamado "foo", o dict de saída {"bin": "%{name}.exe"} declara previamente uma saída chamada foo.exe, que pode ser acessada na função de implementação como ctx.outputs.bin.

Se a função de implementação omitir qualquer um dos tipos de provedores listados aqui do valor de retorno, isso constituirá um erro. No entanto, a função de implementação pode retornar outros provedores não listados aqui.

Cada elemento da lista é um objeto *Info retornado por provider(), mas um provedor legado é representado pelo nome da string dele.Quando um destino da regra é usado como dependência para um destino que declara um provedor necessário, não é necessário especificar esse provedor aqui. Basta que a função de implementação o retorne. No entanto, é uma prática recomendada especificá-lo, mesmo que isso não seja necessário. No entanto, o campo required_providers de um aspecto exige que os provedores sejam especificados aqui.

Observação: as regras de teste de análise são definidas principalmente usando a infraestrutura fornecida nas principais bibliotecas do Starlark. Consulte Testes para conferir as orientações.

Se uma regra for definida como uma regra de teste de análise, ela poderá usar transições de configuração definidas com analysis_test_transition nos atributos, mas aceita algumas restrições:

• Os destinos desta regra são limitados quanto ao número de dependências transitivas que eles podem ter.
• A regra é considerada de teste, como se test=True tivesse sido definida. Ele substitui o valor de test
• A função de implementação da regra não pode registrar ações. Em vez disso, ele precisa registrar um resultado de aprovação/reprovação fornecendo AnalysisTestResultInfo.

A função é chamada no tempo de carregamento para cada instância da regra. Ela é chamada com valores de atributos públicos definidos pela regra (não com atributos genéricos, por exemplo, name ou tags).

Ela precisa retornar um dicionário dos nomes dos atributos para os valores desejados. Os atributos que não são retornados não são afetados. Retornar None como valor resulta no uso do valor padrão especificado na definição do atributo.

Os inicializadores são avaliados antes dos valores padrão especificados em uma definição de atributo. Consequentemente, se um parâmetro na assinatura do inicializador contiver um valor padrão, ele vai substituir o padrão da definição do atributo (exceto se retornar None).

Da mesma forma, se um parâmetro na assinatura do inicializador não tiver um padrão, ele se tornará obrigatório. É uma boa prática omitir as configurações padrão/obrigatórias na definição de um atributo nesses casos.

Recomendamos usar **kwargs para atributos que não são processados.

No caso de regras estendidas, todos os inicializadores são chamados, partindo do filho para ancestrais. Cada inicializador recebe apenas os atributos públicos que ele conhece.

As subregras só podem ter atributos particulares que são rotulados por marcador (ou seja, marcador ou lista de marcadores). Os valores resolvidos correspondentes a esses rótulos são transmitidos automaticamente pelo Bazel para a função de implementação da sub-regra como argumentos nomeados. Assim, a função de implementação é obrigatória para aceitar parâmetros nomeados correspondentes aos nomes dos atributos. Os tipos desses valores serão:

• FilesToRunProvider para atributos de rótulo com executable=True
• File para atributos de rótulo com allow_single_file=True
• Target para todos os outros atributos de rótulo
• [Target] para todos os atributos da lista de rótulos

As especificações do pacote seguem o mesmo formato de package_group, com a exceção de que especificações de pacote negativas não são permitidas. Ou seja, uma especificação pode ter os formatos:

• "//foo": o pacote //foo.
• "//foo/...": o pacote //foo e todos os subpacotes dele.
• "public" ou "private": todos ou nenhum pacote, respectivamente.

A sintaxe "@" não é permitida. Todas as especificações são interpretadas em relação ao repositório do módulo atual.

Se value for uma lista de strings, o conjunto de pacotes concedido para esse módulo será a união dos pacotes representados por cada especificação. Uma lista vazia tem o mesmo efeito que private. Se value for uma string única, ela vai ser tratada como se fosse a lista de singleton [value].

As sinalizações --incompatible_package_group_has_public_syntax e --incompatible_fix_package_group_reporoot_syntax não afetam esse argumento. Os valores "public" e "private" estão sempre disponíveis, e "//..." é sempre interpretado como "todos os pacotes no repositório atual".