src/test/java/com/google/devtools/build/lib/analysis/MacroVisibilityTest.java

// Copyright 2024 The Bazel Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package com.google.devtools.build.lib.analysis;

import static com.google.common.truth.Truth.assertWithMessage;

import com.google.common.base.Preconditions;
import com.google.devtools.build.lib.analysis.util.BuildViewTestCase;
import com.google.testing.junit.testparameterinjector.TestParameterInjector;
import com.google.testing.junit.testparameterinjector.TestParameters;
import org.junit.Test;
import org.junit.runner.RunWith;

/**
 * Tests for the how the visibility system works with respect to symbolic macros, i.e. the
 * Macro-Aware Visibility design.
 *
 * <p>This does *not* include tests of how the {@code visibility} attribute's value gets determined
 * and threaded through macros. See SymbolicMacroTest.java for that.
 */
@RunWith(TestParameterInjector.class)
public final class MacroVisibilityTest extends BuildViewTestCase {

  @Override
  protected String getDefaultVisibility() {
    // We're testing visibility. Avoid having to litter our test cases with `visibility=` attribute
    // declarations, by using the same behavior seen in production.
    return "private";
  }

  /**
   * Returns a substring expected to be in the error event reported for a visibility violation from
   * {@code consumer} (expressed as a label string) to {@code dependency} (expressed as a label
   * string, or for {@code alias} targets, the string returned by {@link
   * AliasProvider#describeTargetWithAliases}).
   */
  private String visibilityErrorMessage(
      String consumer, String dependency, boolean dependencyIsAlias) {
    if (!dependencyIsAlias) {
      dependency = String.format("target '%s'", dependency);
    }
    return String.format(
        "Visibility error:\n%s is not visible from\ntarget '%s'", dependency, consumer);
  }

  /**
   * Convenience wrapper for {@link #visibilityErrorMessage} for when {@code dependency} is not an
   * {@code alias}.
   */
  private String visibilityErrorMessage(String consumer, String dependency) {
    return visibilityErrorMessage(consumer, dependency, /* dependencyIsAlias= */ false);
  }

  /**
   * Requests the evaluation of the configured target identified by the label {@code consumer}, and
   * asserts that the target analyzes successfully and has a dependency on the target identified by
   * the label {@code dependency}.
   *
   * <p>Does not work when {@code dependency} is an {@code alias} target.
   */
  private void assertVisibilityPermits(String consumer, String dependency) throws Exception {
    ConfiguredTarget consumerTarget = getConfiguredTarget(consumer);
    // If the dependency is in fact *not* visible, consumerTarget will be null. So we assert on the
    // absence of the visibility error event first, to deliver a better error message than just
    // saying consumerTarget was null. (We can't just attach a nicer message to the null check
    // because consumerTarget could be null due to other unexpected errors.)
    //
    // This nicer handling is moot if the failFastHandler is present, in which case we'll see the
    // visibility error event in a traceback.
    assertDoesNotContainEvent(visibilityErrorMessage(consumer, dependency));
    assertWithMessage(
            String.format(
                "%s had an error (other than a visibility violation on %s)", consumer, dependency))
        .that(consumerTarget)
        .isNotNull();
    assertWithMessage(String.format("%s does not have a dependency on %s", consumer, dependency))
        .that(getDirectPrerequisite(consumerTarget, dependency))
        .isNotNull();
  }

  /**
   * Requests the evaluation of the configured target identified by the label {@code consumer}, and
   * asserts that the target is in error due to a visibility violation on the target identified by
   * the label {@code dependency}.
   *
   * <p>Removes the {@code failFastHandler}.
   */
  private void assertVisibilityDisallows(
      String consumer, String dependency, boolean dependencyIsAlias) throws Exception {
    reporter.removeHandler(failFastHandler);
    ConfiguredTarget consumerTarget = getConfiguredTarget(consumer);
    assertWithMessage(
            String.format(
                "%s unexpectedly did not have an error (no visibility violation due to %s)",
                consumer, dependency))
        .that(consumerTarget)
        .isNull();
    assertContainsEvent(visibilityErrorMessage(consumer, dependency, dependencyIsAlias));
  }

  /**
   * Convenience wrapper for {@link #assertVisibilityDisallows} for when {@code dependency} is not
   * an {@code alias}.
   */
  private void assertVisibilityDisallows(String consumer, String dependency) throws Exception {
    assertVisibilityDisallows(consumer, dependency, /* dependencyIsAlias= */ false);
  }

  /**
   * Creates definition of {@code //rules:simple_rule.bzl%simple_rule}, a rule that has a label
   * attribute {@code dep} and implicit output {@code <NAME>.bin}.
   */
  private void defineSimpleRule() throws Exception {
    scratch.file("rules/BUILD");
    scratch.file(
        "rules/simple_rule.bzl",
        """
        def _impl(ctx):
            ctx.actions.write(ctx.outputs.out, "")

        simple_rule = rule(
            implementation = _impl,
            attrs = {"dep": attr.label(mandatory=False, allow_files=True)},
            outputs = {"out": "%{name}.bin"},
        )
        """);
  }

