// Copyright 2023 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.rules.starlarkdocextract;

import static com.google.common.truth.Truth.assertThat;
import static com.google.common.truth.Truth8.assertThat;
import static com.google.common.truth.extensions.proto.ProtoTruth.assertThat;
import static org.junit.Assert.assertThrows;

import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.devtools.build.lib.actions.Action;
import com.google.devtools.build.lib.analysis.ConfiguredRuleClassProvider;
import com.google.devtools.build.lib.analysis.ConfiguredTarget;
import com.google.devtools.build.lib.analysis.actions.BinaryFileWriteAction;
import com.google.devtools.build.lib.analysis.actions.FileWriteAction;
import com.google.devtools.build.lib.analysis.util.BuildViewTestCase;
import com.google.devtools.build.lib.bazel.bzlmod.BazelLockFileFunction;
import com.google.devtools.build.lib.bazel.bzlmod.BazelModuleResolutionFunction;
import com.google.devtools.build.lib.bazel.bzlmod.BzlmodTestUtil;
import com.google.devtools.build.lib.bazel.bzlmod.FakeRegistry;
import com.google.devtools.build.lib.bazel.bzlmod.ModuleFileFunction;
import com.google.devtools.build.lib.bazel.bzlmod.YankedVersionsUtil;
import com.google.devtools.build.lib.bazel.repository.RepositoryOptions.BazelCompatibilityMode;
import com.google.devtools.build.lib.bazel.repository.RepositoryOptions.CheckDirectDepsMode;
import com.google.devtools.build.lib.bazel.repository.RepositoryOptions.LockfileMode;
import com.google.devtools.build.lib.bazel.repository.starlark.StarlarkRepositoryModule;
import com.google.devtools.build.lib.cmdline.Label;
import com.google.devtools.build.lib.skyframe.PrecomputedValue;
import com.google.devtools.build.lib.skyframe.PrecomputedValue.Injected;
import com.google.devtools.build.lib.starlarkbuildapi.repository.RepositoryBootstrap;
import com.google.devtools.build.lib.testutil.TestRuleClassProvider;
import com.google.devtools.build.lib.vfs.Path;
import com.google.devtools.build.skydoc.rendering.proto.StardocOutputProtos.AspectInfo;
import com.google.devtools.build.skydoc.rendering.proto.StardocOutputProtos.AttributeInfo;
import com.google.devtools.build.skydoc.rendering.proto.StardocOutputProtos.AttributeType;
import com.google.devtools.build.skydoc.rendering.proto.StardocOutputProtos.FunctionParamInfo;
import com.google.devtools.build.skydoc.rendering.proto.StardocOutputProtos.ModuleExtensionInfo;
import com.google.devtools.build.skydoc.rendering.proto.StardocOutputProtos.ModuleExtensionTagClassInfo;
import com.google.devtools.build.skydoc.rendering.proto.StardocOutputProtos.ModuleInfo;
import com.google.devtools.build.skydoc.rendering.proto.StardocOutputProtos.OriginKey;
import com.google.devtools.build.skydoc.rendering.proto.StardocOutputProtos.ProviderInfo;
import com.google.devtools.build.skydoc.rendering.proto.StardocOutputProtos.ProviderNameGroup;
import com.google.devtools.build.skydoc.rendering.proto.StardocOutputProtos.RepositoryRuleInfo;
import com.google.devtools.build.skydoc.rendering.proto.StardocOutputProtos.RuleInfo;
import com.google.devtools.build.skydoc.rendering.proto.StardocOutputProtos.StarlarkFunctionInfo;
import com.google.protobuf.ExtensionRegistry;
import com.google.protobuf.TextFormat;
import java.io.IOException;
import java.util.NoSuchElementException;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;

@RunWith(JUnit4.class)
public final class StarlarkDocExtractTest extends BuildViewTestCase {
  private Path moduleRoot; // initialized by extraPrecomputedValues
  private FakeRegistry registry;

  @Override
  protected ImmutableList<Injected> extraPrecomputedValues() {
    // TODO(b/285924565): support --enable_bzlmod in BuildViewTestCase tests without needing the
    // boilerplate below.
    try {
      moduleRoot = scratch.dir("modules");
    } catch (IOException e) {
      throw new IllegalStateException(e);
    }
    registry = FakeRegistry.DEFAULT_FACTORY.newFakeRegistry(moduleRoot.getPathString());
    return ImmutableList.of(
        PrecomputedValue.injected(
            ModuleFileFunction.REGISTRIES, ImmutableList.of(registry.getUrl())),
        PrecomputedValue.injected(ModuleFileFunction.IGNORE_DEV_DEPS, false),
        PrecomputedValue.injected(ModuleFileFunction.MODULE_OVERRIDES, ImmutableMap.of()),
        PrecomputedValue.injected(YankedVersionsUtil.ALLOWED_YANKED_VERSIONS, ImmutableList.of()),
        PrecomputedValue.injected(
            BazelModuleResolutionFunction.CHECK_DIRECT_DEPENDENCIES, CheckDirectDepsMode.WARNING),
        PrecomputedValue.injected(
            BazelModuleResolutionFunction.BAZEL_COMPATIBILITY_MODE, BazelCompatibilityMode.ERROR),
        PrecomputedValue.injected(BazelLockFileFunction.LOCKFILE_MODE, LockfileMode.UPDATE));
  }

  @Override
  protected ConfiguredRuleClassProvider createRuleClassProvider() {
    ConfiguredRuleClassProvider.Builder builder = new ConfiguredRuleClassProvider.Builder();
    TestRuleClassProvider.addStandardRules(builder);
    // Ensure repository_rule is supported.
    builder.addStarlarkBootstrap(new RepositoryBootstrap(new StarlarkRepositoryModule()));
    return builder.build();
  }

  private static ModuleInfo protoFromBinaryFileWriteAction(Action action) throws Exception {
    assertThat(action).isInstanceOf(BinaryFileWriteAction.class);
    return ModuleInfo.parseFrom(
        ((BinaryFileWriteAction) action).getSource().openStream(),
        ExtensionRegistry.getEmptyRegistry());
  }

