// Copyright 2015 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.starlark; import static com.google.common.collect.ImmutableList.toImmutableList; import static com.google.common.truth.Truth.assertThat; import static com.google.common.truth.Truth.assertWithMessage; import static com.google.common.truth.Truth8.assertThat; import static com.google.devtools.build.lib.analysis.OutputGroupInfo.INTERNAL_SUFFIX; import static java.util.stream.Collectors.toList; import static org.junit.Assert.assertThrows; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableMap; import com.google.common.collect.Iterables; import com.google.devtools.build.lib.actions.Action; import com.google.devtools.build.lib.actions.ActionOwner; import com.google.devtools.build.lib.actions.Artifact; import com.google.devtools.build.lib.analysis.AnalysisResult; import com.google.devtools.build.lib.analysis.AspectValue; import com.google.devtools.build.lib.analysis.ConfiguredAspect; import com.google.devtools.build.lib.analysis.ConfiguredRuleClassProvider; import com.google.devtools.build.lib.analysis.ConfiguredTarget; import com.google.devtools.build.lib.analysis.OutputGroupInfo; import com.google.devtools.build.lib.analysis.ViewCreationFailedException; import com.google.devtools.build.lib.analysis.util.AnalysisTestCase; import com.google.devtools.build.lib.analysis.util.TestAspects; import com.google.devtools.build.lib.cmdline.Label; import com.google.devtools.build.lib.cmdline.TargetParsingException; import com.google.devtools.build.lib.collect.nestedset.Depset; import com.google.devtools.build.lib.collect.nestedset.NestedSet; import com.google.devtools.build.lib.packages.AspectClass; import com.google.devtools.build.lib.packages.AspectDefinition; import com.google.devtools.build.lib.packages.StarlarkAspectClass; import com.google.devtools.build.lib.packages.StarlarkProvider; import com.google.devtools.build.lib.packages.StructImpl; import com.google.devtools.build.lib.rules.cpp.CppConfiguration; import com.google.devtools.build.lib.rules.java.JavaConfiguration; import com.google.devtools.build.lib.server.FailureDetails.Analysis; import com.google.devtools.build.lib.server.FailureDetails.Analysis.Code; import com.google.devtools.build.lib.server.FailureDetails.FailureDetail; import com.google.devtools.build.lib.skyframe.AspectKeyCreator.AspectKey; import com.google.devtools.build.lib.testutil.TestRuleClassProvider; import com.google.devtools.build.lib.vfs.FileSystemUtils; import com.google.devtools.build.lib.vfs.Path; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.Map; import net.starlark.java.eval.Sequence; import net.starlark.java.eval.Starlark; import net.starlark.java.eval.StarlarkInt; import net.starlark.java.eval.StarlarkList; import org.junit.Ignore; import org.junit.Test; import org.junit.runner.RunWith; import org.junit.runners.JUnit4; /** Tests for Starlark aspects */ @RunWith(JUnit4.class) public class StarlarkDefinedAspectsTest extends AnalysisTestCase { protected boolean keepGoing() { return false; } @Test public void simpleAspect() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " print('This aspect does nothing')", " return struct()", "MyAspect = aspect(implementation=_impl)"); scratch.file("test/BUILD", "java_library(name = 'xxx',)"); AnalysisResult analysisResult = update(ImmutableList.of("test/aspect.bzl%MyAspect"), "//test:xxx"); assertThat(getLabelsToBuild(analysisResult)).containsExactly("//test:xxx"); assertThat(getAspectDescriptions(analysisResult)) .containsExactly("//test:aspect.bzl%MyAspect(//test:xxx)"); } @Test public void aspectWithSingleDeclaredProvider() throws Exception { scratch.file( "test/aspect.bzl", "foo = provider()", "def _impl(target, ctx):", " return foo()", "MyAspect = aspect(implementation=_impl)"); scratch.file("test/BUILD", "java_library(name = 'xxx',)"); AnalysisResult analysisResult = update(ImmutableList.of("test/aspect.bzl%MyAspect"), "//test:xxx"); assertThat(getLabelsToBuild(analysisResult)).containsExactly("//test:xxx"); assertThat(getAspectDescriptions(analysisResult)) .containsExactly("//test:aspect.bzl%MyAspect(//test:xxx)"); ConfiguredAspect configuredAspect = Iterables.getOnlyElement(analysisResult.getAspectsMap().values()); StarlarkProvider.Key fooKey = new StarlarkProvider.Key(Label.parseCanonical("//test:aspect.bzl"), "foo"); assertThat(configuredAspect.get(fooKey).getProvider().getKey()).isEqualTo(fooKey); } @Test public void aspectWithDeclaredProviders() throws Exception { scratch.file( "test/aspect.bzl", "foo = provider()", "bar = provider()", "def _impl(target, ctx):", " return [foo(), bar()]", "MyAspect = aspect(implementation=_impl)"); scratch.file("test/BUILD", "java_library(name = 'xxx',)"); AnalysisResult analysisResult = update(ImmutableList.of("test/aspect.bzl%MyAspect"), "//test:xxx"); assertThat(getLabelsToBuild(analysisResult)).containsExactly("//test:xxx"); assertThat(getAspectDescriptions(analysisResult)) .containsExactly("//test:aspect.bzl%MyAspect(//test:xxx)"); ConfiguredAspect configuredAspect = Iterables.getOnlyElement(analysisResult.getAspectsMap().values()); StarlarkProvider.Key fooKey = new StarlarkProvider.Key(Label.parseCanonical("//test:aspect.bzl"), "foo"); StarlarkProvider.Key barKey = new StarlarkProvider.Key(Label.parseCanonical("//test:aspect.bzl"), "bar"); assertThat(configuredAspect.get(fooKey).getProvider().getKey()).isEqualTo(fooKey); assertThat(configuredAspect.get(barKey).getProvider().getKey()).isEqualTo(barKey); } @Test public void aspectWithDeclaredProvidersInAStruct() throws Exception { scratch.file( "test/aspect.bzl", "foo = provider()", "bar = provider()", "def _impl(target, ctx):", " return struct(foobar='foobar', providers=[foo(), bar()])", "MyAspect = aspect(implementation=_impl)"); scratch.file("test/BUILD", "java_library(name = 'xxx',)"); AnalysisResult analysisResult = update(ImmutableList.of("test/aspect.bzl%MyAspect"), "//test:xxx"); assertThat(getLabelsToBuild(analysisResult)).containsExactly("//test:xxx"); assertThat(getAspectDescriptions(analysisResult)) .containsExactly("//test:aspect.bzl%MyAspect(//test:xxx)"); ConfiguredAspect configuredAspect = Iterables.getOnlyElement(analysisResult.getAspectsMap().values()); StarlarkProvider.Key fooKey = new StarlarkProvider.Key(Label.parseCanonical("//test:aspect.bzl"), "foo"); StarlarkProvider.Key barKey = new StarlarkProvider.Key(Label.parseCanonical("//test:aspect.bzl"), "bar"); assertThat(configuredAspect.get(fooKey).getProvider().getKey()).isEqualTo(fooKey); assertThat(configuredAspect.get(barKey).getProvider().getKey()).isEqualTo(barKey); } private static Iterable getAspectDescriptions(AnalysisResult analysisResult) { return Iterables.transform( analysisResult.getAspectsMap().keySet(), aspectKey -> String.format("%s(%s)", aspectKey.getAspectClass().getName(), aspectKey.getLabel())); } @Test public void aspectCommandLineLabel() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " print('This aspect does nothing')", " return struct()", "MyAspect = aspect(implementation=_impl)"); scratch.file("test/BUILD", "java_library(name = 'xxx',)"); AnalysisResult analysisResult = update(ImmutableList.of("//test:aspect.bzl%MyAspect"), "//test:xxx"); assertThat(getLabelsToBuild(analysisResult)).containsExactly("//test:xxx"); assertThat(getAspectDescriptions(analysisResult)) .containsExactly("//test:aspect.bzl%MyAspect(//test:xxx)"); } @Test public void aspectCommandLineRepoLabel() throws Exception { scratch.overwriteFile( "WORKSPACE", scratch.readFile("WORKSPACE"), "local_repository(name='local', path='local/repo')"); scratch.file("local/repo/WORKSPACE"); scratch.file( "local/repo/aspect.bzl", "def _impl(target, ctx):", " print('This aspect does nothing')", " return struct()", "MyAspect = aspect(implementation=_impl)"); scratch.file("local/repo/BUILD"); scratch.file("test/BUILD", "java_library(name = 'xxx',)"); AnalysisResult analysisResult = update(ImmutableList.of("@local//:aspect.bzl%MyAspect"), "//test:xxx"); assertThat(getLabelsToBuild(analysisResult)).containsExactly("//test:xxx"); assertThat(getAspectDescriptions(analysisResult)) .containsExactly("@local//:aspect.bzl%MyAspect(//test:xxx)"); } private static Iterable getLabelsToBuild(AnalysisResult analysisResult) { return Iterables.transform( analysisResult.getTargetsToBuild(), configuredTarget -> configuredTarget.getLabel().toString()); } @Test public void aspectAllowsFragmentsToBeSpecified() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " print('This aspect does nothing')", " return struct()", "MyAspect = aspect(implementation=_impl, fragments=['java'])"); scratch.file("test/BUILD", "java_library(name = 'xxx',)"); AnalysisResult analysisResult = update(ImmutableList.of("test/aspect.bzl%MyAspect"), "//test:xxx"); AspectKey key = Iterables.getOnlyElement(analysisResult.getAspectsMap().keySet()); AspectValue aspectValue = (AspectValue) skyframeExecutor.getEvaluator().getExistingValue(key); AspectDefinition aspectDefinition = aspectValue.getAspect().getDefinition(); assertThat( aspectDefinition .getConfigurationFragmentPolicy() .isLegalConfigurationFragment(JavaConfiguration.class)) .isTrue(); assertThat( aspectDefinition .getConfigurationFragmentPolicy() .isLegalConfigurationFragment(CppConfiguration.class)) .isFalse(); } @Test public void aspectPropagating() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " s = depset([target.label], transitive = [i.target_labels for i in ctx.rule.attr.deps])", " c = depset([ctx.rule.kind], transitive = [i.rule_kinds for i in ctx.rule.attr.deps])", " return struct(target_labels = s, rule_kinds = c)", "", "MyAspect = aspect(", " implementation=_impl,", " attr_aspects=['deps'],", ")"); scratch.file( "test/BUILD", "java_library(", " name = 'yyy',", ")", "java_library(", " name = 'xxx',", " srcs = ['A.java'],", " deps = [':yyy'],", ")"); AnalysisResult analysisResult = update(ImmutableList.of("test/aspect.bzl%MyAspect"), "//test:xxx"); assertThat(getLabelsToBuild(analysisResult)).containsExactly("//test:xxx"); ConfiguredAspect configuredAspect = analysisResult.getAspectsMap().values().iterator().next(); assertThat(configuredAspect).isNotNull(); Object names = configuredAspect.get("target_labels"); assertThat(names).isInstanceOf(Depset.class); assertThat( Iterables.transform( ((Depset) names).toList(), o -> { assertThat(o).isInstanceOf(Label.class); return o.toString(); })) .containsExactly("//test:xxx", "//test:yyy"); Object ruleKinds = configuredAspect.get("rule_kinds"); assertThat(ruleKinds).isInstanceOf(Depset.class); assertThat(((Depset) ruleKinds).toList()).containsExactly("java_library"); } @Test public void aspectsPropagatingForDefaultAndImplicit() throws Exception { useConfiguration("--experimental_builtins_injection_override=+cc_library"); scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " s = []", " c = []", " a = ctx.rule.attr", " if getattr(a, '_defaultattr', None):", " s += [a._defaultattr.target_labels]", " c += [a._defaultattr.rule_kinds]", " if getattr(a, '_cc_toolchain', None):", " s += [a._cc_toolchain.target_labels]", " c += [a._cc_toolchain.rule_kinds]", " return struct(", " target_labels = depset([target.label], transitive = s),", " rule_kinds = depset([ctx.rule.kind], transitive = c))", "", "def _rule_impl(ctx):", " pass", "", "my_rule = rule(implementation = _rule_impl,", " attrs = { '_defaultattr' : attr.label(default = Label('//test:xxx')) },", ")", "MyAspect = aspect(", " implementation=_impl,", " attr_aspects=['_defaultattr', '_cc_toolchain'],", ")"); scratch.file( "test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "cc_library(", " name = 'xxx',", ")", "my_rule(", " name = 'yyy',", ")"); AnalysisResult analysisResult = update(ImmutableList.of("test/aspect.bzl%MyAspect"), "//test:yyy"); ConfiguredAspect configuredAspect = analysisResult.getAspectsMap().values().iterator().next(); assertThat(configuredAspect).isNotNull(); Object nameSet = configuredAspect.get("target_labels"); ImmutableList names = ImmutableList.copyOf( Iterables.transform( ((Depset) nameSet).toList(), o -> { assertThat(o).isInstanceOf(Label.class); return ((Label) o).getName(); })); assertThat(names).containsAtLeast("xxx", "yyy"); // 3-4 is the C++ toolchain and alias; its name changes between Blaze and Bazel. assertThat(names).hasSize(4); } @Test public void aspectsDirOnMergedTargets() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " return struct(aspect_provider = 'data')", "", "p = provider()", "MyAspect = aspect(implementation=_impl)", "def _rule_impl(ctx):", " if ctx.attr.dep:", " return [p(dir = dir(ctx.attr.dep))]", " return [p()]", "", "my_rule = rule(implementation = _rule_impl,", " attrs = { 'dep' : attr.label(aspects = [MyAspect]) },", ")"); StarlarkProvider.Key providerKey = new StarlarkProvider.Key(Label.parseCanonicalUnchecked("//test:aspect.bzl"), "p"); scratch.file( "test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "my_rule(name = 'xxx',)", "my_rule(name = 'yyy', dep = ':xxx')"); AnalysisResult analysisResult = update("//test:yyy"); ConfiguredTarget target = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); StructImpl names = (StructImpl) target.get(providerKey); assertThat((Iterable) names.getValue("dir")) .containsExactly( "actions", "aspect_provider", "data_runfiles", "default_runfiles", "files", "files_to_run", "label", "output_groups"); } @Test public void aspectWithOutputGroupsDeclaredProvider() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " f = target[OutputGroupInfo]._hidden_top_level" + INTERNAL_SUFFIX, " return [OutputGroupInfo(my_result = f)]", "", "MyAspect = aspect(", " implementation=_impl,", ")"); scratch.file( "test/BUILD", "java_library(", " name = 'xxx',", " srcs = ['A.java'],", ")"); AnalysisResult analysisResult = update(ImmutableList.of("test/aspect.bzl%MyAspect"), "//test:xxx"); assertThat(getLabelsToBuild(analysisResult)).containsExactly("//test:xxx"); ConfiguredAspect configuredAspect = analysisResult.getAspectsMap().values().iterator().next(); OutputGroupInfo outputGroupInfo = OutputGroupInfo.get(configuredAspect); assertThat(outputGroupInfo).isNotNull(); NestedSet names = outputGroupInfo.getOutputGroup("my_result"); assertThat(names.toList()).isNotEmpty(); // Configuration of the true Artifact may diverge slightly (e.g. be trimmed) causing owners to // also diverge so just compare paths instead of the whole Artifact. ImmutableList paths = names.toList().stream().map(Artifact::getPath).collect(toImmutableList()); ImmutableList expectedPaths = OutputGroupInfo.get(getConfiguredTarget("//test:xxx")) .getOutputGroup(OutputGroupInfo.HIDDEN_TOP_LEVEL) .toList() .stream() .map(Artifact::getPath) .collect(toImmutableList()); assertThat(paths).containsExactlyElementsIn(expectedPaths); } @Test public void aspectWithOutputGroupsAsListDeclaredProvider() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " g = target[OutputGroupInfo]._hidden_top_level" + INTERNAL_SUFFIX, " return [OutputGroupInfo(my_result=g.to_list())]", "", "MyAspect = aspect(", " implementation=_impl,", ")"); scratch.file( "test/BUILD", "java_library(", " name = 'xxx',", " srcs = ['A.java'],", ")"); AnalysisResult analysisResult = update(ImmutableList.of("test/aspect.bzl%MyAspect"), "//test:xxx"); assertThat( Iterables.transform( analysisResult.getTargetsToBuild(), configuredTarget -> configuredTarget.getLabel().toString())) .containsExactly("//test:xxx"); ConfiguredAspect configuredAspect = analysisResult.getAspectsMap().values().iterator().next(); OutputGroupInfo outputGroupInfo = OutputGroupInfo.get(configuredAspect); assertThat(outputGroupInfo).isNotNull(); NestedSet names = outputGroupInfo.getOutputGroup("my_result"); assertThat(names.toList()).isNotEmpty(); // Configuration of the true Artifact may diverge slightly (e.g. be trimmed) causing owners to // also diverge so just compare paths instead of the whole Artifact. ImmutableList paths = names.toList().stream().map(Artifact::getPath).collect(toImmutableList()); ImmutableList expectedPaths = OutputGroupInfo.get(getConfiguredTarget("//test:xxx")) .getOutputGroup(OutputGroupInfo.HIDDEN_TOP_LEVEL) .toList() .stream() .map(Artifact::getPath) .collect(toImmutableList()); assertThat(paths).containsExactlyElementsIn(expectedPaths); } @Test public void aspectsFromStarlarkRules() throws Exception { scratch.file( "test/aspect.bzl", "def _aspect_impl(target, ctx):", " s = depset([target.label], transitive = [i.target_labels for i in ctx.rule.attr.deps])", " return struct(target_labels = s)", "", "def _rule_impl(ctx):", " s = depset(transitive = [i.target_labels for i in ctx.attr.attr])", " return struct(rule_deps = s)", "", "MyAspect = aspect(", " implementation=_aspect_impl,", " attr_aspects=['deps'],", ")", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'attr' : ", " attr.label_list(mandatory=True, allow_files=True, aspects = [MyAspect]) },", ")"); scratch.file( "test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "java_library(", " name = 'yyy',", ")", "my_rule(", " name = 'xxx',", " attr = [':yyy'],", ")"); AnalysisResult analysisResult = update("//test:xxx"); assertThat(getLabelsToBuild(analysisResult)).containsExactly("//test:xxx"); ConfiguredTarget target = analysisResult.getTargetsToBuild().iterator().next(); Object names = target.get("rule_deps"); assertThat(names).isInstanceOf(Depset.class); assertThat( Iterables.transform( ((Depset) names).toList(), o -> { assertThat(o).isInstanceOf(Label.class); return o.toString(); })) .containsExactly("//test:yyy"); } @Test public void aspectsNonExported() throws Exception { scratch.file( "test/aspect.bzl", "def _aspect_impl(target, ctx):", " return []", "", "def _rule_impl(ctx):", " pass", "", "def mk_aspect():", " return aspect(implementation=_aspect_impl)", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'attr' : attr.label_list(aspects = [mk_aspect()]) },", // line 11 ")"); scratch.file( "test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "java_library(", " name = 'yyy',", ")", "my_rule(", " name = 'xxx',", " attr = [':yyy'],", ")"); reporter.removeHandler(failFastHandler); try { AnalysisResult analysisResult = update("//test:xxx"); assertThat(keepGoing()).isTrue(); assertThat(analysisResult.hasError()).isTrue(); } catch (ViewCreationFailedException | TargetParsingException e) { // expected } // attr.label_list() fails, stack=[@rules.bzl:11:38, label_list:] assertContainsEvent("File \"/workspace/test/aspect.bzl\", line 11, column 38, in "); assertContainsEvent( "Error in label_list: Aspects should be top-level values in extension files that define" + " them."); } @Test @SuppressWarnings("EmptyCatchBlock") public void aspectReturnsNonExportedProvider() throws Exception { scratch.file( "test/inc.bzl", "a = aspect(implementation = lambda target, ctx: [provider()()])", "r = rule(", " implementation = lambda ctx: [],", " attrs = {'a': attr.label_list(aspects = [a])})"); scratch.file( "test/BUILD", "load('//test:inc.bzl', 'r')", "java_library(name = 'j')", "r(name = 'test', a = [':j'])"); reporter.removeHandler(failFastHandler); try { update("//test"); /* reached if --keep_going=true */ } catch (ViewCreationFailedException unused) { /* reached if --keep_going=false */ } assertContainsEvent( "aspect function returned an instance of a provider " + "(defined at /workspace/test/inc.bzl:1:58) that is not a global"); } @Test public void providerNonExported() throws Exception { scratch.file( "test/rule.bzl", "def mk_provider():", " return provider()", "def _rule_impl(ctx):", " pass", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'attr' : attr.label_list(providers = [mk_provider()]) },", // line 7 ")"); scratch.file( "test/BUILD", "load('//test:rule.bzl', 'my_rule')", "java_library(", " name = 'yyy',", ")", "my_rule(", " name = 'xxx',", " attr = [':yyy'],", ")"); reporter.removeHandler(failFastHandler); try { AnalysisResult analysisResult = update("//test:xxx"); assertThat(keepGoing()).isTrue(); assertThat(analysisResult.hasError()).isTrue(); } catch (ViewCreationFailedException | TargetParsingException e) { // expected } // attr.label_list() fails, stack=[@rules.bzl:7:38, label_list:] assertContainsEvent("File \"/workspace/test/rule.bzl\", line 7, column 38, in "); assertContainsEvent( "Error in label_list: Providers should be top-level values in extension files that define" + " them."); } @Test public void aspectOnLabelAttr() throws Exception { scratch.file( "test/aspect.bzl", "def _aspect_impl(target, ctx):", " return struct(aspect_data='foo')", "", "def _rule_impl(ctx):", " return struct(data=ctx.attr.attr.aspect_data)", "", "MyAspect = aspect(", " implementation=_aspect_impl,", ")", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'attr' : ", " attr.label(aspects = [MyAspect]) },", ")"); scratch.file( "test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "java_library(", " name = 'yyy',", ")", "my_rule(", " name = 'xxx',", " attr = ':yyy',", ")"); AnalysisResult analysisResult = update("//test:xxx"); ConfiguredTarget target = analysisResult.getTargetsToBuild().iterator().next(); Object value = target.get("data"); assertThat(value).isEqualTo("foo"); } @Test public void labelKeyedStringDictAllowsAspects() throws Exception { scratch.file( "test/aspect.bzl", "def _aspect_impl(target, ctx):", " return struct(aspect_data=target.label.name)", "", "def _rule_impl(ctx):", " return struct(", " data=','.join(['{}:{}'.format(dep.aspect_data, val)", " for dep, val in ctx.attr.attr.items()]))", "", "MyAspect = aspect(", " implementation=_aspect_impl,", ")", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'attr' : ", " attr.label_keyed_string_dict(aspects = [MyAspect]) },", ")"); scratch.file( "test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "java_library(", " name = 'yyy',", ")", "my_rule(", " name = 'xxx',", " attr = {':yyy': 'zzz'},", ")"); AnalysisResult analysisResult = update("//test:xxx"); ConfiguredTarget target = analysisResult.getTargetsToBuild().iterator().next(); Object value = target.get("data"); assertThat(value).isEqualTo("yyy:zzz"); } @Test public void aspectsDoNotAttachToFiles() throws Exception { FileSystemUtils.appendIsoLatin1( scratch.resolve("WORKSPACE"), "bind(name = 'yyy', actual = '//test:zzz.jar')"); scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " return struct()", "", "MyAspect = aspect(", " implementation=_impl,", " attr_aspects=['deps'],", ")"); scratch.file("test/zzz.jar"); scratch.file( "test/BUILD", "exports_files(['zzz.jar'])", "java_library(", " name = 'xxx',", " srcs = ['A.java'],", " deps = ['//external:yyy'],", ")"); AnalysisResult result = update(ImmutableList.of("test/aspect.bzl%MyAspect"), "//test:xxx"); assertThat(result.hasError()).isFalse(); } @Test public void aspectsDoNotAttachToTopLevelFiles() throws Exception { FileSystemUtils.appendIsoLatin1( scratch.resolve("WORKSPACE"), "bind(name = 'yyy', actual = '//test:zzz.jar')"); scratch.file( "test/aspect.bzl", "p = provider()", "def _impl(target, ctx):", " return [p()]", "", "MyAspect = aspect(", " implementation=_impl,", " attr_aspects=['deps'],", ")"); scratch.file("test/zzz.jar"); scratch.file( "test/BUILD", "exports_files(['zzz.jar'])", "java_library(", " name = 'xxx',", " srcs = ['A.java'],", " deps = ['//external:yyy'],", ")"); AnalysisResult result = update(ImmutableList.of("test/aspect.bzl%MyAspect"), "//test:zzz.jar"); assertThat(result.hasError()).isFalse(); assertThat( Iterables.getOnlyElement(result.getAspectsMap().values()) .getProviders() .getProviderCount()) .isEqualTo(0); } @Test public void aspectFailingExecution() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " return 1 // 0", "", "MyAspect = aspect(implementation=_impl)"); scratch.file("test/BUILD", "java_library(name = 'xxx',)"); reporter.removeHandler(failFastHandler); try { AnalysisResult result = update(ImmutableList.of("test/aspect.bzl%MyAspect"), "//test:xxx"); assertThat(keepGoing()).isTrue(); assertThat(result.hasError()).isTrue(); } catch (ViewCreationFailedException e) { // expect to fail. } // Stack doesn't include source lines because we haven't told EvalException // how to read from scratch. assertContainsEvent( "ERROR /workspace/test/BUILD:1:13: in " + "//test:aspect.bzl%MyAspect aspect on java_library rule //test:xxx: \n" + "Traceback (most recent call last):\n" + "\tFile \"/workspace/test/aspect.bzl\", line 2, column 13, in _impl\n" + "Error: integer division by zero"); } @Test public void aspectFailingReturnsNotAStruct() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " return 0", "", "MyAspect = aspect(implementation=_impl)"); scratch.file("test/BUILD", "java_library(name = 'xxx',)"); reporter.removeHandler(failFastHandler); try { AnalysisResult result = update(ImmutableList.of("test/aspect.bzl%MyAspect"), "//test:xxx"); assertThat(keepGoing()).isTrue(); assertThat(result.hasError()).isTrue(); } catch (ViewCreationFailedException e) { // expect to fail. } assertContainsEvent( "Aspect implementation should return a struct, a list, or a provider " + "instance, but got int"); } @Test public void aspectFailingOrphanArtifacts() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " ctx.actions.declare_file('missing_in_action.txt')", " return struct()", "", "MyAspect = aspect(implementation=_impl)"); scratch.file("test/BUILD", "java_library(name = 'xxx',)"); reporter.removeHandler(failFastHandler); try { AnalysisResult result = update(ImmutableList.of("test/aspect.bzl%MyAspect"), "//test:xxx"); assertThat(keepGoing()).isTrue(); assertThat(result.hasError()).isTrue(); } catch (ViewCreationFailedException e) { // expect to fail. } assertContainsEvent( "ERROR /workspace/test/BUILD:1:13: in " + "//test:aspect.bzl%MyAspect aspect on java_library rule //test:xxx: \n" + "The following files have no generating action:\n" + "test/missing_in_action.txt"); } @Test public void aspectSkippingOrphanArtifactsWithLocation() throws Exception { scratch.file( "simple/print.bzl", "def _print_expanded_location_impl(target, ctx):", " return struct(result=ctx.expand_location(ctx.rule.attr.cmd, []))", "", "print_expanded_location = aspect(", " implementation = _print_expanded_location_impl,", ")"); scratch.file( "simple/BUILD", "filegroup(", " name = \"files\",", " srcs = [\"afile\"],", ")", "", "genrule(", " name = \"concat_all_files\",", " srcs = [\":files\"],", " outs = [\"concatenated.txt\"],", " cmd = \"$(location :files)\"", ")"); reporter.removeHandler(failFastHandler); AnalysisResult analysisResult = update( ImmutableList.of("//simple:print.bzl%print_expanded_location"), "//simple:concat_all_files"); assertThat(analysisResult.hasError()).isFalse(); ConfiguredAspect configuredAspect = analysisResult.getAspectsMap().values().iterator().next(); String result = (String) configuredAspect.get("result"); assertThat(result).isEqualTo("simple/afile"); } @Test public void topLevelAspectIsNotAnAspect() throws Exception { scratch.file("test/aspect.bzl", "MyAspect = 4"); scratch.file("test/BUILD", "java_library(name = 'xxx')"); reporter.removeHandler(failFastHandler); try { AnalysisResult result = update(ImmutableList.of("test/aspect.bzl%MyAspect"), "//test:xxx"); assertThat(keepGoing()).isTrue(); assertThat(result.hasError()).isTrue(); } catch (ViewCreationFailedException e) { // expect to fail. } assertContainsEvent("MyAspect from //test:aspect.bzl is not an aspect"); } @Test public void duplicateOutputGroups() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " f = ctx.actions.declare_file('f.txt')", " ctx.actions.write(f, 'f')", " return struct(output_groups = { 'duplicate' : depset([f]) })", "", "MyAspect = aspect(implementation=_impl)", "def _rule_impl(ctx):", " g = ctx.actions.declare_file('g.txt')", " ctx.actions.write(g, 'g')", " return struct(output_groups = { 'duplicate' : depset([g]) })", "my_rule = rule(_rule_impl)", "def _noop(ctx):", " pass", "rbase = rule(_noop, attrs = { 'dep' : attr.label(aspects = [MyAspect]) })"); scratch.file( "test/BUILD", "load(':aspect.bzl', 'my_rule', 'rbase')", "my_rule(name = 'xxx')", "rbase(name = 'yyy', dep = ':xxx')"); reporter.removeHandler(failFastHandler); try { AnalysisResult result = update("//test:yyy"); assertThat(keepGoing()).isTrue(); assertThat(result.hasError()).isTrue(); } catch (ViewCreationFailedException e) { // expect to fail. } assertContainsEvent("ERROR /workspace/test/BUILD:3:6: Output group duplicate provided twice"); } @Test public void outputGroupsFromOneAspect() throws Exception { scratch.file( "test/aspect.bzl", "def _a1_impl(target, ctx):", " f = ctx.actions.declare_file(target.label.name + '_a1.txt')", " ctx.actions.write(f, 'f')", " return struct(output_groups = { 'a1_group' : depset([f]) })", "", "a1 = aspect(implementation=_a1_impl, attr_aspects = ['dep'])", "def _rule_impl(ctx):", " if not ctx.attr.dep:", " return struct()", " og = {k:ctx.attr.dep.output_groups[k] for k in ctx.attr.dep.output_groups}", " return struct(output_groups = og)", "my_rule1 = rule(_rule_impl, attrs = { 'dep' : attr.label(aspects = [a1]) })"); scratch.file( "test/BUILD", "load(':aspect.bzl', 'my_rule1')", "my_rule1(name = 'base')", "my_rule1(name = 'xxx', dep = ':base')"); AnalysisResult analysisResult = update("//test:xxx"); OutputGroupInfo outputGroupInfo = OutputGroupInfo.get(Iterables.getOnlyElement(analysisResult.getTargetsToBuild())); assertThat(getOutputGroupContents(outputGroupInfo, "a1_group")) .containsExactly("test/base_a1.txt"); } @Test public void outputGroupsDeclaredProviderFromOneAspect() throws Exception { scratch.file( "test/aspect.bzl", "def _a1_impl(target, ctx):", " f = ctx.actions.declare_file(target.label.name + '_a1.txt')", " ctx.actions.write(f, 'f')", " return [OutputGroupInfo(a1_group = depset([f]))]", "", "a1 = aspect(implementation=_a1_impl, attr_aspects = ['dep'])", "def _rule_impl(ctx):", " if not ctx.attr.dep:", " return struct()", " return [OutputGroupInfo(a1_group = ctx.attr.dep[OutputGroupInfo].a1_group)]", "my_rule1 = rule(_rule_impl, attrs = { 'dep' : attr.label(aspects = [a1]) })"); scratch.file( "test/BUILD", "load(':aspect.bzl', 'my_rule1')", "my_rule1(name = 'base')", "my_rule1(name = 'xxx', dep = ':base')"); AnalysisResult analysisResult = update("//test:xxx"); OutputGroupInfo outputGroupInfo = OutputGroupInfo.get(Iterables.getOnlyElement(analysisResult.getTargetsToBuild())); assertThat(getOutputGroupContents(outputGroupInfo, "a1_group")) .containsExactly("test/base_a1.txt"); } @Test public void outputGroupsFromTwoAspects() throws Exception { scratch.file( "test/aspect.bzl", "def _a1_impl(target, ctx):", " f = ctx.actions.declare_file(target.label.name + '_a1.txt')", " ctx.actions.write(f, 'f')", " return struct(output_groups = { 'a1_group' : depset([f]) })", "", "a1 = aspect(implementation=_a1_impl, attr_aspects = ['dep'])", "def _rule_impl(ctx):", " if not ctx.attr.dep:", " return struct()", " og = {k:ctx.attr.dep.output_groups[k] for k in ctx.attr.dep.output_groups}", " return struct(output_groups = og)", "my_rule1 = rule(_rule_impl, attrs = { 'dep' : attr.label(aspects = [a1]) })", "def _a2_impl(target, ctx):", " g = ctx.actions.declare_file(target.label.name + '_a2.txt')", " ctx.actions.write(g, 'f')", " return struct(output_groups = { 'a2_group' : depset([g]) })", "", "a2 = aspect(implementation=_a2_impl, attr_aspects = ['dep'])", "my_rule2 = rule(_rule_impl, attrs = { 'dep' : attr.label(aspects = [a2]) })"); scratch.file( "test/BUILD", "load(':aspect.bzl', 'my_rule1', 'my_rule2')", "my_rule1(name = 'base')", "my_rule1(name = 'xxx', dep = ':base')", "my_rule2(name = 'yyy', dep = ':xxx')"); AnalysisResult analysisResult = update("//test:yyy"); OutputGroupInfo outputGroupInfo = OutputGroupInfo.get(Iterables.getOnlyElement(analysisResult.getTargetsToBuild())); assertThat(getOutputGroupContents(outputGroupInfo, "a1_group")) .containsExactly("test/base_a1.txt"); assertThat(getOutputGroupContents(outputGroupInfo, "a2_group")) .containsExactly("test/xxx_a2.txt"); } @Test public void outputGroupsDeclaredProvidersFromTwoAspects() throws Exception { scratch.file( "test/aspect.bzl", "def _a1_impl(target, ctx):", " f = ctx.actions.declare_file(target.label.name + '_a1.txt')", " ctx.actions.write(f, 'f')", " return [OutputGroupInfo(a1_group = depset([f]))]", "", "a1 = aspect(implementation=_a1_impl, attr_aspects = ['dep'])", "def _rule_impl(ctx):", " if not ctx.attr.dep:", " return struct()", " og = dict()", " dep_og = ctx.attr.dep[OutputGroupInfo]", " if hasattr(dep_og, 'a1_group'):", " og['a1_group'] = dep_og.a1_group", " if hasattr(dep_og, 'a2_group'):", " og['a2_group'] = dep_og.a2_group", " return [OutputGroupInfo(**og)]", "my_rule1 = rule(_rule_impl, attrs = { 'dep' : attr.label(aspects = [a1]) })", "def _a2_impl(target, ctx):", " g = ctx.actions.declare_file(target.label.name + '_a2.txt')", " ctx.actions.write(g, 'f')", " return [OutputGroupInfo(a2_group = depset([g]))]", "", "a2 = aspect(implementation=_a2_impl, attr_aspects = ['dep'])", "my_rule2 = rule(_rule_impl, attrs = { 'dep' : attr.label(aspects = [a2]) })"); scratch.file( "test/BUILD", "load(':aspect.bzl', 'my_rule1', 'my_rule2')", "my_rule1(name = 'base')", "my_rule1(name = 'xxx', dep = ':base')", "my_rule2(name = 'yyy', dep = ':xxx')"); AnalysisResult analysisResult = update("//test:yyy"); OutputGroupInfo outputGroupInfo = OutputGroupInfo.get(Iterables.getOnlyElement(analysisResult.getTargetsToBuild())); assertThat(getOutputGroupContents(outputGroupInfo, "a1_group")) .containsExactly("test/base_a1.txt"); assertThat(getOutputGroupContents(outputGroupInfo, "a2_group")) .containsExactly("test/xxx_a2.txt"); } @Test public void duplicateOutputGroupsFromTwoAspects() throws Exception { scratch.file( "test/aspect.bzl", "def _a1_impl(target, ctx):", " f = ctx.actions.declare_file(target.label.name + '_a1.txt')", " ctx.actions.write(f, 'f')", " return struct(output_groups = { 'a1_group' : depset([f]) })", "", "a1 = aspect(implementation=_a1_impl, attr_aspects = ['dep'])", "def _rule_impl(ctx):", " if not ctx.attr.dep:", " return struct()", " og = {k:ctx.attr.dep.output_groups[k] for k in ctx.attr.dep.output_groups}", " return struct(output_groups = og)", "my_rule1 = rule(_rule_impl, attrs = { 'dep' : attr.label(aspects = [a1]) })", "def _a2_impl(target, ctx):", " g = ctx.actions.declare_file(target.label.name + '_a2.txt')", " ctx.actions.write(g, 'f')", " return struct(output_groups = { 'a1_group' : depset([g]) })", "", "a2 = aspect(implementation=_a2_impl, attr_aspects = ['dep'])", "my_rule2 = rule(_rule_impl, attrs = { 'dep' : attr.label(aspects = [a2]) })"); scratch.file( "test/BUILD", "load(':aspect.bzl', 'my_rule1', 'my_rule2')", "my_rule1(name = 'base')", "my_rule1(name = 'xxx', dep = ':base')", "my_rule2(name = 'yyy', dep = ':xxx')"); reporter.removeHandler(failFastHandler); try { AnalysisResult analysisResult = update("//test:yyy"); assertThat(analysisResult.hasError()).isTrue(); assertThat(keepGoing()).isTrue(); } catch (ViewCreationFailedException e) { // expected. } assertContainsEvent("ERROR /workspace/test/BUILD:3:9: Output group a1_group provided twice"); } private static Iterable getOutputGroupContents( OutputGroupInfo outputGroupInfo, String groupName) { return Iterables.transform( outputGroupInfo.getOutputGroup(groupName).toList(), Artifact::getRootRelativePathString); } @Test public void duplicateStarlarkProviders() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " return struct(duplicate = 'x')", "", "MyAspect = aspect(implementation=_impl)", "def _rule_impl(ctx):", " return struct(duplicate = 'y')", "my_rule = rule(_rule_impl)", "def _noop(ctx):", " pass", "rbase = rule(_noop, attrs = { 'dep' : attr.label(aspects = [MyAspect]) })"); scratch.file( "test/BUILD", "load(':aspect.bzl', 'my_rule', 'rbase')", "my_rule(name = 'xxx')", "rbase(name = 'yyy', dep = ':xxx')"); reporter.removeHandler(failFastHandler); try { AnalysisResult result = update("//test:yyy"); assertThat(keepGoing()).isTrue(); assertThat(result.hasError()).isTrue(); } catch (ViewCreationFailedException e) { // expect to fail. } assertContainsEvent("ERROR /workspace/test/BUILD:3:6: Provider duplicate provided twice"); } @Test public void topLevelAspectDoesNotExist() throws Exception { scratch.file("test/aspect.bzl", ""); scratch.file("test/BUILD", "java_library(name = 'xxx')"); reporter.removeHandler(failFastHandler); try { AnalysisResult result = update(ImmutableList.of("test/aspect.bzl%MyAspect"), "//test:xxx"); assertThat(keepGoing()).isTrue(); assertThat(result.hasError()).isTrue(); } catch (ViewCreationFailedException e) { // expect to fail. } assertContainsEvent("MyAspect is not exported from //test:aspect.bzl"); } @Test public void topLevelAspectDoesNotExist2() throws Exception { scratch.file("test/BUILD", "java_library(name = 'xxx')"); reporter.removeHandler(failFastHandler); try { AnalysisResult result = update(ImmutableList.of("test/aspect.bzl%MyAspect"), "//test:xxx"); assertThat(keepGoing()).isTrue(); assertThat(result.hasError()).isTrue(); } catch (ViewCreationFailedException e) { // expect to fail. } assertContainsEvent("cannot load '//test:aspect.bzl': no such file"); } @Test public void topLevelAspectDoesNotExistNoBuildFile() throws Exception { scratch.file("test/BUILD", "java_library(name = 'xxx')"); reporter.removeHandler(failFastHandler); try { AnalysisResult result = update(ImmutableList.of("foo/aspect.bzl%MyAspect"), "//test:xxx"); assertThat(keepGoing()).isTrue(); assertThat(result.hasError()).isTrue(); } catch (ViewCreationFailedException e) { // expect to fail. } assertContainsEvent("Every .bzl file must have a corresponding package"); } /** * Tests that a loading-level error (missing bzl file) is properly transformed by the configured * target that requested the relevant package, and doesn't bubble up to a higher configured * target/aspect that wasn't expecting a loading-level error. The complication is that the * configured target that depends directly on the error tries to do configuration resolution after * noticing the error, and configuration resolution is interruptible, so it is interrupted. It * needs to then throw the error, rather than the interruption. * *