  /**
   * Creates a package {@code //common} defining several {@code simple_rule} targets with the given
   * names and visibility declarations.
   *
   * <p>The argument list must have even length, and contains pairs of (unquoted) target names and
   * Starlark expression strings that evaluate to visibility lists (e.g. pass the string {@code
   * "[]"} for no visibility).
   */
  private void defineCommonPackageWithSimpleTargets(String... targetNamesAndVisibilities)
      throws Exception {
    Preconditions.checkArgument(targetNamesAndVisibilities.length % 2 == 0);
    StringBuilder s = new StringBuilder();
    s.append(
        """
        load("//rules:simple_rule.bzl", "simple_rule")
        """);
    for (int i = 0; i < targetNamesAndVisibilities.length; i += 2) {
      s.append(
          String.format(
              """
              simple_rule(
                  name = "%s",
                  visibility = %s,
              )
              """,
              targetNamesAndVisibilities[i], targetNamesAndVisibilities[i + 1]));
    }
    scratch.file("common/BUILD", s.toString());
  }

  @Test
  public void buildFileAccessToMacroTargetsIsControlled() throws Exception {
    defineSimpleRule();
    scratch.file("lib/BUILD");
    scratch.file(
        "lib/macro.bzl",
        """
        load("//rules:simple_rule.bzl", "simple_rule")

        def _impl(name, visibility):
            simple_rule(
                name = name + "_exported",
                visibility = ["//pkg:__pkg__"],
            )
            simple_rule(
                name = name + "_internal",
            )
            native.exports_files([name + "_exported_input"], visibility = ["//pkg:__pkg__"])
            native.exports_files([name + "_internal_input"], visibility = ["//visibility:private"])

        my_macro = macro(implementation=_impl)
        """);
    scratch.file(
        "pkg/BUILD",
        """
        load("//rules:simple_rule.bzl", "simple_rule")
        load("//lib:macro.bzl", "my_macro")

        my_macro(name = "foo")

        simple_rule(name = "consumes_exported_ruletarget", dep = ":foo_exported")
        simple_rule(name = "consumes_exported_output", dep = ":foo_exported.bin")
        simple_rule(name = "consumes_exported_input", dep = ":foo_exported_input")
        simple_rule(name = "consumes_internal_ruletarget", dep = ":foo_internal")
        simple_rule(name = "consumes_internal_output", dep = ":foo_internal.bin")
        simple_rule(name = "consumes_internal_input", dep = ":foo_internal_input")
        """);

    assertVisibilityPermits("//pkg:consumes_exported_ruletarget", "//pkg:foo_exported");
    assertVisibilityPermits("//pkg:consumes_exported_output", "//pkg:foo_exported.bin");
    assertVisibilityPermits("//pkg:consumes_exported_input", "//pkg:foo_exported_input");
    assertVisibilityDisallows("//pkg:consumes_internal_ruletarget", "//pkg:foo_internal");
    assertVisibilityDisallows("//pkg:consumes_internal_output", "//pkg:foo_internal.bin");
    assertVisibilityDisallows("//pkg:consumes_internal_input", "//pkg:foo_internal_input");
  }

  @Test
  public void macroAccessToBuildFileTargetsIsControlled() throws Exception {
    defineSimpleRule();
    scratch.file("lib/BUILD");
    scratch.file(
        "lib/macro.bzl",
        """
        load("//rules:simple_rule.bzl", "simple_rule")

        def _impl(name, visibility):
            simple_rule(name = name + "_consumes_exported_ruletarget", dep = "//pkg:exported")
            simple_rule(name = name + "_consumes_exported_output", dep = "//pkg:exported.bin")
            simple_rule(name = name + "_consumes_exported_input", dep = "//pkg:exported_input")
            simple_rule(name = name + "_consumes_internal_ruletarget", dep = "//pkg:internal")
            simple_rule(name = name + "_consumes_internal_output", dep = "//pkg:internal.bin")
            simple_rule(name = name + "_consumes_internal_input", dep = "//pkg:internal_input")

        my_macro = macro(implementation=_impl)
        """);
    scratch.file(
        "pkg/BUILD",
        """
        load("//rules:simple_rule.bzl", "simple_rule")
        load("//lib:macro.bzl", "my_macro")

        my_macro(name = "foo")

        simple_rule(
            name = "exported",
            visibility = ["//lib:__pkg__"],
        )
        simple_rule(
            name = "internal",
        )
        exports_files(["exported_input"], visibility = ["//lib:__pkg__"])
        exports_files(["internal_input"], visibility = ["//visibility:private"])
        """);

    assertVisibilityPermits("//pkg:foo_consumes_exported_ruletarget", "//pkg:exported");
    assertVisibilityPermits("//pkg:foo_consumes_exported_output", "//pkg:exported.bin");
    assertVisibilityPermits("//pkg:foo_consumes_exported_input", "//pkg:exported_input");
    assertVisibilityDisallows("//pkg:foo_consumes_internal_ruletarget", "//pkg:internal");
    assertVisibilityDisallows("//pkg:foo_consumes_internal_output", "//pkg:internal.bin");
    assertVisibilityDisallows("//pkg:foo_consumes_internal_input", "//pkg:internal_input");
  }