  private static ModuleInfo protoFromTextFileWriteAction(Action action) throws Exception {
    assertThat(action).isInstanceOf(FileWriteAction.class);
    return TextFormat.parse(
        ((FileWriteAction) action).getFileContents(),
        ExtensionRegistry.getEmptyRegistry(),
        ModuleInfo.class);
  }

  private ModuleInfo protoFromConfiguredTarget(String targetName) throws Exception {
    ConfiguredTarget target = getConfiguredTarget(targetName);
    Label targetLabel = Label.parseCanonicalUnchecked(targetName);
    String outputName = targetLabel.toPathFragment().getPathString() + ".binaryproto";
    if (!targetLabel.getRepository().isMain()) {
      outputName =
          String.format("external/%s/%s", targetLabel.getRepository().getName(), outputName);
    }
    return protoFromBinaryFileWriteAction(getGeneratingAction(target, outputName));
  }

  @Before
  public void setUpBzlLibrary() throws Exception {
    // TODO(https://github.com/bazelbuild/bazel/issues/18599): get rid of this when we bundle
    // bzl_library with Bazel.
    scratch.file(
        "bzl_library.bzl",
        "def _bzl_library_impl(ctx):",
        "    deps_files = [x.files for x in ctx.attr.deps]",
        "    all_files = depset(ctx.files.srcs, order = 'postorder', transitive = deps_files)",
        "    return DefaultInfo(files = all_files)",
        "",
        "bzl_library = rule(",
        "    implementation = _bzl_library_impl,",
        "    attrs = {",
        "        'srcs': attr.label_list(allow_files = ['.bzl', '.scl']),",
        "        'deps': attr.label_list(),",
        "    }",
        ")");
  }

  @Test
  public void basicFunctionality() throws Exception {
    scratch.file(
        "foo.bzl", //
        "'''Module doc string'''",
        "True");
    scratch.file(
        "BUILD", //
        "starlark_doc_extract(",
        "    name = 'extract',",
        "    src = 'foo.bzl',",
        ")");
    ConfiguredTarget target = getConfiguredTarget("//:extract");
    ModuleInfo moduleInfo =
        protoFromBinaryFileWriteAction(getGeneratingAction(target, "extract.binaryproto"));
    assertThat(moduleInfo.getModuleDocstring()).isEqualTo("Module doc string");
    assertThat(moduleInfo.getFile()).isEqualTo("//:foo.bzl");
  }

  @Test
  public void textprotoOut() throws Exception {
    scratch.file(
        "foo.bzl", //
        "'''Module doc string'''",
        "True");
    scratch.file(
        "BUILD", //
        "starlark_doc_extract(",
        "    name = 'extract',",
        "    src = 'foo.bzl',",
        ")");
    ConfiguredTarget ruleTarget = getConfiguredTarget("//:extract");
    // Verify that we do not generate textproto output unless explicitly requested.
    assertThrows(
        NoSuchElementException.class, () -> getGeneratingAction(ruleTarget, "extract.textproto"));

    ConfiguredTarget textprotoOutputTarget = getConfiguredTarget("//:extract.textproto");
    ModuleInfo moduleInfo =
        protoFromTextFileWriteAction(
            getGeneratingAction(textprotoOutputTarget, "extract.textproto"));
    assertThat(moduleInfo.getModuleDocstring()).isEqualTo("Module doc string");
  }

  @Test
  public void sclDialect() throws Exception {
    setBuildLanguageOptions("--experimental_enable_scl_dialect");
    scratch.file(
        "foo.scl", //
        "def f():",
        "    '''This is my function'''",
        "    pass");
    scratch.file(
        "bar.scl", //
        "'''My scl module string'''",
        "load('//:foo.scl', 'f')",
        "bar_f = f");
    scratch.file(
        "BUILD", //
        "load('bzl_library.bzl', 'bzl_library')",
        "bzl_library(",
        "    name = 'foo_scl',",
        "    srcs = ['foo.scl'],",
        ")",
        "starlark_doc_extract(",
        "    name = 'extract',",
        "    src = 'bar.scl',",
        "    deps = ['foo_scl'],",
        ")");
    ModuleInfo moduleInfo = protoFromConfiguredTarget("//:extract");
    assertThat(moduleInfo.getModuleDocstring()).isEqualTo("My scl module string");
    assertThat(moduleInfo.getFile()).isEqualTo("//:bar.scl");
    assertThat(moduleInfo.getFuncInfo(0).getDocString()).isEqualTo("This is my function");
  }

  @Test
  public void sourceWithSyntaxError_fails() throws Exception {
    scratch.file(
        "error.bzl", //
        "!!!");
    scratch.file(
        "error_loader.bzl", //
        "'''This is my module'''",
        "load('error.bzl', 'x')");
    scratch.file(
        "BUILD", //
        "load('bzl_library.bzl', 'bzl_library')",
        "bzl_library(",
        "    name = 'error_bzl',",
        "    srcs = ['error.bzl'],",
        ")",
        "starlark_doc_extract(",
        "    name = 'error_doc',",
        "    src = 'error.bzl',",
        ")",
        "starlark_doc_extract(",
        "    name = 'error_loader_doc',",
        "    src = 'error_loader.bzl',",
        "    deps = ['error_bzl'],",
        ")");

    AssertionError errorDocFailure =
        assertThrows(AssertionError.class, () -> getConfiguredTarget("//:error_doc"));
    assertThat(errorDocFailure).hasMessageThat().contains("invalid character: '!'");

    AssertionError errorLoaderDocFailure =
        assertThrows(AssertionError.class, () -> getConfiguredTarget("//:error_loader_doc"));
    assertThat(errorLoaderDocFailure).hasMessageThat().contains("invalid character: '!'");
  }