This test covers error propagation up to both the configured target that depends on the one * in error, as well as the aspect on that configured target, since the error goes through both. */ @Test public void aspectBaseConfiguredTargetTransitivelyDependingOnPackageInError() throws Exception { setRulesAndAspectsAvailableInTests(ImmutableList.of(), ImmutableList.of()); scratch.overwriteFile( "tools/allowlists/function_transition_allowlist/BUILD", "package_group(name = 'function_transition_allowlist', packages = ['//aspect/...'])"); scratch.file( "aspect/aspect.bzl", "def _setting_impl(ctx):", " return []", "", "string_flag = rule(", " implementation = _setting_impl,", " build_setting = config.string(flag=True),", ")", "", "def _rule_impl(ctx):", " pass", "", "def _transition_impl(settings, attr):", " return {'//aspect:formation': 'mesa'}", "", "formation_transition = transition(", " implementation = _transition_impl,", " inputs = ['//aspect:formation'],", " outputs = ['//aspect:formation'],", ")", "", "def _aspect_impl(target, ctx):", " pass", "", "myaspect = aspect(implementation = _aspect_impl)", "", "cfgrule = rule(", " implementation = _rule_impl,", " attrs = {", " '_allowlist_function_transition': attr.label(", " default = '//tools/allowlists/function_transition_allowlist',", " ),", " 'to': attr.label(),", " 'innocent': attr.label(cfg = formation_transition),", " }", ")"); scratch.file( "aspect/BUILD", "load('aspect.bzl', 'cfgrule', 'string_flag')", "string_flag(name = 'formation', build_setting_default = 'canyon')", "sh_library(name = 'innocent')", "cfgrule(name = 'top', to = '//baz:baz', innocent = ':innocent')"); scratch.file("bar/BUILD", "sh_library(name = 'bar', deps = ['//baz:baz'])"); scratch.file( "baz/BUILD", "load('//baz/subdir:missing.bzl', 'sym')", "sh_library(name = 'baz')"); scratch.file("baz/subdir/missing.bzl"); reporter.removeHandler(failFastHandler); try { AnalysisResult result = update(ImmutableList.of("//aspect:aspect.bzl%myaspect"), "//aspect:top"); assertThat(keepGoing()).isTrue(); assertThat(result.hasError()).isTrue(); } catch (ViewCreationFailedException e) { // expect to fail. assertThat(keepGoing()).isFalse(); } assertContainsEvent("Label '//baz/subdir:missing.bzl' is invalid"); } @Test public void aspectParametersUncovered() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " return struct()", "def _rule_impl(ctx):", " return struct()", "MyAspectUncovered = aspect(", " implementation=_impl,", " attrs = { 'my_attr' : attr.string(values=['aaa']) },", ")", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'deps' : attr.label_list(aspects=[MyAspectUncovered]) },", ")"); scratch.file("test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "my_rule(name = 'xxx')"); reporter.removeHandler(failFastHandler); try { AnalysisResult result = update(ImmutableList.of(), "//test:xxx"); assertThat(keepGoing()).isTrue(); assertThat(result.hasError()).isTrue(); } catch (Exception e) { // expect to fail. } assertContainsEvent( // "ERROR /workspace/test/aspect.bzl:9:11: " "Aspect //test:aspect.bzl%MyAspectUncovered requires rule my_rule to specify attribute " + "'my_attr' with type string."); } @Test public void aspectParametersTypeMismatch() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " return struct()", "def _rule_impl(ctx):", " return struct()", "MyAspectMismatch = aspect(", " implementation=_impl,", " attrs = { 'my_attr' : attr.string(values=['aaa']) },", ")", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'deps' : attr.label_list(aspects=[MyAspectMismatch]),", " 'my_attr' : attr.int() },", ")"); scratch.file( "test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "my_rule(name = 'xxx', my_attr = 4)"); reporter.removeHandler(failFastHandler); try { AnalysisResult result = update(ImmutableList.of(), "//test:xxx"); assertThat(keepGoing()).isTrue(); assertThat(result.hasError()).isTrue(); } catch (Exception e) { // expect to fail. } assertContainsEvent( "Aspect //test:aspect.bzl%MyAspectMismatch requires rule my_rule to specify attribute " + "'my_attr' with type string."); } @Test public void aspectParametersDontSupportSelect() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " return struct()", "def _rule_impl(ctx):", " return struct()", "MyAspectMismatch = aspect(", " implementation=_impl,", " attrs = { 'my_attr' : attr.string(values=['aaa']) },", ")", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'deps' : attr.label_list(aspects=[MyAspectMismatch]),", " 'my_attr' : attr.string() },", ")"); scratch.file( "test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "my_rule(name = 'xxx', my_attr = select({'//conditions:default': 'foo'}))"); reporter.removeHandler(failFastHandler); try { AnalysisResult result = update(ImmutableList.of(), "//test:xxx"); assertThat(keepGoing()).isTrue(); assertThat(result.hasError()).isTrue(); } catch (Exception e) { // expect to fail. } assertContainsEvent( "//test:xxx: attribute 'my_attr' has a select() and aspect " + "//test:aspect.bzl%MyAspectMismatch also declares '//test:xxx'. Aspect attributes " + "don't currently support select()."); } @Test public void aspectParametersBadDefault() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " return struct()", "def _rule_impl(ctx):", " return struct()", "MyAspectBadDefault = aspect(", " implementation=_impl,", " attrs = { 'my_attr' : attr.string(values=['a'], default='b') },", ")", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'deps' : attr.label_list(aspects=[MyAspectBadDefault]) },", // line 11 ")"); scratch.file("test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "my_rule(name = 'xxx')"); reporter.removeHandler(failFastHandler); try { AnalysisResult result = update(ImmutableList.of(), "//test:xxx"); assertThat(keepGoing()).isTrue(); assertThat(result.hasError()).isTrue(); } catch (Exception e) { // expect to fail. } // aspect fails, stack = [@:5:28, aspect@] assertContainsEvent("File \"/workspace/test/aspect.bzl\", line 5, column 28, in "); assertContainsEvent( "Error in aspect: Aspect parameter attribute 'my_attr' has a bad default value: has to be" + " one of 'a' instead of 'b'"); } @Test public void aspectParametersBadValue() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " return struct()", "def _rule_impl(ctx):", " return struct()", "MyAspectBadValue = aspect(", " implementation=_impl,", " attrs = { 'my_attr' : attr.string(values=['a']) },", ")", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'deps' : attr.label_list(aspects=[MyAspectBadValue]),", " 'my_attr' : attr.string() },", ")"); scratch.file( "test/BUILD", // "load('//test:aspect.bzl', 'my_rule')", "my_rule(name = 'xxx', my_attr='b')"); reporter.removeHandler(failFastHandler); try { AnalysisResult result = update(ImmutableList.of(), "//test:xxx"); assertThat(keepGoing()).isTrue(); assertThat(result.hasError()).isTrue(); } catch (Exception e) { // expect to fail. } assertContainsEvent( "ERROR /workspace/test/BUILD:2:8: //test:xxx: invalid value in 'my_attr' " + "attribute: has to be one of 'a' instead of 'b'"); } @Test public void aspectParameters() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " return struct()", "def _rule_impl(ctx):", " return struct()", "MyAspect = aspect(", " implementation=_impl,", " attrs = { 'my_attr' : attr.string(values=['aaa']) },", ")", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'deps' : attr.label_list(aspects=[MyAspect]),", " 'my_attr' : attr.string() },", ")"); scratch.file( "test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "my_rule(name = 'xxx', my_attr = 'aaa')"); AnalysisResult result = update(ImmutableList.of(), "//test:xxx"); assertThat(result.hasError()).isFalse(); } @Test public void aspectParametersConfigurationField() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " return struct()", "def _rule_impl(ctx):", " return struct()", "MyAspect = aspect(", " implementation=_impl,", " attrs = { '_my_attr' : attr.label(default=", " configuration_field(fragment='cpp', name = 'cc_toolchain')) },", ")", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'deps' : attr.label_list(aspects=[MyAspect]) },", ")"); scratch.file("test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "my_rule(name = 'xxx')"); AnalysisResult result = update(ImmutableList.of(), "//test:xxx"); assertThat(result.hasError()).isFalse(); } @Test public void aspectParameterComputedDefault() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " return struct()", "def _rule_impl(ctx):", " return struct()", "def _defattr():", " return Label('//foo/bar:baz')", "MyAspect = aspect(", " implementation=_impl,", " attrs = { '_extra' : attr.label(default = _defattr) }", ")", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'deps' : attr.label_list(aspects=[MyAspect]) },", ")"); scratch.file("test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "my_rule(name = 'xxx')"); reporter.removeHandler(failFastHandler); if (keepGoing()) { AnalysisResult result = update("//test:xxx"); assertThat(result.hasError()).isTrue(); } else { assertThrows(TargetParsingException.class, () -> update("//test:xxx")); } assertContainsEvent( "Aspect attribute '_extra' (label) with computed default value is unsupported."); } @Test public void aspectParametersOptional() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " return struct()", "def _rule_impl(ctx):", " return struct()", "MyAspectOptParam = aspect(", " implementation=_impl,", " attrs = { 'my_attr' : attr.string(values=['aaa'], default='aaa') },", ")", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'deps' : attr.label_list(aspects=[MyAspectOptParam]) },", ")"); scratch.file("test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "my_rule(name = 'xxx')"); AnalysisResult result = update(ImmutableList.of(), "//test:xxx"); assertThat(result.hasError()).isFalse(); } @Test public void aspectParametersOptionalOverride() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " if (ctx.attr.my_attr == 'a'):", " fail('Rule is not overriding default, still has value ' + ctx.attr.my_attr)", " return struct()", "def _rule_impl(ctx):", " return struct()", "MyAspectOptOverride = aspect(", " implementation=_impl,", " attrs = { 'my_attr' : attr.string(values=['a', 'b'], default='a') },", ")", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'deps' : attr.label_list(aspects=[MyAspectOptOverride]),", " 'my_attr' : attr.string() },", ")"); scratch.file( "test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "my_rule(name = 'xxx', my_attr = 'b')"); AnalysisResult result = update(ImmutableList.of(), "//test:xxx"); assertThat(result.hasError()).isFalse(); } @Test public void testMultipleExecutablesInTarget() throws Exception { scratch.file( "foo/extension.bzl", "def _aspect_impl(target, ctx):", " return struct()", "my_aspect = aspect(_aspect_impl)", "def _main_rule_impl(ctx):", " pass", "my_rule = rule(_main_rule_impl,", " attrs = { ", " 'exe1' : attr.label(executable = True, allow_files = True, cfg = 'exec'),", " 'exe2' : attr.label(executable = True, allow_files = True, cfg = 'exec'),", " },", ")"); scratch.file("foo/tool.sh", "#!/bin/bash"); scratch.file( "foo/BUILD", "load(':extension.bzl', 'my_rule')", "my_rule(name = 'main', exe1 = ':tool.sh', exe2 = ':tool.sh')"); AnalysisResult analysisResultOfRule = update(ImmutableList.of(), "//foo:main"); assertThat(analysisResultOfRule.hasError()).isFalse(); AnalysisResult analysisResultOfAspect = update(ImmutableList.of("/foo/extension.bzl%my_aspect"), "//foo:main"); assertThat(analysisResultOfAspect.hasError()).isFalse(); } @Test public void aspectFragmentAccessSuccess() throws Exception { analyzeConfiguredTargetForAspectFragment("ctx.fragments.java.strict_java_deps", "'java'", ""); assertNoEvents(); } @Test public void aspectFragmentAccessError() { reporter.removeHandler(failFastHandler); assertThrows( ViewCreationFailedException.class, () -> analyzeConfiguredTargetForAspectFragment( "ctx.fragments.java.strict_java_deps", "'cpp'", "'cpp'")); assertContainsEvent( "//test:aspect.bzl%MyAspect aspect on my_rule has to declare 'java' as a " + "required fragment in order to access it. Please update the 'fragments' argument of " + "the rule definition (for example: fragments = [\"java\"])"); } private void analyzeConfiguredTargetForAspectFragment( String fullFieldName, String fragments, String ruleFragments) throws Exception { scratch.file( "test/aspect.bzl", "def _aspect_impl(target, ctx):", " return struct(result = str(" + fullFieldName + "))", "", "def _rule_impl(ctx):", " return struct(stuff = '...')", "", "MyAspect = aspect(", " implementation=_aspect_impl,", " attr_aspects=['deps'],", " fragments=[" + fragments + "],", ")", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'attr' : ", " attr.label_list(mandatory=True, allow_files=True, aspects = [MyAspect]) },", " fragments=[" + ruleFragments + "],", ")"); scratch.file( "test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "exports_files(['zzz'])", "my_rule(", " name = 'yyy',", " attr = ['zzz'],", ")", "my_rule(", " name = 'xxx',", " attr = ['yyy'],", ")"); AnalysisResult result = update(ImmutableList.of("test/aspect.bzl%MyAspect"), "//test:xxx"); if (result.hasError()) { assertThat(keepGoing()).isTrue(); String errorMessage = "Analysis failed"; throw new ViewCreationFailedException( errorMessage, FailureDetail.newBuilder() .setMessage(errorMessage) .setAnalysis(Analysis.newBuilder().setCode(Code.ANALYSIS_UNKNOWN)) .build()); } assertThat(getConfiguredTarget("//test:xxx")).isNotNull(); } @Test public void invalidateAspectOnBzlFileChange() throws Exception { scratch.file("test/build_defs.bzl", aspectBzlFile("'deps'")); scratch.file( "test/BUILD", "load(':build_defs.bzl', 'repro', 'repro_no_aspect')", "repro_no_aspect(name = 'r0')", "repro_no_aspect(name = 'r1', deps = [':r0'])", "repro(name = 'r2', deps = [':r1'])"); buildTargetAndCheckRuleInfo("@//test:r0", "@//test:r1"); // Make aspect propagation list empty. scratch.overwriteFile("test/build_defs.bzl", aspectBzlFile("")); // The aspect should not propagate to //test:r0 anymore. buildTargetAndCheckRuleInfo("@//test:r1"); } private void buildTargetAndCheckRuleInfo(String... expectedLabels) throws Exception { AnalysisResult result = update(ImmutableList.of(), "//test:r2"); ConfiguredTarget configuredTarget = result.getTargetsToBuild().iterator().next(); Depset ruleInfoValue = (Depset) configuredTarget.get("rule_info"); assertThat(ruleInfoValue.getSet(String.class).toList()) .containsExactlyElementsIn(expectedLabels); } private static String[] aspectBzlFile(String attrAspects) { return new String[] { "def _repro_aspect_impl(target, ctx):", " s = depset([str(target.label)], transitive =", " [d.aspect_info for d in ctx.rule.attr.deps if hasattr(d, 'aspect_info')])", " return struct(aspect_info = s)", "", "_repro_aspect = aspect(", " _repro_aspect_impl,", " attr_aspects = [" + attrAspects + "],", ")", "", "def repro_impl(ctx):", " s = depset(transitive = ", " [d.aspect_info for d in ctx.attr.deps if hasattr(d, 'aspect_info')])", " return struct(rule_info = s)", "", "def repro_no_aspect_impl(ctx):", " pass", "", "repro_no_aspect = rule(implementation = repro_no_aspect_impl,", " attrs = {", " 'deps': attr.label_list(", " allow_files = True,", " )", " },", ")", "", "repro = rule(implementation = repro_impl,", " attrs = {", " 'deps': attr.label_list(", " allow_files = True,", " aspects = [_repro_aspect],", " )", " },", ")" }; } @Test public void aspectOutputsToBinDirectory() throws Exception { scratch.file( "foo/extension.bzl", "def _aspect_impl(target, ctx):", " file = ctx.actions.declare_file('aspect-output-' + target.label.name)", " ctx.actions.write(file, 'data')", " return struct(aspect_file = file)", "my_aspect = aspect(_aspect_impl)", "def _rule_impl(ctx):", " pass", "rule_bin_out = rule(_rule_impl, output_to_genfiles=False)", "rule_gen_out = rule(_rule_impl, output_to_genfiles=True)", "def _main_rule_impl(ctx):", " s = depset([d.aspect_file for d in ctx.attr.deps])", " return struct(aspect_files = s)", "main_rule = rule(_main_rule_impl,", " attrs = { 'deps' : attr.label_list(aspects = [my_aspect]) },", ")"); scratch.file( "foo/BUILD", "load(':extension.bzl', 'rule_bin_out', 'rule_gen_out', 'main_rule')", "rule_bin_out(name = 'rbin')", "rule_gen_out(name = 'rgen')", "main_rule(name = 'main', deps = [':rbin', ':rgen'])"); AnalysisResult analysisResult = update(ImmutableList.of(), "//foo:main"); ConfiguredTarget target = analysisResult.getTargetsToBuild().iterator().next(); NestedSet aspectFiles = ((Depset) target.get("aspect_files")).getSet(Artifact.class); assertThat(Iterables.transform(aspectFiles.toList(), Artifact::getFilename)) .containsExactly("aspect-output-rbin", "aspect-output-rgen"); for (Artifact aspectFile : aspectFiles.toList()) { String rootPath = aspectFile.getRoot().getExecPath().toString(); assertWithMessage("Artifact %s should not be in genfiles", aspectFile) .that(rootPath) .doesNotContain("genfiles"); assertWithMessage("Artifact %s should be in bin", aspectFile).that(rootPath).endsWith("bin"); } } @Test public void toplevelAspectOnFile() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " print('This aspect does nothing')", " return struct()", "MyAspect = aspect(implementation=_impl)"); scratch.file("test/BUILD", "exports_files(['file.txt'])"); scratch.file("test/file.txt", ""); AnalysisResult analysisResult = update(ImmutableList.of("test/aspect.bzl%MyAspect"), "//test:file.txt"); assertThat(analysisResult.hasError()).isFalse(); assertThat( Iterables.getOnlyElement(analysisResult.getAspectsMap().values()) .getProviders() .getProviderCount()) .isEqualTo(0); } @Test public void sharedAttributeDefinitionWithAspects() throws Exception { scratch.file( "test/aspect.bzl", "def _aspect_impl(target,ctx):", " return struct()", "my_aspect = aspect(implementation = _aspect_impl)", "_ATTR = { 'deps' : attr.label_list(aspects = [my_aspect]) }", "def _dummy_impl(ctx):", " pass", "r1 = rule(_dummy_impl, attrs = _ATTR)", "r2 = rule(_dummy_impl, attrs = _ATTR)"); scratch.file( "test/BUILD", "load(':aspect.bzl', 'r1', 'r2')", "r1(name = 't1')", "r2(name = 't2', deps = [':t1'])"); AnalysisResult analysisResult = update("//test:t2"); assertThat(analysisResult.hasError()).isFalse(); } @Test public void multipleAspects() throws Exception { scratch.file( "test/aspect.bzl", "def _aspect_impl(target,ctx):", " return struct()", "my_aspect = aspect(implementation = _aspect_impl)", "def _dummy_impl(ctx):", " pass", "r1 = rule(_dummy_impl, ", " attrs = { 'deps' : attr.label_list(aspects = [my_aspect, my_aspect]) })"); scratch.file("test/BUILD", "load(':aspect.bzl', 'r1')", "r1(name = 't1')"); reporter.removeHandler(failFastHandler); // This call succeeds if "--keep_going" was passed, which it does in the WithKeepGoing test // suite. Otherwise, it fails and throws a TargetParsingException. if (keepGoing()) { AnalysisResult result = update("//test:r1"); assertThat(result.hasError()).isTrue(); } else { assertThrows(TargetParsingException.class, () -> update("//test:r1")); } assertContainsEvent("aspect //test:aspect.bzl%my_aspect added more than once"); } @Test public void topLevelAspectsAndExtraActions() throws Exception { scratch.file( "test/aspect.bzl", "def _aspect_impl(target,ctx):", " f = ctx.actions.declare_file('dummy.txt')", " ctx.actions.run_shell(outputs = [f], command='echo xxx > $(location f)',", " mnemonic='AspectAction')", " return struct()", "my_aspect = aspect(implementation = _aspect_impl)"); scratch.file( "test/BUILD", "extra_action(", " name = 'xa',", " cmd = 'echo $(EXTRA_ACTION_FILE) > $(output file.xa)',", " out_templates = ['file.xa'],", ")", "action_listener(", " name = 'al',", " mnemonics = [ 'AspectAction' ],", " extra_actions = [ ':xa' ])", "java_library(name = 'xxx')"); useConfiguration("--experimental_action_listener=//test:al"); AnalysisResult analysisResult = update(ImmutableList.of("test/aspect.bzl%my_aspect"), "//test:xxx"); assertThat(Iterables.transform(analysisResult.getArtifactsToBuild(), Artifact::getFilename)) .contains("file.xa"); } /** Regression test for b/137960630. */ @Test public void topLevelAspectsAndExtraActionsWithConflict() throws Exception { scratch.file( "test/aspect.bzl", "def _aspect_impl(target, ctx):", " f = ctx.actions.declare_file('dummy.txt')", " ctx.actions.run_shell(outputs = [f], command='echo xxx > $(location f)',", " mnemonic='AspectAction')", " return struct()", "my_aspect = aspect(implementation = _aspect_impl)"); scratch.file( "test/BUILD", "extra_action(", " name = 'xa',", " cmd = 'echo $(EXTRA_ACTION_FILE) > $(output file.xa)',", " out_templates = ['file.xa'],", ")", "action_listener(", " name = 'al',", " mnemonics = ['AspectAction'],", " extra_actions = [':xa'],", ")", "java_library(name = 'xxx')", "java_library(name = 'yyy')"); useConfiguration("--experimental_action_listener=//test:al"); reporter.removeHandler(failFastHandler); // We expect an error. if (keepGoing()) { AnalysisResult result = update(ImmutableList.of("test/aspect.bzl%my_aspect"), "//test:xxx", "//test:yyy"); assertThat(result.hasError()).isTrue(); } else { assertThrows( ViewCreationFailedException.class, () -> update(ImmutableList.of("test/aspect.bzl%my_aspect"), "//test:xxx", "//test:yyy")); } assertContainsEvent( "file 'extra_actions/test/xa/test/file.xa' is generated by these conflicting actions"); } @Test public void aspectsPropagatingToAllAttributes() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " s = depset([target.label], transitive =", " [i.target_labels for i in ctx.rule.attr.runtime_deps]", " if hasattr(ctx.rule.attr, 'runtime_deps') else [])", " return struct(target_labels = s)", "", "MyAspect = aspect(", " implementation=_impl,", " attrs = { '_tool' : attr.label(default = Label('//test:tool')) },", " attr_aspects=['*'],", ")"); scratch.file( "test/BUILD", "java_library(", " name = 'tool',", ")", "java_library(", " name = 'bar',", " runtime_deps = [':tool'],", ")", "java_library(", " name = 'foo',", " runtime_deps = [':bar'],", ")"); AnalysisResult analysisResult = update(ImmutableList.of("test/aspect.bzl%MyAspect"), "//test:foo"); ConfiguredAspect configuredAspect = analysisResult.getAspectsMap().values().iterator().next(); assertThat(configuredAspect).isNotNull(); Object names = configuredAspect.get("target_labels"); assertThat(names).isInstanceOf(Depset.class); assertThat( Iterables.transform( ((Depset) names).toList(), o -> { assertThat(o).isInstanceOf(Label.class); return ((Label) o).getName(); })) .containsExactly("foo", "bar", "tool"); } /** Simple straightforward linear aspects-on-aspects. */ @Test public void aspectOnAspectLinear() throws Exception { scratch.file( "test/aspect.bzl", "a1p = provider()", "def _a1_impl(target,ctx):", " return struct(a1p = a1p(text = 'random'))", "a1 = aspect(_a1_impl, attr_aspects = ['dep'], provides = ['a1p'])", "a2p = provider()", "def _a2_impl(target,ctx):", " value = []", " if hasattr(ctx.rule.attr.dep, 'a2p'):", " value += ctx.rule.attr.dep.a2p.value", " if hasattr(target, 'a1p'):", " value.append(str(target.label) + str(ctx.aspect_ids) + '=yes')", " else:", " value.append(str(target.label) + str(ctx.aspect_ids) + '=no')", " return struct(a2p = a2p(value = value))", "a2 = aspect(_a2_impl, attr_aspects = ['dep'], required_aspect_providers = ['a1p'])", "def _r1_impl(ctx):", " pass", "def _r2_impl(ctx):", " return struct(result = ctx.attr.dep.a2p.value)", "r1 = rule(_r1_impl, attrs = { 'dep' : attr.label(aspects = [a1])})", "r2 = rule(_r2_impl, attrs = { 'dep' : attr.label(aspects = [a2])})"); scratch.file( "test/BUILD", "load(':aspect.bzl', 'r1', 'r2')", "r1(name = 'r0')", "r1(name = 'r1', dep = ':r0')", "r2(name = 'r2', dep = ':r1')"); AnalysisResult analysisResult = update("//test:r2"); ConfiguredTarget target = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); Sequence result = (Sequence) target.get("result"); // "yes" means that aspect a2 sees a1's providers. assertThat(result) .containsExactly( "@//test:r0[\"//test:aspect.bzl%a1\", \"//test:aspect.bzl%a2\"]=yes", "@//test:r1[\"//test:aspect.bzl%a2\"]=no"); } /** * Diamond case. rule r1 depends or r0 with aspect a1. rule r2 depends or r0 with aspect a2. rule * rcollect depends on r1, r2 with aspect a3. * *

Aspect a3 should be applied twice to target r0: once in [a1, a3] sequence and once in [a2, * a3] sequence. */ @Test public void aspectOnAspectDiamond() throws Exception { scratch.file( "test/aspect.bzl", "def _a1_impl(target,ctx):", " return struct(a1p = 'text from a1')", "a1 = aspect(_a1_impl, attr_aspects = ['deps'], provides = ['a1p'])", "", "def _a2_impl(target,ctx):", " return struct(a2p = 'text from a2')", "a2 = aspect(_a2_impl, attr_aspects = ['deps'], provides = ['a2p'])", "", "def _a3_impl(target,ctx):", " value = []", " f = ctx.actions.declare_file('a3.out')", " ctx.actions.write(f, 'text')", " for dep in ctx.rule.attr.deps:", " if hasattr(dep, 'a3p'):", " value += dep.a3p", " s = str(target.label) + str(ctx.aspect_ids) + '='", " if hasattr(target, 'a1p'):", " s += 'a1p'", " if hasattr(target, 'a2p'):", " s += 'a2p'", " value.append(s)", " return struct(a3p = value)", "a3 = aspect(_a3_impl, attr_aspects = ['deps'],", " required_aspect_providers = [['a1p'], ['a2p']])", "def _r1_impl(ctx):", " pass", "def _rcollect_impl(ctx):", " value = []", " for dep in ctx.attr.deps:", " if hasattr(dep, 'a3p'):", " value += dep.a3p", " return struct(result = value)", "r1 = rule(_r1_impl, attrs = { 'deps' : attr.label_list(aspects = [a1])})", "r2 = rule(_r1_impl, attrs = { 'deps' : attr.label_list(aspects = [a2])})", "rcollect = rule(_rcollect_impl, attrs = { 'deps' : attr.label_list(aspects = [a3])})"); scratch.file( "test/BUILD", "load(':aspect.bzl', 'r1', 'r2', 'rcollect')", "r1(name = 'r0')", "r1(name = 'r1', deps = [':r0'])", "r2(name = 'r2', deps = [':r0'])", "rcollect(name = 'rcollect', deps = [':r1', ':r2'])"); AnalysisResult analysisResult = update("//test:rcollect"); ConfiguredTarget target = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); Sequence result = (Sequence) target.get("result"); assertThat(result) .containsExactly( "@//test:r0[\"//test:aspect.bzl%a1\", \"//test:aspect.bzl%a3\"]=a1p", "@//test:r1[\"//test:aspect.bzl%a3\"]=", "@//test:r0[\"//test:aspect.bzl%a2\", \"//test:aspect.bzl%a3\"]=a2p", "@//test:r2[\"//test:aspect.bzl%a3\"]="); } /** * Linear with duplicates. r2_1 depends on r0 with aspect a2. r1 depends on r2_1 with aspect a1. * r2 depends on r1 with aspect a2. * *

a2 is not interested in a1. There should be just one instance of aspect a2 on r0, and is * should *not* see a1. */ @Test public void aspectOnAspectLinearDuplicates() throws Exception { scratch.file( "test/aspect.bzl", "a1p = provider()", "def _a1_impl(target,ctx):", " return struct(a1p = 'a1p')", "a1 = aspect(_a1_impl, attr_aspects = ['dep'], provides = ['a1p'])", "a2p = provider()", "def _a2_impl(target,ctx):", " value = []", " if hasattr(ctx.rule.attr.dep, 'a2p'):", " value += ctx.rule.attr.dep.a2p.value", " if hasattr(target, 'a1p'):", " value.append(str(target.label) + str(ctx.aspect_ids) + '=yes')", " else:", " value.append(str(target.label) + str(ctx.aspect_ids) + '=no')", " return struct(a2p = a2p(value = value))", "a2 = aspect(_a2_impl, attr_aspects = ['dep'], required_aspect_providers = [])", "def _r1_impl(ctx):", " pass", "def _r2_impl(ctx):", " return struct(result = ctx.attr.dep.a2p.value)", "r1 = rule(_r1_impl, attrs = { 'dep' : attr.label(aspects = [a1])})", "r2 = rule(_r2_impl, attrs = { 'dep' : attr.label(aspects = [a2])})"); scratch.file( "test/BUILD", "load(':aspect.bzl', 'r1', 'r2')", "r1(name = 'r0')", "r2(name = 'r2_1', dep = ':r0')", "r1(name = 'r1', dep = ':r2_1')", "r2(name = 'r2', dep = ':r1')"); AnalysisResult analysisResult = update("//test:r2"); ConfiguredTarget target = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); Sequence result = (Sequence) target.get("result"); // "yes" means that aspect a2 sees a1's providers. assertThat(result) .containsExactly( "@//test:r0[\"//test:aspect.bzl%a2\"]=no", "@//test:r1[\"//test:aspect.bzl%a2\"]=no", "@//test:r2_1[\"//test:aspect.bzl%a2\"]=no"); } /** Linear aspects-on-aspects with alias rule. */ @Test public void aspectOnAspectLinearAlias() throws Exception { scratch.file( "test/aspect.bzl", "a1p = provider()", "def _a1_impl(target,ctx):", " return struct(a1p = a1p(text = 'random'))", "a1 = aspect(_a1_impl, attr_aspects = ['dep'], provides = ['a1p'])", "a2p = provider()", "def _a2_impl(target,ctx):", " value = []", " if hasattr(ctx.rule.attr.dep, 'a2p'):", " value += ctx.rule.attr.dep.a2p.value", " if hasattr(target, 'a1p'):", " value.append(str(target.label) + str(ctx.aspect_ids) + '=yes')", " else:", " value.append(str(target.label) + str(ctx.aspect_ids) + '=no')", " return struct(a2p = a2p(value = value))", "a2 = aspect(_a2_impl, attr_aspects = ['dep'], required_aspect_providers = ['a1p'])", "def _r1_impl(ctx):", " pass", "def _r2_impl(ctx):", " return struct(result = ctx.attr.dep.a2p.value)", "r1 = rule(_r1_impl, attrs = { 'dep' : attr.label(aspects = [a1])})", "r2 = rule(_r2_impl, attrs = { 'dep' : attr.label(aspects = [a2])})"); scratch.file( "test/BUILD", "load(':aspect.bzl', 'r1', 'r2')", "r1(name = 'r0')", "alias(name = 'a0', actual = ':r0')", "r1(name = 'r1', dep = ':a0')", "r2(name = 'r2', dep = ':r1')"); AnalysisResult analysisResult = update("//test:r2"); ConfiguredTarget target = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); Sequence result = (Sequence) target.get("result"); // "yes" means that aspect a2 sees a1's providers. assertThat(result) .containsExactly( "@//test:r0[\"//test:aspect.bzl%a1\", \"//test:aspect.bzl%a2\"]=yes", "@//test:r1[\"//test:aspect.bzl%a2\"]=no"); } @Test public void aspectDescriptions() throws Exception { scratch.file( "test/aspect.bzl", "def _a_impl(target,ctx):", " s = str(target.label) + str(ctx.aspect_ids) + '='", " value = []", " if ctx.rule.attr.dep:", " d = ctx.rule.attr.dep", " this_id = ctx.aspect_ids[len(ctx.aspect_ids) - 1]", " s += str(d.label) + str(d.my_ids) + ',' + str(this_id in d.my_ids)", " value += ctx.rule.attr.dep.ap", " else:", " s += 'None'", " value.append(s)", " return struct(ap = value, my_ids = ctx.aspect_ids)", "a = aspect(_a_impl, attr_aspects = ['dep'])", "def _r_impl(ctx):", " if not ctx.attr.dep:", " return struct(result = [])", " return struct(result = ctx.attr.dep.ap)", "r = rule(_r_impl, attrs = { 'dep' : attr.label(aspects = [a])})"); scratch.file( "test/BUILD", "load(':aspect.bzl', 'r')", "r(name = 'r0')", "r(name = 'r1', dep = ':r0')", "r(name = 'r2', dep = ':r1')"); AnalysisResult analysisResult = update("//test:r2"); ConfiguredTarget target = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); Sequence result = (Sequence) target.get("result"); assertThat(result) .containsExactly( "@//test:r0[\"//test:aspect.bzl%a\"]=None", "@//test:r1[\"//test:aspect.bzl%a\"]=@//test:r0[\"//test:aspect.bzl%a\"],True"); } @Test public void attributesWithAspectsReused() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " return struct()", "my_aspect = aspect(_impl)", "a_dict = { 'foo' : attr.label_list(aspects = [my_aspect]) }"); scratch.file( "test/r1.bzl", "load(':aspect.bzl', 'my_aspect', 'a_dict')", "def _rule_impl(ctx):", " pass", "r1 = rule(_rule_impl, attrs = a_dict)"); scratch.file( "test/r2.bzl", "load(':aspect.bzl', 'my_aspect', 'a_dict')", "def _rule_impl(ctx):", " pass", "r2 = rule(_rule_impl, attrs = a_dict)"); scratch.file( "test/BUILD", "load(':r1.bzl', 'r1')", "load(':r2.bzl', 'r2')", "r1(name = 'x1')", "r2(name = 'x2', foo = [':x1'])"); AnalysisResult analysisResult = update("//test:x2"); assertThat(analysisResult.hasError()).isFalse(); } @Test public void aspectAdvertisingProviders() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " return struct()", "my_aspect = aspect(_impl, provides = ['foo'])", "a_dict = { 'foo' : attr.label_list(aspects = [my_aspect]) }"); scratch.file("test/BUILD", "java_library(name = 'xxx',)"); reporter.removeHandler(failFastHandler); try { AnalysisResult analysisResult = update(ImmutableList.of("//test:aspect.bzl%my_aspect"), "//test:xxx"); assertThat(keepGoing()).isTrue(); assertThat(analysisResult.hasError()).isTrue(); } catch (ViewCreationFailedException e) { // expect exception } assertContainsEvent( "Aspect '//test:aspect.bzl%my_aspect', applied to '//test:xxx', " + "does not provide advertised provider 'foo'"); } @Test public void aspectOnAspectInconsistentVisibility() throws Exception { scratch.file( "test/aspect.bzl", "a1p = provider()", "def _a1_impl(target,ctx):", " return struct(a1p = a1p(text = 'random'))", "a1 = aspect(_a1_impl, attr_aspects = ['dep'], provides = ['a1p'])", "a2p = provider()", "def _a2_impl(target,ctx):", " return struct(a2p = a2p(value = 'random'))", "a2 = aspect(_a2_impl, attr_aspects = ['dep'], required_aspect_providers = ['a1p'])", "def _r1_impl(ctx):", " pass", "def _r2_impl(ctx):", " return struct(result = ctx.attr.dep.a2p.value)", "r1 = rule(_r1_impl, attrs = { 'dep' : attr.label(aspects = [a1])})", "r2 = rule(_r2_impl, attrs = { 'dep' : attr.label(aspects = [a2])})"); scratch.file( "test/BUILD", "load(':aspect.bzl', 'r1', 'r2')", "r1(name = 'r0')", "r1(name = 'r1', dep = ':r0')", "r2(name = 'r2', dep = ':r1')", "r1(name = 'r1_1', dep = ':r2')", "r2(name = 'r2_1', dep = ':r1_1')"); reporter.removeHandler(failFastHandler); try { AnalysisResult analysisResult = update("//test:r2_1"); assertThat(analysisResult.hasError()).isTrue(); assertThat(keepGoing()).isTrue(); } catch (ViewCreationFailedException e) { // expected } assertContainsEvent( "ERROR /workspace/test/BUILD:3:3: Aspect //test:aspect.bzl%a2 is" + " applied twice, both before and after aspect //test:aspect.bzl%a1 " + "(when propagating to //test:r1)"); } @Test public void aspectOnAspectInconsistentVisibilityIndirect() throws Exception { scratch.file( "test/aspect.bzl", "a1p = provider()", "def _a1_impl(target,ctx):", " return struct(a1p = a1p(text = 'random'))", "a1 = aspect(_a1_impl, attr_aspects = ['dep'], provides = ['a1p'])", "a2p = provider()", "def _a2_impl(target,ctx):", " return struct(a2p = a2p(value = 'random'))", "a2 = aspect(_a2_impl, attr_aspects = ['dep'], required_aspect_providers = ['a1p'])", "def _r1_impl(ctx):", " pass", "def _r2_impl(ctx):", " return struct(result = ctx.attr.dep.a2p.value)", "r1 = rule(_r1_impl, attrs = { 'dep' : attr.label(aspects = [a1])})", "r2 = rule(_r2_impl, attrs = { 'dep' : attr.label(aspects = [a2])})", "def _r0_impl(ctx):", " pass", "r0 = rule(_r0_impl, attrs = { 'dep' : attr.label()})"); scratch.file( "test/BUILD", "load(':aspect.bzl', 'r0', 'r1', 'r2')", "r0(name = 'r0')", "r1(name = 'r1', dep = ':r0')", "r2(name = 'r2', dep = ':r1')", "r1(name = 'r1_1', dep = ':r2')", "r2(name = 'r2_1', dep = ':r1_1')", "r0(name = 'r0_2', dep = ':r2_1')"); reporter.removeHandler(failFastHandler); try { AnalysisResult analysisResult = update("//test:r0_2"); assertThat(analysisResult.hasError()).isTrue(); assertThat(keepGoing()).isTrue(); } catch (ViewCreationFailedException e) { // expected } assertContainsEvent( "ERROR /workspace/test/BUILD:3:3: Aspect //test:aspect.bzl%a2 is" + " applied twice, both before and after aspect //test:aspect.bzl%a1 " + "(when propagating to //test:r1)"); } /** * Aspect a3 sees aspect a2, aspect a2 sees aspect a1, but a3 does not see a1. All three aspects * should still propagate together. */ @Test public void aspectOnAspectOnAspect() throws Exception { scratch.file( "test/aspect.bzl", "p1 = provider()", "def _a1_impl(target, ctx):", " return [p1()]", "a1 = aspect(_a1_impl, attr_aspects = ['dep'], provides = [p1])", "p2 = provider()", "def _a2_impl(target, ctx):", " value = True if p1 in target else False", " return [p2(has_p1 = value)]", "a2 = aspect(_a2_impl, attr_aspects = ['dep'],", " required_aspect_providers = [p1], provides = [p2])", "p3 = provider()", "def _a3_impl(target, ctx):", " list = []", " if ctx.rule.attr.dep:", " list = ctx.rule.attr.dep[p3].value", " my_value = str(target.label) +'=' + str(target[p2].has_p1 if p2 in target else False)", " return [p3(value = list + [my_value])]", "a3 = aspect(_a3_impl, attr_aspects = ['dep'],", " required_aspect_providers = [p2])", "def _r0_impl(ctx):", " pass", "r0 = rule(_r0_impl, attrs = { 'dep' : attr.label()})", "def _r1_impl(ctx):", " pass", "def _r2_impl(ctx):", " pass", "r1 = rule(_r1_impl, attrs = { 'dep' : attr.label(aspects = [a1])})", "r2 = rule(_r2_impl, attrs = { 'dep' : attr.label(aspects = [a2])})"); scratch.file( "test/BUILD", "load(':aspect.bzl', 'r0', 'r1', 'r2')", "r0(name = 'r0_1')", "r0(name = 'r0_2', dep = ':r0_1')", "r0(name = 'r0_3', dep = ':r0_2')", "r1(name = 'r1_1', dep = ':r0_3')", "r2(name = 'r2_1', dep = ':r1_1')"); AnalysisResult analysisResult = update(ImmutableList.of("//test:aspect.bzl%a3"), "//test:r2_1"); ConfiguredAspect configuredAspect = Iterables.getOnlyElement(analysisResult.getAspectsMap().values()); StarlarkProvider.Key p3 = new StarlarkProvider.Key(Label.parseCanonical("//test:aspect.bzl"), "p3"); StructImpl p3Provider = (StructImpl) configuredAspect.get(p3); assertThat((Sequence) p3Provider.getValue("value")) .containsExactly( "@//test:r0_1=True", "@//test:r0_2=True", "@//test:r0_3=True", "@//test:r1_1=False", "@//test:r2_1=False"); } /** * r0 is a dependency of r1 via two attributes, dep1 and dep2. r1 sends an aspect 'a' along dep1 * but not along dep2. * *

rcollect depends upon r1 and sends another aspect, 'collector', along its dep dependency. * 'collector' wants to see aspect 'a' and propagates along dep1 and dep2. It should be applied * both to r0 and to r0+a. */ @Test public void multipleDepsDifferentAspects() throws Exception { scratch.file( "test/aspect.bzl", "PAspect = provider()", "PCollector = provider()", "def _aspect_impl(target, ctx):", " return [PAspect()]", "a = aspect(_aspect_impl, attr_aspects = ['dep'], provides = [PAspect])", "def _collector_impl(target, ctx):", " suffix = '+PAspect' if PAspect in target else ''", " result = [str(target.label)+suffix]", " for a in ['dep', 'dep1', 'dep2']:", " if hasattr(ctx.rule.attr, a):", " result += getattr(ctx.rule.attr, a)[PCollector].result", " return [PCollector(result=result)]", "collector = aspect(_collector_impl, attr_aspects = ['*'], ", " required_aspect_providers = [PAspect])", "def _rimpl(ctx):", " pass", "r0 = rule(_rimpl)", "r1 = rule(_rimpl, ", " attrs = {", " 'dep1' : attr.label(),", " 'dep2' : attr.label(aspects = [a]),", " },", ")", "def _rcollect_impl(ctx):", " return [ctx.attr.dep[PCollector]]", "rcollect = rule(_rcollect_impl,", " attrs = {", " 'dep' : attr.label(aspects = [collector]),", " })"); scratch.file( "test/BUILD", "load(':aspect.bzl', 'r0', 'r1', 'rcollect')", "r0(name = 'r0')", "r1(name = 'r1', dep1 = ':r0', dep2 = ':r0')", "rcollect(name = 'rcollect', dep = ':r1')"); AnalysisResult analysisResult = update(ImmutableList.of(), "//test:rcollect"); ConfiguredTarget configuredTarget = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); StarlarkProvider.Key pCollector = new StarlarkProvider.Key(Label.parseCanonical("//test:aspect.bzl"), "PCollector"); StructImpl pCollectorProvider = (StructImpl) configuredTarget.get(pCollector); assertThat((Sequence) pCollectorProvider.getValue("result")) .containsExactly("@//test:r1", "@//test:r0", "@//test:r0+PAspect"); } @Test public void aspectSeesOtherAspectAttributes() throws Exception { scratch.file( "test/aspect.bzl", "PAspect = provider(fields = [])", "PCollector = provider(fields = ['aspect_attr'])", "def _a_impl(target, ctx):", " return [PAspect()]", "a = aspect(_a_impl, ", " provides = [PAspect],", " attrs = {'_a_attr' : attr.label(default = '//test:foo')})", "def _rcollect(target, ctx):", " if hasattr(ctx.rule.attr, '_a_attr'):", " return [PCollector(aspect_attr = ctx.rule.attr._a_attr.label)]", " if hasattr(ctx.rule.attr, 'dep'):", " return [ctx.rule.attr.dep[PCollector]]", " return [PCollector()]", "acollect = aspect(_rcollect, attr_aspects = ['*'], required_aspect_providers = [PAspect])", "def _rimpl(ctx):", " pass", "r0 = rule(_rimpl)", "r = rule(_rimpl, attrs = { 'dep' : attr.label(aspects = [a]) })"); scratch.file( "test/BUILD", "load(':aspect.bzl', 'r0', 'r')", "r0(name = 'foo')", "r0(name = 'bar')", "r(name = 'baz', dep = ':bar')"); AnalysisResult analysisResult = update(ImmutableList.of("//test:aspect.bzl%acollect"), "//test:baz"); ConfiguredAspect configuredAspect = Iterables.getOnlyElement(analysisResult.getAspectsMap().values()); StarlarkProvider.Key pCollector = new StarlarkProvider.Key(Label.parseCanonical("//test:aspect.bzl"), "PCollector"); StructImpl collector = (StructImpl) configuredAspect.get(pCollector); assertThat(collector.getValue("aspect_attr")).isEqualTo(Label.parseCanonical("//test:foo")); } @Test public void ruleAttributesWinOverAspects() throws Exception { scratch.file( "test/aspect.bzl", "PAspect = provider(fields = [])", "PCollector = provider(fields = ['attr_value'])", "def _a_impl(target, ctx):", " return [PAspect()]", "a = aspect(_a_impl, ", " provides = [PAspect],", " attrs = {'_same_attr' : attr.int(default = 239)})", "def _rcollect(target, ctx):", " if hasattr(ctx.rule.attr, '_same_attr'):", " return [PCollector(attr_value = ctx.rule.attr._same_attr)]", " if hasattr(ctx.rule.attr, 'dep'):", " return [ctx.rule.attr.dep[PCollector]]", " return [PCollector()]", "acollect = aspect(_rcollect, attr_aspects = ['*'], required_aspect_providers = [PAspect])", "def _rimpl(ctx):", " pass", "r0 = rule(_rimpl)", "r = rule(_rimpl, ", " attrs = { ", " 'dep' : attr.label(aspects = [a]), ", " '_same_attr' : attr.int(default = 30)", " })"); scratch.file( "test/BUILD", "load(':aspect.bzl', 'r0', 'r')", "r0(name = 'foo')", "r0(name = 'bar')", "r(name = 'baz', dep = ':bar')"); AnalysisResult analysisResult = update(ImmutableList.of("//test:aspect.bzl%acollect"), "//test:baz"); ConfiguredAspect configuredAspect = Iterables.getOnlyElement(analysisResult.getAspectsMap().values()); StarlarkProvider.Key pCollector = new StarlarkProvider.Key(Label.parseCanonical("//test:aspect.bzl"), "PCollector"); StructImpl collector = (StructImpl) configuredAspect.get(pCollector); assertThat(collector.getValue("attr_value")).isEqualTo(StarlarkInt.of(30)); } @Test public void earlyAspectAttributesWin() throws Exception { scratch.file( "test/aspect.bzl", "PAspect1 = provider(fields = [])", "PAspect2 = provider(fields = [])", "PCollector = provider(fields = ['attr_value'])", "def _a1_impl(target, ctx):", " return [PAspect1()]", "def _a2_impl(target, ctx):", " return [PAspect2()]", "a1 = aspect(_a1_impl, ", " provides = [PAspect1],", " attrs = {'_same_attr' : attr.int(default = 30)})", "a2 = aspect(_a2_impl, ", " provides = [PAspect2],", " attrs = {'_same_attr' : attr.int(default = 239)})", "def _rcollect(target, ctx):", " if hasattr(ctx.rule.attr, 'dep'):", " return [ctx.rule.attr.dep[PCollector]]", " if hasattr(ctx.rule.attr, '_same_attr'):", " return [PCollector(attr_value = ctx.rule.attr._same_attr)]", " fail('???')", " return [PCollector()]", "acollect = aspect(_rcollect, attr_aspects = ['*'], ", " required_aspect_providers = [[PAspect1], [PAspect2]])", "def _rimpl(ctx):", " pass", "r0 = rule(_rimpl)", "r1 = rule(_rimpl, ", " attrs = { ", " 'dep' : attr.label(aspects = [a1]), ", " })", "r2 = rule(_rimpl, ", " attrs = { ", " 'dep' : attr.label(aspects = [a2]), ", " })"); scratch.file( "test/BUILD", "load(':aspect.bzl', 'r0', 'r1', 'r2')", "r0(name = 'bar')", "r1(name = 'baz', dep = ':bar')", "r2(name = 'quux', dep = ':baz')"); AnalysisResult analysisResult = update(ImmutableList.of("//test:aspect.bzl%acollect"), "//test:quux"); ConfiguredAspect configuredAspect = Iterables.getOnlyElement(analysisResult.getAspectsMap().values()); StarlarkProvider.Key pCollector = new StarlarkProvider.Key(Label.parseCanonical("//test:aspect.bzl"), "PCollector"); StructImpl collector = (StructImpl) configuredAspect.get(pCollector); assertThat(collector.getValue("attr_value")).isEqualTo(StarlarkInt.of(30)); } @Test public void aspectPropagatesOverOtherAspectAttributes() throws Exception { scratch.file( "test/aspect.bzl", "PAspect = provider(fields = [])", "PCollector = provider(fields = ['visited'])", "def _a_impl(target, ctx):", " return [PAspect()]", "a = aspect(_a_impl, ", " provides = [PAspect],", " attrs = {'_a_attr' : attr.label(default = '//test:referenced_from_aspect_only')})", "def _rcollect(target, ctx):", " transitive = []", " if hasattr(ctx.rule.attr, 'dep') and ctx.rule.attr.dep:", " transitive += [ctx.rule.attr.dep[PCollector].visited]", " if hasattr(ctx.rule.attr, '_a_attr') and ctx.rule.attr._a_attr:", " transitive += [ctx.rule.attr._a_attr[PCollector].visited] ", " visited = depset([target.label], transitive = transitive, )", " return [PCollector(visited = visited)]", "acollect = aspect(_rcollect, attr_aspects = ['*'], required_aspect_providers = [PAspect])", "def _rimpl(ctx):", " pass", "r0 = rule(_rimpl)", "r = rule(_rimpl, attrs = { 'dep' : attr.label(aspects = [a]) })"); scratch.file( "test/BUILD", "load(':aspect.bzl', 'r0', 'r')", "r0(name = 'referenced_from_aspect_only')", "r0(name = 'bar')", "r(name = 'baz', dep = ':bar')"); AnalysisResult analysisResult = update(ImmutableList.of("//test:aspect.bzl%acollect"), "//test:baz"); ConfiguredAspect configuredAspect = Iterables.getOnlyElement(analysisResult.getAspectsMap().values()); StarlarkProvider.Key pCollector = new StarlarkProvider.Key(Label.parseCanonical("//test:aspect.bzl"), "PCollector"); StructImpl collector = (StructImpl) configuredAspect.get(pCollector); assertThat(((Depset) collector.getValue("visited")).toList()) .containsExactly( Label.parseCanonical("//test:referenced_from_aspect_only"), Label.parseCanonical("//test:bar"), Label.parseCanonical("//test:baz")); } @Test public void testAspectActionProvider() throws Exception { scratch.file( "test/aspect.bzl", "a1p = provider()", "def _a1_impl(target,ctx):", " ctx.actions.run_shell(", " outputs = [ctx.actions.declare_file('a1')],", " command = 'touch $@'", " )", " return struct(a1p=a1p())", "a1 = aspect(_a1_impl, attr_aspects = ['dep'], provides = ['a1p'])", "a2p = provider()", "def _a2_impl(target, ctx):", " value = []", " if hasattr(ctx.rule.attr, 'dep') and hasattr(ctx.rule.attr.dep, 'a2p'):", " value += ctx.rule.attr.dep.a2p.value", " value += target.actions", " return struct(a2p = a2p(value = value))", "a2 = aspect(_a2_impl, attr_aspects = ['dep'], required_aspect_providers = ['a1p'])", "def _r0_impl(ctx):", " ctx.actions.run_shell(", " outputs = [ctx.actions.declare_file('r0')],", " command = 'touch $@'", " )", "def _r1_impl(ctx):", " pass", "def _r2_impl(ctx):", " return struct(result = ctx.attr.dep.a2p.value)", "r0 = rule(_r0_impl)", "r1 = rule(_r1_impl, attrs = { 'dep' : attr.label(aspects = [a1])})", "r2 = rule(_r2_impl, attrs = { 'dep' : attr.label(aspects = [a2])})"); scratch.file( "test/BUILD", "load(':aspect.bzl', 'r0', 'r1', 'r2')", "r0(name = 'r0')", "r1(name = 'r1', dep = ':r0')", "r2(name = 'r2', dep = ':r1')"); AnalysisResult analysisResult = update("//test:r2"); ConfiguredTarget target = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); Sequence result = (Sequence) target.get("result"); // We should see both the action from the 'r0' rule, and the action from the 'a1' aspect assertThat(result).hasSize(2); assertThat( result.stream() .map(a -> ((Action) a).getPrimaryOutput().getExecPath().getBaseName()) .collect(toList())) .containsExactly("r0", "a1"); } @Test public void testRuleAndAspectAttrConflict() throws Exception { scratch.file( "test/aspect.bzl", "MyInfo = provider()", "def _impl(target, ctx):", " return [MyInfo(hidden_attr_label = str(ctx.attr._hiddenattr.label))]", "", "def _rule_impl(ctx):", " return []", "", "my_rule = rule(implementation = _rule_impl,", " attrs = { '_hiddenattr' : attr.label(default = Label('//test:xxx')) },", ")", "MyAspect = aspect(", " implementation=_impl,", " attrs = { '_hiddenattr' : attr.label(default = Label('//test:zzz')) },", ")"); scratch.file( "test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "cc_library(", " name = 'xxx',", ")", "my_rule(", " name = 'yyy',", ")", "cc_library(", " name = 'zzz',", ")"); AnalysisResult analysisResult = update(ImmutableList.of("test/aspect.bzl%MyAspect"), "//test:yyy"); ConfiguredAspect configuredAspect = analysisResult.getAspectsMap().values().iterator().next(); assertThat(configuredAspect).isNotNull(); StarlarkProvider.Key myInfoKey = new StarlarkProvider.Key(Label.parseCanonical("//test:aspect.bzl"), "MyInfo"); StructImpl myInfo = (StructImpl) configuredAspect.get(myInfoKey); assertThat(myInfo.getValue("hidden_attr_label")).isEqualTo("@//test:zzz"); } /** Simple straightforward linear aspects-on-aspects. */ @Test public void aspectOnAspectAttrConflict() throws Exception { scratch.file( "test/aspect.bzl", "MyInfo = provider()", "a1p = provider()", "def _a1_impl(target,ctx):", " return struct(a1p = a1p(text = 'random'))", "a1 = aspect(_a1_impl,", " attrs = { '_hiddenattr' : attr.label(default = Label('//test:xxx')) },", " attr_aspects = ['dep'], provides = ['a1p'])", "a2p = provider()", "def _a2_impl(target,ctx):", " return [MyInfo(hidden_attr_label = str(ctx.attr._hiddenattr.label))]", "a2 = aspect(_a2_impl,", " attrs = { '_hiddenattr' : attr.label(default = Label('//test:zzz')) },", " attr_aspects = ['dep'], required_aspect_providers = ['a1p'])", "def _r1_impl(ctx):", " pass", "def _r2_impl(ctx):", " return struct(result = ctx.attr.dep[MyInfo].hidden_attr_label)", "r1 = rule(_r1_impl, attrs = { 'dep' : attr.label(aspects = [a1])})", "r2 = rule(_r2_impl, attrs = { 'dep' : attr.label(aspects = [a2])})"); scratch.file( "test/BUILD", "load(':aspect.bzl', 'r1', 'r2')", "r1(name = 'r0')", "r1(name = 'r1', dep = ':r0')", "r2(name = 'r2', dep = ':r1')", "cc_library(", " name = 'xxx',", ")", "cc_library(", " name = 'zzz',", ")"); AnalysisResult analysisResult = update("//test:r2"); ConfiguredTarget target = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); String result = (String) target.get("result"); assertThat(result).isEqualTo("@//test:zzz"); } @Test public void testAllCcLibraryAttrsAreValidTypes() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " for entry in dir(ctx.rule.attr):", " val = getattr(ctx.rule.attr, entry, None)", " # Only legitimate Starlark values can be passed to dir(), so this effectively", " # verifies val is an appropriate Starlark type.", " _test_dir = dir(val)", " return []", "", "MyAspect = aspect(", " implementation=_impl,", ")"); scratch.file("test/BUILD", "cc_library(", " name = 'xxx',", ")"); AnalysisResult analysisResult = update(ImmutableList.of("test/aspect.bzl%MyAspect"), "//test:xxx"); assertThat(analysisResult.getAspectsMap().values().iterator().next()).isNotNull(); } @Test public void testApplyToGeneratingRules() throws Exception { // Create test rules: // dep_rule: a rule which may depend on other dep_rule targets and may optionally create // an output file. // root_{with,no}_files: a rule which depends on dep_rule targets and attaches an aspect. // The rule returns a RootInfo provider which contains two fields: // 'from_aspect' : a list of all labels that the aspect propagated to // 'non_aspect' : a list of all labels that information was obtained from without aspect // root_with_files uses an aspect with apply_to_generating_rules=True, and root_no_files // uses an aspect with apply_to_generating_rules=False. scratch.file( "test/lib.bzl", "RootInfo = provider()", "NonAspectInfo = provider()", "FromAspectInfo = provider()", "def _aspect_impl(target, ctx):", " dep_labels = []", " for dep in ctx.rule.attr.deps:", " if FromAspectInfo in dep:", " dep_labels += [dep[FromAspectInfo].labels]", " return FromAspectInfo(labels = depset(direct = [ctx.label], transitive = dep_labels))", "", "def _rule_impl(ctx):", " non_aspect = []", " from_aspect = []", " for dep in ctx.attr.deps:", " if NonAspectInfo in dep:", " non_aspect += dep[NonAspectInfo].labels.to_list()", " if FromAspectInfo in dep:", " from_aspect += dep[FromAspectInfo].labels.to_list()", " return RootInfo(from_aspect = from_aspect, non_aspect = non_aspect)", "", "def _dep_rule_impl(ctx):", " if ctx.outputs.output:", " ctx.actions.run_shell(outputs = [ctx.outputs.output], command = 'dont run me')", " dep_labels = []", " for dep in ctx.attr.deps:", " if NonAspectInfo in dep:", " dep_labels += [dep[NonAspectInfo].labels]", " return NonAspectInfo(labels = depset(direct = [ctx.label], transitive = dep_labels))", "", "aspect_with_files = aspect(", " implementation = _aspect_impl,", " attr_aspects = ['deps'],", " apply_to_generating_rules = True)", "", "aspect_no_files = aspect(", " implementation = _aspect_impl,", " attr_aspects = ['deps'],", " apply_to_generating_rules = False)", "", "root_with_files = rule(implementation = _rule_impl,", " attrs = {'deps' : attr.label_list(aspects = [aspect_with_files])})", "", "root_no_files = rule(implementation = _rule_impl,", " attrs = {'deps' : attr.label_list(aspects = [aspect_no_files])})", "", "dep_rule = rule(implementation = _dep_rule_impl,", " attrs = {'deps' : attr.label_list(allow_files = True), 'output' : attr.output()})"); // Create a target graph such that two graph roots each point to a common subgraph // alpha -> beta_output -> charlie, where beta_output is a generated output file of target // 'beta'. scratch.file( "test/BUILD", "load('//test:lib.bzl', 'root_with_files', 'root_no_files', 'dep_rule')", "", "root_with_files(name = 'test_with_files', deps = [':alpha'])", "root_no_files(name = 'test_no_files', deps = [':alpha'])", "dep_rule(name = 'alpha', deps = [':beta_output'])", "dep_rule(name = 'beta', deps = [':charlie'], output = 'beta_output')", "dep_rule(name = 'charlie')"); StarlarkProvider.Key rootInfoKey = new StarlarkProvider.Key(Label.parseCanonical("//test:lib.bzl"), "RootInfo"); AnalysisResult analysisResultWithFiles = update("//test:test_with_files"); ConfiguredTarget targetWithFiles = Iterables.getOnlyElement(analysisResultWithFiles.getTargetsToBuild()); StructImpl rootInfoWithFiles = (StructImpl) targetWithFiles.get(rootInfoKey); // With apply_to_generating_rules=True, the aspect should have traversed :beta_output and // applied to both :beta and :charlie. assertThat(rootInfoWithFiles.getValue("from_aspect", Sequence.class)) .containsExactly( Label.parseCanonical("//test:charlie"), Label.parseCanonical("//test:beta"), Label.parseCanonical("//test:alpha")); assertThat(rootInfoWithFiles.getValue("non_aspect", Sequence.class)) .containsExactly(Label.parseCanonical("//test:alpha")); AnalysisResult analysisResultNoFiles = update("//test:test_no_files"); ConfiguredTarget targetNoFiles = Iterables.getOnlyElement(analysisResultNoFiles.getTargetsToBuild()); StructImpl rootInfoNoFiles = (StructImpl) targetNoFiles.get(rootInfoKey); // With apply_to_generating_rules=False, the aspect should have only accessed :alpha, as it // must have stopped before :beta_output. assertThat(rootInfoNoFiles.getValue("from_aspect", Sequence.class)) .containsExactly(Label.parseCanonical("//test:alpha")); assertThat(rootInfoWithFiles.getValue("non_aspect", Sequence.class)) .containsExactly(Label.parseCanonical("//test:alpha")); } private void setupAspectOnAspectTargetGraph( boolean applyRootToGeneratingRules, boolean applyDepToGeneratingRules) throws Exception { // RootAspectInfo.both_labels returns a list of target labels which // were evaluated as [root_aspect(dep_aspect(target))]. // RootAspectInfo.root_only_labels returns a list of target labels which // were evaluated as [root_aspect(target)]. // DepAspectInfo.labels returns a list of target labels which were evaluated by dep_aspect. scratch.file( "test/lib.bzl", "RootAspectInfo = provider()", "DepAspectInfo = provider()", "def _root_aspect_impl(target, ctx):", " both_labels = []", " root_only_labels = []", " for dep in ctx.rule.attr.deps:", " if RootAspectInfo in dep:", " both_labels += dep[RootAspectInfo].both_labels", " root_only_labels += dep[RootAspectInfo].root_only_labels", " if DepAspectInfo in dep:", " both_labels += [dep.label]", " else:", " root_only_labels += [dep.label]", " return RootAspectInfo(both_labels = both_labels, root_only_labels = root_only_labels)", "", "def _dep_aspect_impl(target, ctx):", " dep_labels = [ctx.label]", " for dep in ctx.rule.attr.deps:", " if DepAspectInfo in dep:", " dep_labels += dep[DepAspectInfo].labels", " return DepAspectInfo(labels = dep_labels)", "", "def _root_rule_impl(ctx):", " return [ctx.attr.deps[0][RootAspectInfo], ctx.attr.deps[0][DepAspectInfo]]", "", "def _dep_with_aspect_rule_impl(ctx):", " return [ctx.attr.deps[0][DepAspectInfo]]", "", "def _dep_rule_impl(ctx):", " if ctx.outputs.output:", " ctx.actions.run_shell(outputs = [ctx.outputs.output], command = 'dont run me')", " return []", "", "root_aspect = aspect(", " implementation = _root_aspect_impl,", " attr_aspects = ['deps'],", " required_aspect_providers = [DepAspectInfo],", " apply_to_generating_rules = " + (applyRootToGeneratingRules ? "True" : "False") + ")", "", "dep_aspect = aspect(", " implementation = _dep_aspect_impl,", " attr_aspects = ['deps'],", " provides = [DepAspectInfo],", " apply_to_generating_rules = " + (applyDepToGeneratingRules ? "True" : "False") + ")", "", "root_rule = rule(implementation = _root_rule_impl,", " attrs = {'deps' : attr.label_list(aspects = [root_aspect])})", "", "dep_with_aspect_rule = rule(implementation = _dep_with_aspect_rule_impl,", " attrs = {'deps' : attr.label_list(aspects = [dep_aspect])})", "", "dep_rule = rule(implementation = _dep_rule_impl,", " attrs = {'deps' : attr.label_list(allow_files = True), 'output' : attr.output()})"); // Target graph: test -> aspect_propagating_target -> alpha -> beta_output // beta_output is an output of target `beta` // beta -> charlie scratch.file( "test/BUILD", "load('//test:lib.bzl', 'root_rule', 'dep_with_aspect_rule', 'dep_rule')", "", "root_rule(name = 'test', deps = [':aspect_propagating_target'])", "dep_with_aspect_rule(name = 'aspect_propagating_target', deps = [':alpha'])", "dep_rule(name = 'alpha', deps = [':beta_output'])", "dep_rule(name = 'beta', deps = [':charlie'], output = 'beta_output')", "dep_rule(name = 'charlie')"); } @Test public void testAspectOnAspectApplyToGeneratingRules_bothPropagate() throws Exception { setupAspectOnAspectTargetGraph( /* applyRootToGeneratingRules= */ true, /* applyDepToGeneratingRules= */ true); StarlarkProvider.Key rootInfoKey = new StarlarkProvider.Key(Label.parseCanonical("//test:lib.bzl"), "RootAspectInfo"); StarlarkProvider.Key depInfoKey = new StarlarkProvider.Key(Label.parseCanonical("//test:lib.bzl"), "DepAspectInfo"); AnalysisResult analysisResult = update("//test:test"); ConfiguredTarget target = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); StructImpl rootInfo = (StructImpl) target.get(rootInfoKey); StructImpl depInfo = (StructImpl) target.get(depInfoKey); assertThat(rootInfo.getValue("both_labels", Sequence.class)) .containsExactly( Label.parseCanonical("//test:alpha"), Label.parseCanonical("//test:beta_output"), Label.parseCanonical("//test:charlie")); assertThat(rootInfo.getValue("root_only_labels", Sequence.class)).isEmpty(); assertThat(depInfo.getValue("labels", Sequence.class)) .containsExactly( Label.parseCanonical("//test:alpha"), Label.parseCanonical("//test:beta"), Label.parseCanonical("//test:charlie")); } @Test public void testAspectOnAspectApplyToGeneratingRules_neitherPropagate() throws Exception { setupAspectOnAspectTargetGraph( /* applyRootToGeneratingRules= */ false, /* applyDepToGeneratingRules= */ false); StarlarkProvider.Key rootInfoKey = new StarlarkProvider.Key(Label.parseCanonical("//test:lib.bzl"), "RootAspectInfo"); StarlarkProvider.Key depInfoKey = new StarlarkProvider.Key(Label.parseCanonical("//test:lib.bzl"), "DepAspectInfo"); AnalysisResult analysisResult = update("//test:test"); ConfiguredTarget target = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); StructImpl rootInfo = (StructImpl) target.get(rootInfoKey); StructImpl depInfo = (StructImpl) target.get(depInfoKey); assertThat(rootInfo.getValue("both_labels", Sequence.class)) .containsExactly(Label.parseCanonical("//test:alpha")); assertThat(rootInfo.getValue("root_only_labels", Sequence.class)).isEmpty(); assertThat(depInfo.getValue("labels", Sequence.class)) .containsExactly(Label.parseCanonical("//test:alpha")); } @Test public void testAspectOnAspectApplyToGeneratingRules_rootOnly() throws Exception { setupAspectOnAspectTargetGraph( /* applyRootToGeneratingRules= */ true, /* applyDepToGeneratingRules= */ false); StarlarkProvider.Key rootInfoKey = new StarlarkProvider.Key(Label.parseCanonical("//test:lib.bzl"), "RootAspectInfo"); StarlarkProvider.Key depInfoKey = new StarlarkProvider.Key(Label.parseCanonical("//test:lib.bzl"), "DepAspectInfo"); AnalysisResult analysisResult = update("//test:test"); ConfiguredTarget target = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); StructImpl rootInfo = (StructImpl) target.get(rootInfoKey); StructImpl depInfo = (StructImpl) target.get(depInfoKey); assertThat(rootInfo.getValue("both_labels", Sequence.class)) .containsExactly(Label.parseCanonical("//test:alpha")); assertThat(rootInfo.getValue("root_only_labels", Sequence.class)) .containsExactly( Label.parseCanonical("//test:beta_output"), Label.parseCanonical("//test:charlie")); assertThat(depInfo.getValue("labels", Sequence.class)) .containsExactly(Label.parseCanonical("//test:alpha")); } @Test public void testAspectOnAspectApplyToGeneratingRules_depOnly() throws Exception { setupAspectOnAspectTargetGraph( /* applyRootToGeneratingRules= */ false, /* applyDepToGeneratingRules= */ true); StarlarkProvider.Key rootInfoKey = new StarlarkProvider.Key(Label.parseCanonical("//test:lib.bzl"), "RootAspectInfo"); StarlarkProvider.Key depInfoKey = new StarlarkProvider.Key(Label.parseCanonical("//test:lib.bzl"), "DepAspectInfo"); AnalysisResult analysisResult = update("//test:test"); ConfiguredTarget target = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); StructImpl rootInfo = (StructImpl) target.get(rootInfoKey); StructImpl depInfo = (StructImpl) target.get(depInfoKey); assertThat(rootInfo.getValue("both_labels", Sequence.class)) .containsExactly(Label.parseCanonical("//test:alpha")); assertThat(rootInfo.getValue("root_only_labels", Sequence.class)).isEmpty(); assertThat(depInfo.getValue("labels", Sequence.class)) .containsExactly( Label.parseCanonical("//test:alpha"), Label.parseCanonical("//test:beta"), Label.parseCanonical("//test:charlie")); } @Test public void testAspectActionsDontInheritExecProperties() throws Exception { scratch.file( "test/BUILD", "load('//test:defs.bzl', 'my_rule')", "my_rule(", " name = 'my_target',", " deps = [':my_dep'],", ")", "cc_binary(", " name = 'my_dep',", " srcs = ['dep.cc'],", " exec_properties = {'mem': '16g'},", ")"); scratch.file( "test/defs.bzl", "def _aspect_impl(target, ctx):", " f = ctx.actions.declare_file('f.txt')", " ctx.actions.write(f, 'f')", " return []", "my_aspect = aspect(", " implementation = _aspect_impl,", " attr_aspects = ['deps'],", ")", "def _rule_impl(ctx):", " pass", "my_rule = rule(", " implementation = _rule_impl,", " attrs = {", " 'deps': attr.label_list(aspects = [my_aspect])", " },", ")"); scratch.file("test/dep.cc", "int main() {return 0;}"); AnalysisResult analysisResult = update(ImmutableList.of("test/defs.bzl%my_aspect"), "//test:my_target"); assertThat(analysisResult).isNotNull(); ActionOwner owner = Iterables.getOnlyElement( Iterables.getOnlyElement(analysisResult.getAspectsMap().values()).getActions()) .getOwner(); assertThat(owner.getExecProperties()).isEmpty(); } @Test public void testAspectRequiredProviders_defaultNoRequiredProviders() throws Exception { scratch.file( "test/defs.bzl", "prov_a = provider()", "prov_b = provider()", "", "def _my_aspect_impl(target, ctx):", " targets_labels = [\"//test:defs.bzl%my_aspect({})\".format(target.label)]", " for dep in ctx.rule.attr.deps:", " if hasattr(dep, 'target_labels'):", " targets_labels.extend(dep.target_labels)", " return struct(target_labels = targets_labels)", "", "my_aspect = aspect(", " implementation = _my_aspect_impl,", " attr_aspects = ['deps'],", ")", "", "def _rule_without_providers_impl(ctx):", " s = []", " for dep in ctx.attr.deps:", " if hasattr(dep, 'target_labels'):", " s.extend(dep.target_labels)", " return struct(rule_deps = s)", "", "rule_without_providers = rule(", " implementation = _rule_without_providers_impl,", " attrs = {", " 'deps': attr.label_list(aspects = [my_aspect])", " },", ")", "", "def _rule_with_providers_impl(ctx):", " return [prov_a(), prov_b()]", "", "rule_with_providers = rule(", " implementation = _rule_with_providers_impl,", " attrs = {", " 'deps': attr.label_list()", " },", " provides = [prov_a, prov_b]", ")", "", "rule_with_providers_not_advertised = rule(", " implementation = _rule_with_providers_impl,", " attrs = {", " 'deps': attr.label_list()", " },", " provides = []", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'rule_with_providers', 'rule_without_providers',", " 'rule_with_providers_not_advertised')", "rule_without_providers(", " name = 'main',", " deps = [':target_without_providers', ':target_with_providers',", " ':target_with_providers_not_advertised'],", ")", "rule_without_providers(", " name = 'target_without_providers',", ")", "rule_with_providers(", " name = 'target_with_providers',", ")", "rule_with_providers(", " name = 'target_with_providers_indeps',", ")", "rule_with_providers_not_advertised(", " name = 'target_with_providers_not_advertised',", " deps = [':target_with_providers_indeps'],", ")"); AnalysisResult analysisResult = update("//test:main"); // my_aspect does not require any providers so it will be applied to all the dependencies of // main target List expected = new ArrayList<>(); expected.add("//test:defs.bzl%my_aspect(@//test:target_without_providers)"); expected.add("//test:defs.bzl%my_aspect(@//test:target_with_providers)"); expected.add("//test:defs.bzl%my_aspect(@//test:target_with_providers_not_advertised)"); expected.add("//test:defs.bzl%my_aspect(@//test:target_with_providers_indeps)"); assertThat(getLabelsToBuild(analysisResult)).containsExactly("//test:main"); ConfiguredTarget target = analysisResult.getTargetsToBuild().iterator().next(); Object ruleDepsUnchecked = target.get("rule_deps"); assertThat(ruleDepsUnchecked).isInstanceOf(StarlarkList.class); StarlarkList ruleDeps = (StarlarkList) ruleDepsUnchecked; assertThat(Starlark.toIterable(ruleDeps)).containsExactlyElementsIn(expected); } @Test public void testAspectRequiredProviders_flatSetOfRequiredProviders() throws Exception { scratch.file( "test/defs.bzl", "prov_a = provider()", "prov_b = provider()", "", "def _my_aspect_impl(target, ctx):", " targets_labels = [\"//test:defs.bzl%my_aspect({})\".format(target.label)]", " for dep in ctx.rule.attr.deps:", " if hasattr(dep, 'target_labels'):", " targets_labels.extend(dep.target_labels)", " return struct(target_labels = targets_labels)", "", "my_aspect = aspect(", " implementation = _my_aspect_impl,", " attr_aspects = ['deps'],", " required_providers = [prov_a, prov_b],", ")", "", "def _rule_without_providers_impl(ctx):", " s = []", " for dep in ctx.attr.deps:", " if hasattr(dep, 'target_labels'):", " s.extend(dep.target_labels)", " return struct(rule_deps = s)", "", "rule_without_providers = rule(", " implementation = _rule_without_providers_impl,", " attrs = {", " 'deps': attr.label_list(aspects=[my_aspect])", " },", " provides = []", ")", "", "def _rule_with_a_impl(ctx):", " return [prov_a()]", "", "rule_with_a = rule(", " implementation = _rule_with_a_impl,", " attrs = {", " 'deps': attr.label_list()", " },", " provides = [prov_a]", ")", "", "def _rule_with_ab_impl(ctx):", " return [prov_a(), prov_b()]", "", "rule_with_ab = rule(", " implementation = _rule_with_ab_impl,", " attrs = {", " 'deps': attr.label_list()", " },", " provides = [prov_a, prov_b]", ")", "", "rule_with_ab_not_advertised = rule(", " implementation = _rule_with_ab_impl,", " attrs = {", " 'deps': attr.label_list()", " },", " provides = []", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'rule_without_providers', 'rule_with_a', 'rule_with_ab',", " 'rule_with_ab_not_advertised')", "rule_without_providers(", " name = 'main',", " deps = [':target_without_providers', ':target_with_a', ':target_with_ab',", " ':target_with_ab_not_advertised'],", ")", "rule_without_providers(", " name = 'target_without_providers',", ")", "rule_with_a(", " name = 'target_with_a',", " deps = [':target_with_ab_indeps_not_reached']", ")", "rule_with_ab(", " name = 'target_with_ab',", " deps = [':target_with_ab_indeps_reached']", ")", "rule_with_ab(", " name = 'target_with_ab_indeps_not_reached',", ")", "rule_with_ab(", " name = 'target_with_ab_indeps_reached',", ")", "rule_with_ab_not_advertised(", " name = 'target_with_ab_not_advertised',", ")"); AnalysisResult analysisResult = update("//test:main"); // my_aspect will only be applied on target_with_ab and target_with_ab_indeps_reached since // their rule (rule_with_ab) is the only rule that advertises the aspect required providers. // However, my_aspect cannot be propagated to target_with_ab_indeps_not_reached because it was // not applied to its parent (target_with_a) List expected = new ArrayList<>(); expected.add("//test:defs.bzl%my_aspect(@//test:target_with_ab)"); expected.add("//test:defs.bzl%my_aspect(@//test:target_with_ab_indeps_reached)"); assertThat(getLabelsToBuild(analysisResult)).containsExactly("//test:main"); ConfiguredTarget target = analysisResult.getTargetsToBuild().iterator().next(); Object ruleDepsUnchecked = target.get("rule_deps"); assertThat(ruleDepsUnchecked).isInstanceOf(StarlarkList.class); StarlarkList ruleDeps = (StarlarkList) ruleDepsUnchecked; assertThat(Starlark.toIterable(ruleDeps)).containsExactlyElementsIn(expected); } @Test public void testAspectRequiredProviders_listOfRequiredProvidersLists() throws Exception { scratch.file( "test/defs.bzl", "prov_a = provider()", "prov_b = provider()", "prov_c = provider()", "", "def _my_aspect_impl(target, ctx):", " targets_labels = [\"//test:defs.bzl%my_aspect({})\".format(target.label)]", " for dep in ctx.rule.attr.deps:", " if hasattr(dep, 'target_labels'):", " targets_labels.extend(dep.target_labels)", " return struct(target_labels = targets_labels)", "", "my_aspect = aspect(", " implementation = _my_aspect_impl,", " attr_aspects = ['deps'],", " required_providers = [[prov_a, prov_b], [prov_c]],", ")", "", "def _rule_without_providers_impl(ctx):", " s = []", " for dep in ctx.attr.deps:", " if hasattr(dep, 'target_labels'):", " s.extend(dep.target_labels)", " return struct(rule_deps = s)", "", "rule_without_providers = rule(", " implementation = _rule_without_providers_impl,", " attrs = {", " 'deps': attr.label_list(aspects=[my_aspect])", " },", " provides = []", ")", "", "def _rule_with_a_impl(ctx):", " return [prov_a()]", "", "rule_with_a = rule(", " implementation = _rule_with_a_impl,", " attrs = {", " 'deps': attr.label_list()", " },", " provides = [prov_a]", ")", "", "def _rule_with_c_impl(ctx):", " return [prov_c()]", "", "rule_with_c = rule(", " implementation = _rule_with_c_impl,", " attrs = {", " 'deps': attr.label_list()", " },", " provides = [prov_c]", ")", "", "def _rule_with_ab_impl(ctx):", " return [prov_a(), prov_b()]", "", "rule_with_ab = rule(", " implementation = _rule_with_ab_impl,", " attrs = {", " 'deps': attr.label_list()", " },", " provides = [prov_a, prov_b]", ")", "", "rule_with_ab_not_advertised = rule(", " implementation = _rule_with_ab_impl,", " attrs = {", " 'deps': attr.label_list()", " },", " provides = []", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'rule_without_providers', 'rule_with_a', 'rule_with_c',", " 'rule_with_ab', 'rule_with_ab_not_advertised')", "rule_without_providers(", " name = 'main',", " deps = [':target_without_providers', ':target_with_a', ':target_with_c',", " ':target_with_ab', 'target_with_ab_not_advertised'],", ")", "rule_without_providers(", " name = 'target_without_providers',", ")", "rule_with_a(", " name = 'target_with_a',", " deps = [':target_with_c_indeps_not_reached'],", ")", "rule_with_c(", " name = 'target_with_c',", ")", "rule_with_c(", " name = 'target_with_c_indeps_reached',", ")", "rule_with_c(", " name = 'target_with_c_indeps_not_reached',", ")", "rule_with_ab(", " name = 'target_with_ab',", " deps = [':target_with_c_indeps_reached'],", ")", "rule_with_ab_not_advertised(", " name = 'target_with_ab_not_advertised',", ")"); AnalysisResult analysisResult = update("//test:main"); // my_aspect will only be applied on target_with_ab, target_wtih_c and // target_with_c_indeps_reached because their rules (rule_with_ab and rule_with_c) are the only // rules advertising the aspect required providers // However, my_aspect cannot be propagated to target_with_c_indeps_not_reached because it was // not applied to its parent (target_with_a) List expected = new ArrayList<>(); expected.add("//test:defs.bzl%my_aspect(@//test:target_with_ab)"); expected.add("//test:defs.bzl%my_aspect(@//test:target_with_c)"); expected.add("//test:defs.bzl%my_aspect(@//test:target_with_c_indeps_reached)"); assertThat(getLabelsToBuild(analysisResult)).containsExactly("//test:main"); ConfiguredTarget target = analysisResult.getTargetsToBuild().iterator().next(); Object ruleDepsUnchecked = target.get("rule_deps"); assertThat(ruleDepsUnchecked).isInstanceOf(StarlarkList.class); StarlarkList ruleDeps = (StarlarkList) ruleDepsUnchecked; assertThat(Starlark.toIterable(ruleDeps)).containsExactlyElementsIn(expected); } @Test public void testAspectRequiredByMultipleAspects_inheritsAttrAspects() throws Exception { scratch.file( "test/defs.bzl", "prov_a = provider()", "prov_b = provider()", "prov_c = provider()", "", "def _aspect_c_impl(target, ctx):", " res = ['aspect_c runs on target {}'.format(target.label)]", " return [prov_c(val = res)]", "aspect_c = aspect(", " implementation = _aspect_c_impl,", ")", "", "def _aspect_b_impl(target, ctx):", " res = []", " res += target[prov_c].val", " res += ['aspect_b runs on target {}'.format(target.label)]", " if ctx.rule.attr.dep_b:", " res += ctx.rule.attr.dep_b[prov_b].val", " return [prov_b(val = res)]", "aspect_b = aspect(", " implementation = _aspect_b_impl,", " attr_aspects = ['dep_b'],", " requires = [aspect_c],", ")", "", "def _aspect_a_impl(target, ctx):", " res = []", " res += target[prov_c].val", " res += ['aspect_a runs on target {}'.format(target.label)]", " if ctx.rule.attr.dep_a:", " res += ctx.rule.attr.dep_a[prov_a].val", " return [prov_a(val = res)]", "aspect_a = aspect(", " implementation = _aspect_a_impl,", " attr_aspects = ['dep_a'],", " requires = [aspect_c],", ")", "", "def _my_rule_impl(ctx):", " pass", "", "my_rule = rule(", " implementation = _my_rule_impl,", " attrs = {", " 'dep_a': attr.label(),", " 'dep_b': attr.label(),", " },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'my_rule')", "my_rule(", " name = 'main_target',", " dep_a = ':dep_target_a',", " dep_b = ':dep_target_b',", ")", "my_rule(", " name = 'dep_target_a',", ")", "my_rule(", " name = 'dep_target_b',", ")"); AnalysisResult analysisResult = update( ImmutableList.of("test/defs.bzl%aspect_a", "test/defs.bzl%aspect_b"), "//test:main_target"); Map configuredAspects = analysisResult.getAspectsMap(); // aspect_a should run on main_target and dep_target_a and can retrieve aspect_c provider value // on both of them ConfiguredAspect aspectA = getConfiguredAspect(configuredAspects, "aspect_a"); assertThat(aspectA).isNotNull(); StarlarkProvider.Key aResult = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "prov_a"); StructImpl aResultProvider = (StructImpl) aspectA.get(aResult); assertThat((Sequence) aResultProvider.getValue("val")) .containsExactly( "aspect_c runs on target @//test:dep_target_a", "aspect_a runs on target @//test:dep_target_a", "aspect_c runs on target @//test:main_target", "aspect_a runs on target @//test:main_target"); // aspect_b should run on main_target and dep_target_b and can retrieve aspect_c provider value // on both of them ConfiguredAspect aspectB = getConfiguredAspect(configuredAspects, "aspect_b"); assertThat(aspectA).isNotNull(); StarlarkProvider.Key bResult = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "prov_b"); StructImpl bResultProvider = (StructImpl) aspectB.get(bResult); assertThat((Sequence) bResultProvider.getValue("val")) .containsExactly( "aspect_c runs on target @//test:dep_target_b", "aspect_b runs on target @//test:dep_target_b", "aspect_c runs on target @//test:main_target", "aspect_b runs on target @//test:main_target"); } @Test public void testAspectRequiredByMultipleAspects_inheritsRequiredProviders() throws Exception { scratch.file( "test/defs.bzl", "aspect_prov_a = provider()", "aspect_prov_b = provider()", "aspect_prov_c = provider()", "rule_prov_a = provider()", "rule_prov_b = provider()", "rule_prov_c = provider()", "", "def _aspect_c_impl(target, ctx):", " res = ['aspect_c runs on target {}'.format(target.label)]", " return [aspect_prov_c(val = res)]", "aspect_c = aspect(", " implementation = _aspect_c_impl,", " required_providers = [rule_prov_c],", ")", "", "def _aspect_b_impl(target, ctx):", " res = []", " if aspect_prov_c in target:", " res += target[aspect_prov_c].val", " res += ['aspect_b runs on target {}'.format(target.label)]", " if ctx.rule.attr.deps:", " for dep in ctx.rule.attr.deps:", " if aspect_prov_b in dep:", " res += dep[aspect_prov_b].val", " return [aspect_prov_b(val = res)]", "aspect_b = aspect(", " implementation = _aspect_b_impl,", " attr_aspects = ['deps'],", " required_providers = [[rule_prov_b], [rule_prov_c]],", " requires = [aspect_c],", ")", "", "def _aspect_a_impl(target, ctx):", " res = []", " if aspect_prov_c in target:", " res += target[aspect_prov_c].val", " res += ['aspect_a runs on target {}'.format(target.label)]", " if ctx.rule.attr.deps:", " for dep in ctx.rule.attr.deps:", " if aspect_prov_a in dep:", " res += dep[aspect_prov_a].val", " return [aspect_prov_a(val = res)]", "aspect_a = aspect(", " implementation = _aspect_a_impl,", " attr_aspects = ['deps'],", " required_providers = [[rule_prov_a], [rule_prov_c]],", " requires = [aspect_c],", ")", "", "def _my_rule_impl(ctx):", " return [rule_prov_a(), rule_prov_b()]", "", "my_rule = rule(", " implementation = _my_rule_impl,", " attrs = {", " 'deps': attr.label_list(),", " },", " provides = [rule_prov_a, rule_prov_b]", ")", "", "def _rule_with_prov_a_impl(ctx):", " return [rule_prov_a()]", "", "rule_with_prov_a = rule(", " implementation = _rule_with_prov_a_impl,", " attrs = {", " 'deps': attr.label_list(),", " },", " provides = [rule_prov_a]", ")", "", "def _rule_with_prov_b_impl(ctx):", " return [rule_prov_b()]", "", "rule_with_prov_b = rule(", " implementation = _rule_with_prov_b_impl,", " attrs = {", " 'deps': attr.label_list(),", " },", " provides = [rule_prov_b]", ")", "", "def _rule_with_prov_c_impl(ctx):", " return [rule_prov_c()]", "rule_with_prov_c = rule(", " implementation = _rule_with_prov_c_impl,", " attrs = {", " 'deps': attr.label_list(),", " },", " provides = [rule_prov_c]", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'my_rule', 'rule_with_prov_a',", " 'rule_with_prov_b', 'rule_with_prov_c')", "my_rule(", " name = 'main_target',", " deps = [':dep_target_with_prov_a', ':dep_target_with_prov_b']", ")", "rule_with_prov_a(", " name = 'dep_target_with_prov_a',", " deps = [':dep_target_with_prov_c'],", ")", "rule_with_prov_b(", " name = 'dep_target_with_prov_b',", " deps = [':dep_target_with_prov_c'],", ")", "rule_with_prov_c(", " name = 'dep_target_with_prov_c',", ")"); AnalysisResult analysisResult = update( ImmutableList.of("test/defs.bzl%aspect_a", "test/defs.bzl%aspect_b"), "//test:main_target"); Map configuredAspects = analysisResult.getAspectsMap(); // aspect_a runs on main_target, dep_target_with_prov_a and dep_target_with_prov_c and it can // only retrieve aspect_c provider value on dep_target_with_prov_c ConfiguredAspect aspectA = getConfiguredAspect(configuredAspects, "aspect_a"); assertThat(aspectA).isNotNull(); StarlarkProvider.Key aResult = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "aspect_prov_a"); StructImpl aResultProvider = (StructImpl) aspectA.get(aResult); assertThat((Sequence) aResultProvider.getValue("val")) .containsExactly( "aspect_c runs on target @//test:dep_target_with_prov_c", "aspect_a runs on target @//test:dep_target_with_prov_c", "aspect_a runs on target @//test:dep_target_with_prov_a", "aspect_a runs on target @//test:main_target"); // aspect_b runs on main_target, dep_target_with_prov_b and dep_target_with_prov_c and it can // only retrieve aspect_c provider value on dep_target_with_prov_c ConfiguredAspect aspectB = getConfiguredAspect(configuredAspects, "aspect_b"); assertThat(aspectA).isNotNull(); StarlarkProvider.Key bResult = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "aspect_prov_b"); StructImpl bResultProvider = (StructImpl) aspectB.get(bResult); assertThat((Sequence) bResultProvider.getValue("val")) .containsExactly( "aspect_c runs on target @//test:dep_target_with_prov_c", "aspect_b runs on target @//test:dep_target_with_prov_c", "aspect_b runs on target @//test:dep_target_with_prov_b", "aspect_b runs on target @//test:main_target"); } @Test public void testAspectRequiredByMultipleAspects_withDifferentParametersValues() throws Exception { scratch.file( "test/defs.bzl", "prov_a = provider()", "prov_b = provider()", "prov_c = provider()", "", "def _aspect_c_impl(target, ctx):", " res = ['aspect_c runs on target {} and param = {}'.format(target.label, ctx.attr.p)]", " return [prov_c(val = res)]", "aspect_c = aspect(", " implementation = _aspect_c_impl,", " attrs = {", " 'p': attr.string(values=['rule_1_val', 'rule_2_val']),", " },", ")", "", "def _aspect_b_impl(target, ctx):", " res = []", " res += target[prov_c].val", " res += ['aspect_b runs on target {}'.format(target.label)]", " if ctx.rule.attr.dep:", " res += ctx.rule.attr.dep[prov_b].val", " return [prov_b(val = res)]", "aspect_b = aspect(", " implementation = _aspect_b_impl,", " attr_aspects = ['dep'],", " requires = [aspect_c],", ")", "", "def _aspect_a_impl(target, ctx):", " res = []", " res += target[prov_c].val", " res += ['aspect_a runs on target {}'.format(target.label)]", " if ctx.rule.attr.dep:", " res += ctx.rule.attr.dep[prov_a].val", " return [prov_a(val = res)]", "aspect_a = aspect(", " implementation = _aspect_a_impl,", " attr_aspects = ['dep'],", " requires = [aspect_c],", ")", "", "def _rule_1_impl(ctx):", " return ctx.attr.dep[prov_a]", "", "rule_1 = rule(", " implementation = _rule_1_impl,", " attrs = {", " 'dep': attr.label(aspects = [aspect_a]),", " 'p': attr.string(values = ['rule_1_val', 'rule_2_val'])", " },", ")", "", "def _rule_2_impl(ctx):", " return ctx.attr.dep[prov_b]", "", "rule_2 = rule(", " implementation = _rule_2_impl,", " attrs = {", " 'dep': attr.label(aspects = [aspect_b]),", " 'p': attr.string(values = ['rule_1_val', 'rule_2_val'])", " },", ")", "", "def _rule_3_impl(ctx):", " pass", "", "rule_3 = rule(", " implementation = _rule_3_impl,", " attrs = {", " 'dep': attr.label(),", " },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'rule_1', 'rule_2', 'rule_3')", "rule_1(", " name = 'target_1',", " dep = ':dep_1',", " p = 'rule_1_val'", ")", "rule_2(", " name = 'target_2',", " dep = ':dep_2',", " p = 'rule_2_val'", ")", "rule_3(", " name = 'dep_1',", " dep = ':dep_3',", ")", "rule_3(", " name = 'dep_2',", " dep = ':dep_3',", ")", "rule_3(", " name = 'dep_3',", ")"); AnalysisResult analysisResult = update("//test:target_1", "//test:target_2"); Iterator it = analysisResult.getTargetsToBuild().iterator(); // aspect_a runs on dep_1 and dep_3 and it can retrieve aspect_c provider value on them // aspect_c here should get its parameter value from rule_2 ConfiguredTarget target1 = it.next(); StarlarkProvider.Key provAkey = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "prov_a"); StructImpl provA = (StructImpl) target1.get(provAkey); assertThat((Sequence) provA.getValue("val")) .containsExactly( "aspect_c runs on target @//test:dep_1 and param = rule_1_val", "aspect_a runs on target @//test:dep_1", "aspect_c runs on target @//test:dep_3 and param = rule_1_val", "aspect_a runs on target @//test:dep_3"); // aspect_b runs on dep_2 and dep_3 and it can retrieve aspect_c provider value on them. // aspect_c here should get its parameter value from rule_2 ConfiguredTarget target2 = it.next(); StarlarkProvider.Key provBkey = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "prov_b"); StructImpl provB = (StructImpl) target2.get(provBkey); assertThat((Sequence) provB.getValue("val")) .containsExactly( "aspect_c runs on target @//test:dep_2 and param = rule_2_val", "aspect_b runs on target @//test:dep_2", "aspect_c runs on target @//test:dep_3 and param = rule_2_val", "aspect_b runs on target @//test:dep_3"); } @Test public void testAspectRequiresAspect_requireNativeAspect() throws Exception { exposeNativeAspectToStarlark(); scratch.file( "test/defs.bzl", "prov_a = provider()", "def _impl(target, ctx):", " res = 'aspect_a on target {} '.format(target.label)", " if hasattr(target, 'native_aspect_prov'):", " res += 'can see native aspect provider'", " else:", " res += 'cannot see native aspect provider'", " complete_res = [res]", " if hasattr(ctx.rule.attr, 'dep'):", " complete_res += ctx.rule.attr.dep[prov_a].val", " return [prov_a(val = complete_res)]", "aspect_a = aspect(implementation = _impl,", " requires = [starlark_native_aspect],", " attr_aspects = ['dep'],)", "", "def _my_rule_impl(ctx):", " pass", "my_rule = rule(implementation = _my_rule_impl,", " attrs = {'dep': attr.label()})"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'my_rule')", "my_rule(", " name = 'main_target',", " dep = ':dep_1',", ")", "my_rule(", " name = 'dep_1',", " dep = ':dep_2',", ")", "honest(", " name = 'dep_2',", ")"); AnalysisResult analysisResult = update(ImmutableList.of("test/defs.bzl%aspect_a"), "//test:main_target"); Map configuredAspects = analysisResult.getAspectsMap(); // aspect_a runs on main_target, dep_1 and dep_2 but it can only see the required native aspect // run on dep_2 because its rule satisfies its required provider. ConfiguredAspect aspectA = getConfiguredAspect(configuredAspects, "aspect_a"); assertThat(aspectA).isNotNull(); StarlarkProvider.Key aResult = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "prov_a"); StructImpl aResultProvider = (StructImpl) aspectA.get(aResult); assertThat((Sequence) aResultProvider.getValue("val")) .containsExactly( "aspect_a on target @//test:main_target cannot see native aspect provider", "aspect_a on target @//test:dep_1 cannot see native aspect provider", "aspect_a on target @//test:dep_2 can see native aspect provider"); } @Test public void testAspectRequiresAspect_aspectsParameters() throws Exception { scratch.file( "test/defs.bzl", "RequiredAspectProv = provider()", "BaseAspectProv = provider()", "", "def _required_aspect_impl(target, ctx):", " p1_val = 'In required_aspect, p1 = {} on target {}'.format(ctx.attr.p1, target.label)", " p2_val = 'invalid value'", " if not hasattr(ctx.attr, 'p2'):", " p2_val = 'In required_aspect, p2 not found on target {}'.format(target.label)", " return [RequiredAspectProv(p1_val = p1_val, p2_val = p2_val)]", "required_aspect = aspect(", " implementation = _required_aspect_impl,", " attr_aspects = ['dep'],", " attrs = {'p1' : attr.string(values = ['p1_v1', 'p1_v2'])}", ")", "", "def _base_aspect_impl(target, ctx):", " p2_val = 'In base_aspect, p2 = {} on target {}'.format(ctx.attr.p2, target.label)", " p1_val = 'invalid value'", " if not hasattr(ctx.attr, 'p1'):", " p1_val = 'In base_aspect, p1 not found on target {}'.format(target.label)", " return [BaseAspectProv(p1_val = p1_val, p2_val = p2_val)]", "base_aspect = aspect(", " implementation = _base_aspect_impl,", " attr_aspects = ['dep'],", " attrs = {'p2' : attr.string(values = ['p2_v1', 'p2_v2'])},", " requires = [required_aspect],", ")", "", "def _main_rule_impl(ctx):", " return [ctx.attr.dep[RequiredAspectProv], ctx.attr.dep[BaseAspectProv]]", "def _dep_rule_impl(ctx):", " pass", "", "main_rule = rule(", " implementation = _main_rule_impl,", " attrs = {", " 'dep': attr.label(aspects=[base_aspect]),", " 'p1' : attr.string(values = ['p1_v1', 'p1_v2']),", " 'p2' : attr.string(values = ['p2_v1', 'p2_v2'])", " },", ")", "", "dep_rule = rule(", " implementation = _dep_rule_impl,", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'main_rule', 'dep_rule')", "main_rule(", " name = 'main',", " dep = ':dep_target',", " p1 = 'p1_v1',", " p2 = 'p2_v1'", ")", "dep_rule(", " name = 'dep_target',", ")"); AnalysisResult analysisResult = update("//test:main"); // Both base_aspect and required_aspect can get their parameters values from the base rule ConfiguredTarget configuredTarget = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); StarlarkProvider.Key requiredAspectProv = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "RequiredAspectProv"); StructImpl requiredAspectProvider = (StructImpl) configuredTarget.get(requiredAspectProv); assertThat(requiredAspectProvider.getValue("p1_val")) .isEqualTo("In required_aspect, p1 = p1_v1 on target @//test:dep_target"); assertThat(requiredAspectProvider.getValue("p2_val")) .isEqualTo("In required_aspect, p2 not found on target @//test:dep_target"); StarlarkProvider.Key baseAspectProv = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "BaseAspectProv"); StructImpl baseAspectProvider = (StructImpl) configuredTarget.get(baseAspectProv); assertThat(baseAspectProvider.getValue("p1_val")) .isEqualTo("In base_aspect, p1 not found on target @//test:dep_target"); assertThat(baseAspectProvider.getValue("p2_val")) .isEqualTo("In base_aspect, p2 = p2_v1 on target @//test:dep_target"); } @Test public void testAspectRequiresAspect_ruleAttributes() throws Exception { scratch.file( "test/defs.bzl", "RequiredAspectProv = provider()", "BaseAspectProv = provider()", "", "def _required_aspect_impl(target, ctx):", " p_val = 'In required_aspect, p = {} on target {}'.format(ctx.rule.attr.p, target.label)", " return [RequiredAspectProv(p_val = p_val)]", "required_aspect = aspect(", " implementation = _required_aspect_impl,", ")", "", "def _base_aspect_impl(target, ctx):", " p_val = 'In base_aspect, p = {} on target {}'.format(ctx.rule.attr.p, target.label)", " return [BaseAspectProv(p_val = p_val)]", "base_aspect = aspect(", " implementation = _base_aspect_impl,", " attr_aspects = ['dep'],", " requires = [required_aspect],", ")", "", "def _main_rule_impl(ctx):", " return [ctx.attr.dep[RequiredAspectProv], ctx.attr.dep[BaseAspectProv]]", "def _dep_rule_impl(ctx):", " pass", "", "main_rule = rule(", " implementation = _main_rule_impl,", " attrs = {", " 'dep': attr.label(aspects=[base_aspect]),", " },", ")", "", "dep_rule = rule(", " implementation = _dep_rule_impl,", " attrs = {", " 'p' : attr.string(values = ['p_v1', 'p_v2']),", " },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'main_rule', 'dep_rule')", "main_rule(", " name = 'main',", " dep = ':dep_target',", ")", "dep_rule(", " name = 'dep_target',", " p = 'p_v2',", ")"); AnalysisResult analysisResult = update("//test:main"); // Both base_aspect and required_aspect can see the attributes of the rule they run on ConfiguredTarget configuredTarget = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); StarlarkProvider.Key requiredAspectProv = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "RequiredAspectProv"); StructImpl requiredAspectProvider = (StructImpl) configuredTarget.get(requiredAspectProv); assertThat(requiredAspectProvider.getValue("p_val")) .isEqualTo("In required_aspect, p = p_v2 on target @//test:dep_target"); StarlarkProvider.Key baseAspectProv = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "BaseAspectProv"); StructImpl baseAspectProvider = (StructImpl) configuredTarget.get(baseAspectProv); assertThat(baseAspectProvider.getValue("p_val")) .isEqualTo("In base_aspect, p = p_v2 on target @//test:dep_target"); } @Test public void testAspectRequiresAspect_inheritPropagationAttributes() throws Exception { // base_aspect propagates over base_dep attribute and requires first_required_aspect which // propagates over first_dep attribute and requires second_required aspect which propagates // over second_dep attribute scratch.file( "test/defs.bzl", "BaseAspectProv = provider()", "FirstRequiredAspectProv = provider()", "SecondRequiredAspectProv = provider()", "", "def _second_required_aspect_impl(target, ctx):", " result = []", " if getattr(ctx.rule.attr, 'second_dep'):", " result += getattr(ctx.rule.attr, 'second_dep')[SecondRequiredAspectProv].result", " result += ['second_required_aspect run on target {}'.format(target.label)]", " return [SecondRequiredAspectProv(result = result)]", "second_required_aspect = aspect(", " implementation = _second_required_aspect_impl,", " attr_aspects = ['second_dep'],", ")", "", "def _first_required_aspect_impl(target, ctx):", " result = []", " result += target[SecondRequiredAspectProv].result", " if getattr(ctx.rule.attr, 'first_dep'):", " result += getattr(ctx.rule.attr, 'first_dep')[FirstRequiredAspectProv].result", " result += ['first_required_aspect run on target {}'.format(target.label)]", " return [FirstRequiredAspectProv(result = result)]", "first_required_aspect = aspect(", " implementation = _first_required_aspect_impl,", " attr_aspects = ['first_dep'],", " requires = [second_required_aspect],", ")", "", "def _base_aspect_impl(target, ctx):", " result = []", " result += target[FirstRequiredAspectProv].result", " if getattr(ctx.rule.attr, 'base_dep'):", " result += getattr(ctx.rule.attr, 'base_dep')[BaseAspectProv].result", " result += ['base_aspect run on target {}'.format(target.label)]", " return [BaseAspectProv(result = result)]", "base_aspect = aspect(", " implementation = _base_aspect_impl,", " attr_aspects = ['base_dep'],", " requires = [first_required_aspect],", ")", "", "def _main_rule_impl(ctx):", " return [ctx.attr.dep[BaseAspectProv]]", "def _dep_rule_impl(ctx):", " pass", "", "main_rule = rule(", " implementation = _main_rule_impl,", " attrs = {", " 'dep': attr.label(aspects=[base_aspect]),", " },", ")", "", "dep_rule = rule(", " implementation = _dep_rule_impl,", " attrs = {", " 'base_dep': attr.label(),", " 'first_dep': attr.label(),", " 'second_dep': attr.label()", " },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'main_rule', 'dep_rule')", "main_rule(", " name = 'main',", " dep = ':dep_target',", ")", "dep_rule(", " name = 'dep_target',", " base_dep = ':base_dep_target',", " first_dep = ':first_dep_target',", " second_dep = ':second_dep_target',", ")", "dep_rule(", " name = 'base_dep_target',", ")", "dep_rule(", " name = 'first_dep_target',", ")", "dep_rule(", " name = 'second_dep_target',", ")"); AnalysisResult analysisResult = update("//test:main"); // base_aspect should propagate only along its attr_aspects: 'base_dep' // first_required_aspect should propagate along 'base_dep' and 'first_dep' // second_required_aspect should propagate along 'base_dep', 'first_dep' and `second_dep` ConfiguredTarget configuredTarget = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); StarlarkProvider.Key baseAspectProv = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "BaseAspectProv"); StructImpl baseAspectProvider = (StructImpl) configuredTarget.get(baseAspectProv); assertThat((Sequence) baseAspectProvider.getValue("result")) .containsExactly( "second_required_aspect run on target @//test:second_dep_target", "second_required_aspect run on target @//test:dep_target", "second_required_aspect run on target @//test:first_dep_target", "first_required_aspect run on target @//test:first_dep_target", "first_required_aspect run on target @//test:dep_target", "second_required_aspect run on target @//test:base_dep_target", "first_required_aspect run on target @//test:base_dep_target", "base_aspect run on target @//test:base_dep_target", "base_aspect run on target @//test:dep_target"); } @Test public void testAspectRequiresAspect_inheritRequiredProviders() throws Exception { // aspect_a requires provider Prov_A and requires aspect_b which requires // provider Prov_B and requires aspect_c which requires provider Prov_C scratch.file( "test/defs.bzl", "Prov_A = provider()", "Prov_B = provider()", "Prov_C = provider()", "", "CollectorProv = provider()", "", "def _aspect_c_impl(target, ctx):", " collector_result = ['aspect_c run on target {} and value of Prov_C =" + " {}'.format(target.label, target[Prov_C].val)]", " return [CollectorProv(result = collector_result)]", "aspect_c = aspect(", " implementation = _aspect_c_impl,", " required_providers = [Prov_C],", " attr_aspects = ['dep'],", ")", "", "def _aspect_b_impl(target, ctx):", " collector_result = []", " collector_result += ctx.rule.attr.dep[CollectorProv].result", " collector_result += ['aspect_b run on target {} and value of Prov_B =" + " {}'.format(target.label, target[Prov_B].val)]", " return [ CollectorProv(result = collector_result)]", "aspect_b = aspect(", " implementation = _aspect_b_impl,", " required_providers = [Prov_B],", " requires = [aspect_c],", " attr_aspects = ['dep'],", ")", "", "def _aspect_a_impl(target, ctx):", " collector_result = []", " collector_result += ctx.rule.attr.dep[CollectorProv].result", " collector_result += ['aspect_a run on target {} and value of Prov_A =" + " {}'.format(target.label, target[Prov_A].val)]", " return [CollectorProv(result = collector_result)]", "aspect_a = aspect(", " implementation = _aspect_a_impl,", " attr_aspects = ['dep'],", " required_providers = [Prov_A],", " requires = [aspect_b],", ")", "", "def _main_rule_impl(ctx):", " return [ctx.attr.dep[CollectorProv]]", "main_rule = rule(", " implementation = _main_rule_impl,", " attrs = {", " 'dep': attr.label(aspects = [aspect_a]),", " },", ")", "", "def _rule_with_prov_a_impl(ctx):", " return [Prov_A(val='val_a')]", "rule_with_prov_a = rule(", " implementation = _rule_with_prov_a_impl,", " attrs = {", " 'dep': attr.label(),", " },", " provides = [Prov_A]", ")", "", "def _rule_with_prov_b_impl(ctx):", " return [Prov_B(val = 'val_b')]", "rule_with_prov_b = rule(", " implementation = _rule_with_prov_b_impl,", " attrs = {", " 'dep': attr.label(),", " },", " provides = [Prov_B]", ")", "", "def _rule_with_prov_c_impl(ctx):", " return [Prov_C(val = 'val_c')]", "rule_with_prov_c = rule(", " implementation = _rule_with_prov_c_impl,", " provides = [Prov_C]", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'main_rule', 'rule_with_prov_a', 'rule_with_prov_b'," + " 'rule_with_prov_c')", "main_rule(", " name = 'main',", " dep = ':target_with_prov_a',", ")", "rule_with_prov_a(", " name = 'target_with_prov_a',", " dep = ':target_with_prov_b'", ")", "rule_with_prov_b(", " name = 'target_with_prov_b',", " dep = ':target_with_prov_c'", ")", "rule_with_prov_c(", " name = 'target_with_prov_c'", ")"); AnalysisResult analysisResult = update("//test:main"); // aspect_a should only run on target_with_prov_a, aspect_b should only run on // target_with_prov_b and aspect_c should only run on target_with_prov_c. // aspect_c will reach target target_with_prov_c because it inherits the required_providers of // aspect_b otherwise it would have stopped propagating after target_with_prov_b. ConfiguredTarget configuredTarget = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); StarlarkProvider.Key collectorProv = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "CollectorProv"); StructImpl collectorProvider = (StructImpl) configuredTarget.get(collectorProv); assertThat((Sequence) collectorProvider.getValue("result")) .containsExactly( "aspect_c run on target @//test:target_with_prov_c and value of Prov_C = val_c", "aspect_b run on target @//test:target_with_prov_b and value of Prov_B = val_b", "aspect_a run on target @//test:target_with_prov_a and value of Prov_A = val_a") .inOrder(); } @Test public void testAspectRequiresAspect_inspectRequiredAspectActions() throws Exception { scratch.file( "test/defs.bzl", "def _required_aspect_impl(target, ctx):", " f = ctx.actions.declare_file('dummy.txt')", " ctx.actions.run_shell(outputs = [f], command='echo xxx > $(location f)',", " mnemonic='RequiredAspectAction')", " return struct()", "required_aspect = aspect(", " implementation = _required_aspect_impl,", ")", "", "def _base_aspect_impl(target, ctx):", " required_aspect_action = None", " for action in target.actions:", " if action.mnemonic == 'RequiredAspectAction':", " required_aspect_action = action", " if required_aspect_action:", " return struct(result = 'base_aspect can see required_aspect action')", " else:", " return struct(result = 'base_aspect cannot see required_aspect action')", "base_aspect = aspect(", " implementation = _base_aspect_impl,", " attr_aspects = ['dep'],", " requires = [required_aspect]", ")", "", "def _main_rule_impl(ctx):", " return struct(result = ctx.attr.dep.result)", "main_rule = rule(", " implementation = _main_rule_impl,", " attrs = {", " 'dep': attr.label(aspects = [base_aspect]),", " },", ")", "", "def _dep_rule_impl(ctx):", " pass", "dep_rule = rule(", " implementation = _dep_rule_impl,", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'main_rule', 'dep_rule')", "main_rule(", " name = 'main',", " dep = ':dep_target',", ")", "dep_rule(", " name = 'dep_target',", ")"); AnalysisResult analysisResult = update("//test:main"); ConfiguredTarget configuredTarget = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); String result = (String) configuredTarget.get("result"); assertThat(result).isEqualTo("base_aspect can see required_aspect action"); } @Test public void testAspectRequiresAspect_inspectRequiredAspectGeneratedFiles() throws Exception { scratch.file( "test/defs.bzl", "def _required_aspect_impl(target, ctx):", " file = ctx.actions.declare_file('required_aspect_file')", " ctx.actions.write(file, 'data')", " return [OutputGroupInfo(out = [file])]", "required_aspect = aspect(", " implementation = _required_aspect_impl,", ")", "", "def _base_aspect_impl(target, ctx):", " files = ['base_aspect can see file ' + f.path.split('/')[-1] for f in" + " target[OutputGroupInfo].out.to_list()]", " return struct(my_files = files)", "base_aspect = aspect(", " implementation = _base_aspect_impl,", " attr_aspects = ['dep'],", " requires = [required_aspect]", ")", "", "def _main_rule_impl(ctx):", " return struct(my_files = ctx.attr.dep.my_files)", "main_rule = rule(", " implementation = _main_rule_impl,", " attrs = {", " 'dep': attr.label(aspects = [base_aspect]),", " },", ")", "", "def _dep_rule_impl(ctx):", " pass", "dep_rule = rule(", " implementation = _dep_rule_impl,", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'main_rule', 'dep_rule')", "main_rule(", " name = 'main',", " dep = ':dep_target',", ")", "dep_rule(", " name = 'dep_target',", ")"); AnalysisResult analysisResult = update("//test:main"); ConfiguredTarget configuredTarget = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); StarlarkList files = (StarlarkList) configuredTarget.get("my_files"); assertThat(Starlark.toIterable(files)) .containsExactly("base_aspect can see file required_aspect_file"); } @Test public void testAspectRequiresAspect_withRequiredAspectProvidersSatisfied() throws Exception { scratch.file( "test/defs.bzl", "prov_a = provider()", "prov_b = provider()", "prov_b_forwarded = provider()", "", "def _aspect_b_impl(target, ctx):", " result = 'aspect_b on target {} '.format(target.label)", " if prov_b in target:", " result += 'found prov_b = {}'.format(target[prov_b].val)", " return struct(aspect_b_result = result,", " providers = [prov_b_forwarded(val = target[prov_b].val)])", " else:", " result += 'cannot find prov_b'", " return struct(aspect_b_result = result)", "aspect_b = aspect(", " implementation = _aspect_b_impl,", " required_aspect_providers = [prov_b]", ")", "", "def _aspect_a_impl(target, ctx):", " result = 'aspect_a on target {} '.format(target.label)", " if prov_a in target:", " result += 'found prov_a = {}'.format(target[prov_a].val)", " else:", " result += 'cannot find prov_a'", " if prov_b_forwarded in target:", " result += ' and found prov_b = {}'.format(target[prov_b_forwarded].val)", " else:", " result += ' but cannot find prov_b'", " return struct(aspect_a_result = result)", "", "aspect_a = aspect(", " implementation = _aspect_a_impl,", " required_aspect_providers = [prov_a],", " attr_aspects = ['dep'],", " requires = [aspect_b]", ")", "", "def _aspect_with_prov_a_impl(target, ctx):", " return [prov_a(val = 'a1')]", "aspect_with_prov_a = aspect(", " implementation = _aspect_with_prov_a_impl,", " provides = [prov_a],", " attr_aspects = ['dep'],", ")", "", "def _aspect_with_prov_b_impl(target, ctx):", " return [prov_b(val = 'b1')]", "aspect_with_prov_b = aspect(", " implementation = _aspect_with_prov_b_impl,", " provides = [prov_b],", " attr_aspects = ['dep'],", ")", "", "def _main_rule_impl(ctx):", " return struct(aspect_a_result = ctx.attr.dep.aspect_a_result,", " aspect_b_result = ctx.attr.dep.aspect_b_result)", "main_rule = rule(", " implementation = _main_rule_impl,", " attrs = {", " 'dep': attr.label(aspects = [aspect_with_prov_a, aspect_with_prov_b, aspect_a]),", " },", ")", "", "def _dep_rule_impl(ctx):", " pass", "dep_rule = rule(", " implementation = _dep_rule_impl,", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'main_rule', 'dep_rule')", "main_rule(", " name = 'main',", " dep = ':dep_target',", ")", "dep_rule(", " name = 'dep_target',", ")"); AnalysisResult analysisResult = update("//test:main"); ConfiguredTarget configuredTarget = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); String aspectAResult = (String) configuredTarget.get("aspect_a_result"); assertThat(aspectAResult) .isEqualTo("aspect_a on target @//test:dep_target found prov_a = a1 and found prov_b = b1"); String aspectBResult = (String) configuredTarget.get("aspect_b_result"); assertThat(aspectBResult).isEqualTo("aspect_b on target @//test:dep_target found prov_b = b1"); } @Test public void testAspectRequiresAspect_withRequiredAspectProvidersNotFound() throws Exception { scratch.file( "test/defs.bzl", "prov_a = provider()", "prov_b = provider()", "", "def _aspect_b_impl(target, ctx):", " result = 'aspect_b on target {} '.format(target.label)", " if prov_b in target:", " result += 'found prov_b = {}'.format(target[prov_b].val)", " else:", " result += 'cannot find prov_b'", " return struct(aspect_b_result = result)", "aspect_b = aspect(", " implementation = _aspect_b_impl,", " required_aspect_providers = [prov_b]", ")", "", "def _aspect_a_impl(target, ctx):", " result = 'aspect_a on target {} '.format(target.label)", " if prov_a in target:", " result += 'found prov_a = {}'.format(target[prov_a].val)", " else:", " result += 'cannot find prov_a'", " return struct(aspect_a_result = result)", "", "aspect_a = aspect(", " implementation = _aspect_a_impl,", " required_aspect_providers = [prov_a],", " attr_aspects = ['dep'],", " requires = [aspect_b]", ")", "", "def _aspect_with_prov_a_impl(target, ctx):", " return [prov_a(val = 'a1')]", "aspect_with_prov_a = aspect(", " implementation = _aspect_with_prov_a_impl,", " provides = [prov_a],", " attr_aspects = ['dep'],", ")", "", "def _main_rule_impl(ctx):", " return struct(aspect_a_result = ctx.attr.dep.aspect_a_result,", " aspect_b_result = ctx.attr.dep.aspect_b_result)", "main_rule = rule(", " implementation = _main_rule_impl,", " attrs = {", " 'dep': attr.label(aspects = [aspect_with_prov_a, aspect_a]),", " },", ")", "", "def _dep_rule_impl(ctx):", " pass", "dep_rule = rule(", " implementation = _dep_rule_impl,", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'main_rule', 'dep_rule')", "main_rule(", " name = 'main',", " dep = ':dep_target',", ")", "dep_rule(", " name = 'dep_target',", ")"); AnalysisResult analysisResult = update("//test:main"); ConfiguredTarget configuredTarget = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); String aspectAResult = (String) configuredTarget.get("aspect_a_result"); assertThat(aspectAResult).isEqualTo("aspect_a on target @//test:dep_target found prov_a = a1"); String aspectBResult = (String) configuredTarget.get("aspect_b_result"); assertThat(aspectBResult).isEqualTo("aspect_b on target @//test:dep_target cannot find prov_b"); } /** * --aspects = a3, a2, a1: aspect a1 requires provider a1p, aspect a2 requires provider a2p and * provides a1p and aspect a3 provides a2p. The three aspects will propagate together but aspect * a1 will only see a1p and aspect a2 will only see a2p. */ @Test public void testTopLevelAspectOnAspect_stackOfAspects() throws Exception { scratch.file( "test/defs.bzl", "a1p = provider()", "a2p = provider()", "a1_result = provider()", "a2_result = provider()", "a3_result = provider()", "", "def _a1_impl(target, ctx):", " result = 'aspect a1 on target {}'.format(target.label)", " if a1p in target:", " result += ' sees a1p = {}'.format(target[a1p].value)", " else:", " result += ' cannot see a1p'", " if a2p in target:", " result += ' and sees a2p = {}'.format(target[a2p].value)", " else:", " result += ' and cannot see a2p'", " complete_result = []", " if ctx.rule.attr.dep:", " complete_result = ctx.rule.attr.dep[a1_result].value + [result]", " else:", " complete_result = [result]", " return [a1_result(value = complete_result)]", "a1 = aspect(", " implementation = _a1_impl,", " attr_aspects = ['dep'],", " required_aspect_providers = [a1p]", ")", "", "def _a2_impl(target, ctx):", " result = 'aspect a2 on target {}'.format(target.label)", " if a1p in target:", " result += ' sees a1p = {}'.format(target[a1p].value)", " else:", " result += ' cannot see a1p'", " if a2p in target:", " result += ' and sees a2p = {}'.format(target[a2p].value)", " else:", " result += ' and cannot see a2p'", " complete_result = []", " if ctx.rule.attr.dep:", " complete_result = ctx.rule.attr.dep[a2_result].value + [result]", " else:", " complete_result = [result]", " return [a2_result(value = complete_result), a1p(value = 'a1p_val')]", "a2 = aspect(", " implementation = _a2_impl,", " attr_aspects = ['dep'],", " provides = [a1p],", " required_aspect_providers = [a2p],", ")", "", "def _a3_impl(target, ctx):", " result = 'aspect a3 on target {}'.format(target.label)", " if a1p in target:", " result += ' sees a1p = {}'.format(target[a1p].value)", " else:", " result += ' cannot see a1p'", " if a2p in target:", " result += ' and sees a2p = {}'.format(target[a2p].value)", " else:", " result += ' and cannot see a2p'", " complete_result = []", " if ctx.rule.attr.dep:", " complete_result = ctx.rule.attr.dep[a3_result].value + [result]", " else:", " complete_result = [result]", " return [a3_result(value = complete_result), a2p(value = 'a2p_val')]", "a3 = aspect(", " implementation = _a3_impl,", " attr_aspects = ['dep'],", " provides = [a2p],", ")", "", "def _simple_rule_impl(ctx):", " pass", "simple_rule = rule(", " implementation = _simple_rule_impl,", " attrs = {", " 'dep': attr.label(),", " },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'simple_rule')", "simple_rule(", " name = 'main',", " dep = ':dep_target',", ")", "simple_rule(", " name = 'dep_target',", ")"); AnalysisResult analysisResult = update( ImmutableList.of("test/defs.bzl%a3", "test/defs.bzl%a2", "test/defs.bzl%a1"), "//test:main"); Map configuredAspects = analysisResult.getAspectsMap(); ConfiguredAspect a3 = getConfiguredAspect(configuredAspects, "a3"); assertThat(a3).isNotNull(); StarlarkProvider.Key a3Result = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "a3_result"); StructImpl a3ResultProvider = (StructImpl) a3.get(a3Result); assertThat((Sequence) a3ResultProvider.getValue("value")) .containsExactly( "aspect a3 on target @//test:dep_target cannot see a1p and cannot see a2p", "aspect a3 on target @//test:main cannot see a1p and cannot see a2p"); ConfiguredAspect a2 = getConfiguredAspect(configuredAspects, "a2"); assertThat(a2).isNotNull(); StarlarkProvider.Key a2Result = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "a2_result"); StructImpl a2ResultProvider = (StructImpl) a2.get(a2Result); assertThat((Sequence) a2ResultProvider.getValue("value")) .containsExactly( "aspect a2 on target @//test:dep_target cannot see a1p and sees a2p = a2p_val", "aspect a2 on target @//test:main cannot see a1p and sees a2p = a2p_val"); ConfiguredAspect a1 = getConfiguredAspect(configuredAspects, "a1"); assertThat(a1).isNotNull(); StarlarkProvider.Key a1Result = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "a1_result"); StructImpl a1ResultProvider = (StructImpl) a1.get(a1Result); assertThat((Sequence) a1ResultProvider.getValue("value")) .containsExactly( "aspect a1 on target @//test:dep_target sees a1p = a1p_val and cannot see a2p", "aspect a1 on target @//test:main sees a1p = a1p_val and cannot see a2p"); } /** * --aspects = a3, a2, a1: aspect a1 requires provider a1p, aspect a2 and aspect a3 provides a1p. * This should fail because provider a1p is provided twice. */ @Test public void testTopLevelAspectOnAspect_requiredProviderProvidedTwiceFailed() throws Exception { scratch.file( "test/defs.bzl", "a1p = provider()", "a1_result = provider()", "", "def _a1_impl(target, ctx):", " result = 'aspect a1 on target {}'.format(target.label)", " if a1p in target:", " result += ' sees a1p = {}'.format(target[a1p].value)", " else:", " result += ' cannot see a1p'", " complete_result = []", " if ctx.rule.attr.dep:", " complete_result = ctx.rule.attr.dep[a1_result].value + [result]", " else:", " complete_result = [result]", " return [a1_result(value = complete_result)]", "a1 = aspect(", " implementation = _a1_impl,", " attr_aspects = ['dep'],", " required_aspect_providers = [a1p]", ")", "", "def _a2_impl(target, ctx):", " return [a1p(value = 'a1p_a2_val')]", "a2 = aspect(", " implementation = _a2_impl,", " attr_aspects = ['dep'],", " provides = [a1p],", ")", "", "def _a3_impl(target, ctx):", " return [a1p(value = 'a1p_a3_val')]", "a3 = aspect(", " implementation = _a3_impl,", " attr_aspects = ['dep'],", " provides = [a1p],", ")", "", "def _simple_rule_impl(ctx):", " pass", "simple_rule = rule(", " implementation = _simple_rule_impl,", " attrs = {", " 'dep': attr.label(),", " },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'simple_rule')", "simple_rule(", " name = 'main',", " dep = ':dep_target',", ")", "simple_rule(", " name = 'dep_target',", ")"); reporter.removeHandler(failFastHandler); // The call to `update` does not throw an exception when "--keep_going" is passed in the // WithKeepGoing test suite. Otherwise, it throws ViewCreationFailedException. if (keepGoing()) { AnalysisResult result = update( ImmutableList.of("test/defs.bzl%a3", "test/defs.bzl%a2", "test/defs.bzl%a1"), "//test:main"); assertThat(result.hasError()).isTrue(); } else { assertThrows( ViewCreationFailedException.class, () -> update( ImmutableList.of("test/defs.bzl%a3", "test/defs.bzl%a2", "test/defs.bzl%a1"), "//test:main")); } assertContainsEvent("ERROR /workspace/test/BUILD:2:12: Provider a1p provided twice"); } /** * --aspects = a3, a1, a2: aspect a1 requires provider a1p, aspect a2 and aspect a3 provide a1p. * a1 should see the value provided by a3 because a3 is listed before a1. */ @Test public void testTopLevelAspectOnAspect_requiredProviderProvidedTwicePassed() throws Exception { scratch.file( "test/defs.bzl", "a1p = provider()", "a1_result = provider()", "", "def _a1_impl(target, ctx):", " result = 'aspect a1 on target {}'.format(target.label)", " if a1p in target:", " result += ' sees a1p = {}'.format(target[a1p].value)", " else:", " result += ' cannot see a1p'", " complete_result = []", " if ctx.rule.attr.dep:", " complete_result = ctx.rule.attr.dep[a1_result].value + [result]", " else:", " complete_result = [result]", " return [a1_result(value = complete_result)]", "a1 = aspect(", " implementation = _a1_impl,", " attr_aspects = ['dep'],", " required_aspect_providers = [a1p]", ")", "", "def _a2_impl(target, ctx):", " return [a1p(value = 'a1p_a2_val')]", "a2 = aspect(", " implementation = _a2_impl,", " attr_aspects = ['dep'],", " provides = [a1p],", ")", "", "def _a3_impl(target, ctx):", " return [a1p(value = 'a1p_a3_val')]", "a3 = aspect(", " implementation = _a3_impl,", " attr_aspects = ['dep'],", " provides = [a1p],", ")", "", "def _simple_rule_impl(ctx):", " pass", "simple_rule = rule(", " implementation = _simple_rule_impl,", " attrs = {", " 'dep': attr.label(),", " },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'simple_rule')", "simple_rule(", " name = 'main',", " dep = ':dep_target',", ")", "simple_rule(", " name = 'dep_target',", ")"); AnalysisResult analysisResult = update( ImmutableList.of("test/defs.bzl%a3", "test/defs.bzl%a1", "test/defs.bzl%a2"), "//test:main"); Map configuredAspects = analysisResult.getAspectsMap(); ConfiguredAspect a1 = getConfiguredAspect(configuredAspects, "a1"); assertThat(a1).isNotNull(); StarlarkProvider.Key a1Result = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "a1_result"); StructImpl a1ResultProvider = (StructImpl) a1.get(a1Result); assertThat((Sequence) a1ResultProvider.getValue("value")) .containsExactly( "aspect a1 on target @//test:dep_target sees a1p = a1p_a3_val", "aspect a1 on target @//test:main sees a1p = a1p_a3_val"); } @Test public void testTopLevelAspectOnAspect_requiredProviderNotProvided() throws Exception { scratch.file( "test/defs.bzl", "a1p = provider()", "a2p = provider()", "a1_result = provider()", "", "def _a1_impl(target, ctx):", " result = 'aspect a1 on target {}'.format(target.label)", " if a1p in target:", " result += ' sees a1p = {}'.format(target[a1p].value)", " else:", " result += ' cannot see a1p'", " complete_result = []", " if ctx.rule.attr.dep:", " complete_result = ctx.rule.attr.dep[a1_result].value + [result]", " else:", " complete_result = [result]", " return [a1_result(value = complete_result)]", "a1 = aspect(", " implementation = _a1_impl,", " attr_aspects = ['dep'],", " required_aspect_providers = [a1p]", ")", "", "def _a2_impl(target, ctx):", " return [a2p(value = 'a2p_val')]", "a2 = aspect(", " implementation = _a2_impl,", " attr_aspects = ['dep'],", " provides = [a2p],", ")", "", "def _simple_rule_impl(ctx):", " pass", "simple_rule = rule(", " implementation = _simple_rule_impl,", " attrs = {", " 'dep': attr.label(),", " },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'simple_rule')", "simple_rule(", " name = 'main',", " dep = ':dep_target',", ")", "simple_rule(", " name = 'dep_target',", ")"); AnalysisResult analysisResult = update(ImmutableList.of("test/defs.bzl%a2", "test/defs.bzl%a1"), "//test:main"); Map configuredAspects = analysisResult.getAspectsMap(); ConfiguredAspect a1 = getConfiguredAspect(configuredAspects, "a1"); assertThat(a1).isNotNull(); StarlarkProvider.Key a1Result = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "a1_result"); StructImpl a1ResultProvider = (StructImpl) a1.get(a1Result); assertThat((Sequence) a1ResultProvider.getValue("value")) .containsExactly( "aspect a1 on target @//test:dep_target cannot see a1p", "aspect a1 on target @//test:main cannot see a1p"); } /** * --aspects = a1, a2: aspect a1 requires provider a1p, aspect a2 provides a1p but it was listed * after a1 so aspect a1 cannot see a1p value. */ @Test public void testTopLevelAspectOnAspect_requiredProviderProvidedAfterTheAspect() throws Exception { scratch.file( "test/defs.bzl", "a1p = provider()", "a1_result = provider()", "", "def _a1_impl(target, ctx):", " result = 'aspect a1 on target {}'.format(target.label)", " if a1p in target:", " result += ' sees a1p = {}'.format(target[a1p].value)", " else:", " result += ' cannot see a1p'", " complete_result = []", " if ctx.rule.attr.dep:", " complete_result = ctx.rule.attr.dep[a1_result].value + [result]", " else:", " complete_result = [result]", " return [a1_result(value = complete_result)]", "a1 = aspect(", " implementation = _a1_impl,", " attr_aspects = ['dep'],", " required_aspect_providers = [a1p]", ")", "", "def _a2_impl(target, ctx):", " return [a1p(value = 'a1p_val')]", "a2 = aspect(", " implementation = _a2_impl,", " attr_aspects = ['dep'],", " provides = [a1p],", ")", "", "def _simple_rule_impl(ctx):", " pass", "simple_rule = rule(", " implementation = _simple_rule_impl,", " attrs = {", " 'dep': attr.label(),", " },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'simple_rule')", "simple_rule(", " name = 'main',", " dep = ':dep_target',", ")", "simple_rule(", " name = 'dep_target',", ")"); AnalysisResult analysisResult = update(ImmutableList.of("test/defs.bzl%a1", "test/defs.bzl%a2"), "//test:main"); Map configuredAspects = analysisResult.getAspectsMap(); ConfiguredAspect a1 = getConfiguredAspect(configuredAspects, "a1"); assertThat(a1).isNotNull(); StarlarkProvider.Key a1Result = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "a1_result"); StructImpl a1ResultProvider = (StructImpl) a1.get(a1Result); assertThat((Sequence) a1ResultProvider.getValue("value")) .containsExactly( "aspect a1 on target @//test:dep_target cannot see a1p", "aspect a1 on target @//test:main cannot see a1p"); } /** * --aspects = a2, a1: aspect a1 requires provider a1p, aspect a2 provides a1p. But aspect a2 * propagates along different attr_aspects from a1 so a1 cannot get a1p on all dependency targets. */ @Test public void testTopLevelAspectOnAspect_differentAttrAspects() throws Exception { scratch.file( "test/defs.bzl", "a1p = provider()", "a1_result = provider()", "", "def _a1_impl(target, ctx):", " result = 'aspect a1 on target {}'.format(target.label)", " if a1p in target:", " result += ' sees a1p = {}'.format(target[a1p].value)", " else:", " result += ' cannot see a1p'", " complete_result = []", " if ctx.rule.attr.dep:", " complete_result += ctx.rule.attr.dep[a1_result].value", " if ctx.rule.attr.extra_dep:", " complete_result += ctx.rule.attr.extra_dep[a1_result].value", " complete_result += [result]", " return [a1_result(value = complete_result)]", "a1 = aspect(", " implementation = _a1_impl,", " attr_aspects = ['dep', 'extra_dep'],", " required_aspect_providers = [a1p]", ")", "", "def _a2_impl(target, ctx):", " return [a1p(value = 'a1p_val')]", "a2 = aspect(", " implementation = _a2_impl,", " attr_aspects = ['dep'],", " provides = [a1p],", ")", "", "def _simple_rule_impl(ctx):", " pass", "simple_rule = rule(", " implementation = _simple_rule_impl,", " attrs = {", " 'dep': attr.label(),", " 'extra_dep': attr.label(),", " },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'simple_rule')", "simple_rule(", " name = 'main',", " dep = ':dep_target',", " extra_dep = ':extra_dep_target',", ")", "simple_rule(", " name = 'dep_target',", ")", "simple_rule(", " name = 'extra_dep_target',", ")"); AnalysisResult analysisResult = update(ImmutableList.of("test/defs.bzl%a2", "test/defs.bzl%a1"), "//test:main"); Map configuredAspects = analysisResult.getAspectsMap(); ConfiguredAspect a1 = getConfiguredAspect(configuredAspects, "a1"); assertThat(a1).isNotNull(); StarlarkProvider.Key a1Result = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "a1_result"); StructImpl a1ResultProvider = (StructImpl) a1.get(a1Result); assertThat((Sequence) a1ResultProvider.getValue("value")) .containsExactly( "aspect a1 on target @//test:dep_target sees a1p = a1p_val", "aspect a1 on target @//test:extra_dep_target cannot see a1p", "aspect a1 on target @//test:main sees a1p = a1p_val"); } /** * --aspects = a2, a1: aspect a1 requires provider a1p, aspect a2 provides a1p. But aspect a2 * propagates along different required_providers from a1 so a1 cannot get a1p on all dependency * targets. */ @Test public void testTopLevelAspectOnAspect_differentRequiredRuleProviders() throws Exception { scratch.file( "test/defs.bzl", "a1p = provider()", "a1_result = provider()", "rule_prov_a = provider()", "rule_prov_b = provider()", "", "def _a1_impl(target, ctx):", " result = 'aspect a1 on target {}'.format(target.label)", " if a1p in target:", " result += ' sees a1p = {}'.format(target[a1p].value)", " else:", " result += ' cannot see a1p'", " complete_result = []", " if hasattr(ctx.rule.attr, 'deps'):", " for dep in ctx.rule.attr.deps:", " complete_result += dep[a1_result].value", " complete_result += [result]", " return [a1_result(value = complete_result)]", "a1 = aspect(", " implementation = _a1_impl,", " attr_aspects = ['deps'],", " required_aspect_providers = [a1p],", " required_providers = [[rule_prov_a], [rule_prov_b]],", ")", "", "def _a2_impl(target, ctx):", " return [a1p(value = 'a1p_val')]", "a2 = aspect(", " implementation = _a2_impl,", " attr_aspects = ['deps'],", " provides = [a1p],", " required_providers = [rule_prov_a],", ")", "", "def _main_rule_impl(ctx):", " return [rule_prov_a(), rule_prov_b()]", "main_rule = rule(", " implementation = _main_rule_impl,", " attrs = {", " 'deps': attr.label_list(),", " },", ")", "", "def _rule_with_prov_a_impl(ctx):", " return [rule_prov_a()]", "rule_with_prov_a = rule(", " implementation = _rule_with_prov_a_impl,", " provides = [rule_prov_a]", ")", "", "def _rule_with_prov_b_impl(ctx):", " return [rule_prov_b()]", "rule_with_prov_b = rule(", " implementation = _rule_with_prov_b_impl,", " provides = [rule_prov_b]", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'main_rule', 'rule_with_prov_a', 'rule_with_prov_b')", "main_rule(", " name = 'main',", " deps = [':target_with_prov_a', ':target_with_prov_b'],", ")", "rule_with_prov_a(", " name = 'target_with_prov_a',", ")", "rule_with_prov_b(", " name = 'target_with_prov_b',", ")"); AnalysisResult analysisResult = update(ImmutableList.of("test/defs.bzl%a2", "test/defs.bzl%a1"), "//test:main"); Map configuredAspects = analysisResult.getAspectsMap(); ConfiguredAspect a1 = getConfiguredAspect(configuredAspects, "a1"); assertThat(a1).isNotNull(); StarlarkProvider.Key a1Result = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "a1_result"); StructImpl a1ResultProvider = (StructImpl) a1.get(a1Result); assertThat((Sequence) a1ResultProvider.getValue("value")) .containsExactly( "aspect a1 on target @//test:target_with_prov_a sees a1p = a1p_val", "aspect a1 on target @//test:target_with_prov_b cannot see a1p", "aspect a1 on target @//test:main sees a1p = a1p_val"); } /** * --aspects = a3, a2, a1: both aspects a1 and a2 require provider a3p, aspect a3 provides a3p. a1 * and a2 should be able to read a3p. */ @Test public void testTopLevelAspectOnAspect_providerRequiredByMultipleAspects() throws Exception { scratch.file( "test/defs.bzl", "a3p = provider()", "a1_result = provider()", "a2_result = provider()", "", "def _a1_impl(target, ctx):", " result = 'aspect a1 on target {}'.format(target.label)", " if a3p in target:", " result += ' sees a3p = {}'.format(target[a3p].value)", " else:", " result += ' cannot see a3p'", " complete_result = []", " if ctx.rule.attr.dep:", " complete_result = ctx.rule.attr.dep[a1_result].value + [result]", " else:", " complete_result = [result]", " return [a1_result(value = complete_result)]", "a1 = aspect(", " implementation = _a1_impl,", " attr_aspects = ['dep'],", " required_aspect_providers = [a3p]", ")", "", "def _a2_impl(target, ctx):", " result = 'aspect a2 on target {}'.format(target.label)", " if a3p in target:", " result += ' sees a3p = {}'.format(target[a3p].value)", " else:", " result += ' cannot see a3p'", " complete_result = []", " if ctx.rule.attr.dep:", " complete_result = ctx.rule.attr.dep[a2_result].value + [result]", " else:", " complete_result = [result]", " return [a2_result(value = complete_result)]", "a2 = aspect(", " implementation = _a2_impl,", " attr_aspects = ['dep'],", " required_aspect_providers = [a3p]", ")", "", "def _a3_impl(target, ctx):", " return [a3p(value = 'a3p_val')]", "a3 = aspect(", " implementation = _a3_impl,", " attr_aspects = ['dep'],", " provides = [a3p],", ")", "", "def _simple_rule_impl(ctx):", " pass", "simple_rule = rule(", " implementation = _simple_rule_impl,", " attrs = {", " 'dep': attr.label(),", " },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'simple_rule')", "simple_rule(", " name = 'main',", " dep = ':dep_target',", ")", "simple_rule(", " name = 'dep_target',", ")"); AnalysisResult analysisResult = update( ImmutableList.of("test/defs.bzl%a3", "test/defs.bzl%a2", "test/defs.bzl%a1"), "//test:main"); Map configuredAspects = analysisResult.getAspectsMap(); ConfiguredAspect a2 = getConfiguredAspect(configuredAspects, "a2"); assertThat(a2).isNotNull(); StarlarkProvider.Key a2Result = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "a2_result"); StructImpl a2ResultProvider = (StructImpl) a2.get(a2Result); assertThat((Sequence) a2ResultProvider.getValue("value")) .containsExactly( "aspect a2 on target @//test:dep_target sees a3p = a3p_val", "aspect a2 on target @//test:main sees a3p = a3p_val"); ConfiguredAspect a1 = getConfiguredAspect(configuredAspects, "a1"); assertThat(a1).isNotNull(); StarlarkProvider.Key a1Result = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "a1_result"); StructImpl a1ResultProvider = (StructImpl) a1.get(a1Result); assertThat((Sequence) a1ResultProvider.getValue("value")) .containsExactly( "aspect a1 on target @//test:dep_target sees a3p = a3p_val", "aspect a1 on target @//test:main sees a3p = a3p_val"); } /** * --aspects = a1, a2, a3: aspect a3 requires a1p and a2p, a1 provides a1p and a2 provides a2p. * *