  @Test
  public void macroAccessToOtherMacrosInSameBuildFileIsControlled() throws Exception {
    defineSimpleRule();
    scratch.file("producer/BUILD");
    scratch.file(
        "producer/macro.bzl",
        """
        load("//rules:simple_rule.bzl", "simple_rule")

        def _impl(name, visibility):
            simple_rule(
                name = name + "_internal",
            )
            simple_rule(
                name = name + "_visible_to_pkg",
                visibility = ["//pkg:__pkg__"],
            )
            simple_rule(
                name = name + "_visible_to_consumer",
                visibility = ["//consumer:__pkg__"],
            )

        producer_macro = macro(implementation=_impl)
        """);
    scratch.file("consumer/BUILD");
    scratch.file(
        "consumer/macro.bzl",
        """
        load("//rules:simple_rule.bzl", "simple_rule")

        def _impl(name, visibility):
            simple_rule(
                name = name + "_consumes_internal",
                dep = "//pkg:foo_internal",
            )
            simple_rule(
                name = name + "_consumes_visible_to_pkg",
                dep = "//pkg:foo_visible_to_pkg",
            )
            simple_rule(
                name = name + "_consumes_visible_to_consumer",
                dep = "//pkg:foo_visible_to_consumer",
            )

        consumer_macro = macro(implementation=_impl)
        """);
    scratch.file(
        "pkg/BUILD",
        """
        load("//producer:macro.bzl", "producer_macro")
        load("//consumer:macro.bzl", "consumer_macro")

        producer_macro(name = "foo")
        consumer_macro(name = "bar")
        """);

    assertVisibilityDisallows("//pkg:bar_consumes_internal", "//pkg:foo_internal");
    assertVisibilityDisallows("//pkg:bar_consumes_visible_to_pkg", "//pkg:foo_visible_to_pkg");
    assertVisibilityPermits(
        "//pkg:bar_consumes_visible_to_consumer", "//pkg:foo_visible_to_consumer");
  }

  @Test
  public void siblingsInSameMacroCanSeeEachOther() throws Exception {
    defineSimpleRule();
    scratch.file("lib/BUILD");
    scratch.file(
        "lib/macro.bzl",
        """
        load("//rules:simple_rule.bzl", "simple_rule")

        def _impl(name, visibility):
            simple_rule(
                name = name + "_ruletarget",
            )
            simple_rule(
                name = name + "_consumes_ruletarget",
                dep = name + "_ruletarget",
            )
            native.exports_files([name + "_input"], visibility = ["//visibility:private"])
            simple_rule(
                name = name + "_consumes_input",
                dep = name + "_input",
            )

        my_macro = macro(implementation=_impl)
        """);
    scratch.file(
        "pkg/BUILD",
        """
        load("//rules:simple_rule.bzl", "simple_rule")
        load("//lib:macro.bzl", "my_macro")

        my_macro(name = "foo")

        simple_rule(
            name = "control",
            dep = ":foo_ruletarget",
        )
        """);

    assertVisibilityPermits("//pkg:foo_consumes_ruletarget", "//pkg:foo_ruletarget");
    assertVisibilityPermits("//pkg:foo_consumes_input", "//pkg:foo_input");
    assertVisibilityDisallows("//pkg:control", "//pkg:foo_ruletarget");
  }

  @Test
  public void buildFileTargetIsVisibleToTargetsDefinedByMacroFromSamePackage() throws Exception {
    // This test is needed because the declaration location of a target is only materialized in its
    // visibility attribute when the target is declared inside a symbolic macro. We need to
    // confirm that we're still allowing the edge from a target declared by a macro whose code is in
    // //pkg, to a dependency declared in //pkg:BUILD, despite the dependency not materializing
    // //pkg in its own visibility.
    defineSimpleRule();
    scratch.file(
        "pkg/macro.bzl",
        """
        load("//rules:simple_rule.bzl", "simple_rule")

        def _impl(name, visibility):
            simple_rule(name = name + "_macro_target", dep = "//pkg:build_target")

        my_macro = macro(implementation=_impl)
        """);
    scratch.file(
        "other_pkg/BUILD",
        """
        load("//pkg:macro.bzl", "my_macro")

        my_macro(name = "foo")
        """);
    scratch.file(
        "pkg/BUILD",
        """
        load("//rules:simple_rule.bzl", "simple_rule")

        simple_rule(name = "build_target")
        """);

    // Allowed because my_macro's code was defined in //pkg, even though it was instantiated in
    // //other_pkg.
    assertVisibilityPermits("//other_pkg:foo_macro_target", "//pkg:build_target");
  }