  @Test
  public void symbolNames() throws Exception {
    scratch.file(
        "foo.bzl", //
        "def func1():",
        "    pass",
        "def func2():",
        "    pass",
        "def _hidden():",
        "    pass");
    scratch.file(
        "BUILD", //
        "starlark_doc_extract(",
        "    name = 'extract_some',",
        "    src = 'foo.bzl',",
        "    symbol_names = ['func1'],",
        ")",
        "starlark_doc_extract(",
        "    name = 'extract_all',",
        "    src = 'foo.bzl',",
        ")");

    ModuleInfo dumpSome = protoFromConfiguredTarget("//:extract_some");
    assertThat(dumpSome.getFuncInfoList().stream().map(StarlarkFunctionInfo::getFunctionName))
        .containsExactly("func1");

    ModuleInfo dumpAll = protoFromConfiguredTarget("//:extract_all");
    assertThat(dumpAll.getFuncInfoList().stream().map(StarlarkFunctionInfo::getFunctionName))
        .containsExactly("func1", "func2");
  }

  @Test
  public void originKey() throws Exception {
    scratch.file(
        "origin.bzl", //
        "def my_macro():",
        "    pass",
        "MyInfo = provider()",
        "MyOtherInfo = provider()",
        "my_rule = rule(",
        "    implementation = lambda ctx: None,",
        "    attrs = {'a': attr.label(providers = [MyInfo, MyOtherInfo])},",
        "    provides = [MyInfo, MyOtherInfo],",
        ")",
        "my_aspect = aspect(implementation = lambda target, ctx: None)");
    scratch.file(
        "renamer.bzl", //
        "load(':origin.bzl', 'my_macro', 'MyInfo', 'MyOtherInfo', 'my_rule', 'my_aspect')",
        "namespace = struct(",
        "    renamed_macro = my_macro,",
        "    RenamedInfo = MyInfo,",
        "    renamed_rule = my_rule,",
        "    renamed_aspect = my_aspect,",
        ")",
        "other_namespace = struct(",
        "    RenamedOtherInfo = MyOtherInfo,",
        ")");
    scratch.file(
        "BUILD", //
        "load('bzl_library.bzl', 'bzl_library')",
        "bzl_library(",
        "    name = 'origin_bzl',",
        "    srcs = ['origin.bzl'],",
        ")",
        "starlark_doc_extract(",
        "    name = 'extract_renamed',",
        "    src = 'renamer.bzl',",
        "    deps = ['origin_bzl'],",
        "    symbol_names = ['namespace'],",
        ")");

    ModuleInfo moduleInfo = protoFromConfiguredTarget("//:extract_renamed");

    assertThat(moduleInfo.getFuncInfoList().stream().map(StarlarkFunctionInfo::getFunctionName))
        .containsExactly("namespace.renamed_macro");
    assertThat(moduleInfo.getFuncInfoList().stream().map(StarlarkFunctionInfo::getOriginKey))
        .containsExactly(
            OriginKey.newBuilder().setName("my_macro").setFile("//:origin.bzl").build());

    assertThat(moduleInfo.getProviderInfoList().stream().map(ProviderInfo::getProviderName))
        .containsExactly("namespace.RenamedInfo");
    assertThat(moduleInfo.getProviderInfoList().stream().map(ProviderInfo::getOriginKey))
        .containsExactly(OriginKey.newBuilder().setName("MyInfo").setFile("//:origin.bzl").build());

    assertThat(moduleInfo.getRuleInfoList().stream().map(RuleInfo::getRuleName))
        .containsExactly("namespace.renamed_rule");
    assertThat(moduleInfo.getRuleInfoList().stream().map(RuleInfo::getOriginKey))
        .containsExactly(
            OriginKey.newBuilder().setName("my_rule").setFile("//:origin.bzl").build());

    assertThat(moduleInfo.getRuleInfo(0).getAttributeList())
        .containsExactly(
            ModuleInfoExtractor.IMPLICIT_NAME_ATTRIBUTE_INFO,
            AttributeInfo.newBuilder()
                .setName("a")
                .setType(AttributeType.LABEL)
                .setDefaultValue("None")
                .addProviderNameGroup(
                    ProviderNameGroup.newBuilder()
                        .addProviderName("namespace.RenamedInfo")
                        .addProviderName("other_namespace.RenamedOtherInfo")
                        .addOriginKey(
                            OriginKey.newBuilder().setName("MyInfo").setFile("//:origin.bzl"))
                        .addOriginKey(
                            OriginKey.newBuilder().setName("MyOtherInfo").setFile("//:origin.bzl")))
                .build());
    assertThat(moduleInfo.getRuleInfo(0).getAdvertisedProviders())
        .isEqualTo(
            ProviderNameGroup.newBuilder()
                .addProviderName("namespace.RenamedInfo")
                .addProviderName("other_namespace.RenamedOtherInfo")
                .addOriginKey(OriginKey.newBuilder().setName("MyInfo").setFile("//:origin.bzl"))
                .addOriginKey(
                    OriginKey.newBuilder().setName("MyOtherInfo").setFile("//:origin.bzl"))
                .build());

    assertThat(moduleInfo.getAspectInfoList().stream().map(AspectInfo::getAspectName))
        .containsExactly("namespace.renamed_aspect");
    assertThat(moduleInfo.getAspectInfoList().stream().map(AspectInfo::getOriginKey))
        .containsExactly(
            OriginKey.newBuilder().setName("my_aspect").setFile("//:origin.bzl").build());
  }

  private static AttributeInfo getFirstRuleFirstAttr(ModuleInfo moduleInfo) {
    // Attribute 0 is the implicit `name` attribute
    return moduleInfo.getRuleInfo(0).getAttribute(1);
  }