top level target (main) has two dependencies t1 and t2. Aspects a1 and a3 can propagate to * t1 and aspects a2 and a3 can propagate to t2. Both t1 and t2 have t0 as dependency, aspect a3 * will run twice on t0 once with aspects path (a1, a3) and the other with (a2, a3). */ @Test public void testTopLevelAspectOnAspect_diamondCase() throws Exception { scratch.file( "test/defs.bzl", "a1p = provider()", "a2p = provider()", "a3_result = provider()", "", "r1p = provider()", "r2p = provider()", "", "def _a1_impl(target, ctx):", " return [a1p(value = 'a1p_val')]", "a1 = aspect(", " implementation = _a1_impl,", " attr_aspects = ['deps'],", " required_providers = [r1p],", " provides = [a1p]", ")", "", "def _a2_impl(target, ctx):", " return [a2p(value = 'a2p_val')]", "a2 = aspect(", " implementation = _a2_impl,", " attr_aspects = ['deps'],", " required_providers = [r2p],", " provides = [a2p]", ")", "", "def _a3_impl(target, ctx):", " result = 'aspect a3 on target {}'.format(target.label)", " if a1p in target:", " result += ' sees a1p = {}'.format(target[a1p].value)", " else:", " result += ' cannot see a1p'", " if a2p in target:", " result += ' and sees a2p = {}'.format(target[a2p].value)", " else:", " result += ' and cannot see a2p'", " complete_result = []", " if ctx.rule.attr.deps:", " for dep in ctx.rule.attr.deps:", " complete_result.extend(dep[a3_result].value)", " complete_result.append(result)", " return [a3_result(value = complete_result)]", "a3 = aspect(", " implementation = _a3_impl,", " attr_aspects = ['deps'],", " required_aspect_providers = [[a1p], [a2p]],", ")", "", "def _r0_impl(ctx):", " return [r1p(), r2p()]", "r0 = rule(", " implementation = _r0_impl,", " attrs = {", " 'deps': attr.label_list(),", " },", " provides = [r1p, r2p]", ")", "def _r1_impl(ctx):", " return [r1p()]", "r1 = rule(", " implementation = _r1_impl,", " attrs = {", " 'deps': attr.label_list(),", " },", " provides = [r1p]", ")", "def _r2_impl(ctx):", " return [r2p()]", "r2 = rule(", " implementation = _r2_impl,", " attrs = {", " 'deps': attr.label_list(),", " },", " provides = [r2p]", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'r0', 'r1', 'r2')", "r0(", " name = 'main',", " deps = [':t1', ':t2'],", ")", "r1(", " name = 't1',", " deps = [':t0'],", ")", "r2(", " name = 't2',", " deps = [':t0'],", ")", "r0(", " name = 't0',", ")"); AnalysisResult analysisResult = update( ImmutableList.of("test/defs.bzl%a1", "test/defs.bzl%a2", "test/defs.bzl%a3"), "//test:main"); Map configuredAspects = analysisResult.getAspectsMap(); ConfiguredAspect a3 = getConfiguredAspect(configuredAspects, "a3"); assertThat(a3).isNotNull(); StarlarkProvider.Key a3Result = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "a3_result"); StructImpl a3ResultProvider = (StructImpl) a3.get(a3Result); assertThat((Sequence) a3ResultProvider.getValue("value")) .containsExactly( "aspect a3 on target @//test:t0 sees a1p = a1p_val and cannot see a2p", "aspect a3 on target @//test:t0 cannot see a1p and sees a2p = a2p_val", "aspect a3 on target @//test:t1 sees a1p = a1p_val and cannot see a2p", "aspect a3 on target @//test:t2 cannot see a1p and sees a2p = a2p_val", "aspect a3 on target @//test:main sees a1p = a1p_val and sees a2p = a2p_val"); } @Test public void testTopLevelAspectOnAspect_duplicateAspectsNotAllowed() throws Exception { scratch.file( "test/defs.bzl", "a2p = provider()", "a1_result = provider()", "", "def _a1_impl(target, ctx):", " result = 'aspect a1 on target {}'.format(target.label)", " if a2p in target:", " result += ' sees a2p = {}'.format(target[a2p].value)", " else:", " result += ' cannot see a2p'", " complete_result = []", " if ctx.rule.attr.deps:", " for dep in ctx.rule.attr.deps:", " complete_result.extend(dep[a1_result].value)", " complete_result.append(result)", " return [a1_result(value = complete_result)]", "a1 = aspect(", " implementation = _a1_impl,", " attr_aspects = ['deps'],", " required_aspect_providers = [a2p]", ")", "", "def _a2_impl(target, ctx):", " return [a2p(value = 'a2p_val')]", "a2 = aspect(", " implementation = _a2_impl,", " attr_aspects = ['deps'],", " provides = [a2p]", ")", "", "def _simple_rule_impl(ctx):", " pass", "simple_rule = rule(", " implementation = _simple_rule_impl,", " attrs = {", " 'deps': attr.label_list(),", " },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'simple_rule')", "simple_rule(", " name = 'main',", " deps = [':dep_target'],", ")", "simple_rule(", " name = 'dep_target',", ")"); reporter.removeHandler(failFastHandler); // The call to `update` does not throw an exception when "--keep_going" is passed in the // WithKeepGoing test suite. Otherwise, it throws ViewCreationFailedException. if (keepGoing()) { AnalysisResult result = update( ImmutableList.of("test/defs.bzl%a1", "test/defs.bzl%a2", "test/defs.bzl%a1"), "//test:main"); assertThat(result.hasError()).isTrue(); } else { assertThrows( ViewCreationFailedException.class, () -> update( ImmutableList.of("test/defs.bzl%a1", "test/defs.bzl%a2", "test/defs.bzl%a1"), "//test:main")); } assertContainsEvent("aspect //test:defs.bzl%a1 added more than once"); } /** * --aspects = a1 requires provider a2p provided by aspect a2. a1 is applied on top level target * `main` whose rule propagates aspect a2 to its `deps`. So a1 on `main` cannot see a2p but it can * see a2p on `main` deps. */ @Test public void testTopLevelAspectOnAspect_requiredAspectProviderOnlyAvailableOnDep() throws Exception { scratch.file( "test/defs.bzl", "a2p = provider()", "a1_result = provider()", "", "def _a1_impl(target, ctx):", " result = 'aspect a1 on target {}'.format(target.label)", " if a2p in target:", " result += ' sees a2p = {}'.format(target[a2p].value)", " else:", " result += ' cannot see a2p'", " complete_result = []", " if ctx.rule.attr.deps:", " for dep in ctx.rule.attr.deps:", " complete_result.extend(dep[a1_result].value)", " complete_result.append(result)", " return [a1_result(value = complete_result)]", "a1 = aspect(", " implementation = _a1_impl,", " attr_aspects = ['deps'],", " required_aspect_providers = [a2p]", ")", "", "def _a2_impl(target, ctx):", " return [a2p(value = 'a2p_val')]", "a2 = aspect(", " implementation = _a2_impl,", " attr_aspects = ['deps'],", " provides = [a2p]", ")", "", "def _simple_rule_impl(ctx):", " pass", "simple_rule = rule(", " implementation = _simple_rule_impl,", " attrs = {", " 'deps': attr.label_list(aspects=[a2]),", " },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'simple_rule')", "simple_rule(", " name = 'main',", " deps = [':dep_target'],", ")", "simple_rule(", " name = 'dep_target',", ")"); AnalysisResult analysisResult = update(ImmutableList.of("test/defs.bzl%a1"), "//test:main"); Map configuredAspects = analysisResult.getAspectsMap(); ConfiguredAspect a1 = getConfiguredAspect(configuredAspects, "a1"); assertThat(a1).isNotNull(); StarlarkProvider.Key a1Result = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "a1_result"); StructImpl a1ResultProvider = (StructImpl) a1.get(a1Result); assertThat((Sequence) a1ResultProvider.getValue("value")) .containsExactly( "aspect a1 on target @//test:dep_target sees a2p = a2p_val", "aspect a1 on target @//test:main cannot see a2p"); } @Test public void testTopLevelAspectOnAspect_multipleTopLevelTargets() throws Exception { scratch.file( "test/defs.bzl", "a2p = provider()", "a1_result = provider()", "", "def _a1_impl(target, ctx):", " result = 'aspect a1 on target {}'.format(target.label)", " if a2p in target:", " result += ' sees a2p = {}'.format(target[a2p].value)", " else:", " result += ' cannot see a2p'", " complete_result = []", " if ctx.rule.attr.deps:", " for dep in ctx.rule.attr.deps:", " complete_result.extend(dep[a1_result].value)", " complete_result.append(result)", " return [a1_result(value = complete_result)]", "a1 = aspect(", " implementation = _a1_impl,", " attr_aspects = ['deps'],", " required_aspect_providers = [a2p],", ")", "", "def _a2_impl(target, ctx):", " return [a2p(value = 'a2p_val')]", "a2 = aspect(", " implementation = _a2_impl,", " attr_aspects = ['deps'],", " provides = [a2p]", ")", "", "def _simple_rule_impl(ctx):", " pass", "simple_rule = rule(", " implementation = _simple_rule_impl,", " attrs = {", " 'deps': attr.label_list(),", " },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'simple_rule')", "simple_rule(", " name = 't1',", ")", "simple_rule(", " name = 't2',", ")"); AnalysisResult analysisResult = update(ImmutableList.of("test/defs.bzl%a2", "test/defs.bzl%a1"), "//test:t2", "//test:t1"); Map configuredAspects = analysisResult.getAspectsMap(); ConfiguredAspect a1Ont1 = getConfiguredAspect(configuredAspects, "a1", "t1"); assertThat(a1Ont1).isNotNull(); StarlarkProvider.Key a1Result = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "a1_result"); StructImpl a1ResultProvider = (StructImpl) a1Ont1.get(a1Result); assertThat((Sequence) a1ResultProvider.getValue("value")) .containsExactly("aspect a1 on target @//test:t1 sees a2p = a2p_val"); ConfiguredAspect a1Ont2 = getConfiguredAspect(configuredAspects, "a1", "t2"); assertThat(a1Ont2).isNotNull(); a1ResultProvider = (StructImpl) a1Ont2.get(a1Result); assertThat((Sequence) a1ResultProvider.getValue("value")) .containsExactly("aspect a1 on target @//test:t2 sees a2p = a2p_val"); } @Test public void testTopLevelAspectOnAspect_multipleRequiredProviders() throws Exception { scratch.file( "test/defs.bzl", "a2p = provider()", "a3p = provider()", "a1_result = provider()", "", "def _a1_impl(target, ctx):", " result = 'aspect a1 on target {}'.format(target.label)", " if a2p in target:", " result += ' sees a2p = {}'.format(target[a2p].value)", " else:", " result += ' cannot see a2p'", " if a3p in target:", " result += ' and sees a3p = {}'.format(target[a3p].value)", " else:", " result += ' and cannot see a3p'", " complete_result = []", " if ctx.rule.attr.deps:", " for dep in ctx.rule.attr.deps:", " complete_result.extend(dep[a1_result].value)", " complete_result.append(result)", " return [a1_result(value = complete_result)]", "a1 = aspect(", " implementation = _a1_impl,", " attr_aspects = ['deps'],", " required_aspect_providers = [[a2p], [a3p]],", ")", "", "def _a2_impl(target, ctx):", " return [a2p(value = 'a2p_val')]", "a2 = aspect(", " implementation = _a2_impl,", " attr_aspects = ['deps'],", " provides = [a2p]", ")", "", "def _a3_impl(target, ctx):", " return [a3p(value = 'a3p_val')]", "a3 = aspect(", " implementation = _a3_impl,", " attr_aspects = ['deps'],", " provides = [a3p]", ")", "", "def _simple_rule_impl(ctx):", " pass", "simple_rule = rule(", " implementation = _simple_rule_impl,", " attrs = {", " 'deps': attr.label_list(),", " },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'simple_rule')", "simple_rule(", " name = 'main',", " deps = [':dep_target'],", ")", "simple_rule(", " name = 'dep_target',", ")"); AnalysisResult analysisResult = update( ImmutableList.of("test/defs.bzl%a3", "test/defs.bzl%a2", "test/defs.bzl%a1"), "//test:main"); Map configuredAspects = analysisResult.getAspectsMap(); ConfiguredAspect a1 = getConfiguredAspect(configuredAspects, "a1"); assertThat(a1).isNotNull(); StarlarkProvider.Key a1Result = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "a1_result"); StructImpl a1ResultProvider = (StructImpl) a1.get(a1Result); assertThat((Sequence) a1ResultProvider.getValue("value")) .containsExactly( "aspect a1 on target @//test:dep_target sees a2p = a2p_val and sees a3p = a3p_val", "aspect a1 on target @//test:main sees a2p = a2p_val and sees a3p = a3p_val"); } @Test public void testTopLevelAspectOnAspect_multipleRequiredProviders2() throws Exception { scratch.file( "test/defs.bzl", "a2p = provider()", "a3p = provider()", "a1_result = provider()", "a2_result = provider()", "", "def _a1_impl(target, ctx):", " result = 'aspect a1 on target {}'.format(target.label)", " if a2p in target:", " result += ' sees a2p = {}'.format(target[a2p].value)", " else:", " result += ' cannot see a2p'", " if a3p in target:", " result += ' and sees a3p = {}'.format(target[a3p].value)", " else:", " result += ' and cannot see a3p'", " complete_result = []", " if ctx.rule.attr.deps:", " for dep in ctx.rule.attr.deps:", " complete_result.extend(dep[a1_result].value)", " complete_result.append(result)", " return [a1_result(value = complete_result)]", "a1 = aspect(", " implementation = _a1_impl,", " attr_aspects = ['deps'],", " required_aspect_providers = [[a2p], [a3p]],", ")", "", "def _a2_impl(target, ctx):", " result = 'aspect a2 on target {}'.format(target.label)", " if a3p in target:", " result += ' sees a3p = {}'.format(target[a3p].value)", " else:", " result += ' cannot see a3p'", " complete_result = []", " if ctx.rule.attr.deps:", " for dep in ctx.rule.attr.deps:", " complete_result.extend(dep[a2_result].value)", " complete_result.append(result)", " return [a2_result(value = complete_result), a2p(value = 'a2p_val')]", "a2 = aspect(", " implementation = _a2_impl,", " attr_aspects = ['deps'],", " provides = [a2p],", " required_aspect_providers = [a3p]", ")", "", "def _a3_impl(target, ctx):", " return [a3p(value = 'a3p_val')]", "a3 = aspect(", " implementation = _a3_impl,", " attr_aspects = ['deps'],", " provides = [a3p]", ")", "", "def _simple_rule_impl(ctx):", " pass", "simple_rule = rule(", " implementation = _simple_rule_impl,", " attrs = {", " 'deps': attr.label_list(),", " },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'simple_rule')", "simple_rule(", " name = 'main',", " deps = [':dep_target'],", ")", "simple_rule(", " name = 'dep_target',", ")"); AnalysisResult analysisResult = update( ImmutableList.of("test/defs.bzl%a3", "test/defs.bzl%a2", "test/defs.bzl%a1"), "//test:main"); Map configuredAspects = analysisResult.getAspectsMap(); ConfiguredAspect a1 = getConfiguredAspect(configuredAspects, "a1"); assertThat(a1).isNotNull(); StarlarkProvider.Key a1Result = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "a1_result"); StructImpl a1ResultProvider = (StructImpl) a1.get(a1Result); assertThat((Sequence) a1ResultProvider.getValue("value")) .containsExactly( "aspect a1 on target @//test:dep_target sees a2p = a2p_val and sees a3p = a3p_val", "aspect a1 on target @//test:main sees a2p = a2p_val and sees a3p = a3p_val"); ConfiguredAspect a2 = getConfiguredAspect(configuredAspects, "a2"); assertThat(a2).isNotNull(); StarlarkProvider.Key a2Result = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "a2_result"); StructImpl a2ResultProvider = (StructImpl) a2.get(a2Result); assertThat((Sequence) a2ResultProvider.getValue("value")) .containsExactly( "aspect a2 on target @//test:dep_target sees a3p = a3p_val", "aspect a2 on target @//test:main sees a3p = a3p_val"); } /** * aspects = a1, a2; aspect a1 provides a1p provider and aspect a2 requires a1p provider. These * top-level aspects are applied on top-level target `main` whose rule also provides a1p. * *

By default, the dependency between a1 and a2 will be established, the build will fail since * a2 will receive provider a1p twice (from a1 applied on `main` and from `main` target itself). */ @Test public void testTopLevelAspects_duplicateRuleProviderError() throws Exception { scratch.file( "test/defs.bzl", "a1p = provider()", "a2p = provider()", "", "def _a1_impl(target, ctx):", " return [a1p(value = 'aspect_a1p_val')]", "a1 = aspect(", " implementation = _a1_impl,", " provides = [a1p],", ")", "", "def _a2_impl(target, ctx):", " result = 'aspect a2 on target {}'.format(target.label)", " if a1p in target:", " result += ' sees a1p = {}'.format(target[a1p].value)", " else:", " result += ' cannot see a1p'", " return [a2p(value = result)]", "a2 = aspect(", " implementation = _a2_impl,", " provides = [a2p],", " required_aspect_providers = [a1p]", ")", "", "def _my_rule_impl(ctx):", " return [a1p(value = 'rule_a1p_val')]", "my_rule = rule(", " implementation = _my_rule_impl,", ")"); scratch.file("test/BUILD", "load('//test:defs.bzl', 'my_rule')", "my_rule(name = 'main')"); reporter.removeHandler(failFastHandler); // The call to `update` does not throw an exception when "--keep_going" is passed in the // WithKeepGoing test suite. Otherwise, it throws ViewCreationFailedException. if (keepGoing()) { AnalysisResult result = update(ImmutableList.of("test/defs.bzl%a1", "test/defs.bzl%a2"), "//test:main"); assertThat(result.hasError()).isTrue(); } else { assertThrows( ViewCreationFailedException.class, () -> update(ImmutableList.of("test/defs.bzl%a1", "test/defs.bzl%a2"), "//test:main")); } assertContainsEvent("Provider a1p provided twice"); } @Test public void testTopLevelAspectRequiresAspect_stackOfRequiredAspects() throws Exception { scratch.file( "test/defs.bzl", "def _impl(target, ctx):", " return []", "aspect_c = aspect(implementation = _impl)", "aspect_b = aspect(implementation = _impl, requires = [aspect_c])", "aspect_a = aspect(implementation = _impl, requires = [aspect_b])"); scratch.file("test/BUILD", "cc_binary(name = 'main_target')"); AnalysisResult analysisResult = update(ImmutableList.of("test/defs.bzl%aspect_a"), "//test:main_target"); Map configuredAspects = analysisResult.getAspectsMap(); assertThat(configuredAspects).hasSize(3); assertThat(getConfiguredAspect(configuredAspects, "aspect_a")).isNotNull(); assertThat(getConfiguredAspect(configuredAspects, "aspect_b")).isNotNull(); assertThat(getConfiguredAspect(configuredAspects, "aspect_c")).isNotNull(); } @Test public void testTopLevelAspectRequiresAspect_aspectRequiredByMultipleAspects() throws Exception { scratch.file( "test/defs.bzl", "def _impl(target, ctx):", " return []", "aspect_c = aspect(implementation = _impl)", "aspect_b = aspect(implementation = _impl, requires = [aspect_c])", "aspect_a = aspect(implementation = _impl, requires = [aspect_c])"); scratch.file("test/BUILD", "cc_binary(name = 'main_target')"); AnalysisResult analysisResult = update( ImmutableList.of("test/defs.bzl%aspect_a", "test/defs.bzl%aspect_b"), "//test:main_target"); Map configuredAspects = analysisResult.getAspectsMap(); assertThat(configuredAspects).hasSize(3); assertThat(getConfiguredAspect(configuredAspects, "aspect_a")).isNotNull(); assertThat(getConfiguredAspect(configuredAspects, "aspect_b")).isNotNull(); assertThat(getConfiguredAspect(configuredAspects, "aspect_c")).isNotNull(); } @Test public void testTopLevelAspectRequiresAspect_aspectRequiredByMultipleAspects2() throws Exception { scratch.file( "test/defs.bzl", "def _impl(target, ctx):", " return []", "aspect_d = aspect(implementation = _impl)", "aspect_c = aspect(implementation = _impl, requires = [aspect_d])", "aspect_b = aspect(implementation = _impl, requires = [aspect_d])", "aspect_a = aspect(implementation = _impl, requires = [aspect_b, aspect_c])"); scratch.file("test/BUILD", "cc_binary(name = 'main_target')"); AnalysisResult analysisResult = update(ImmutableList.of("test/defs.bzl%aspect_a"), "//test:main_target"); Map configuredAspects = analysisResult.getAspectsMap(); assertThat(configuredAspects).hasSize(4); assertThat(getConfiguredAspect(configuredAspects, "aspect_a")).isNotNull(); assertThat(getConfiguredAspect(configuredAspects, "aspect_b")).isNotNull(); assertThat(getConfiguredAspect(configuredAspects, "aspect_c")).isNotNull(); assertThat(getConfiguredAspect(configuredAspects, "aspect_d")).isNotNull(); } @Test public void testTopLevelAspectRequiresAspect_requireExistingAspect_passed() throws Exception { scratch.file( "test/defs.bzl", "def _impl(target, ctx):", " return []", "aspect_b = aspect(implementation = _impl)", "aspect_a = aspect(implementation = _impl, requires = [aspect_b])"); scratch.file("test/BUILD", "cc_binary(name = 'main_target')"); AnalysisResult analysisResult = update( ImmutableList.of("test/defs.bzl%aspect_b", "test/defs.bzl%aspect_a"), "//test:main_target"); Map configuredAspects = analysisResult.getAspectsMap(); assertThat(configuredAspects).hasSize(2); assertThat(getConfiguredAspect(configuredAspects, "aspect_a")).isNotNull(); assertThat(getConfiguredAspect(configuredAspects, "aspect_b")).isNotNull(); } @Test public void testTopLevelAspectRequiresAspect_requireExistingAspect_failed() throws Exception { scratch.file( "test/defs.bzl", "def _impl(target, ctx):", " return []", "aspect_b = aspect(implementation = _impl)", "aspect_a = aspect(implementation = _impl, requires = [aspect_b])"); scratch.file("test/BUILD", "cc_binary(name = 'main_target')"); reporter.removeHandler(failFastHandler); // The call to `update` does not throw an exception when "--keep_going" is passed in the // WithKeepGoing test suite. Otherwise, it throws ViewCreationFailedException. if (keepGoing()) { AnalysisResult result = update( ImmutableList.of("test/defs.bzl%aspect_a", "test/defs.bzl%aspect_b"), "//test:main_target"); assertThat(result.hasError()).isTrue(); } else { assertThrows( ViewCreationFailedException.class, () -> update( ImmutableList.of("test/defs.bzl%aspect_a", "test/defs.bzl%aspect_b"), "//test:main_target")); } assertContainsEvent( "aspect //test:defs.bzl%aspect_b was added before as a required" + " aspect of aspect //test:defs.bzl%aspect_a"); } @Test public void testTopLevelAspectRequiresAspect_ruleAttributes() throws Exception { scratch.file( "test/defs.bzl", "RequiredAspectProv = provider()", "BaseAspectProv = provider()", "", "def _required_aspect_impl(target, ctx):", " p_val = ['In required_aspect, p = {} on target {}'", " .format(ctx.rule.attr.p, target.label)]", " if ctx.rule.attr.dep and RequiredAspectProv in ctx.rule.attr.dep:", " p_val += ctx.rule.attr.dep[RequiredAspectProv].p_val", " return [RequiredAspectProv(p_val = p_val)]", "required_aspect = aspect(", " implementation = _required_aspect_impl,", ")", "", "def _base_aspect_impl(target, ctx):", " p_val = []", " p_val += target[RequiredAspectProv].p_val", " p_val += ['In base_aspect, p = {} on target {}'.format(ctx.rule.attr.p, target.label)]", " if ctx.rule.attr.dep:", " p_val += ctx.rule.attr.dep[BaseAspectProv].p_val", " return [BaseAspectProv(p_val = p_val)]", "base_aspect = aspect(", " implementation = _base_aspect_impl,", " attr_aspects = ['dep'],", " requires = [required_aspect],", ")", "", "def _rule_impl(ctx):", " pass", "", "my_rule = rule(", " implementation = _rule_impl,", " attrs = {", " 'dep': attr.label(),", " 'p' : attr.string(values = ['main_val', 'dep_val']),", " },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'my_rule')", "my_rule(", " name = 'main_target',", " dep = ':dep_target',", " p = 'main_val',", ")", "my_rule(", " name = 'dep_target',", " p = 'dep_val',", ")"); AnalysisResult analysisResult = update(ImmutableList.of("test/defs.bzl%base_aspect"), "//test:main_target"); // required_aspect can only run on main_target when propagated alone since its attr_aspects is // empty. Map configuredAspects = analysisResult.getAspectsMap(); ConfiguredAspect requiredAspect = getConfiguredAspect(configuredAspects, "required_aspect"); assertThat(requiredAspect).isNotNull(); StarlarkProvider.Key requiredAspectProv = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "RequiredAspectProv"); StructImpl requiredAspectProvider = (StructImpl) requiredAspect.get(requiredAspectProv); assertThat((Sequence) requiredAspectProvider.getValue("p_val")) .containsExactly("In required_aspect, p = main_val on target @//test:main_target"); // base_aspect can run on main_target and dep_target and it can also see the providers created // by running required_target on them. ConfiguredAspect baseAspect = getConfiguredAspect(configuredAspects, "base_aspect"); assertThat(baseAspect).isNotNull(); StarlarkProvider.Key baseAspectProv = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "BaseAspectProv"); StructImpl baseAspectProvider = (StructImpl) baseAspect.get(baseAspectProv); assertThat((Sequence) baseAspectProvider.getValue("p_val")) .containsExactly( "In base_aspect, p = dep_val on target @//test:dep_target", "In base_aspect, p = main_val on target @//test:main_target", "In required_aspect, p = dep_val on target @//test:dep_target", "In required_aspect, p = main_val on target @//test:main_target"); } @Test public void testTopLevelAspectRequiresAspect_inheritPropagationAttributes() throws Exception { // base_aspect propagates over base_dep attribute and requires first_required_aspect which // propagates over first_dep attribute and requires second_required_aspect which propagates over // second_dep attribute scratch.file( "test/defs.bzl", "BaseAspectProv = provider()", "FirstRequiredAspectProv = provider()", "SecondRequiredAspectProv = provider()", "", "def _second_required_aspect_impl(target, ctx):", " result = []", " if getattr(ctx.rule.attr, 'second_dep'):", " result += getattr(ctx.rule.attr, 'second_dep')[SecondRequiredAspectProv].result", " result += ['second_required_aspect run on target {}'.format(target.label)]", " return [SecondRequiredAspectProv(result = result)]", "second_required_aspect = aspect(", " implementation = _second_required_aspect_impl,", " attr_aspects = ['second_dep'],", ")", "", "def _first_required_aspect_impl(target, ctx):", " result = []", " result += target[SecondRequiredAspectProv].result", " if getattr(ctx.rule.attr, 'first_dep'):", " result += getattr(ctx.rule.attr, 'first_dep')[FirstRequiredAspectProv].result", " result += ['first_required_aspect run on target {}'.format(target.label)]", " return [FirstRequiredAspectProv(result = result)]", "first_required_aspect = aspect(", " implementation = _first_required_aspect_impl,", " attr_aspects = ['first_dep'],", " requires = [second_required_aspect],", ")", "", "def _base_aspect_impl(target, ctx):", " result = []", " result += target[FirstRequiredAspectProv].result", " if getattr(ctx.rule.attr, 'base_dep'):", " result += getattr(ctx.rule.attr, 'base_dep')[BaseAspectProv].result", " result += ['base_aspect run on target {}'.format(target.label)]", " return [BaseAspectProv(result = result)]", "base_aspect = aspect(", " implementation = _base_aspect_impl,", " attr_aspects = ['base_dep'],", " requires = [first_required_aspect],", ")", "", "def _my_rule_impl(ctx):", " pass", "", "my_rule = rule(", " implementation = _my_rule_impl,", " attrs = {", " 'base_dep': attr.label(),", " 'first_dep': attr.label(),", " 'second_dep': attr.label()", " },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'my_rule')", "my_rule(", " name = 'main_target',", " base_dep = ':base_dep_target',", " first_dep = ':first_dep_target',", " second_dep = ':second_dep_target',", ")", "my_rule(", " name = 'base_dep_target',", ")", "my_rule(", " name = 'first_dep_target',", ")", "my_rule(", " name = 'second_dep_target',", ")"); AnalysisResult analysisResult = update(ImmutableList.of("test/defs.bzl%base_aspect"), "//test:main_target"); // base_aspect should propagate only along its attr_aspects: 'base_dep' // first_required_aspect should propagate along 'base_dep' and 'first_dep' // second_required_aspect should propagate along 'base_dep', 'first_dep' and 'second_dep' Map configuredAspects = analysisResult.getAspectsMap(); ConfiguredAspect baseAspect = getConfiguredAspect(configuredAspects, "base_aspect"); assertThat(baseAspect).isNotNull(); StarlarkProvider.Key baseAspectProv = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "BaseAspectProv"); StructImpl baseAspectProvider = (StructImpl) baseAspect.get(baseAspectProv); assertThat((Sequence) baseAspectProvider.getValue("result")) .containsExactly( "second_required_aspect run on target @//test:second_dep_target", "second_required_aspect run on target @//test:main_target", "second_required_aspect run on target @//test:first_dep_target", "second_required_aspect run on target @//test:base_dep_target", "first_required_aspect run on target @//test:first_dep_target", "first_required_aspect run on target @//test:main_target", "first_required_aspect run on target @//test:base_dep_target", "base_aspect run on target @//test:base_dep_target", "base_aspect run on target @//test:main_target"); } @Test public void testTopLevelAspectRequiresAspect_inheritRequiredProviders() throws Exception { // aspect_a requires provider Prov_A and requires aspect_b which requires // provider Prov_B and requires aspect_c which requires provider Prov_C scratch.file( "test/defs.bzl", "Prov_A = provider()", "Prov_B = provider()", "Prov_C = provider()", "", "CollectorProv = provider()", "", "def _aspect_c_impl(target, ctx):", " collector_result = ['aspect_c run on target {} and value of Prov_C = {}'", " .format(target.label, target[Prov_C].val)]", " return [CollectorProv(result = collector_result)]", "aspect_c = aspect(", " implementation = _aspect_c_impl,", " required_providers = [Prov_C],", " attr_aspects = ['dep'],", ")", "", "def _aspect_b_impl(target, ctx):", " collector_result = []", " collector_result += ctx.rule.attr.dep[CollectorProv].result", " collector_result += ['aspect_b run on target {} and value of Prov_B = {}'", " .format(target.label, target[Prov_B].val)]", " return [CollectorProv(result = collector_result)]", "aspect_b = aspect(", " implementation = _aspect_b_impl,", " required_providers = [Prov_B],", " requires = [aspect_c],", " attr_aspects = ['dep'],", ")", "", "def _aspect_a_impl(target, ctx):", " collector_result = []", " collector_result += ctx.rule.attr.dep[CollectorProv].result", " collector_result += ['aspect_a run on target {} and value of Prov_A = {}'", " .format(target.label, target[Prov_A].val)]", " return [CollectorProv(result = collector_result)]", "aspect_a = aspect(", " implementation = _aspect_a_impl,", " attr_aspects = ['dep'],", " required_providers = [Prov_A],", " requires = [aspect_b],", ")", "", "def _my_rule_impl(ctx):", " return [Prov_A(val='main_val_a')]", "my_rule = rule(", " implementation = _my_rule_impl,", " attrs = {", " 'dep': attr.label(),", " },", " provides = [Prov_A]", ")", "", "def _rule_with_prov_a_impl(ctx):", " return [Prov_A(val='val_a')]", "rule_with_prov_a = rule(", " implementation = _rule_with_prov_a_impl,", " attrs = {", " 'dep': attr.label(),", " },", " provides = [Prov_A]", ")", "", "def _rule_with_prov_b_impl(ctx):", " return [Prov_B(val = 'val_b')]", "rule_with_prov_b = rule(", " implementation = _rule_with_prov_b_impl,", " attrs = {", " 'dep': attr.label(),", " },", " provides = [Prov_B]", ")", "", "def _rule_with_prov_c_impl(ctx):", " return [Prov_C(val = 'val_c')]", "rule_with_prov_c = rule(", " implementation = _rule_with_prov_c_impl,", " provides = [Prov_C]", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'my_rule', 'rule_with_prov_a', 'rule_with_prov_b'," + " 'rule_with_prov_c')", "my_rule(", " name = 'main_target',", " dep = ':target_with_prov_a',", ")", "rule_with_prov_a(", " name = 'target_with_prov_a',", " dep = ':target_with_prov_b'", ")", "rule_with_prov_b(", " name = 'target_with_prov_b',", " dep = ':target_with_prov_c'", ")", "rule_with_prov_c(", " name = 'target_with_prov_c'", ")"); AnalysisResult analysisResult = update(ImmutableList.of("test/defs.bzl%aspect_a"), "//test:main_target"); // aspect_a should run on main_target and target_with_prov_a // aspect_b can reach target_with_prov_b because it inherits the required_providers of aspect_a // aspect_c can reach target_with_prov_c because it inherits the required_providers of aspect_a // and aspect_b Map configuredAspects = analysisResult.getAspectsMap(); ConfiguredAspect aspectA = getConfiguredAspect(configuredAspects, "aspect_a"); assertThat(aspectA).isNotNull(); StarlarkProvider.Key collectorProv = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "CollectorProv"); StructImpl collectorProvider = (StructImpl) aspectA.get(collectorProv); assertThat((Sequence) collectorProvider.getValue("result")) .containsExactly( "aspect_c run on target @//test:target_with_prov_c and value of Prov_C = val_c", "aspect_b run on target @//test:target_with_prov_b and value of Prov_B = val_b", "aspect_a run on target @//test:target_with_prov_a and value of Prov_A = val_a", "aspect_a run on target @//test:main_target and value of Prov_A = main_val_a") .inOrder(); } @Test public void testTopLevelAspectRequiresAspect_inspectRequiredAspectActions() throws Exception { scratch.file( "test/defs.bzl", "BaseAspectProvider = provider()", "def _required_aspect_impl(target, ctx):", " f = ctx.actions.declare_file('dummy.txt')", " ctx.actions.run_shell(outputs = [f], command='echo xxx > $(location f)',", " mnemonic='RequiredAspectAction')", " return struct()", "required_aspect = aspect(", " implementation = _required_aspect_impl,", ")", "", "def _base_aspect_impl(target, ctx):", " required_aspect_action = None", " for action in target.actions:", " if action.mnemonic == 'RequiredAspectAction':", " required_aspect_action = action", " if required_aspect_action:", " return [BaseAspectProvider(result = 'base_aspect can see required_aspect action')]", " else:", " return [BaseAspectProvider(result = 'base_aspect cannot see required_aspect action')]", "base_aspect = aspect(", " implementation = _base_aspect_impl,", " attr_aspects = ['dep'],", " requires = [required_aspect]", ")", "", "def _my_rule_impl(ctx):", " pass", "my_rule = rule(", " implementation = _my_rule_impl,", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'my_rule')", "my_rule(", " name = 'main_target',", ")"); AnalysisResult analysisResult = update(ImmutableList.of("test/defs.bzl%base_aspect"), "//test:main_target"); Map configuredAspects = analysisResult.getAspectsMap(); ConfiguredAspect baseAspect = getConfiguredAspect(configuredAspects, "base_aspect"); assertThat(baseAspect).isNotNull(); StarlarkProvider.Key baseAspectProv = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "BaseAspectProvider"); StructImpl baseAspectProvider = (StructImpl) baseAspect.get(baseAspectProv); assertThat(baseAspectProvider.getValue("result")) .isEqualTo("base_aspect can see required_aspect action"); } @Test public void testTopLevelAspectRequiresAspect_inspectRequiredAspectGeneratedFiles() throws Exception { scratch.file( "test/defs.bzl", "BaseAspectProvider = provider()", "def _required_aspect_impl(target, ctx):", " file = ctx.actions.declare_file('required_aspect_file')", " ctx.actions.write(file, 'data')", " return [OutputGroupInfo(out = [file])]", "required_aspect = aspect(", " implementation = _required_aspect_impl,", ")", "", "def _base_aspect_impl(target, ctx):", " files = ['base_aspect can see file ' + f.path.split('/')[-1] ", " for f in target[OutputGroupInfo].out.to_list()]", " return [BaseAspectProvider(my_files = files)]", "base_aspect = aspect(", " implementation = _base_aspect_impl,", " attr_aspects = ['dep'],", " requires = [required_aspect]", ")", "", "def _my_rule_impl(ctx):", " pass", "my_rule = rule(", " implementation = _my_rule_impl,", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'my_rule')", "my_rule(", " name = 'main_target',", ")"); AnalysisResult analysisResult = update(ImmutableList.of("test/defs.bzl%base_aspect"), "//test:main_target"); Map configuredAspects = analysisResult.getAspectsMap(); ConfiguredAspect baseAspect = getConfiguredAspect(configuredAspects, "base_aspect"); assertThat(baseAspect).isNotNull(); StarlarkProvider.Key baseAspectProv = new StarlarkProvider.Key(Label.parseCanonical("//test:defs.bzl"), "BaseAspectProvider"); StructImpl baseAspectProvider = (StructImpl) baseAspect.get(baseAspectProv); assertThat((Sequence) baseAspectProvider.getValue("my_files")) .containsExactly("base_aspect can see file required_aspect_file"); } @Test public void testTopLevelAspectRequiresAspect_withRequiredAspectProvidersSatisfied() throws Exception { scratch.file( "test/defs.bzl", "prov_a = provider()", "prov_b = provider()", "prov_b_forwarded = provider()", "", "def _aspect_b_impl(target, ctx):", " result = 'aspect_b on target {} '.format(target.label)", " if prov_b in target:", " result += 'found prov_b = {}'.format(target[prov_b].val)", " return struct(aspect_b_result = result,", " providers = [prov_b_forwarded(val = target[prov_b].val)])", " else:", " result += 'cannot find prov_b'", " return struct(aspect_b_result = result)", "aspect_b = aspect(", " implementation = _aspect_b_impl,", " required_aspect_providers = [prov_b]", ")", "", "def _aspect_a_impl(target, ctx):", " result = 'aspect_a on target {} '.format(target.label)", " if prov_a in target:", " result += 'found prov_a = {}'.format(target[prov_a].val)", " else:", " result += 'cannot find prov_a'", " if prov_b_forwarded in target:", " result += ' and found prov_b = {}'.format(target[prov_b_forwarded].val)", " else:", " result += ' but cannot find prov_b'", " return struct(aspect_a_result = result)", "", "aspect_a = aspect(", " implementation = _aspect_a_impl,", " required_aspect_providers = [prov_a],", " attr_aspects = ['dep'],", " requires = [aspect_b]", ")", "", "def _aspect_with_prov_a_impl(target, ctx):", " return [prov_a(val = 'a1')]", "aspect_with_prov_a = aspect(", " implementation = _aspect_with_prov_a_impl,", " provides = [prov_a],", " attr_aspects = ['dep'],", ")", "", "def _aspect_with_prov_b_impl(target, ctx):", " return [prov_b(val = 'b1')]", "aspect_with_prov_b = aspect(", " implementation = _aspect_with_prov_b_impl,", " provides = [prov_b],", " attr_aspects = ['dep'],", ")", "", "def _my_rule_impl(ctx):", " pass", "my_rule = rule(", " implementation = _my_rule_impl,", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'my_rule')", "my_rule(", " name = 'main_target',", ")"); AnalysisResult analysisResult = update( ImmutableList.of( "test/defs.bzl%aspect_with_prov_a", "test/defs.bzl%aspect_with_prov_b", "test/defs.bzl%aspect_a"), "//test:main_target"); Map configuredAspects = analysisResult.getAspectsMap(); ConfiguredAspect aspectA = getConfiguredAspect(configuredAspects, "aspect_a"); assertThat(aspectA).isNotNull(); String aspectAResult = (String) aspectA.get("aspect_a_result"); assertThat(aspectAResult) .isEqualTo( "aspect_a on target @//test:main_target found prov_a = a1 and found prov_b = b1"); ConfiguredAspect aspectB = getConfiguredAspect(configuredAspects, "aspect_b"); assertThat(aspectB).isNotNull(); String aspectBResult = (String) aspectB.get("aspect_b_result"); assertThat(aspectBResult).isEqualTo("aspect_b on target @//test:main_target found prov_b = b1"); } @Test public void testTopLevelAspectRequiresAspect_withRequiredAspectProvidersNotFound() throws Exception { scratch.file( "test/defs.bzl", "prov_a = provider()", "prov_b = provider()", "", "def _aspect_b_impl(target, ctx):", " result = 'aspect_b on target {} '.format(target.label)", " if prov_b in target:", " result += 'found prov_b = {}'.format(target[prov_b].val)", " else:", " result += 'cannot find prov_b'", " return struct(aspect_b_result = result)", "aspect_b = aspect(", " implementation = _aspect_b_impl,", " required_aspect_providers = [prov_b]", ")", "", "def _aspect_a_impl(target, ctx):", " result = 'aspect_a on target {} '.format(target.label)", " if prov_a in target:", " result += 'found prov_a = {}'.format(target[prov_a].val)", " else:", " result += 'cannot find prov_a'", " return struct(aspect_a_result = result)", "", "aspect_a = aspect(", " implementation = _aspect_a_impl,", " required_aspect_providers = [prov_a],", " attr_aspects = ['dep'],", " requires = [aspect_b]", ")", "", "def _aspect_with_prov_a_impl(target, ctx):", " return [prov_a(val = 'a1')]", "aspect_with_prov_a = aspect(", " implementation = _aspect_with_prov_a_impl,", " provides = [prov_a],", " attr_aspects = ['dep'],", ")", "", "def _my_rule_impl(ctx):", " pass", "my_rule = rule(", " implementation = _my_rule_impl,", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'my_rule')", "my_rule(", " name = 'main_target',", ")"); AnalysisResult analysisResult = update( ImmutableList.of("test/defs.bzl%aspect_with_prov_a", "test/defs.bzl%aspect_a"), "//test:main_target"); Map configuredAspects = analysisResult.getAspectsMap(); ConfiguredAspect aspectA = getConfiguredAspect(configuredAspects, "aspect_a"); assertThat(aspectA).isNotNull(); String aspectAResult = (String) aspectA.get("aspect_a_result"); assertThat(aspectAResult).isEqualTo("aspect_a on target @//test:main_target found prov_a = a1"); ConfiguredAspect aspectB = getConfiguredAspect(configuredAspects, "aspect_b"); assertThat(aspectB).isNotNull(); String aspectBResult = (String) aspectB.get("aspect_b_result"); assertThat(aspectBResult) .isEqualTo("aspect_b on target @//test:main_target cannot find prov_b"); } @Ignore("TODO(b/206127051): Fix the crash, rename the test and add a check the error message.") @Test public void testDependentAspectWithNonExecutableTool_doesNotCrash() throws Exception { scratch.file("test/BUILD", "sh_binary(name='bin', srcs=['bin.sh'])", "sh_library(name='lib')"); scratch.file( "test/defs.bzl", "AInfo = provider(fields={})", "def _aspect_a(target, ctx): return AInfo()", "aspect_a = aspect(", " implementation = _aspect_a,", " provides=[AInfo],", " attrs = {'_attr':" + " attr.label(default=':lib')},", ")", "def _aspect_b(target, ctx):", " print(str(ctx.executable._attr))", " return []", "aspect_b = aspect(", " implementation = _aspect_b,", " required_aspect_providers = [AInfo],", " attrs = {'_attr': attr.label(default=':bin', executable=True, cfg='exec')},", ")"); scratch.file("test/bin.sh").setExecutable(true); // TODO(b/206127051): This currently crashes with an IllegalStateException. update(ImmutableList.of("test/defs.bzl%aspect_a", "test/defs.bzl%aspect_b"), "//test:bin"); } @Test public void testTopLevelAspectsWithParameters() throws Exception { scratch.file( "test/defs.bzl", "def _aspect_a_impl(target, ctx):", " result = ['aspect_a on target {}, p1 = {} and a_p = {}'.", " format(target.label, ctx.attr.p1, ctx.attr.a_p)]", " if ctx.rule.attr.dep:", " result += ctx.rule.attr.dep.aspect_a_result", " return struct(aspect_a_result = result)", "", "aspect_a = aspect(", " implementation = _aspect_a_impl,", " attr_aspects = ['dep'],", " attrs = { 'p1' : attr.string(values = ['p1_v1', 'p1_v2']),", " 'a_p' : attr.string(values = ['a_p_v1', 'a_p_v2'])},", ")", "", "def _aspect_b_impl(target, ctx):", " result = ['aspect_b on target {}, p1 = {} and b_p = {}'.", " format(target.label, ctx.attr.p1, ctx.attr.b_p)]", " if ctx.rule.attr.dep:", " result += ctx.rule.attr.dep.aspect_b_result", " return struct(aspect_b_result = result)", "", "aspect_b = aspect(", " implementation = _aspect_b_impl,", " attr_aspects = ['dep'],", " attrs = { 'p1' : attr.string(values = ['p1_v1', 'p1_v2']),", " 'b_p' : attr.string(values = ['b_p_v1', 'b_p_v2'])},", ")", "", "def _my_rule_impl(ctx):", " pass", "my_rule = rule(", " implementation = _my_rule_impl,", " attrs = { 'dep' : attr.label() },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'my_rule')", "my_rule(", " name = 'main_target',", " dep = ':dep_target_1',", ")", "my_rule(", " name = 'dep_target_1',", " dep = ':dep_target_2',", ")", "my_rule(", " name = 'dep_target_2',", ")"); AnalysisResult analysisResult = update( ImmutableList.of("//test:defs.bzl%aspect_a", "//test:defs.bzl%aspect_b"), ImmutableMap.of("p1", "p1_v1", "a_p", "a_p_v1", "b_p", "b_p_v1"), "//test:main_target"); Map configuredAspects = analysisResult.getAspectsMap(); ConfiguredAspect aspectA = getConfiguredAspect(configuredAspects, "aspect_a"); assertThat(aspectA).isNotNull(); StarlarkList aspectAResult = (StarlarkList) aspectA.get("aspect_a_result"); assertThat(Starlark.toIterable(aspectAResult)) .containsExactly( "aspect_a on target @//test:main_target, p1 = p1_v1 and a_p = a_p_v1", "aspect_a on target @//test:dep_target_1, p1 = p1_v1 and a_p = a_p_v1", "aspect_a on target @//test:dep_target_2, p1 = p1_v1 and a_p = a_p_v1"); ConfiguredAspect aspectB = getConfiguredAspect(configuredAspects, "aspect_b"); assertThat(aspectB).isNotNull(); StarlarkList aspectBResult = (StarlarkList) aspectB.get("aspect_b_result"); assertThat(Starlark.toIterable(aspectBResult)) .containsExactly( "aspect_b on target @//test:main_target, p1 = p1_v1 and b_p = b_p_v1", "aspect_b on target @//test:dep_target_1, p1 = p1_v1 and b_p = b_p_v1", "aspect_b on target @//test:dep_target_2, p1 = p1_v1 and b_p = b_p_v1"); } @Test public void testTopLevelAspectsWithParameters_differentAllowedValues() throws Exception { scratch.file( "test/defs.bzl", "def _aspect_a_impl(target, ctx):", " result = ['aspect_a on target {}, p1 = {} and p2 = {}'.", " format(target.label, ctx.attr.p1, ctx.attr.p2)]", " if ctx.rule.attr.dep:", " result += ctx.rule.attr.dep.aspect_a_result", " return struct(aspect_a_result = result)", "", "aspect_a = aspect(", " implementation = _aspect_a_impl,", " attr_aspects = ['dep'],", " attrs = { 'p1' : attr.string(values = ['p1_v1', 'p1_v2']) },", ")", "", "def _aspect_b_impl(target, ctx):", " result = ['aspect_b on target {}, p1 = {} and p2 = {}'.", " format(target.label, ctx.attr.p1, ctx.attr.p2)]", " if ctx.rule.attr.dep:", " result += ctx.rule.attr.dep.aspect_b_result", " return struct(aspect_b_result = result)", "", "aspect_b = aspect(", " implementation = _aspect_b_impl,", " attr_aspects = ['dep'],", " attrs = { 'p1' : attr.string(values = ['p1_v2', 'p1_v3']) },", ")", "", "def _my_rule_impl(ctx):", " pass", "my_rule = rule(", " implementation = _my_rule_impl,", " attrs = { 'dep' : attr.label() },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'my_rule')", "my_rule(", " name = 'main_target',", " dep = ':dep_target_1',", ")", "my_rule(", " name = 'dep_target_1',", " dep = ':dep_target_2',", ")", "my_rule(", " name = 'dep_target_2',", ")"); reporter.removeHandler(failFastHandler); // This call succeeds if "--keep_going" was passed, which it does in the WithKeepGoing test // suite. Otherwise, it fails and throws a ViewCreationFailedException. if (keepGoing()) { AnalysisResult analysisResult = update( ImmutableList.of("//test:defs.bzl%aspect_a", "//test:defs.bzl%aspect_b"), ImmutableMap.of("p1", "p1_v1"), "//test:main_target"); assertThat(analysisResult.hasError()).isTrue(); } else { assertThrows( ViewCreationFailedException.class, () -> update( ImmutableList.of("//test:defs.bzl%aspect_a", "//test:defs.bzl%aspect_b"), ImmutableMap.of("p1", "p1_v1"), "//test:main_target")); } assertContainsEvent( "//test:defs.bzl%aspect_b: invalid value in 'p1' attribute: has to be one of 'p1_v2' or" + " 'p1_v3' instead of 'p1_v1'"); } @Test public void testTopLevelAspectsWithParameters_useDefaultValue() throws Exception { scratch.file( "test/defs.bzl", "def _aspect_a_impl(target, ctx):", " result = ['aspect_a on target {}, p1 = {} and p2 = {}'.", " format(target.label, ctx.attr.p1, ctx.attr.p2)]", " if ctx.rule.attr.dep:", " result += ctx.rule.attr.dep.aspect_a_result", " return struct(aspect_a_result = result)", "", "aspect_a = aspect(", " implementation = _aspect_a_impl,", " attr_aspects = ['dep'],", " attrs = { 'p1' : attr.string(values = ['p1_v1', 'p1_v2'], default = 'p1_v1'),", " 'p2' : attr.string(values = ['p2_v1', 'p2_v2'], default = 'p2_v1')},", ")", "", "def _my_rule_impl(ctx):", " pass", "my_rule = rule(", " implementation = _my_rule_impl,", " attrs = { 'dep' : attr.label() },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'my_rule')", "my_rule(", " name = 'main_target',", " dep = ':dep_target_1',", ")", "my_rule(", " name = 'dep_target_1',", " dep = ':dep_target_2',", ")", "my_rule(", " name = 'dep_target_2',", ")"); AnalysisResult analysisResult = update( ImmutableList.of("//test:defs.bzl%aspect_a"), ImmutableMap.of("p1", "p1_v2"), "//test:main_target"); Map configuredAspects = analysisResult.getAspectsMap(); ConfiguredAspect aspectA = getConfiguredAspect(configuredAspects, "aspect_a"); assertThat(aspectA).isNotNull(); StarlarkList aspectAResult = (StarlarkList) aspectA.get("aspect_a_result"); assertThat(Starlark.toIterable(aspectAResult)) .containsExactly( "aspect_a on target @//test:main_target, p1 = p1_v2 and p2 = p2_v1", "aspect_a on target @//test:dep_target_1, p1 = p1_v2 and p2 = p2_v1", "aspect_a on target @//test:dep_target_2, p1 = p1_v2 and p2 = p2_v1"); } @Test public void testTopLevelAspectsWithParameters_passParametersToRequiredAspect() throws Exception { scratch.file( "test/defs.bzl", "def _aspect_b_impl(target, ctx):", " result = ['aspect_b on target {}, p1 = {} and p3 = {}'.", " format(target.label, ctx.attr.p1, ctx.attr.p3)]", " if ctx.rule.attr.dep:", " result += ctx.rule.attr.dep.aspect_b_result", " return struct(aspect_b_result = result)", "", "aspect_b = aspect(", " implementation = _aspect_b_impl,", " attr_aspects = ['dep'],", " attrs = { 'p1' : attr.string(values = ['p1_v1', 'p1_v2']),", " 'p3' : attr.string(values = ['p3_v1', 'p3_v2', 'p3_v3'])},", ")", "", "def _aspect_a_impl(target, ctx):", " result = ['aspect_a on target {}, p1 = {} and p2 = {}'.", " format(target.label, ctx.attr.p1, ctx.attr.p2)]", " if ctx.rule.attr.dep:", " result += ctx.rule.attr.dep.aspect_a_result", " return struct(aspect_a_result = result)", "", "aspect_a = aspect(", " implementation = _aspect_a_impl,", " attr_aspects = ['dep'],", " attrs = { 'p1' : attr.string(values = ['p1_v1', 'p1_v2']),", " 'p2' : attr.string(values = ['p2_v1', 'p2_v2'])},", " requires = [aspect_b],", ")", "", "def _my_rule_impl(ctx):", " pass", "my_rule = rule(", " implementation = _my_rule_impl,", " attrs = { 'dep' : attr.label() },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'my_rule')", "my_rule(", " name = 'main_target',", " dep = ':dep_target_1',", ")", "my_rule(", " name = 'dep_target_1',", " dep = ':dep_target_2',", ")", "my_rule(", " name = 'dep_target_2',", ")"); AnalysisResult analysisResult = update( ImmutableList.of("//test:defs.bzl%aspect_a"), ImmutableMap.of("p1", "p1_v1", "p2", "p2_v2", "p3", "p3_v3"), "//test:main_target"); Map configuredAspects = analysisResult.getAspectsMap(); ConfiguredAspect aspectA = getConfiguredAspect(configuredAspects, "aspect_a"); assertThat(aspectA).isNotNull(); StarlarkList aspectAResult = (StarlarkList) aspectA.get("aspect_a_result"); assertThat(Starlark.toIterable(aspectAResult)) .containsExactly( "aspect_a on target @//test:main_target, p1 = p1_v1 and p2 = p2_v2", "aspect_a on target @//test:dep_target_1, p1 = p1_v1 and p2 = p2_v2", "aspect_a on target @//test:dep_target_2, p1 = p1_v1 and p2 = p2_v2"); ConfiguredAspect aspectB = getConfiguredAspect(configuredAspects, "aspect_b"); assertThat(aspectB).isNotNull(); StarlarkList aspectBResult = (StarlarkList) aspectB.get("aspect_b_result"); assertThat(Starlark.toIterable(aspectBResult)) .containsExactly( "aspect_b on target @//test:main_target, p1 = p1_v1 and p3 = p3_v3", "aspect_b on target @//test:dep_target_1, p1 = p1_v1 and p3 = p3_v3", "aspect_b on target @//test:dep_target_2, p1 = p1_v1 and p3 = p3_v3"); } @Test public void testTopLevelAspectsWithParameters_invalidParameterValue() throws Exception { scratch.file( "test/defs.bzl", "def _aspect_a_impl(target, ctx):", " result = ['aspect_a on target {}, p = {}'.", " format(target.label, ctx.attr.p)]", " if ctx.rule.attr.dep:", " result += ctx.rule.attr.dep.aspect_a_result", " return struct(aspect_a_result = result)", "", "aspect_a = aspect(", " implementation = _aspect_a_impl,", " attr_aspects = ['dep'],", " attrs = { 'p' : attr.string(values = ['p_v1', 'p_v2']) },", ")", "", "def _my_rule_impl(ctx):", " pass", "my_rule = rule(", " implementation = _my_rule_impl,", " attrs = { 'dep' : attr.label() },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'my_rule')", "my_rule(", " name = 'main_target',", " dep = ':dep_target_1',", ")", "my_rule(", " name = 'dep_target_1',", " dep = ':dep_target_2',", ")", "my_rule(", " name = 'dep_target_2',", ")"); reporter.removeHandler(failFastHandler); // This call succeeds if "--keep_going" was passed, which it does in the WithKeepGoing test // suite. Otherwise, it fails and throws a ViewCreationFailedException. if (keepGoing()) { AnalysisResult analysisResult = update( ImmutableList.of("//test:defs.bzl%aspect_a"), ImmutableMap.of("p", "p_v"), "//test:main_target"); assertThat(analysisResult.hasError()).isTrue(); } else { assertThrows( ViewCreationFailedException.class, () -> update( ImmutableList.of("//test:defs.bzl%aspect_a"), ImmutableMap.of("p", "p_v"), "//test:main_target")); } assertContainsEvent( "//test:defs.bzl%aspect_a: invalid value in 'p' attribute: has to be one of 'p_v1' or" + " 'p_v2' instead of 'p_v'"); } @Test public void testTopLevelAspectsWithParameters_missingMandatoryParameter() throws Exception { scratch.file( "test/defs.bzl", "def _aspect_a_impl(target, ctx):", " result = ['aspect_a on target {}, p1 = {}'.", " format(target.label, ctx.attr.p1)]", " if ctx.rule.attr.dep:", " result += ctx.rule.attr.dep.aspect_a_result", " return struct(aspect_a_result = result)", "", "aspect_a = aspect(", " implementation = _aspect_a_impl,", " attr_aspects = ['dep'],", " attrs = { 'p1' : attr.string(mandatory = True, default = 'p1_v1',", " values = ['p1_v1', 'p1_v2']),", " 'p2' : attr.string(values = ['p2_v1', 'p2_v2'])},", ")", "", "def _my_rule_impl(ctx):", " pass", "my_rule = rule(", " implementation = _my_rule_impl,", " attrs = { 'dep' : attr.label() },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'my_rule')", "my_rule(", " name = 'main_target',", " dep = ':dep_target_1',", ")", "my_rule(", " name = 'dep_target_1',", " dep = ':dep_target_2',", ")", "my_rule(", " name = 'dep_target_2',", ")"); reporter.removeHandler(failFastHandler); // This call succeeds if "--keep_going" was passed, which it does in the WithKeepGoing test // suite. Otherwise, it fails and throws a ViewCreationFailedException. if (keepGoing()) { AnalysisResult analysisResult = update( ImmutableList.of("//test:defs.bzl%aspect_a"), ImmutableMap.of("p2", "p2_v1"), "//test:main_target"); assertThat(analysisResult.hasError()).isTrue(); } else { assertThrows( ViewCreationFailedException.class, () -> update( ImmutableList.of("//test:defs.bzl%aspect_a"), ImmutableMap.of("p2", "p2_v1"), "//test:main_target")); } assertContainsEvent("Missing mandatory attribute 'p1' for aspect '//test:defs.bzl%aspect_a'"); } @Test public void testTopLevelAspectsWithParameters_unusedParameter() throws Exception { scratch.file( "test/defs.bzl", "def _aspect_a_impl(target, ctx):", " result = ['aspect_a on target {}, p1 = {} and a_p = {}'.", " format(target.label, ctx.attr.p1, ctx.attr.a_p)]", " if ctx.rule.attr.dep:", " result += ctx.rule.attr.dep.aspect_a_result", " return struct(aspect_a_result = result)", "", "aspect_a = aspect(", " implementation = _aspect_a_impl,", " attr_aspects = ['dep'],", " attrs = { 'p1' : attr.string(values = ['p1_v1', 'p1_v2']),", " 'a_p' : attr.string(values = ['a_p_v1', 'a_p_v2'])},", ")", "", "def _aspect_b_impl(target, ctx):", " result = ['aspect_b on target {}, p1 = {} and b_p = {}'.", " format(target.label, ctx.attr.p1, ctx.attr.b_p)]", " if ctx.rule.attr.dep:", " result += ctx.rule.attr.dep.aspect_b_result", " return struct(aspect_b_result = result)", "", "aspect_b = aspect(", " implementation = _aspect_b_impl,", " attr_aspects = ['dep'],", " attrs = { 'p1' : attr.string(values = ['p1_v1', 'p1_v2']),", " 'b_p' : attr.string(values = ['b_p_v1', 'b_p_v2'])},", ")", "", "def _my_rule_impl(ctx):", " pass", "my_rule = rule(", " implementation = _my_rule_impl,", " attrs = { 'dep' : attr.label() },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'my_rule')", "my_rule(", " name = 'main_target',", " dep = ':dep_target_1',", ")", "my_rule(", " name = 'dep_target_1',", " dep = ':dep_target_2',", ")", "my_rule(", " name = 'dep_target_2',", ")"); reporter.removeHandler(failFastHandler); // This call succeeds if "--keep_going" was passed, which it does in the WithKeepGoing test // suite. Otherwise, it fails and throws a ViewCreationFailedException. if (keepGoing()) { AnalysisResult analysisResult = update( ImmutableList.of("//test:defs.bzl%aspect_a", "//test:defs.bzl%aspect_b"), ImmutableMap.of("p2", "p2_v1", "b_p", "b_p_v1"), "//test:main_target"); assertThat(analysisResult.hasError()).isTrue(); } else { assertThrows( ViewCreationFailedException.class, () -> update( ImmutableList.of("//test:defs.bzl%aspect_a", "//test:defs.bzl%aspect_b"), ImmutableMap.of("p2", "p2_v1", "b_p", "b_p_v1"), "//test:main_target")); } assertContainsEvent( "Parameters '[p2]' are not parameters of any of the top-level aspects but they are" + " specified in --aspects_parameters."); } @Test public void testTopLevelAspectsWithParameters_invalidDefaultParameterValue() throws Exception { scratch.file( "test/defs.bzl", "def _aspect_a_impl(target, ctx):", " result = ['aspect_a on target {}, p = {}'.", " format(target.label, ctx.attr.p)]", " if ctx.rule.attr.dep:", " result += ctx.rule.attr.dep.aspect_a_result", " return struct(aspect_a_result = result)", "", "aspect_a = aspect(", " implementation = _aspect_a_impl,", " attr_aspects = ['dep'],", " attrs = { 'p' : attr.string(values = ['p_v1', 'p_v2']) },", ")", "", "def _my_rule_impl(ctx):", " pass", "my_rule = rule(", " implementation = _my_rule_impl,", " attrs = { 'dep' : attr.label() },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'my_rule')", "my_rule(", " name = 'main_target',", " dep = ':dep_target_1',", ")", "my_rule(", " name = 'dep_target_1',", " dep = ':dep_target_2',", ")", "my_rule(", " name = 'dep_target_2',", ")"); reporter.removeHandler(failFastHandler); // This call succeeds if "--keep_going" was passed, which it does in the WithKeepGoing test // suite. Otherwise, it fails and throws a ViewCreationFailedException. if (keepGoing()) { AnalysisResult analysisResult = update(ImmutableList.of("//test:defs.bzl%aspect_a"), "//test:main_target"); assertThat(analysisResult.hasError()).isTrue(); } else { assertThrows( ViewCreationFailedException.class, () -> update(ImmutableList.of("//test:defs.bzl%aspect_a"), "//test:main_target")); } assertContainsEvent( "//test:defs.bzl%aspect_a: invalid value in 'p' attribute: has to be one of 'p_v1' or" + " 'p_v2' instead of ''"); } @Test public void testTopLevelAspectsWithParameters_noNeedForAllowedValues() throws Exception { scratch.file( "test/defs.bzl", "def _aspect_a_impl(target, ctx):", " result = ['aspect_a on target {}, p = {}'.", " format(target.label, ctx.attr.p)]", " if ctx.rule.attr.dep:", " result += ctx.rule.attr.dep.aspect_a_result", " return struct(aspect_a_result = result)", "", "aspect_a = aspect(", " implementation = _aspect_a_impl,", " attr_aspects = ['dep'],", " attrs = { 'p' : attr.string(default='val') },", ")", "", "def _my_rule_impl(ctx):", " pass", "my_rule = rule(", " implementation = _my_rule_impl,", " attrs = { 'dep' : attr.label() },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'my_rule')", "my_rule(", " name = 'main_target',", " dep = ':dep_target_1',", ")", "my_rule(", " name = 'dep_target_1',", " dep = ':dep_target_2',", ")", "my_rule(", " name = 'dep_target_2',", ")"); AnalysisResult analysisResult = update( ImmutableList.of("//test:defs.bzl%aspect_a"), ImmutableMap.of("p", "p_v"), "//test:main_target"); ImmutableMap configuredAspects = analysisResult.getAspectsMap(); ConfiguredAspect aspectA = getConfiguredAspect(configuredAspects, "aspect_a"); assertThat(aspectA).isNotNull(); StarlarkList aspectAResult = (StarlarkList) aspectA.get("aspect_a_result"); assertThat(Starlark.toIterable(aspectAResult)) .containsExactly( "aspect_a on target @//test:main_target, p = p_v", "aspect_a on target @//test:dep_target_1, p = p_v", "aspect_a on target @//test:dep_target_2, p = p_v"); } /** * Aspect parameter has to require set of values only if the aspect is used in a rule attribute. */ @Test public void testAttrAspectParameterMissingRequiredValues() throws Exception { scratch.file( "test/defs.bzl", "def _impl(target, ctx):", " pass", "my_aspect = aspect(_impl,", " attrs = { 'param' : attr.string(default = 'c') }", ")", "def _rule_impl(ctx):", " pass", "r1 = rule(_rule_impl, attrs={'dep': attr.label(aspects = [my_aspect])})"); scratch.file("test/BUILD", "load('//test:defs.bzl', 'r1')", "r1(name = 'main_target')"); reporter.removeHandler(failFastHandler); // This call succeeds if "--keep_going" was passed, which it does in the WithKeepGoing test // suite. Otherwise, it fails and throws a TargetParsingException. if (keepGoing()) { AnalysisResult analysisResult = update("//test:main_target"); assertThat(analysisResult.hasError()).isTrue(); } else { assertThrows(TargetParsingException.class, () -> update("//test:main_target")); } assertContainsEvent( "Aspect //test:defs.bzl%my_aspect: Aspect parameter attribute 'param' must use the 'values'" + " restriction."); } /** * Aspect parameter has to require set of values only if the aspect is used in a rule attribute. */ @Test public void testAttrRequiredAspectParameterMissingRequiredValues() throws Exception { scratch.file( "test/defs.bzl", "def _impl(target, ctx):", " pass", "required_aspect = aspect(_impl,", " attrs = { 'p1' : attr.string(default = 'b') }", ")", "my_aspect = aspect(_impl,", " attrs = { 'p2' : attr.string(default = 'c', values = ['c']) },", " requires = [required_aspect],", ")", "def _rule_impl(ctx):", " pass", "r1 = rule(_rule_impl, attrs={'dep': attr.label(aspects = [my_aspect])})"); scratch.file("test/BUILD", "load('//test:defs.bzl', 'r1')", "r1(name = 'main_target')"); reporter.removeHandler(failFastHandler); // This call succeeds if "--keep_going" was passed, which it does in the WithKeepGoing test // suite. Otherwise, it fails and throws a TargetParsingException. if (keepGoing()) { AnalysisResult analysisResult = update("//test:main_target"); assertThat(analysisResult.hasError()).isTrue(); } else { assertThrows(TargetParsingException.class, () -> update("//test:main_target")); } assertContainsEvent( "Aspect //test:defs.bzl%required_aspect: Aspect parameter attribute 'p1' must use the" + " 'values' restriction."); } @Test public void integerAspectParameter_mandatoryAttrNotCoveredByRule() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " return struct()", "def _rule_impl(ctx):", " return struct()", "MyAspectUncovered = aspect(", " implementation=_impl,", " attrs = { 'my_attr' : attr.int(default = 1, values = [1, 2], mandatory = True) },", ")", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'deps' : attr.label_list(aspects=[MyAspectUncovered]) },", ")"); scratch.file("test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "my_rule(name ='main')"); reporter.removeHandler(failFastHandler); // This call succeeds if "--keep_going" was passed, which it does in the WithKeepGoing test // suite. Otherwise, it fails and throws a TargetParsingException. if (keepGoing()) { AnalysisResult analysisResult = update(ImmutableList.of(), "//test:main"); assertThat(analysisResult.hasError()).isTrue(); } else { assertThrows(TargetParsingException.class, () -> update(ImmutableList.of(), "//test:main")); } assertContainsEvent( "Aspect //test:aspect.bzl%MyAspectUncovered requires rule my_rule to specify attribute " + "'my_attr' with type int."); } @Test public void integerAspectParameter_mandatoryAttrWithWrongTypeInRule() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " return struct()", "def _rule_impl(ctx):", " return struct()", "MyAspectUncovered = aspect(", " implementation=_impl,", " attrs = { 'my_attr' : attr.int(default = 1, values = [1, 2], mandatory = True) },", ")", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'deps' : attr.label_list(aspects=[MyAspectUncovered]),", " 'my_attr': attr.string() },", ")"); scratch.file("test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "my_rule(name ='main')"); reporter.removeHandler(failFastHandler); // This call succeeds if "--keep_going" was passed, which it does in the WithKeepGoing test // suite. Otherwise, it fails and throws a TargetParsingException. if (keepGoing()) { AnalysisResult analysisResult = update(ImmutableList.of(), "//test:main"); assertThat(analysisResult.hasError()).isTrue(); } else { assertThrows(TargetParsingException.class, () -> update(ImmutableList.of(), "//test:main")); } assertContainsEvent( "Aspect //test:aspect.bzl%MyAspectUncovered requires rule my_rule to specify attribute " + "'my_attr' with type int."); } @Test public void integerAspectParameter_attrWithoutDefaultNotCoveredByRule() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " return struct()", "def _rule_impl(ctx):", " return struct()", "MyAspectUncovered = aspect(", " implementation=_impl,", " attrs = { 'my_attr' : attr.int(values = [1, 2]) },", ")", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'deps' : attr.label_list(aspects=[MyAspectUncovered]) },", ")"); scratch.file("test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "my_rule(name ='main')"); reporter.removeHandler(failFastHandler); // This call succeeds if "--keep_going" was passed, which it does in the WithKeepGoing test // suite. Otherwise, it fails and throws a TargetParsingException. if (keepGoing()) { AnalysisResult analysisResult = update(ImmutableList.of(), "//test:main"); assertThat(analysisResult.hasError()).isTrue(); } else { assertThrows(TargetParsingException.class, () -> update(ImmutableList.of(), "//test:main")); } assertContainsEvent( "Aspect //test:aspect.bzl%MyAspectUncovered requires rule my_rule to specify attribute " + "'my_attr' with type int."); } @Test public void integerAspectParameter_attrWithoutDefaultWrongTypeInRule() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " return struct()", "def _rule_impl(ctx):", " return struct()", "MyAspectUncovered = aspect(", " implementation=_impl,", " attrs = { 'my_attr' : attr.int(values = [1, 2]) },", ")", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'deps' : attr.label_list(aspects=[MyAspectUncovered]),", " 'my_attr': attr.string() },", ")"); scratch.file("test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "my_rule(name ='main')"); reporter.removeHandler(failFastHandler); // This call succeeds if "--keep_going" was passed, which it does in the WithKeepGoing test // suite. Otherwise, it fails and throws a TargetParsingException. if (keepGoing()) { AnalysisResult analysisResult = update(ImmutableList.of(), "//test:main"); assertThat(analysisResult.hasError()).isTrue(); } else { assertThrows(TargetParsingException.class, () -> update(ImmutableList.of(), "//test:main")); } assertContainsEvent( "Aspect //test:aspect.bzl%MyAspectUncovered requires rule my_rule to specify attribute " + "'my_attr' with type int."); } @Test public void integerAspectParameter_missingValuesRestriction() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " return struct()", "def _rule_impl(ctx):", " return struct()", "MyAspectUncovered = aspect(", " implementation=_impl,", " attrs = { 'my_attr' : attr.int() },", ")", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'deps' : attr.label_list(aspects=[MyAspectUncovered]),", " 'my_attr' : attr.int() },", ")"); scratch.file("test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "my_rule(name ='main')"); reporter.removeHandler(failFastHandler); // This call succeeds if "--keep_going" was passed, which it does in the WithKeepGoing test // suite. Otherwise, it fails and throws a TargetParsingException. if (keepGoing()) { AnalysisResult analysisResult = update(ImmutableList.of(), "//test:main"); assertThat(analysisResult.hasError()).isTrue(); } else { assertThrows(TargetParsingException.class, () -> update(ImmutableList.of(), "//test:main")); } assertContainsEvent( "Aspect //test:aspect.bzl%MyAspectUncovered: Aspect parameter attribute 'my_attr' must use" + " the 'values' restriction."); } @Test public void integerAspectParameter_invalidDefault() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " return struct()", "def _rule_impl(ctx):", " return struct()", "MyAspectUncovered = aspect(", " implementation=_impl,", " attrs = { 'my_attr' : attr.int(default = 2, values = [0, 1]) },", ")", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'deps' : attr.label_list(aspects=[MyAspectUncovered]) },", ")"); scratch.file("test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "my_rule(name ='main')"); reporter.removeHandler(failFastHandler); // This call succeeds if "--keep_going" was passed, which it does in the WithKeepGoing test // suite. Otherwise, it fails and throws a TargetParsingException. if (keepGoing()) { AnalysisResult analysisResult = update(ImmutableList.of(), "//test:main"); assertThat(analysisResult.hasError()).isTrue(); } else { assertThrows(TargetParsingException.class, () -> update(ImmutableList.of(), "//test:main")); } assertContainsEvent( "Aspect parameter attribute 'my_attr' has a bad default value: has to be one of '0' or '1'" + " instead of '2'"); } @Test public void aspectIntegerParameter_withDefaultValue() throws Exception { scratch.file( "test/aspect.bzl", "def _aspect_impl(target, ctx):", " result = ['my_aspect on target {}, my_attr = {}'.", " format(target.label, ctx.attr.my_attr)]", " if ctx.rule.attr.dep:", " result += ctx.rule.attr.dep.my_aspect_result", " return struct(my_aspect_result = result)", "", "def _rule_impl(ctx):", " if ctx.attr.dep:", " return struct(my_rule_result = ctx.attr.dep.my_aspect_result)", " pass", "", "MyAspect = aspect(", " implementation = _aspect_impl,", " attrs = { 'my_attr' : attr.int(default = 1, values = [1, 2, 3]) },", ")", "", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'dep' : attr.label(aspects=[MyAspect]) }", ")"); scratch.file( "test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "my_rule(name = 'main_target',", " dep = ':dep_target',", ")", "my_rule(name = 'dep_target')"); AnalysisResult analysisResult = update(ImmutableList.of(), "//test:main_target"); ConfiguredTarget configuredTarget = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); StarlarkList ruleResult = (StarlarkList) configuredTarget.get("my_rule_result"); assertThat(Starlark.toIterable(ruleResult)) .containsExactly("my_aspect on target @//test:dep_target, my_attr = 1"); } @Test public void aspectIntegerParameter_valueOverwrittenByRuleDefault() throws Exception { scratch.file( "test/aspect.bzl", "def _aspect_impl(target, ctx):", " result = ['my_aspect on target {}, my_attr = {}'.", " format(target.label, ctx.attr.my_attr)]", " if ctx.rule.attr.dep:", " result += ctx.rule.attr.dep.my_aspect_result", " return struct(my_aspect_result = result)", "", "def _rule_impl(ctx):", " if ctx.attr.dep:", " return struct(my_rule_result = ctx.attr.dep.my_aspect_result)", " pass", "", "MyAspect = aspect(", " implementation = _aspect_impl,", " attrs = { 'my_attr' : attr.int(default = 1, values = [1, 2, 3]) },", ")", "", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'dep' : attr.label(aspects=[MyAspect]),", " 'my_attr': attr.int(default = 2) }", ")"); scratch.file( "test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "my_rule(name = 'main_target',", " dep = ':dep_target',", ")", "my_rule(name = 'dep_target')"); AnalysisResult analysisResult = update(ImmutableList.of(), "//test:main_target"); ConfiguredTarget configuredTarget = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); StarlarkList ruleResult = (StarlarkList) configuredTarget.get("my_rule_result"); assertThat(Starlark.toIterable(ruleResult)) .containsExactly("my_aspect on target @//test:dep_target, my_attr = 2"); } @Test public void aspectIntegerParameter_valueOverwrittenByTargetValue() throws Exception { scratch.file( "test/aspect.bzl", "def _aspect_impl(target, ctx):", " result = ['my_aspect on target {}, my_attr = {}'.", " format(target.label, ctx.attr.my_attr)]", " if ctx.rule.attr.dep:", " result += ctx.rule.attr.dep.my_aspect_result", " return struct(my_aspect_result = result)", "", "def _rule_impl(ctx):", " if ctx.attr.dep:", " return struct(my_rule_result = ctx.attr.dep.my_aspect_result)", " pass", "", "MyAspect = aspect(", " implementation = _aspect_impl,", " attrs = { 'my_attr' : attr.int(default = 1, values = [1, 2, 3]) },", ")", "", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'dep' : attr.label(aspects=[MyAspect]),", " 'my_attr': attr.int(default = 2) }", ")"); scratch.file( "test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "my_rule(name = 'main_target',", " dep = ':dep_target',", " my_attr = 3,", ")", "my_rule(name = 'dep_target')"); AnalysisResult analysisResult = update(ImmutableList.of(), "//test:main_target"); ConfiguredTarget configuredTarget = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); StarlarkList ruleResult = (StarlarkList) configuredTarget.get("my_rule_result"); assertThat(Starlark.toIterable(ruleResult)) .containsExactly("my_aspect on target @//test:dep_target, my_attr = 3"); } @Test public void testTopLevelAspectsWithParameters_invalidIntegerParameterValue() throws Exception { scratch.file( "test/defs.bzl", "def _aspect_a_impl(target, ctx):", " result = ['aspect_a on target {}, p = {}'.", " format(target.label, ctx.attr.p)]", " if ctx.rule.attr.dep:", " result += ctx.rule.attr.dep.aspect_a_result", " return struct(aspect_a_result = result)", "", "aspect_a = aspect(", " implementation = _aspect_a_impl,", " attr_aspects = ['dep'],", " attrs = { 'p' : attr.int(values = [1, 2]) },", ")", "", "def _my_rule_impl(ctx):", " pass", "my_rule = rule(", " implementation = _my_rule_impl,", " attrs = { 'dep' : attr.label() },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'my_rule')", "my_rule(", " name = 'main_target',", " dep = ':dep_target_1',", ")", "my_rule(", " name = 'dep_target_1',", " dep = ':dep_target_2',", ")", "my_rule(", " name = 'dep_target_2',", ")"); reporter.removeHandler(failFastHandler); // This call succeeds if "--keep_going" was passed, which it does in the WithKeepGoing test // suite. Otherwise, it fails and throws a ViewCreationFailedException. if (keepGoing()) { AnalysisResult analysisResult = update( ImmutableList.of("//test:defs.bzl%aspect_a"), ImmutableMap.of("p", "3"), "//test:main_target"); assertThat(analysisResult.hasError()).isTrue(); } else { assertThrows( ViewCreationFailedException.class, () -> update( ImmutableList.of("//test:defs.bzl%aspect_a"), ImmutableMap.of("p", "3"), "//test:main_target")); } assertContainsEvent( "//test:defs.bzl%aspect_a: invalid value in 'p' attribute: has to be one of '1' or" + " '2' instead of '3'"); } @Test public void testTopLevelAspectsWithIntegerParameter() throws Exception { scratch.file( "test/defs.bzl", "def _aspect_a_impl(target, ctx):", " result = ['aspect_a on target {}, p = {}'.", " format(target.label, ctx.attr.p)]", " if ctx.rule.attr.dep:", " result += ctx.rule.attr.dep.aspect_a_result", " return struct(aspect_a_result = result)", "", "aspect_a = aspect(", " implementation = _aspect_a_impl,", " attr_aspects = ['dep'],", " attrs = { 'p' : attr.int(values = [1, 2, 3]) },", ")", "", "def _my_rule_impl(ctx):", " pass", "my_rule = rule(", " implementation = _my_rule_impl,", " attrs = { 'dep' : attr.label() },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'my_rule')", "my_rule(", " name = 'main_target',", " dep = ':dep_target_1',", ")", "my_rule(", " name = 'dep_target_1',", " dep = ':dep_target_2',", ")", "my_rule(", " name = 'dep_target_2',", ")"); AnalysisResult analysisResult = update( ImmutableList.of("//test:defs.bzl%aspect_a"), ImmutableMap.of("p", "2"), "//test:main_target"); ImmutableMap configuredAspects = analysisResult.getAspectsMap(); ConfiguredAspect aspectA = getConfiguredAspect(configuredAspects, "aspect_a"); assertThat(aspectA).isNotNull(); StarlarkList aspectAResult = (StarlarkList) aspectA.get("aspect_a_result"); assertThat(Starlark.toIterable(aspectAResult)) .containsExactly( "aspect_a on target @//test:main_target, p = 2", "aspect_a on target @//test:dep_target_1, p = 2", "aspect_a on target @//test:dep_target_2, p = 2"); } @Test public void testTopLevelAspectsWithIntegerParameter_useDefaultValue() throws Exception { scratch.file( "test/defs.bzl", "def _aspect_a_impl(target, ctx):", " result = ['aspect_a on target {}, p = {}'.", " format(target.label, ctx.attr.p)]", " if ctx.rule.attr.dep:", " result += ctx.rule.attr.dep.aspect_a_result", " return struct(aspect_a_result = result)", "", "aspect_a = aspect(", " implementation = _aspect_a_impl,", " attr_aspects = ['dep'],", " attrs = { 'p' : attr.int(default = 1, values = [1, 2, 3]) },", ")", "", "def _my_rule_impl(ctx):", " pass", "my_rule = rule(", " implementation = _my_rule_impl,", " attrs = { 'dep' : attr.label() },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'my_rule')", "my_rule(", " name = 'main_target',", " dep = ':dep_target_1',", ")", "my_rule(", " name = 'dep_target_1',", " dep = ':dep_target_2',", ")", "my_rule(", " name = 'dep_target_2',", ")"); AnalysisResult analysisResult = update(ImmutableList.of("//test:defs.bzl%aspect_a"), "//test:main_target"); ImmutableMap configuredAspects = analysisResult.getAspectsMap(); ConfiguredAspect aspectA = getConfiguredAspect(configuredAspects, "aspect_a"); assertThat(aspectA).isNotNull(); StarlarkList aspectAResult = (StarlarkList) aspectA.get("aspect_a_result"); assertThat(Starlark.toIterable(aspectAResult)) .containsExactly( "aspect_a on target @//test:main_target, p = 1", "aspect_a on target @//test:dep_target_1, p = 1", "aspect_a on target @//test:dep_target_2, p = 1"); } @Test public void booleanAspectParameter_mandatoryAttrNotCoveredByRule() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " return struct()", "def _rule_impl(ctx):", " return struct()", "MyAspectUncovered = aspect(", " implementation=_impl,", " attrs = { 'my_attr' : attr.bool(default = True, mandatory = True) },", ")", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'deps' : attr.label_list(aspects=[MyAspectUncovered]) },", ")"); scratch.file("test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "my_rule(name ='main')"); reporter.removeHandler(failFastHandler); // This call succeeds if "--keep_going" was passed, which it does in the WithKeepGoing test // suite. Otherwise, it fails and throws a TargetParsingException. if (keepGoing()) { AnalysisResult analysisResult = update(ImmutableList.of(), "//test:main"); assertThat(analysisResult.hasError()).isTrue(); } else { assertThrows(TargetParsingException.class, () -> update(ImmutableList.of(), "//test:main")); } assertContainsEvent( "Aspect //test:aspect.bzl%MyAspectUncovered requires rule my_rule to specify attribute " + "'my_attr' with type boolean."); } @Test public void booleanAspectParameter_mandatoryAttrWithWrongTypeInRule() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " return struct()", "def _rule_impl(ctx):", " return struct()", "MyAspectUncovered = aspect(", " implementation=_impl,", " attrs = { 'my_attr' : attr.bool(default = True, mandatory = True) },", ")", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'deps' : attr.label_list(aspects=[MyAspectUncovered]),", " 'my_attr': attr.string() },", ")"); scratch.file("test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "my_rule(name ='main')"); reporter.removeHandler(failFastHandler); // This call succeeds if "--keep_going" was passed, which it does in the WithKeepGoing test // suite. Otherwise, it fails and throws a TargetParsingException. if (keepGoing()) { AnalysisResult analysisResult = update(ImmutableList.of(), "//test:main"); assertThat(analysisResult.hasError()).isTrue(); } else { assertThrows(TargetParsingException.class, () -> update(ImmutableList.of(), "//test:main")); } assertContainsEvent( "Aspect //test:aspect.bzl%MyAspectUncovered requires rule my_rule to specify attribute " + "'my_attr' with type boolean."); } @Test public void booleanAspectParameter_attrWithoutDefaultNotCoveredByRule() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " return struct()", "def _rule_impl(ctx):", " return struct()", "MyAspectUncovered = aspect(", " implementation=_impl,", " attrs = { 'my_attr' : attr.bool() },", ")", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'deps' : attr.label_list(aspects=[MyAspectUncovered]) },", ")"); scratch.file("test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "my_rule(name ='main')"); reporter.removeHandler(failFastHandler); // This call succeeds if "--keep_going" was passed, which it does in the WithKeepGoing test // suite. Otherwise, it fails and throws a TargetParsingException. if (keepGoing()) { AnalysisResult analysisResult = update(ImmutableList.of(), "//test:main"); assertThat(analysisResult.hasError()).isTrue(); } else { assertThrows(TargetParsingException.class, () -> update(ImmutableList.of(), "//test:main")); } assertContainsEvent( "Aspect //test:aspect.bzl%MyAspectUncovered requires rule my_rule to specify attribute " + "'my_attr' with type boolean."); } @Test public void booleanAspectParameter_attrWithoutDefaultWrongTypeInRule() throws Exception { scratch.file( "test/aspect.bzl", "def _impl(target, ctx):", " return struct()", "def _rule_impl(ctx):", " return struct()", "MyAspectUncovered = aspect(", " implementation=_impl,", " attrs = { 'my_attr' : attr.bool() },", ")", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'deps' : attr.label_list(aspects=[MyAspectUncovered]),", " 'my_attr': attr.string() },", ")"); scratch.file("test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "my_rule(name ='main')"); reporter.removeHandler(failFastHandler); // This call succeeds if "--keep_going" was passed, which it does in the WithKeepGoing test // suite. Otherwise, it fails and throws a TargetParsingException. if (keepGoing()) { AnalysisResult analysisResult = update(ImmutableList.of(), "//test:main"); assertThat(analysisResult.hasError()).isTrue(); } else { assertThrows(TargetParsingException.class, () -> update(ImmutableList.of(), "//test:main")); } assertContainsEvent( "Aspect //test:aspect.bzl%MyAspectUncovered requires rule my_rule to specify attribute " + "'my_attr' with type boolean."); } @Test public void aspectBooleanParameter_withDefaultValue() throws Exception { scratch.file( "test/aspect.bzl", "def _aspect_impl(target, ctx):", " result = ['my_aspect on target {}, my_attr = {}'.", " format(target.label, ctx.attr.my_attr)]", " if ctx.rule.attr.dep:", " result += ctx.rule.attr.dep.my_aspect_result", " return struct(my_aspect_result = result)", "", "def _rule_impl(ctx):", " if ctx.attr.dep:", " return struct(my_rule_result = ctx.attr.dep.my_aspect_result)", " pass", "", "MyAspect = aspect(", " implementation = _aspect_impl,", " attrs = { 'my_attr' : attr.bool(default = True) },", ")", "", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'dep' : attr.label(aspects=[MyAspect]) }", ")"); scratch.file( "test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "my_rule(name = 'main_target',", " dep = ':dep_target',", ")", "my_rule(name = 'dep_target')"); AnalysisResult analysisResult = update(ImmutableList.of(), "//test:main_target"); ConfiguredTarget configuredTarget = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); StarlarkList ruleResult = (StarlarkList) configuredTarget.get("my_rule_result"); assertThat(Starlark.toIterable(ruleResult)) .containsExactly("my_aspect on target @//test:dep_target, my_attr = True"); } @Test public void aspectBooleanParameter_valueOverwrittenByRuleDefault() throws Exception { scratch.file( "test/aspect.bzl", "def _aspect_impl(target, ctx):", " result = ['my_aspect on target {}, my_attr = {}'.", " format(target.label, ctx.attr.my_attr)]", " if ctx.rule.attr.dep:", " result += ctx.rule.attr.dep.my_aspect_result", " return struct(my_aspect_result = result)", "", "def _rule_impl(ctx):", " if ctx.attr.dep:", " return struct(my_rule_result = ctx.attr.dep.my_aspect_result)", " pass", "", "MyAspect = aspect(", " implementation = _aspect_impl,", " attrs = { 'my_attr' : attr.bool(default = True) },", ")", "", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'dep' : attr.label(aspects=[MyAspect]),", " 'my_attr': attr.bool(default = False) }", ")"); scratch.file( "test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "my_rule(name = 'main_target',", " dep = ':dep_target',", ")", "my_rule(name = 'dep_target')"); AnalysisResult analysisResult = update(ImmutableList.of(), "//test:main_target"); ConfiguredTarget configuredTarget = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); StarlarkList ruleResult = (StarlarkList) configuredTarget.get("my_rule_result"); assertThat(Starlark.toIterable(ruleResult)) .containsExactly("my_aspect on target @//test:dep_target, my_attr = False"); } @Test public void aspectBooleanParameter_valueOverwrittenByTargetValue() throws Exception { scratch.file( "test/aspect.bzl", "def _aspect_impl(target, ctx):", " result = ['my_aspect on target {}, my_attr = {}'.", " format(target.label, ctx.attr.my_attr)]", " if ctx.rule.attr.dep:", " result += ctx.rule.attr.dep.my_aspect_result", " return struct(my_aspect_result = result)", "", "def _rule_impl(ctx):", " if ctx.attr.dep:", " return struct(my_rule_result = ctx.attr.dep.my_aspect_result)", " pass", "", "MyAspect = aspect(", " implementation = _aspect_impl,", " attrs = { 'my_attr' : attr.bool(default = True) },", ")", "", "my_rule = rule(", " implementation=_rule_impl,", " attrs = { 'dep' : attr.label(aspects=[MyAspect]),", " 'my_attr': attr.bool(default = True) }", ")"); scratch.file( "test/BUILD", "load('//test:aspect.bzl', 'my_rule')", "my_rule(name = 'main_target',", " dep = ':dep_target',", " my_attr = False,", ")", "my_rule(name = 'dep_target')"); AnalysisResult analysisResult = update(ImmutableList.of(), "//test:main_target"); ConfiguredTarget configuredTarget = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); StarlarkList ruleResult = (StarlarkList) configuredTarget.get("my_rule_result"); assertThat(Starlark.toIterable(ruleResult)) .containsExactly("my_aspect on target @//test:dep_target, my_attr = False"); } @Test public void testTopLevelAspectsWithBooleanParameter() throws Exception { scratch.file( "test/defs.bzl", "def _aspect_a_impl(target, ctx):", " result = ['aspect_a on target {}, p = {}'.", " format(target.label, ctx.attr.p)]", " if ctx.rule.attr.dep:", " result += ctx.rule.attr.dep.aspect_a_result", " return struct(aspect_a_result = result)", "", "aspect_a = aspect(", " implementation = _aspect_a_impl,", " attr_aspects = ['dep'],", " attrs = { 'p' : attr.bool() },", ")", "", "def _my_rule_impl(ctx):", " pass", "my_rule = rule(", " implementation = _my_rule_impl,", " attrs = { 'dep' : attr.label() },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'my_rule')", "my_rule(", " name = 'main_target',", " dep = ':dep_target_1',", ")", "my_rule(", " name = 'dep_target_1',", " dep = ':dep_target_2',", ")", "my_rule(", " name = 'dep_target_2',", ")"); AnalysisResult analysisResult = update( ImmutableList.of("//test:defs.bzl%aspect_a"), ImmutableMap.of("p", "y"), "//test:main_target"); ImmutableMap configuredAspects = analysisResult.getAspectsMap(); ConfiguredAspect aspectA = getConfiguredAspect(configuredAspects, "aspect_a"); assertThat(aspectA).isNotNull(); StarlarkList aspectAResult = (StarlarkList) aspectA.get("aspect_a_result"); assertThat(Starlark.toIterable(aspectAResult)) .containsExactly( "aspect_a on target @//test:main_target, p = True", "aspect_a on target @//test:dep_target_1, p = True", "aspect_a on target @//test:dep_target_2, p = True"); } @Test public void testTopLevelAspectsWithBooleanParameter_useDefaultValue() throws Exception { scratch.file( "test/defs.bzl", "def _aspect_a_impl(target, ctx):", " result = ['aspect_a on target {}, p = {}'.", " format(target.label, ctx.attr.p)]", " if ctx.rule.attr.dep:", " result += ctx.rule.attr.dep.aspect_a_result", " return struct(aspect_a_result = result)", "", "aspect_a = aspect(", " implementation = _aspect_a_impl,", " attr_aspects = ['dep'],", " attrs = { 'p' : attr.bool(default = False) },", ")", "", "def _my_rule_impl(ctx):", " pass", "my_rule = rule(", " implementation = _my_rule_impl,", " attrs = { 'dep' : attr.label() },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'my_rule')", "my_rule(", " name = 'main_target',", " dep = ':dep_target_1',", ")", "my_rule(", " name = 'dep_target_1',", " dep = ':dep_target_2',", ")", "my_rule(", " name = 'dep_target_2',", ")"); AnalysisResult analysisResult = update(ImmutableList.of("//test:defs.bzl%aspect_a"), "//test:main_target"); ImmutableMap configuredAspects = analysisResult.getAspectsMap(); ConfiguredAspect aspectA = getConfiguredAspect(configuredAspects, "aspect_a"); assertThat(aspectA).isNotNull(); StarlarkList aspectAResult = (StarlarkList) aspectA.get("aspect_a_result"); assertThat(Starlark.toIterable(aspectAResult)) .containsExactly( "aspect_a on target @//test:main_target, p = False", "aspect_a on target @//test:dep_target_1, p = False", "aspect_a on target @//test:dep_target_2, p = False"); } @Test public void testTopLevelAspectsWithBooleanParameter_invalidValue() throws Exception { scratch.file( "test/defs.bzl", "def _aspect_a_impl(target, ctx):", " result = ['aspect_a on target {}, p = {}'.", " format(target.label, ctx.attr.p)]", " if ctx.rule.attr.dep:", " result += ctx.rule.attr.dep.aspect_a_result", " return struct(aspect_a_result = result)", "", "aspect_a = aspect(", " implementation = _aspect_a_impl,", " attr_aspects = ['dep'],", " attrs = { 'p' : attr.bool() },", ")", "", "def _my_rule_impl(ctx):", " pass", "my_rule = rule(", " implementation = _my_rule_impl,", " attrs = { 'dep' : attr.label() },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'my_rule')", "my_rule(", " name = 'main_target',", " dep = ':dep_target_1',", ")", "my_rule(", " name = 'dep_target_1',", " dep = ':dep_target_2',", ")", "my_rule(", " name = 'dep_target_2',", ")"); reporter.removeHandler(failFastHandler); // This call succeeds if "--keep_going" was passed, which it does in the WithKeepGoing test // suite. Otherwise, it fails and throws a ViewCreationFailedException. if (keepGoing()) { AnalysisResult analysisResult = update( ImmutableList.of("//test:defs.bzl%aspect_a"), ImmutableMap.of("p", "x"), "//test:main_target"); assertThat(analysisResult.hasError()).isTrue(); } else { assertThrows( ViewCreationFailedException.class, () -> update( ImmutableList.of("//test:defs.bzl%aspect_a"), ImmutableMap.of("p", "x"), "//test:main_target")); } assertContainsEvent( "//test:defs.bzl%aspect_a: expected value of type 'bool' for attribute 'p' but got 'x'"); } @Test public void testRuleAspectWithMandatoryParameterNotProvided() throws Exception { scratch.file( "test/defs.bzl", "def _aspect_a_impl(target, ctx):", " result = ['aspect_a on target {}, p = {}'.", " format(target.label, ctx.attr.p)]", " if ctx.rule.attr.dep:", " result += ctx.rule.attr.dep.aspect_a_result", " return struct(aspect_a_result = result)", "", "aspect_a = aspect(", " implementation = _aspect_a_impl,", " attr_aspects = ['dep'],", " attrs = { 'p' : attr.string(default = 'p_v', values = ['p_v'], mandatory = True) },", ")", "", "def _my_rule_impl(ctx):", " pass", "my_rule = rule(", " implementation = _my_rule_impl,", " attrs = { 'dep' : attr.label(aspects = [aspect_a]) },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'my_rule')", "my_rule(", " name = 'main_target',", " dep = ':dep_target_1',", ")", "my_rule(", " name = 'dep_target_1',", " dep = ':dep_target_2',", ")", "my_rule(", " name = 'dep_target_2',", ")"); reporter.removeHandler(failFastHandler); // This call succeeds if "--keep_going" was passed, which it does in the WithKeepGoing test // suite. Otherwise, it fails and throws a TargetParsingException. if (keepGoing()) { AnalysisResult analysisResult = update("//test:main_target"); assertThat(analysisResult.hasError()).isTrue(); } else { assertThrows(TargetParsingException.class, () -> update("//test:main_target")); } assertContainsEvent( "Aspect //test:defs.bzl%aspect_a requires rule my_rule to specify attribute 'p' with type" + " string"); } @Test public void testRuleAspectWithMandatoryParameterProvidedWrongType() throws Exception { scratch.file( "test/defs.bzl", "def _aspect_a_impl(target, ctx):", " result = ['aspect_a on target {}, p = {}'.", " format(target.label, ctx.attr.p)]", " if ctx.rule.attr.dep:", " result += ctx.rule.attr.dep.aspect_a_result", " return struct(aspect_a_result = result)", "", "aspect_a = aspect(", " implementation = _aspect_a_impl,", " attr_aspects = ['dep'],", " attrs = { 'p' : attr.string(default = 'p_v', values = ['p_v'], mandatory = True) },", ")", "", "def _my_rule_impl(ctx):", " pass", "my_rule = rule(", " implementation = _my_rule_impl,", " attrs = { 'dep' : attr.label(aspects = [aspect_a]),", " 'p': attr.int() } ", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'my_rule')", "my_rule(", " name = 'main_target',", " dep = ':dep_target_1',", ")", "my_rule(", " name = 'dep_target_1',", " dep = ':dep_target_2',", ")", "my_rule(", " name = 'dep_target_2',", ")"); reporter.removeHandler(failFastHandler); // This call succeeds if "--keep_going" was passed, which it does in the WithKeepGoing test // suite. Otherwise, it fails and throws a TargetParsingException. if (keepGoing()) { AnalysisResult analysisResult = update("//test:main_target"); assertThat(analysisResult.hasError()).isTrue(); } else { assertThrows(TargetParsingException.class, () -> update("//test:main_target")); } assertContainsEvent( "Aspect //test:defs.bzl%aspect_a requires rule my_rule to specify attribute 'p' with type" + " string"); } @Test public void testRuleAspectWithMandatoryParameter_useRuleDefault() throws Exception { scratch.file( "test/defs.bzl", "def _aspect_a_impl(target, ctx):", " result = 'aspect_a on target {}, p = {}'.format(target.label, ctx.attr.p)", " return struct(aspect_a_result = result)", "", "aspect_a = aspect(", " implementation = _aspect_a_impl,", " attr_aspects = ['dep'],", " attrs = { 'p' : attr.string(default = 'p_v1', values = ['p_v1', 'p_v2'],", " mandatory = True) },", ")", "", "def _main_rule_impl(ctx):", " if ctx.attr.dep:", " return struct(aspect_a_result = ctx.attr.dep.aspect_a_result)", " pass", "main_rule = rule(", " implementation = _main_rule_impl,", " attrs = {", " 'dep': attr.label(aspects = [aspect_a]),", " 'p' : attr.string(default = 'p_v2'),", " },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'main_rule')", "main_rule(", " name = 'main',", " dep = ':dep_target',", ")", "main_rule(", " name = 'dep_target',", ")"); AnalysisResult analysisResult = update("//test:main"); ConfiguredTarget configuredTarget = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); String aspectAResult = (String) configuredTarget.get("aspect_a_result"); assertThat(aspectAResult).isEqualTo("aspect_a on target @//test:dep_target, p = p_v2"); } @Test public void testRuleAspectWithMandatoryParameterProvided() throws Exception { scratch.file( "test/defs.bzl", "def _aspect_a_impl(target, ctx):", " result = 'aspect_a on target {}, p = {}'.format(target.label, ctx.attr.p)", " return struct(aspect_a_result = result)", "", "aspect_a = aspect(", " implementation = _aspect_a_impl,", " attr_aspects = ['dep'],", " attrs = { 'p' : attr.string(default = 'p_v2', values = ['p_v1', 'p_v2'],", " mandatory = True) },", ")", "", "def _main_rule_impl(ctx):", " if ctx.attr.dep:", " return struct(aspect_a_result = ctx.attr.dep.aspect_a_result)", " pass", "main_rule = rule(", " implementation = _main_rule_impl,", " attrs = {", " 'dep': attr.label(aspects = [aspect_a]),", " 'p' : attr.string(mandatory = True),", " },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'main_rule')", "main_rule(", " name = 'main',", " dep = ':dep_target',", " p = 'p_v1',", ")", "main_rule(", " name = 'dep_target',", " p = 'p_v2',", ")"); AnalysisResult analysisResult = update("//test:main"); ConfiguredTarget configuredTarget = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); String aspectAResult = (String) configuredTarget.get("aspect_a_result"); assertThat(aspectAResult).isEqualTo("aspect_a on target @//test:dep_target, p = p_v1"); } @Test public void testAspectLabelIsRepoMapped() throws Exception { scratch.appendFile("WORKSPACE", "workspace(name = 'my_repo')"); scratch.file( "test/aspect.bzl", "load(':rule.bzl', 'MyInfo')", "def _impl(target, ctx):", " if MyInfo not in target:", " fail('Provider identity mismatch')", " return struct()", "MyAspect = aspect(implementation=_impl)"); scratch.file( "test/rule.bzl", "MyInfo = provider()", "def _impl(ctx):", " return [MyInfo()]", "my_rule = rule(implementation=_impl)"); scratch.file("test/BUILD", "load(':rule.bzl', 'my_rule')", "my_rule(name = 'target')"); AnalysisResult result = update(ImmutableList.of("@my_repo//test:aspect.bzl%MyAspect"), "//test:target"); assertThat(result.hasError()).isFalse(); } @Test public void testAspectKeyCreatedOnlyOnceForSameBaseKeysInDiffOrder() throws Exception { scratch.file( "test/defs.bzl", "a_provider = provider()", "b_provider = provider()", "c_provider = provider()", "", "def _a_impl(target, ctx):", " result = []", " if ctx.rule.attr.deps:", " for dep in ctx.rule.attr.deps:", " result.extend(dep[a_provider].value)", " result.append('aspect a on target {} aspect_ids {}'.format(target.label,", " ctx.aspect_ids))", " return [a_provider(value = result)]", "a = aspect(", " implementation = _a_impl,", " attr_aspects = ['deps'],", " required_aspect_providers = [[b_provider], [c_provider]],", ")", "", "def _b_impl(target, ctx):", " return [b_provider(value = ['aspect b on target {}'.format(target.label)])]", "b = aspect(", " implementation = _b_impl,", " attr_aspects = ['deps'],", " provides = [b_provider],", ")", "", "def _c_impl(target, ctx):", " return [c_provider(value = ['aspect c on target {}'.format(target.label)])]", "c = aspect(", " implementation = _c_impl,", " attr_aspects = ['deps'],", " provides = [c_provider]", ")", "", "def _r1_impl(ctx):", " result = []", " if ctx.attr.deps:", " for dep in ctx.attr.deps:", " result.extend(dep[a_provider].value)", " return struct(aspect_a_collected_result = result)", "r1 = rule(", " implementation = _r1_impl,", " attrs = {", " 'deps': attr.label_list(aspects = [c, b, a]),", " },", ")", "", "def _r2_impl(ctx):", " pass", "r2 = rule(", " implementation = _r2_impl,", " attrs = {", " 'deps': attr.label_list(aspects = [b]),", " },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'r1', 'r2')", "r1(", " name = 't1',", // base_keys of aspect a on t3 are [c, b] " deps = [':t2', ':t3'],", ")", "r2(", " name = 't2',", // aspects reaching t3 will be [b, c, b, a], after deduplicating aspects path, it will be // [b, c, a] and as a result the base_keys of aspect a will be [b, c] " deps = [':t3'],", ")", "r2(", " name = 't3',", ")"); update("//test:t1"); // Aspect a should have a single AspectKey for its application on t3 and the baseKeys in it will // be sorted as [b, c] ImmutableList keysForAspectAOnT3 = getAspectKeys("//test:t3", "//test:defs.bzl%a"); assertThat(keysForAspectAOnT3).hasSize(1); ImmutableList baseKeys = keysForAspectAOnT3.get(0).getBaseKeys(); assertThat(baseKeys.stream().map(k -> k.getAspectClass().getName())) .containsExactly("//test:defs.bzl%b", "//test:defs.bzl%c") .inOrder(); } @Test public void testAspectRunsTwiceWithDiffBaseAspectsDeps() throws Exception { scratch.file( "test/defs.bzl", "a_provider = provider()", "b_provider = provider()", "c_provider = provider()", "", "def _a_impl(target, ctx):", " result = []", " if ctx.rule.attr.deps:", " for dep in ctx.rule.attr.deps:", " result.extend(dep[a_provider].value)", " if b_provider in target:", " result.append('aspect a on {} sees b_provider = {}'.format(target.label,", " target[b_provider].value))", " return [a_provider(value = result)]", "a = aspect(", " implementation = _a_impl,", " attr_aspects = ['deps'],", " required_aspect_providers = [[b_provider], [c_provider]],", ")", "", "def _b_impl(target, ctx):", " result = 'aspect b cannot see c_provider'", " if c_provider in target:", " result = 'aspect b can see c_provider'", " return [b_provider(value = result)]", "b = aspect(", " implementation = _b_impl,", " attr_aspects = ['deps'],", " provides = [b_provider],", " required_aspect_providers = [[c_provider]]", ")", "", "def _c_impl(target, ctx):", " return [c_provider(value = ['aspect c on target {}'.format(target.label)])]", "c = aspect(", " implementation = _c_impl,", " attr_aspects = ['deps'],", " provides = [c_provider]", ")", "", "def _r1_impl(ctx):", " result = []", " if ctx.attr.deps:", " for dep in ctx.attr.deps:", " result.extend(dep[a_provider].value)", " return struct(aspect_a_collected_result = result)", "r1 = rule(", " implementation = _r1_impl,", " attrs = {", " 'deps': attr.label_list(aspects = [a]),", " },", ")", "", "def _r2_impl(ctx):", " pass", "r2 = rule(", " implementation = _r2_impl,", " attrs = {", " 'deps': attr.label_list(aspects = [c, b]),", " },", ")", "", "def _r3_impl(ctx):", " pass", "r3 = rule(", " implementation = _r3_impl,", " attrs = {", " 'deps': attr.label_list(aspects = [b, c]),", " },", ")"); scratch.file( "test/BUILD", "load('//test:defs.bzl', 'r1', 'r2', 'r3')", "r1(", " name = 't1',", // t1 propagate aspect (a) to targets (t2 and t3) " deps = [':t2', ':t3'],", ")", "r2(", " name = 't2',", // t2 propagates aspects (c, b) to target t4 and aspect a is propagated from the prev level // aspects path on t4 is [c, b, a], this means a can see b and b can see c " deps = [':t4'],", ")", "r3(", " name = 't3',", // t3 propagates aspects (b, c) to target t4 and aspect a is propagated from the prev level // aspects path on t4 is [b, c, a], this means a can see b but b cannot see c " deps = [':t4'],", ")", "r1(", " name = 't4',", ")"); AnalysisResult analysisResult = update("//test:t1"); // Aspect a should have 2 AspectKeys for its application on t4, one where in the basekeys b can // see c and the other is where b cannot see c ImmutableList keysForAspectAOnT4 = getAspectKeys("//test:t4", "//test:defs.bzl%a"); assertThat(keysForAspectAOnT4).hasSize(2); ConfiguredTarget configuredTarget = Iterables.getOnlyElement(analysisResult.getTargetsToBuild()); StarlarkList aspectAResult = (StarlarkList) configuredTarget.get("aspect_a_collected_result"); assertThat(Starlark.toIterable(aspectAResult)) .containsExactly( "aspect a on @//test:t4 sees b_provider = aspect b can see c_provider", "aspect a on @//test:t4 sees b_provider = aspect b cannot see c_provider"); } @Test public void testAspectWithSameExplicitAttributeNameAsUnderlyingTarget() throws Exception { scratch.file( "test/defs.bzl", "def _a_impl(target, ctx):", " value = 'x from aspect = {}, x from target = {}'.format(ctx.attr.x, ctx.rule.attr.x)", " return struct(aspect_result = value)", "a = aspect(", " implementation = _a_impl,", " attrs = {", " 'x': attr.string(default = 'xyz')", " },", ")", "", "def _rule_impl(ctx):", " pass", "r1 = rule(", " implementation = _rule_impl,", " attrs = {", " 'x': attr.int(default = 4)", " },", ")"); scratch.file("test/BUILD", "load('//test:defs.bzl', 'r1')", "r1(name = 't1')"); AnalysisResult analysisResult = update(ImmutableList.of("//test:defs.bzl%a"), "//test:t1"); ImmutableMap configuredAspects = analysisResult.getAspectsMap(); ConfiguredAspect aspectA = getConfiguredAspect(configuredAspects, "a"); assertThat(aspectA).isNotNull(); String aspectAResult = (String) aspectA.get("aspect_result"); assertThat(aspectAResult).isEqualTo("x from aspect = xyz, x from target = 4"); } private ImmutableList getAspectKeys(String targetLabel, String aspectLabel) { return skyframeExecutor.getEvaluator().getDoneValues().entrySet().stream() .filter( entry -> entry.getKey() instanceof AspectKey && ((AspectKey) entry.getKey()).getAspectClass().getName().equals(aspectLabel) && ((AspectKey) entry.getKey()).getLabel().toString().equals(targetLabel)) .map(e -> (AspectKey) e.getKey()) .collect(toImmutableList()); } private ConfiguredAspect getConfiguredAspect( Map aspectsMap, String aspectName) { for (Map.Entry entry : aspectsMap.entrySet()) { AspectClass aspectClass = entry.getKey().getAspectClass(); if (aspectClass instanceof StarlarkAspectClass) { String aspectExportedName = ((StarlarkAspectClass) aspectClass).getExportedName(); if (aspectExportedName.equals(aspectName)) { return entry.getValue(); } } } return null; } private ConfiguredAspect getConfiguredAspect( Map aspectsMap, String aspectName, String targetName) { for (Map.Entry entry : aspectsMap.entrySet()) { AspectClass aspectClass = entry.getKey().getAspectClass(); if (aspectClass instanceof StarlarkAspectClass) { String aspectExportedName = ((StarlarkAspectClass) aspectClass).getExportedName(); String target = entry.getKey().getLabel().getName(); if (aspectExportedName.equals(aspectName) && target.equals(targetName)) { return entry.getValue(); } } } return null; } private void exposeNativeAspectToStarlark() throws Exception { ConfiguredRuleClassProvider.Builder builder = new ConfiguredRuleClassProvider.Builder(); TestRuleClassProvider.addStandardRules(builder); builder.addBzlToplevel( "starlark_native_aspect", TestAspects.STARLARK_NATIVE_ASPECT_WITH_PROVIDER); builder.addBzlToplevel( "parametrized_native_aspect", TestAspects.PARAMETRIZED_STARLARK_NATIVE_ASPECT_WITH_PROVIDER); builder.addNativeAspectClass(TestAspects.STARLARK_NATIVE_ASPECT_WITH_PROVIDER); builder.addNativeAspectClass(TestAspects.PARAMETRIZED_STARLARK_NATIVE_ASPECT_WITH_PROVIDER); builder.addRuleDefinition(TestAspects.BASE_RULE); builder.addRuleDefinition(TestAspects.HONEST_RULE); useRuleClassProvider(builder.build()); } /** StarlarkAspectTest with "keep going" flag */ @RunWith(JUnit4.class) public static final class WithKeepGoing extends StarlarkDefinedAspectsTest { @Override protected FlagBuilder defaultFlags() { return super.defaultFlags().with(Flag.KEEP_GOING); } @Override protected boolean keepGoing() { return true; } } }