  @Test
  public void macroDefinitionLocationIsDeterminedByExportAssignment() throws Exception {
    // Consider a target declared by a helper func in //A, which is called from an impl func in //B,
    // which is used in a macro() definition in //C, which is loaded and exported by //D, and called
    // by a legacy macro defined in //E, itself called in a BUILD file in //F. Then the declaration
    // location of the target is considered to be //D, where the export occurs, rather than any of
    // those other packages.
    //
    // This test defines six targets in //pkg, visible to each of //A through //F. The helper
    // function in //A declares six targets that try to consume each of the respective targets from
    // //pkg. Only the one that consumes the target visible to //D is allowed to succeed.
    defineSimpleRule();
    scratch.file("A/BUILD");
    scratch.file(
        "A/helper.bzl",
        """
        load("//rules:simple_rule.bzl", "simple_rule")
        def helper(name):
            for c in ["A", "B", "C", "D", "E", "F"]:
              simple_rule(
                  name = name + "_wants_vis_to_%s" % c,
                  dep = "//pkg:vis_to_%s" % c,
              )
        """);
    scratch.file("B/BUILD");
    scratch.file(
        "B/impl.bzl",
        """
        load("//A:helper.bzl", "helper")
        def impl(name, visibility):
            helper(name)
        """);
    scratch.file("C/BUILD");
    scratch.file(
        "C/metamacro.bzl",
        """
        load("//B:impl.bzl", "impl")
        def metamacro():
            return macro(implementation = impl)
        """);
    scratch.file("D/BUILD");
    scratch.file(
        "D/my_macro.bzl",
        """
        load("//C:metamacro.bzl", "metamacro")
        my_macro = metamacro()
        """);
    scratch.file("E/BUILD");
    scratch.file(
        "E/legacy_macro.bzl",
        """
        load("//D:my_macro.bzl", "my_macro")
        def legacy_macro(name):
            my_macro(name = name)
        """);
    scratch.file(
        "F/BUILD",
        """
        load("//E:legacy_macro.bzl", "legacy_macro")

        legacy_macro(name = "consumer")
        """);
    scratch.file(
        "pkg/BUILD",
        """
        load("//rules:simple_rule.bzl", "simple_rule")

        [
            simple_rule(
                name = "vis_to_%s" % c,
                visibility = ["//%s:__pkg__" % c])
            for c in ["A", "B", "C", "D", "E", "F"]
        ]
        """);

    assertVisibilityDisallows("//F:consumer_wants_vis_to_A", "//pkg:vis_to_A");
    assertVisibilityDisallows("//F:consumer_wants_vis_to_B", "//pkg:vis_to_B");
    assertVisibilityDisallows("//F:consumer_wants_vis_to_C", "//pkg:vis_to_C");
    assertVisibilityPermits("//F:consumer_wants_vis_to_D", "//pkg:vis_to_D");
    assertVisibilityDisallows("//F:consumer_wants_vis_to_E", "//pkg:vis_to_E");
    assertVisibilityDisallows("//F:consumer_wants_vis_to_F", "//pkg:vis_to_F");
  }

  @Test
  public void locationOfTargetDeclarationIsInnermostMacro() throws Exception {
    // The //common package has a target visible to an outer macro and a target visible to an inner
    // macro. In //pkg, the outer macro is instantiated as "foo" and the inner as "foo_inner". We
    // check each combination of foo and foo_inner trying to access the two common targets.
    defineSimpleRule();
    defineCommonPackageWithSimpleTargets(
        "vis_to_inner", "['//inner:__pkg__']", "vis_to_outer", "['//outer:__pkg__']");
    scratch.file("inner/BUILD");
    scratch.file(
        "inner/macro.bzl",
        """
        load("//rules:simple_rule.bzl", "simple_rule")

        def _impl(name, visibility):
            simple_rule(
                name = name + "_wants_vis_to_inner",
                dep = "//common:vis_to_inner",
            )
            simple_rule(
                name = name + "_wants_vis_to_outer",
                dep = "//common:vis_to_outer",
            )

        inner_macro = macro(implementation=_impl)
        """);
    scratch.file("outer/BUILD");
    scratch.file(
        "outer/macro.bzl",
        """
        load("//rules:simple_rule.bzl", "simple_rule")
        load("//inner:macro.bzl", "inner_macro")

        def _impl(name, visibility):
            inner_macro(name = name + "_inner")
            simple_rule(
                name = name + "_wants_vis_to_inner",
                dep = "//common:vis_to_inner",
            )
            simple_rule(
                name = name + "_wants_vis_to_outer",
                dep = "//common:vis_to_outer",
            )

        outer_macro = macro(implementation=_impl)
        """);
    scratch.file(
        "pkg/BUILD",
        """
        load("//outer:macro.bzl", "outer_macro")

        outer_macro(name = "foo")
        """);

    assertVisibilityPermits("//pkg:foo_inner_wants_vis_to_inner", "//common:vis_to_inner");
    assertVisibilityDisallows("//pkg:foo_inner_wants_vis_to_outer", "//common:vis_to_outer");
    assertVisibilityDisallows("//pkg:foo_wants_vis_to_inner", "//common:vis_to_inner");
    assertVisibilityPermits("//pkg:foo_wants_vis_to_outer", "//common:vis_to_outer");
  }