  @Test
  public void originKeyFileAndModuleInfoFileLabels_forBzlFileInBzlmodModule_areDisplayForm()
      throws Exception {
    setBuildLanguageOptions("--enable_bzlmod");
    scratch.overwriteFile("MODULE.bazel", "bazel_dep(name='origin_repo', version='0.1')");
    registry.addModule(
        BzlmodTestUtil.createModuleKey("origin_repo", "0.1"),
        "module(name='origin_repo', version='0.1')");
    Path originRepoPath = moduleRoot.getRelative("origin_repo~0.1");
    scratch.file(originRepoPath.getRelative("WORKSPACE").getPathString());
    scratch.file(
        originRepoPath.getRelative("BUILD").getPathString(), //
        "exports_files(['origin.bzl'])");
    scratch.file(
        originRepoPath.getRelative("origin.bzl").getPathString(), //
        "def my_macro():",
        "    pass",
        "MyInfo = provider()",
        "my_rule = rule(",
        "    implementation = lambda ctx: None,",
        "    attrs = {'a': attr.label(providers = [MyInfo])},",
        "    provides = [MyInfo],",
        ")",
        "my_aspect = aspect(implementation = lambda target, ctx: None)");
    scratch.file(
        "renamer.bzl", //
        "load('@origin_repo//:origin.bzl', 'my_macro', 'MyInfo', 'my_rule', 'my_aspect')",
        "namespace = struct(",
        "    renamed_macro = my_macro,",
        "    RenamedInfo = MyInfo,",
        "    renamed_rule = my_rule,",
        "    renamed_aspect = my_aspect,",
        ")");
    scratch.file(
        "BUILD", //
        "load('bzl_library.bzl', 'bzl_library')",
        "bzl_library(",
        "    name = 'origin_bzl',",
        "    srcs = ['@origin_repo//:origin.bzl'],",
        ")",
        "starlark_doc_extract(",
        "    name = 'extract_origin',",
        "    src = '@origin_repo//:origin.bzl',",
        ")",
        "starlark_doc_extract(",
        "    name = 'extract_renamed',",
        "    src = 'renamer.bzl',",
        "    deps = ['origin_bzl'],",
        ")");

    // verify that ModuleInfo.name for a .bzl file in another bzlmod module is in display form, i.e.
    // "@origin_repo//:origin.bzl" as opposed to "@@origin_repo~0.1//:origin.bzl"
    ModuleInfo originModuleInfo = protoFromConfiguredTarget("//:extract_origin");
    assertThat(originModuleInfo.getFile()).isEqualTo("@origin_repo//:origin.bzl");

    // verify that OriginKey.name for entities defined in a .bzl file in another bzlmod module is in
    // display form, i.e. "@origin_repo//:origin.bzl" as opposed to "@@origin_repo~0.1//:origin.bzl"
    ModuleInfo renamedModuleInfo = protoFromConfiguredTarget("//:extract_renamed");
    assertThat(renamedModuleInfo.getFile()).isEqualTo("//:renamer.bzl");
    assertThat(renamedModuleInfo.getFuncInfo(0).getOriginKey().getFile())
        .isEqualTo("@origin_repo//:origin.bzl");
    assertThat(renamedModuleInfo.getProviderInfo(0).getOriginKey().getFile())
        .isEqualTo("@origin_repo//:origin.bzl");
    assertThat(renamedModuleInfo.getAspectInfo(0).getOriginKey().getFile())
        .isEqualTo("@origin_repo//:origin.bzl");
    assertThat(renamedModuleInfo.getRuleInfo(0).getOriginKey().getFile())
        .isEqualTo("@origin_repo//:origin.bzl");
    assertThat(
            getFirstRuleFirstAttr(renamedModuleInfo)
                .getProviderNameGroup(0)
                .getOriginKey(0)
                .getFile())
        .isEqualTo("@origin_repo//:origin.bzl");
    assertThat(renamedModuleInfo.getRuleInfo(0).getAdvertisedProviders().getOriginKey(0).getFile())
        .isEqualTo("@origin_repo//:origin.bzl");
  }

  @Test
  public void exportNestedFunctionsAndLambdas() throws Exception {
    scratch.file(
        "origin.bzl", //
        "def return_nested():",
        "    def nested(x):",
        "        '''My nested function'''",
        "        pass",
        "    return nested",
        "",
        "def return_lambda():",
        "    return lambda y: y");
    scratch.file(
        "exporter.bzl", //
        "load(':origin.bzl', 'return_nested', 'return_lambda')",
        "exported_nested = return_nested()",
        "exported_lambda = return_lambda()");
    scratch.file(
        "BUILD", //
        "load('bzl_library.bzl', 'bzl_library')",
        "bzl_library(",
        "    name = 'origin_bzl',",
        "    srcs = ['origin.bzl'],",
        ")",
        "starlark_doc_extract(",
        "    name = 'extract_exporter',",
        "    src = 'exporter.bzl',",
        "    deps = ['origin_bzl'],",
        ")");

    ModuleInfo moduleInfo = protoFromConfiguredTarget("//:extract_exporter");

    assertThat(moduleInfo.getFuncInfoList())
        .containsExactly(
            StarlarkFunctionInfo.newBuilder()
                .setFunctionName("exported_nested")
                .setDocString("My nested function")
                .addParameter(FunctionParamInfo.newBuilder().setName("x").setMandatory(true))
                .setOriginKey(
                    // OriginKey.name for nested functions is explicitly unset
                    OriginKey.newBuilder().setFile("//:origin.bzl"))
                .build(),
            StarlarkFunctionInfo.newBuilder()
                .setFunctionName("exported_lambda")
                .addParameter(FunctionParamInfo.newBuilder().setName("y").setMandatory(true))
                .setOriginKey(
                    // OriginKey.name for lambdas is explicitly unset
                    OriginKey.newBuilder().setFile("//:origin.bzl"))
                .build());
  }