  // This is the simplest version of the caller delegating visibility privileges to a macro.
  // Subsequent test cases don't bother to test opting out of select() promotion by setting
  // configurable=False.
  @Test
  @TestParameters({"{depIsConfigurable: false}", "{depIsConfigurable: true}"})
  public void buildFileCanDelegateVisibilityPrivilegesToMacro(boolean depIsConfigurable)
      throws Exception {
    defineSimpleRule();
    defineCommonPackageWithSimpleTargets("vis_to_pkg", "['//pkg:__pkg__']");
    scratch.file("macros/BUILD");
    scratch.file(
        "macros/simple_rule_wrapper.bzl",
        String.format(
            """
            load("//rules:simple_rule.bzl", "simple_rule")

            def _impl(name, visibility, dep):
                simple_rule(
                    name = name,
                    dep = dep,
                )

            simple_rule_wrapper = macro(
                implementation = _impl,
                attrs = {"dep": attr.label(configurable=%s)},
            )
            """,
            depIsConfigurable ? "True" : "False"));
    scratch.file(
        "pkg/BUILD",
        """
        load("//macros:simple_rule_wrapper.bzl", "simple_rule_wrapper")

        simple_rule_wrapper(
            name = "foo",
            dep = "//common:vis_to_pkg",
        )
        """);

    // Allowed, even though //pkg:foo's declaration location is not //pkg, because the macro that
    // //pkg:foo is declared in is itself declared in //pkg and passes vis_to_pkg in as an
    // attribute.
    assertVisibilityPermits("//pkg:foo", "//common:vis_to_pkg");
  }

  /**
   * Defines a macro {@code name} whose body calls symbol {@code wraps} to instantiate its main
   * target or submacro, passing along {@code attrExpr}.
   *
   * <p>The new macro is declared in {@code //<name>:macro.bzl}. It takes an optional {@code dep}
   * attribute.
   *
   * @param name the macro being introduced, e.g. "my_macro", which would be loaded from {@code
   *     //my_macro:macro.bzl}
   * @param wraps the rule or macro to be called by this macro, in {@code bzlLabel%symbol} form,
   *     e.g. "//some_pkg:defs.bzl%my_rule"
   * @param attrExpr an attribute argument expression for the call site of {@code wraps}, e.g.
   *     "some_attr = dep"
   */
  private void defineWrappingMacro(String name, String wraps, String attrExpr) throws Exception {
    int i = wraps.indexOf("%");
    Preconditions.checkArgument(i != -1);
    String bzlToLoad = wraps.substring(0, i);
    String symbolName = wraps.substring(i + 1);

    scratch.file(String.format("%s/BUILD", name));
    scratch.file(
        String.format("%s/macro.bzl", name),
        String.format(
            """
            load("%2$s", "%3$s")

            def _impl(name, visibility, dep):
                %3$s(
                    name = name,
                    %4$s,
                )

            %1$s = macro(
                implementation = _impl,
                attrs = {"dep": attr.label(mandatory=False)},
            )
            """,
            name, bzlToLoad, symbolName, attrExpr));
  }

  /**
   * Defines a macro {@code name} whose body calls {@code wraps} to instantiate its main target or
   * submacro, forwarding along the {@code dep} attribute (if supplied) unchanged.
   *
   * <p>The new macro is declared in {@code //<name>:macro.bzl}.
   *
   * @param name the macro being introduced, e.g. "my_macro", which would be loaded from {@code
   *     //my_macro:macro.bzl}
   * @param wraps the rule or macro to be called by this macro, in {@code bzlLabel%symbol} form,
   *     e.g. "//some_pkg:defs.bzl%my_rule"
   */
  private void defineWrappingMacroWithSameDep(String name, String wraps) throws Exception {
    defineWrappingMacro(name, wraps, "dep = dep");
  }

  /**
   * Defines a macro {@code name} whose body calls {@code wraps} to instantiate its main target or
   * submacro, passing {@code hardcodedDep} as the value of the {@code dep} attribute.
   *
   * <p>The new macro is declared in {@code //<name>:macro.bzl}. It takes an optional {@code dep}
   * attribute itself, which gets ignored.
   *
   * @param name the macro being introduced, e.g. "my_macro", which would be loaded from {@code
   *     //my_macro:macro.bzl}
   * @param wraps the rule or macro to be called by this macro, in {@code bzlLabel%symbol} form,
   *     e.g. "//some_pkg:defs.bzl%my_rule"
   * @param hardcodedDep a label string to pass as {@code dep = <hardcodedDep>} at the call site of
   *     {@code wraps}, e.g. "//some_pkg:my_target"
   */
  private void defineWrappingMacroWithHardcodedDep(String name, String wraps, String hardcodedDep)
      throws Exception {
    defineWrappingMacro(name, wraps, String.format("dep = \"%s\"", hardcodedDep));
  }