  @Test
  public void missingBzlLibraryDeps_fails() throws Exception {
    scratch.file(
        "dep.bzl", //
        "load('//:forgotten_dep_of_dep.bzl', 'g')",
        "def f(): pass");
    scratch.file(
        "forgotten_dep_of_dep.bzl", //
        "def g(): pass");
    scratch.file(
        "forgotten_dep.bzl", //
        "load('//:forgotten_dep_of_forgotten_dep.bzl', 'j')",
        "def h(): pass");
    scratch.file(
        "forgotten_dep2.bzl", //
        "def i(): pass");
    scratch.file(
        "forgotten_dep_of_forgotten_dep.bzl", //
        "def j(): pass");
    scratch.file(
        "foo.bzl", //
        "load('//:dep.bzl', 'f')",
        "load('//:forgotten_dep.bzl', 'h')",
        "load('//:forgotten_dep2.bzl', 'i')");
    scratch.file(
        "BUILD", //
        "load('bzl_library.bzl', 'bzl_library')",
        "bzl_library(",
        "    name = 'dep_bzl',",
        "    srcs = ['dep.bzl'],",
        ")",
        "starlark_doc_extract(",
        "    name = 'extract',",
        "    src = 'foo.bzl',", // Note that src does not need to be part of deps
        "    deps = ['dep_bzl']",
        ")");

    AssertionError e = assertThrows(AssertionError.class, () -> getConfiguredTarget("//:extract"));
    assertThat(e)
        .hasMessageThat()
        .contains(
            "missing bzl_library targets for Starlark module(s) //:forgotten_dep_of_dep.bzl,"
                + " //:forgotten_dep.bzl, //:forgotten_dep2.bzl");
    // We do not want to log transitive deps of already missing deps in the error message - it would
    // be hard to read and unnecessary, since a valid bzl_library target should bring in its
    // transitive deps.
    assertThat(e).hasMessageThat().doesNotContain("forgotten_dep_of_forgotten_dep.bzl");
  }

  @Test
  public void depsWithDerivedFiles_onUnknownLoads_failsAndPrintsDerivedFiles() throws Exception {
    scratch.file("BUILD");
    scratch.file(
        "pkg/source_file_masked_by_rule_name.bzl", //
        "def f(): pass");
    scratch.file(
        "pkg/source_file_masked_by_rule_output_name.bzl", //
        "def g(): pass");
    scratch.file(
        "pkg/foo.bzl", //
        "load('//pkg:source_file_masked_by_rule_name.bzl', 'f')",
        "load('//pkg:source_file_masked_by_rule_output_name.bzl', 'g')");
    scratch.file(
        "pkg/BUILD", //
        "load('//:bzl_library.bzl', 'bzl_library')",
        "genrule(",
        "    name = 'source_file_masked_by_rule_name.bzl',",
        "    outs = ['some_output.bzl'],",
        "    cmd = 'touch $@'",
        ")",
        "genrule(",
        "    name = 'source_file_masked_by_rule_output_name_bzl_generator',",
        "    outs = ['source_file_masked_by_rule_output_name.bzl'],",
        "    cmd = 'touch $@'",
        ")",
        "genrule(",
        "    name = 'some_rule',",
        "    outs = ['ordinary_generated_file.bzl'],",
        "    cmd = 'touch $@'",
        ")",
        "bzl_library(",
        "    name = 'deps_bzl',",
        "    srcs = [",
        "        'source_file_masked_by_rule_name.bzl',",
        "        'source_file_masked_by_rule_output_name.bzl',",
        "        'ordinary_generated_file.bzl',",
        "    ],",
        ")",
        "starlark_doc_extract(",
        "    name = 'extract',",
        "    src = 'foo.bzl',",
        "    deps = ['deps_bzl']",
        ")");

    AssertionError error =
        assertThrows(AssertionError.class, () -> getConfiguredTarget("//pkg:extract"));
    assertThat(error)
        .hasMessageThat()
        .contains(
            "missing bzl_library targets for Starlark module(s)"
                + " //pkg:source_file_masked_by_rule_name.bzl,"
                + " //pkg:source_file_masked_by_rule_output_name.bzl\n"
                + "Note the following are generated file(s) and cannot be loaded in Starlark:"
                + " pkg/some_output.bzl (generated by rule"
                + " //pkg:source_file_masked_by_rule_name.bzl),"
                + " pkg/source_file_masked_by_rule_output_name.bzl (generated by rule"
                + " //pkg:source_file_masked_by_rule_output_name_bzl_generator),"
                + " pkg/ordinary_generated_file.bzl (generated by rule //pkg:some_rule)");
  }

  @Test
  public void depsWithDerivedFiles_onNoUnknownLoads_succeeds() throws Exception {
    scratch.file("BUILD");
    scratch.file(
        "util.bzl",
        "def _impl(ctx):",
        "    out = ctx.actions.declare_file(ctx.attr.out)",
        "    ctx.actions.run_shell(command = 'touch $1', arguments = [out.path], outputs = [out])",
        "    return DefaultInfo(files = depset([out]), runfiles = ctx.runfiles([out]))",
        "generate_out_without_declaring_it_as_a_target = rule(",
        "    attrs = {'out': attr.string()},",
        "    implementation = _impl,",
        ")");
    scratch.file(
        "pkg/source_dep.bzl", //
        "def f(): pass");
    scratch.file(
        "pkg/foo.bzl", //
        "load('//pkg:source_dep.bzl', 'f')");
    scratch.file(
        "pkg/BUILD", //
        "load('//:bzl_library.bzl', 'bzl_library')",
        "load('//:util.bzl', 'generate_out_without_declaring_it_as_a_target')",
        "genrule(",
        "    name = 'some_rule',",
        "    outs = ['declared_derived_dep.bzl'],",
        "    cmd = 'touch $@'",
        ")",
        // //pkg:generate_source_dep_without_declaring_it_as_a_target masks the source_dep.bzl
        // source artifact with a non-target, derived artifact having the same root-relative path.
        "generate_out_without_declaring_it_as_a_target(",
        "    name = 'generate_source_dep_without_declaring_it_as_a_target',",
        "    out = 'source_dep.bzl'",
        ")",
        "bzl_library(",
        "    name = 'deps_bzl',",
        "    srcs = [",
        "        'declared_derived_dep.bzl',",
        "        'source_dep.bzl',",
        "        'generate_source_dep_without_declaring_it_as_a_target',",
        "    ],",
        ")",
        "starlark_doc_extract(",
        "    name = 'extract',",
        "    src = 'foo.bzl',",
        "    deps = ['deps_bzl']",
        ")");

    getConfiguredTarget("//pkg:extract");
    assertNoEvents();
  }