  @Test
  public void outerMacroCanDelegateVisibilityPrivilegesToSubmacro() throws Exception {
    defineSimpleRule();
    defineCommonPackageWithSimpleTargets("vis_to_outer", "['//outer:__pkg__']");
    defineWrappingMacroWithSameDep("inner", "//rules:simple_rule.bzl%simple_rule");
    defineWrappingMacroWithHardcodedDep(
        "outer", "//inner:macro.bzl%inner", "//common:vis_to_outer");
    scratch.file(
        "pkg/BUILD",
        """
        load("//outer:macro.bzl", "outer")

        outer(name = "foo")
        """);

    // Allowed by same reasoning as buildFileCanDelegateVisibilityPrivilegesToMacro(), but with the
    // privilege originating from an outer macro rather than from the BUILD file.
    assertVisibilityPermits("//pkg:foo", "//common:vis_to_outer");
  }

  @Test
  public void delegationCanBeTransitiveThroughAnIntermediaryMacro() throws Exception {
    defineSimpleRule();
    defineCommonPackageWithSimpleTargets("vis_to_pkg", "['//pkg:__pkg__']");
    defineWrappingMacroWithSameDep("inner", "//rules:simple_rule.bzl%simple_rule");
    defineWrappingMacroWithSameDep("outer", "//inner:macro.bzl%inner");
    scratch.file(
        "pkg/BUILD",
        """
        load("//outer:macro.bzl", "outer")

        outer(
            name = "foo",
            dep = "//common:vis_to_pkg",
        )
        """);

    // Allowed because the package delegates its privilege to the outer macro, which in turn
    // delegates its privilege to the inner macro.
    assertVisibilityPermits("//pkg:foo", "//common:vis_to_pkg");
  }

  @Test
  public void callerPermissionIsCheckedEvenIfCalleeHasItsOwnPermission() throws Exception {
    defineSimpleRule();
    defineCommonPackageWithSimpleTargets("vis_to_macro", "['//macros:__pkg__']");
    defineWrappingMacroWithSameDep("my_macro", "//rules:simple_rule.bzl%simple_rule");
    scratch.file(
        "pkg/BUILD",
        """
        load("//my_macro:macro.bzl", "my_macro")

        my_macro(
            name = "foo",
            dep = "//common:vis_to_macro",
        )
        """);

    // Even though the macro has visibility on the dep, we still fail because the caller tried to
    // pass it in and the caller has no such permission.
    assertVisibilityDisallows("//pkg:foo", "//common:vis_to_macro");
  }

  @Test
  public void noDelegationIfCallerCannotSeeDep() throws Exception {
    defineSimpleRule();
    defineCommonPackageWithSimpleTargets("not_visible", "[]");
    defineWrappingMacroWithSameDep("my_macro", "//rules:simple_rule.bzl%simple_rule");
    scratch.file(
        "pkg/BUILD",
        """
        load("//my_macro:macro.bzl", "my_macro")

        my_macro(
            name = "foo",
            dep = "//common:not_visible",
        )
        """);

    // Passed in from caller, but caller had no permission to delegate.
    assertVisibilityDisallows("//pkg:foo", "//common:not_visible");
  }

  @Test
  public void noDelegationIfCallerDoesNotPassInTarget() throws Exception {
    defineSimpleRule();
    defineCommonPackageWithSimpleTargets(
        // Read: "v2[P|M]" -> "visible to [package|macro]"
        "v2P_hardcoded",
        "['//pkg:__pkg__']",
        "v2P_implicitdep",
        "['//pkg:__pkg__']",
        "v2M_hardcoded",
        "['//macros:__pkg__']",
        "v2M_implicitdep",
        "['//macros:__pkg__']");
    scratch.file("macros/BUILD");
    scratch.file(
        "macros/my_macro.bzl",
        """
        load("//rules:simple_rule.bzl", "simple_rule")

        def _impl(name, visibility, _v2P_implicitdep, _v2M_implicitdep):
            simple_rule(
                name = name + "_consumes_v2P_hardcoded",
                dep = "//common:v2P_hardcoded",
            )
            simple_rule(
                name = name + "_consumes_v2P_implicitdep",
                dep = _v2P_implicitdep,
            )
            simple_rule(
                name = name + "_consumes_v2M_hardcoded",
                dep = "//common:v2M_hardcoded",
            )
            simple_rule(
                name = name + "_consumes_v2M_implicitdep",
                dep = _v2M_implicitdep,
            )

        my_macro = macro(
            implementation = _impl,
            attrs = {
                "_v2P_implicitdep": attr.label(
                    default="//common:v2P_implicitdep"),
                "_v2M_implicitdep": attr.label(
                    default="//common:v2M_implicitdep"),
            },
        )
        """);
    scratch.file(
        "pkg/BUILD",
        """
        load("//macros:my_macro.bzl", "my_macro")

        my_macro(name = "foo")
        """);

    // Macro can't see it. Caller didn't pass it in, so caller's permission is not delegated to the
    // macro.
    assertVisibilityDisallows("//pkg:foo_consumes_v2P_hardcoded", "//common:v2P_hardcoded");
    // Having an implicit dep doesn't count as the caller passing it in.
    assertVisibilityDisallows("//pkg:foo_consumes_v2P_implicitdep", "//common:v2P_implicitdep");

    // Macro can see it. Caller didn't pass it in, so it's fine that the caller can't see it.
    assertVisibilityPermits("//pkg:foo_consumes_v2M_hardcoded", "//common:v2M_hardcoded");
    // Having an implicit dep doesn't count as the caller passing it in.
    assertVisibilityPermits("//pkg:foo_consumes_v2M_implicitdep", "//common:v2M_implicitdep");

    // Theoretically another behavior we could try to demonstrate might be that having a label in
    // the "visibility" attribute does not qualify as the caller passing it in. However, the only
    // non-synthetic labels that can appear in visibility are package_groups or rules that imitate
    // them by providing PackageSpecificationProvider. package_groups always have public visibility,
    // so we can't manufacture a situation demonstrating that delegation has failed unless we make
    // an alternate rule class for that purpose, which doens't seem worth it. See also
    // SymbolicMacroTest#labelVisitation which covers this case at a lower level.
  }