  @Test
  public void srcDerivedFile_fails() throws Exception {
    scratch.file("BUILD");
    scratch.file("pkg/source_file_masked_by_rule_name.bzl");
    scratch.file("pkg/source_file_masked_by_rule_output_name.bzl");
    scratch.file(
        "pkg/BUILD", //
        "genrule(",
        "    name = 'source_file_masked_by_rule_name.bzl',",
        "    outs = ['some_output.bzl'],",
        "    cmd = 'touch $@'",
        ")",
        "genrule(",
        "    name = 'source_file_masked_by_rule_output_name_bzl_generator',",
        "    outs = ['source_file_masked_by_rule_output_name.bzl'],",
        "    cmd = 'touch $@'",
        ")",
        "genrule(",
        "    name = 'some_rule',",
        "    outs = ['ordinary_generated_file.bzl'],",
        "    cmd = 'touch $@'",
        ")",
        "starlark_doc_extract(",
        "    name = 'source_file_masked_by_rule_name_doc',",
        "    src = 'source_file_masked_by_rule_name.bzl',",
        ")",
        "starlark_doc_extract(",
        "    name = 'source_file_masked_by_rule_output_name_doc',",
        "    src = 'source_file_masked_by_rule_output_name.bzl',",
        ")",
        "starlark_doc_extract(",
        "    name = 'ordinary_generated_file_doc',",
        "    src = 'ordinary_generated_file.bzl',",
        ")");

    AssertionError maskedByRuleError =
        assertThrows(
            AssertionError.class,
            () -> getConfiguredTarget("//pkg:source_file_masked_by_rule_name_doc"));
    assertThat(maskedByRuleError)
        .hasMessageThat()
        .contains(
            "pkg/some_output.bzl (generated by rule //pkg:source_file_masked_by_rule_name.bzl)"
                + " is not a source file and cannot be loaded in Starlark");

    AssertionError maskedByRuleOutputError =
        assertThrows(
            AssertionError.class,
            () -> getConfiguredTarget("//pkg:source_file_masked_by_rule_output_name_doc"));
    assertThat(maskedByRuleOutputError)
        .hasMessageThat()
        .contains(
            "pkg/source_file_masked_by_rule_output_name.bzl (generated by rule"
                + " //pkg:source_file_masked_by_rule_output_name_bzl_generator) is not a source"
                + " file and cannot be loaded in Starlark");

    AssertionError ordinaryGeneratedFileError =
        assertThrows(
            AssertionError.class, () -> getConfiguredTarget("//pkg:ordinary_generated_file_doc"));
    assertThat(ordinaryGeneratedFileError)
        .hasMessageThat()
        .contains(
            "pkg/ordinary_generated_file.bzl (generated by rule //pkg:some_rule) is not a source"
                + " file and cannot be loaded in Starlark");
  }

  @Test
  public void srcAlias_resolvesToActual() throws Exception {
    scratch.file("alias_name.bzl");
    scratch.file("alias_actual.bzl");
    scratch.file(
        "BUILD", //
        "alias(",
        "    name = 'alias_name.bzl',",
        "    actual = 'alias_actual.bzl',",
        ")",
        "starlark_doc_extract(",
        "    name = 'extract',",
        "    src = 'alias_name.bzl',",
        ")");

    ModuleInfo moduleInfo = protoFromConfiguredTarget("//:extract");
    assertThat(moduleInfo.getFile()).isEqualTo("//:alias_actual.bzl");
  }

  @Test
  public void srcFilegroup_resolvesToFilegroupSrc() throws Exception {
    scratch.file("masked_by_filegroup_name.bzl");
    scratch.file("filegroup_src_actual.bzl");
    scratch.file(
        "BUILD", //
        "filegroup(",
        "    name = 'masked_by_filegroup_name.bzl',",
        "    srcs = ['filegroup_src_actual.bzl'],",
        ")",
        "starlark_doc_extract(",
        "    name = 'extract',",
        "    src = 'masked_by_filegroup_name.bzl',",
        ")");

    ModuleInfo moduleInfo = protoFromConfiguredTarget("//:extract");
    assertThat(moduleInfo.getFile()).isEqualTo("//:filegroup_src_actual.bzl");
  }

  @Test
  public void srcFilegroup_mustHaveSingleSrc() throws Exception {
    scratch.file("foo.bzl");
    scratch.file("bar.bzl");
    scratch.file(
        "BUILD", //
        "filegroup(",
        "    name = 'no_files',",
        "    srcs = [],",
        ")",
        "filegroup(",
        "    name = 'two_files',",
        "    srcs = ['foo.bzl', 'bar.bzl'],",
        ")",
        "starlark_doc_extract(",
        "    name = 'no_files_doc',",
        "    src = 'no_files',",
        ")",
        "starlark_doc_extract(",
        "    name = 'two_files_doc',",
        "    src = 'two_files',",
        ")");

    AssertionError extractNoFilesError =
        assertThrows(AssertionError.class, () -> getConfiguredTarget("//:no_files_doc"));
    assertThat(extractNoFilesError)
        .hasMessageThat()
        .contains("'//:no_files' must produce a single file");

    AssertionError extractTwoFilesError =
        assertThrows(AssertionError.class, () -> getConfiguredTarget("//:two_files_doc"));
    assertThat(extractTwoFilesError)
        .hasMessageThat()
        .contains("'//:two_files' must produce a single file");
  }

  @Test
  public void repositoryRule() throws Exception {
    scratch.file(
        "dep.bzl",
        "def _impl(repository_ctx):",
        "    pass",
        "",
        "my_repo_rule = repository_rule(",
        "    implementation = _impl,",
        "    doc = 'My repository rule',",
        "    attrs = {",
        "        'a': attr.string(doc = 'My doc', default = 'foo'),",
        "        'b': attr.string(mandatory = True),",
        "        '_c': attr.string(doc = 'Hidden attribute'),",
        "    },",
        "    environ = ['FOO_PATH', 'BAR_COMPILER'],",
        ")");
    scratch.file(
        "foo.bzl", //
        "load('//:dep.bzl', 'my_repo_rule')",
        "foo = struct(repo_rule = my_repo_rule)");
    scratch.file(
        "BUILD", //
        "load('bzl_library.bzl', 'bzl_library')",
        "bzl_library(",
        "    name = 'dep_bzl',",
        "    srcs = ['dep.bzl'],",
        ")",
        "starlark_doc_extract(",
        "    name = 'extract',",
        "    src = 'foo.bzl',",
        "    deps = ['dep_bzl'],",
        ")");
    ModuleInfo moduleInfo = protoFromConfiguredTarget("//:extract");
    assertThat(moduleInfo.getRepositoryRuleInfoList())
        .containsExactly(
            RepositoryRuleInfo.newBuilder()
                .setRuleName("foo.repo_rule")
                .setOriginKey(
                    OriginKey.newBuilder().setName("my_repo_rule").setFile("//:dep.bzl").build())
                .setDocString("My repository rule")
                .addAllAttribute(ModuleInfoExtractor.IMPLICIT_REPOSITORY_RULE_ATTRIBUTES)
                .addAttribute(
                    AttributeInfo.newBuilder()
                        .setName("a")
                        .setType(AttributeType.STRING)
                        .setDocString("My doc")
                        .setDefaultValue("\"foo\""))
                .addAttribute(
                    AttributeInfo.newBuilder()
                        .setName("b")
                        .setType(AttributeType.STRING)
                        .setMandatory(true))
                .addEnviron("FOO_PATH")
                .addEnviron("BAR_COMPILER")
                .build());
  }

  @Test
  public void moduleExtension() throws Exception {
    scratch.file(
        "dep.bzl",
        "_install = tag_class(",
        "    doc = 'Install',",
        "    attrs = {",
        "        'artifacts': attr.string_list(doc = 'Artifacts'),",
        "        '_hidden': attr.bool(),",
        "    },",
        ")",
        "",
        "_artifact = tag_class(",
        "    attrs = {",
        "        'group': attr.string(),",
        "        'artifact': attr.string(default = 'foo'),",
        "    },",
        ")",
        "",
        "def _impl(ctx):",
        "    pass",
        "",
        "my_ext = module_extension(",
        "    doc = 'My extension',",
        "    tag_classes = {",
        "        'install': _install,",
        "        'artifact': _artifact,",
        "    },",
        "    implementation = _impl,",
        ")");
    scratch.file(
        "foo.bzl", //
        "load('//:dep.bzl', 'my_ext')",
        "foo = struct(ext = my_ext)");
    scratch.file(
        "BUILD", //
        "load('bzl_library.bzl', 'bzl_library')",
        "bzl_library(",
        "    name = 'dep_bzl',",
        "    srcs = ['dep.bzl'],",
        ")",
        "starlark_doc_extract(",
        "    name = 'extract',",
        "    src = 'foo.bzl',",
        "    deps = ['dep_bzl'],",
        ")");
    ModuleInfo moduleInfo = protoFromConfiguredTarget("//:extract");
    assertThat(moduleInfo.getFile()).isEqualTo("//:foo.bzl");
    assertThat(moduleInfo.getModuleExtensionInfoList())
        .containsExactly(
            ModuleExtensionInfo.newBuilder()
                .setExtensionName("foo.ext")
                .setDocString("My extension")
                .setOriginKey(OriginKey.newBuilder().setFile("//:dep.bzl").build())
                .addTagClass(
                    ModuleExtensionTagClassInfo.newBuilder()
                        .setTagName("install")
                        .setDocString("Install")
                        .addAttribute(
                            AttributeInfo.newBuilder()
                                .setName("artifacts")
                                .setType(AttributeType.STRING_LIST)
                                .setDocString("Artifacts")
                                .setDefaultValue("[]"))
                        .build())
                .addTagClass(
                    ModuleExtensionTagClassInfo.newBuilder()
                        .setTagName("artifact")
                        .addAttribute(
                            AttributeInfo.newBuilder()
                                .setName("group")
                                .setType(AttributeType.STRING)
                                .setDefaultValue("\"\""))
                        .addAttribute(
                            AttributeInfo.newBuilder()
                                .setName("artifact")
                                .setType(AttributeType.STRING)
                                .setDefaultValue("\"foo\""))
                        .build())
                .build());
  }

  @Test
  public void repoName_inMainBzlmodModule() throws Exception {
    setBuildLanguageOptions("--enable_bzlmod");
    scratch.overwriteFile(
        "MODULE.bazel", //
        "module(name = 'my_module', repo_name = 'legacy_internal_repo_name')");
    scratch.file(
        "foo.bzl", //
        "def my_macro(arg = Label('//target:target')): pass",
        "",
        "my_rule = rule(",
        "    implementation = lambda ctx: None,",
        "    attrs = {'a': attr.label(default = '//target:target')},",
        ")");
    scratch.file(
        "BUILD", //
        "starlark_doc_extract(",
        "    name = 'with_main_repo_name',",
        "    src = 'foo.bzl',",
        "    render_main_repo_name = True,",
        ")",
        "",
        // render_main_repo_name is false by default
        "starlark_doc_extract(",
        "    name = 'without_main_repo_name',",
        "    src = 'foo.bzl',",
        ")");

    ModuleInfo withMainRepoName = protoFromConfiguredTarget("//:with_main_repo_name");
    assertThat(withMainRepoName.getFile()).isEqualTo("@my_module//:foo.bzl");
    assertThat(withMainRepoName.getRuleInfo(0).getOriginKey().getFile())
        .isEqualTo("@my_module//:foo.bzl");
    assertThat(withMainRepoName.getFuncInfo(0).getParameter(0).getDefaultValue())
        .isEqualTo("Label(\"@my_module//target:target\")");
    assertThat(getFirstRuleFirstAttr(withMainRepoName).getDefaultValue())
        .isEqualTo("\"@my_module//target\"");

    ModuleInfo withoutMainRepoName = protoFromConfiguredTarget("//:without_main_repo_name");
    assertThat(withoutMainRepoName.getFile()).isEqualTo("//:foo.bzl");
    assertThat(withoutMainRepoName.getFuncInfo(0).getParameter(0).getDefaultValue())
        .isEqualTo("Label(\"//target:target\")");
    assertThat(withoutMainRepoName.getRuleInfo(0).getOriginKey().getFile()).isEqualTo("//:foo.bzl");
    assertThat(getFirstRuleFirstAttr(withoutMainRepoName).getDefaultValue())
        .isEqualTo("\"//target\"");
  }