  @Test
  public void delegationCannotSkipOverAGap() throws Exception {
    // We have a chain of macro calls A -> B -> C -> D, with a target in D consuming a dep passed in
    // by A. But the dep is not actually threaded all the way through; C hardcodes it, instead of
    // taking it as an argument from B.
    //
    // In this case, when validating the dep's visibility w.r.t. D, we don't consider A at all, even
    // though both A and D participate in passing or receiving this dep, respectively. In
    // particular, 1) we don't get the benefit of A's privileges passed on to us, and 2) if A is
    // violating the dep's visibility, we don't actually enforce that check (because macro
    // visibility violations are only discovered when actually relying on them for visibility
    // delegation).

    defineSimpleRule();
    defineCommonPackageWithSimpleTargets(
        "some_dep", "['//A:__pkg__']", "irrelevant", "['//B:__pkg__']");
    // D calls simple_rule with args unchanged.
    defineWrappingMacroWithSameDep("D", "//rules:simple_rule.bzl%simple_rule");
    // C calls D with hardcoded dep = "//common:some_dep".
    defineWrappingMacroWithHardcodedDep("C", "//D:macro.bzl%D", "//common:some_dep");
    // B calls C with a different hardcoded dep = "//common:irrelevant"
    defineWrappingMacroWithHardcodedDep("B", "//C:macro.bzl%C", "//common:irrelevant");
    // A calls B with hardcoded dep = "//common:some_dep".
    defineWrappingMacroWithHardcodedDep("A", "//B:macro.bzl%B", "//common:some_dep");
    scratch.file(
        "pkg/BUILD",
        """
        load("//A:macro.bzl", "A")

        A(name = "foo")
        """);

    // No privileges delegated through gap.
    assertVisibilityDisallows("//pkg:foo", "//common:some_dep");

    // Let's retry it with the visibility rewritten to allow C, but not A.
    scratch.deleteFile("common/BUILD");
    defineCommonPackageWithSimpleTargets("some_dep", "['//C:__pkg__']");
    invalidatePackages(); // to pick up the changes to common/BUILD
    eventCollector.clear(); // to avoid the assertion matching events emitted above

    // Now D has its own privileges, and we *don't* discover that A is illegally referring to it.
    assertVisibilityPermits("//pkg:foo", "//common:some_dep");
  }

  @Test
  public void delegationDoesNotFollowAliases() throws Exception {
    // The whole visibility system considers alias targets to have distinct permissions from the
    // underlying target they refer to. So check that these are separate entities for the purpose
    // of a caller delegating permission to a macro.
    defineSimpleRule();
    scratch.file(
        "common/BUILD",
        """
        load("//rules:simple_rule.bzl", "simple_rule")

        simple_rule(
            name = "vis_to_pkg",
            visibility = ["//pkg:__pkg__"],
        )

        alias(
            name = "aliasof_vis_to_pkg",
            actual = ":vis_to_pkg",
        )
        """);
    defineWrappingMacroWithHardcodedDep(
        "my_macro", "//rules:simple_rule.bzl%simple_rule", "//common:vis_to_pkg");
    scratch.file(
        "pkg/BUILD",
        """
        load("//my_macro:macro.bzl", "my_macro")

        my_macro(
            name = "foo",
            dep = "//common:aliasof_vis_to_pkg",
        )
        """);

    // Delegation doesn't work, needed the actual but passed the alias.
    assertVisibilityDisallows("//pkg:foo", "//common:vis_to_pkg");

    // Try it the other way around.
    scratch.deleteFile("my_macro/BUILD");
    scratch.deleteFile("my_macro/macro.bzl");
    defineWrappingMacroWithHardcodedDep(
        "my_macro", "//rules:simple_rule.bzl%simple_rule", "//common:aliasof_vis_to_pkg");
    scratch.overwriteFile(
        "pkg/BUILD",
        """
        load("//my_macro:macro.bzl", "my_macro")

        my_macro(
            name = "foo",
            dep = "//common:vis_to_pkg",
        )
        """);
    invalidatePackages(); // to pick up the changes to common/BUILD
    eventCollector.clear(); // to avoid the assertion matching events emitted above

    // Delegation doesn't work, needed the alias but passed the actual.
    assertVisibilityDisallows(
        "//pkg:foo",
        "alias '//common:aliasof_vis_to_pkg' referring to target '//common:vis_to_pkg'",
        /* dependencyIsAlias= */ true);
  }