  @Test
  public void repoName_inMainWorkspaceRepo() throws Exception {
    rewriteWorkspace("workspace(name = 'my_repo')");
    scratch.file(
        "foo.bzl", //
        "def my_macro(arg = Label('//target:target')): pass",
        "",
        "my_rule = rule(",
        "    implementation = lambda ctx: None,",
        "    attrs = {'a': attr.label(default = '//target:target')},",
        ")");
    scratch.file(
        "BUILD", //
        "starlark_doc_extract(",
        "    name = 'with_main_repo_name',",
        "    src = 'foo.bzl',",
        "    render_main_repo_name = True,",
        ")",
        "",
        // render_main_repo_name is false by default
        "starlark_doc_extract(",
        "    name = 'without_main_repo_name',",
        "    src = 'foo.bzl',",
        ")");

    ModuleInfo withMainRepoName = protoFromConfiguredTarget("//:with_main_repo_name");
    assertThat(withMainRepoName.getFile()).isEqualTo("@my_repo//:foo.bzl");
    assertThat(withMainRepoName.getFuncInfo(0).getParameter(0).getDefaultValue())
        .isEqualTo("Label(\"@my_repo//target:target\")");
    assertThat(withMainRepoName.getRuleInfo(0).getOriginKey().getFile())
        .isEqualTo("@my_repo//:foo.bzl");
    assertThat(getFirstRuleFirstAttr(withMainRepoName).getDefaultValue())
        .isEqualTo("\"@my_repo//target\"");

    ModuleInfo withoutMainRepoName = protoFromConfiguredTarget("//:without_main_repo_name");
    assertThat(withoutMainRepoName.getFile()).isEqualTo("//:foo.bzl");
    assertThat(withoutMainRepoName.getFuncInfo(0).getParameter(0).getDefaultValue())
        .isEqualTo("Label(\"//target:target\")");
    assertThat(withoutMainRepoName.getRuleInfo(0).getOriginKey().getFile()).isEqualTo("//:foo.bzl");
    assertThat(getFirstRuleFirstAttr(withoutMainRepoName).getDefaultValue())
        .isEqualTo("\"//target\"");
  }

  @Test
  public void repoName_inBzlmodDep() throws Exception {
    setBuildLanguageOptions("--enable_bzlmod");
    scratch.overwriteFile(
        "MODULE.bazel", "module(name = 'my_module')", "bazel_dep(name='dep_mod', version='0.1')");
    registry.addModule(
        BzlmodTestUtil.createModuleKey("dep_mod", "0.1"), "module(name='dep_mod', version='0.1')");
    Path depModRepoPath = moduleRoot.getRelative("dep_mod~0.1");
    scratch.file(depModRepoPath.getRelative("WORKSPACE").getPathString());
    scratch.file(
        depModRepoPath.getRelative("foo.bzl").getPathString(), //
        "def my_macro(arg = Label('//target:target')): pass",
        "",
        "my_rule = rule(",
        "    implementation = lambda ctx: None,",
        "    attrs = {'a': attr.label(default = '//target:target')},",
        ")");
    scratch.file(
        depModRepoPath.getRelative("BUILD").getPathString(), //
        "starlark_doc_extract(",
        "    name = 'extract',",
        "    src = 'foo.bzl',",
        ")");

    ModuleInfo moduleInfo = protoFromConfiguredTarget("@dep_mod~0.1//:extract");
    assertThat(moduleInfo.getFile()).isEqualTo("@dep_mod//:foo.bzl");
    assertThat(moduleInfo.getFuncInfo(0).getParameter(0).getDefaultValue())
        .isEqualTo("Label(\"@dep_mod//target:target\")");
    assertThat(moduleInfo.getRuleInfo(0).getOriginKey().getFile()).isEqualTo("@dep_mod//:foo.bzl");
    assertThat(getFirstRuleFirstAttr(moduleInfo).getDefaultValue())
        .isEqualTo("\"@dep_mod//target\"");
  }

  @Test
  public void repoName_inWorkspaceDep() throws Exception {
    rewriteWorkspace("local_repository(name = 'dep', path = 'dep_path')");
    scratch.file("dep_path/WORKSPACE", "workspace(name = 'dep')");
    scratch.file(
        "dep_path/foo.bzl", //
        "def my_macro(arg = Label('//target:target')): pass",
        "",
        "my_rule = rule(",
        "    implementation = lambda ctx: None,",
        "    attrs = {'a': attr.label(default = '//target:target')},",
        ")");
    scratch.file(
        "dep_path/BUILD", //
        "starlark_doc_extract(",
        "    name = 'extract',",
        "    src = 'foo.bzl',",
        ")");

    ModuleInfo moduleInfo = protoFromConfiguredTarget("@dep//:extract");
    assertThat(moduleInfo.getFile()).isEqualTo("@dep//:foo.bzl");
    assertThat(moduleInfo.getFuncInfo(0).getParameter(0).getDefaultValue())
        .isEqualTo("Label(\"@dep//target:target\")");
    assertThat(moduleInfo.getRuleInfo(0).getOriginKey().getFile()).isEqualTo("@dep//:foo.bzl");
    assertThat(getFirstRuleFirstAttr(moduleInfo).getDefaultValue()).isEqualTo("\"@dep//target\"");
  }
}