  @Test
  public void packageDefaultVisibilityDoesNotPropagateToInsideMacro() throws Exception {
    defineSimpleRule();
    defineWrappingMacroWithSameDep("my_macro", "//rules:simple_rule.bzl%simple_rule");
    defineWrappingMacroWithSameDep("inner", "//rules:simple_rule.bzl%simple_rule");
    defineWrappingMacroWithSameDep("outer", "//inner:macro.bzl%inner");
    scratch.file(
        "lib/BUILD",
        """
        load("//rules:simple_rule.bzl", "simple_rule")
        load("//my_macro:macro.bzl", "my_macro")
        load("//outer:macro.bzl", "outer")

        package(default_visibility=["//pkg:__pkg__"])

        simple_rule(name = "foo")

        my_macro(name = "bar")

        outer(name = "baz")
        """);
    scratch.file(
        "pkg/BUILD",
        """
        load("//rules:simple_rule.bzl", "simple_rule")

        simple_rule(
            name = "consumes_foo",
            dep = "//lib:foo",
        )

        simple_rule(
            name = "consumes_bar",
            dep = "//lib:bar",
        )

        simple_rule(
            name = "consumes_baz",
            dep = "//lib:baz",
        )
        """);

    // Not in a macro, default_visibility applies.
    assertVisibilityPermits("//pkg:consumes_foo", "//lib:foo");
    // In a macro, default_visibility does not propagate.
    assertVisibilityDisallows("//pkg:consumes_bar", "//lib:bar");
    // In more than one macro, default_visibility still does not propagate.
    assertVisibilityDisallows("//pkg:consumes_baz", "//lib:baz");
  }

  /*
   * TODO: #19922 - Tests cases to add:
   *
   * ---- Implicit deps ----
   *
   * - If a rule's implicit dep is defined in a macro, the check of the rule's def loc against the
   *   dep takes into account the macro's location. In particular, a rule can see implicit deps
   *   defined by macros whose defs are in the same package as the rule's def (when the macro is
   *   called from a totally different package), even if the dep is otherwise private.
   *
   * - If a macro has an implicit dep, that dep's visibility is checked against the macro def's
   *   location, not its instantiation location. So pass even when the instance doesn't have
   *   permission. And fail if the macro def location doesn't have permission, even if the instance
   *   does have permission (either because of its declaration location or because its caller
   *   received permission delegated by its own caller via an explicit attr value).
   *
   * ---- Visibility attr usage ----
   *
   * - Can compose public and private visibilities with other visibilities via concatenation.
   *   Visibility attr is normalized. (Unclear whether to apply normalization to targets defined
   *   outside symbolic macros.)
   *
   * ---- Accounting for CommonPrerequisiteValidator#isSameLogicalPackage() ----
   *
   * - Targets of a macro defined in //javatests/foo can see targets defined in //java/foo, even
   *   when the macro is instantiated in //bar. (Rationale: We just look at the consumer's location,
   *   irrespective of whether that location comes from being in a macro or a BUILD file.)
   *
   * - Targets in //javatest/foo cannot automatically see unexported targets created by a symbolic
   *   macro defined in //java/foo, even when that macro is also instantiated in //java/foo.
   *   (Rationale: Additional visibilities granted by same-logical-package apply only at the
   *   top-level, similar to default_visibility. Macros can still propagate the additional
   *   visibility down to exported targets.)
   *
   * - A target exported from a macro instantiated in //java/foo can be seen in //javatests/foo,
   *   even when the macro is defined in //bar. (Rationale: Exported targets behave similarly to
   *   declaring the target in the BUILD file.)
   */

  // TODO: #19922 - Consider any other edge cases regarding exotic dependencies and other
  // PrerequisiteValidator code paths, e.g. implicit deps, toolchain resolution, etc.

  // TODO: #19922 - Consider correctness for alias targets. Probably just means auditing anywhere we
  // use a PackageIdentifier in visibility logic without going through
  // AliasProvider.getDependencyLabel().
}