Replace apparent_repo_name with repo rule wrappers

This presents the same API, remains compatible with both `WORKSPACE` and
Bzlmod, and avoids relying on the canonical repository name format at
all. Part of bazel-contrib#1482, and supersedes the addition of `apparent_repo_name`
from bazel-contrib#1621.

Also adds the `_SCALA_IMPORT_RULE_LOAD` constant in
`scala/scala_maven_import_external.bzl`, which also removes
`@io_bazel_rules_scala` from the `load`ed file path. It now generates
the correct path with a `Label` instead.

---

With bazelbuild/bazel-skylib#548 going nowhere, I eventually realized a
macro wrapper could generate a default target name for a repository_rule
by duplicating the `name` attr. This isn't as easy as adding
`apparent_repo_name(repository_ctx.name)` to a repo rule's
implementation, but it's also not that much more work.

One small downside is that the macro can't be imported into a
`MODULE.bazel` file directly via `use_repo_rule`, if one wanted to do
that. If you did, you'd have to add a module extension to call it, or
use `modules.as_extension` from the `bazel_skylib` module. I suppose
that's a small price to pay for squashing a canonical repo name format
dependency forever.

The other small downside may be that the documentation from the original
`repository_rule` doesn't automatically convey to the repo wrapper. In
this case, `_alias_repository` is already internal, and the original
`jvm_import_external` didn't have docstrings to begin with.

Author: mbland

scala/private/macros/bzlmod.bzl

@@ -35,9 +35,12 @@ the following macros are defined below that utilize jvm_import_external:
 - java_import_external - to demonstrate that the original functionality of `java_import_external` stayed intact.
 """
 
-load("//scala/private:macros/bzlmod.bzl", "apparent_repo_name")
 load("@bazel_tools//tools/build_defs/repo:utils.bzl", "read_netrc", "read_user_netrc", "use_netrc")
 
+_SCALA_IMPORT_RULE_LOAD = (
+    "load(\"%s\", \"scala_import\")" % Label("//scala:scala_import.bzl")
+)
+
 # https://github.com/bazelbuild/bazel/issues/13709#issuecomment-1336699672
 def _get_auth(ctx, urls):
     """Given the list of URLs obtain the correct auth dict."""
@@ -60,12 +63,12 @@ _PASS_PROPS = (
 
 _FETCH_SOURCES_ENV_VAR_NAME = "BAZEL_JVM_FETCH_SOURCES"
 
-def _jvm_import_external(repository_ctx):
+def _jvm_import_external_impl(repository_ctx):
     """Implementation of `java_import_external` rule."""
     if (repository_ctx.attr.generated_linkable_rule_name and
         not repository_ctx.attr.neverlink):
         fail("Only use generated_linkable_rule_name if neverlink is set")
-    repo_name = apparent_repo_name(repository_ctx)
+    repo_name = repository_ctx.name
     name = repository_ctx.attr.generated_rule_name or repo_name
     urls = repository_ctx.attr.jar_urls
     if repository_ctx.attr.jar_sha256:
@@ -224,8 +227,8 @@ def _serialize_given_rule_import(
     lines.append("")
     return lines
 
-jvm_import_external = repository_rule(
-    implementation = _jvm_import_external,
+_jvm_import_external = repository_rule(
+    implementation = _jvm_import_external_impl,
     attrs = {
         "rule_name": attr.string(mandatory = True),
         "licenses": attr.string_list(mandatory = True, allow_empty = False),
@@ -254,10 +257,18 @@ jvm_import_external = repository_rule(
     environ = [_FETCH_SOURCES_ENV_VAR_NAME],
 )
 
+def jvm_import_external(**kwargs):
+    """Wraps `_jvm_import_external` to pass `name` as `generated_target_name`.
+
+    If `generated_rule_name` is specified already, this is a noop.
+    """
+    generated_rule_name = kwargs.pop("generated_rule_name", kwargs.get("name"))
+    _jvm_import_external(generated_rule_name = generated_rule_name, **kwargs)
+
 def scala_maven_import_external(
         artifact,
         server_urls,
-        rule_load = "load(\"@io_bazel_rules_scala//scala:scala_import.bzl\", \"scala_import\")",
+        rule_load = _SCALA_IMPORT_RULE_LOAD,
         fetch_sources = False,
         **kwargs):
     jvm_maven_import_external(
@@ -299,7 +310,7 @@ def jvm_maven_import_external(
     jvm_import_external(jar_urls = jar_urls, srcjar_urls = srcjar_urls, coordinates = artifact, **kwargs)
 
 def scala_import_external(
-        rule_load = "load(\"@io_bazel_rules_scala//scala:scala_import.bzl\", \"scala_import\")",
+        rule_load = _SCALA_IMPORT_RULE_LOAD,
         **kwargs):
     jvm_import_external(
         rule_name = "scala_import",

scala/scala_maven_import_external.bzl

@@ -1,4 +1,3 @@
-load("//scala/private:macros/bzlmod.bzl", "apparent_repo_name")
 load(
     "//third_party/repositories:scala_2_11.bzl",
     _artifacts_2_11 = "artifacts",
@@ -129,13 +128,13 @@ def repositories(
         # See: https://github.com/bazelbuild/rules_scala/pull/1573
         # Hopefully we can deprecate and remove it one day.
         if suffix and scala_version == SCALA_VERSION:
-            _alias_repository(name = id, target = artifact_repo_name)
+            _alias_repository_wrapper(name = id, target = artifact_repo_name)
 
 def _alias_repository_impl(rctx):
     """ Builds a repository containing just two aliases to the Scala Maven artifacts in the `target` repository. """
 
     format_kwargs = {
-        "name": apparent_repo_name(rctx),
+        "name": rctx.attr.default_target_name,
         "target": rctx.attr.target,
     }
     rctx.file("BUILD", """alias(
@@ -154,6 +153,12 @@ def _alias_repository_impl(rctx):
 _alias_repository = repository_rule(
     implementation = _alias_repository_impl,
     attrs = {
+        "default_target_name": attr.string(mandatory = True),
         "target": attr.string(mandatory = True),
     },
 )
+
+def _alias_repository_wrapper(**kwargs):
+    """Wraps `_alias_repository` to pass `name` as `default_target_name`."""
+    default_target_name = kwargs.pop("default_target_name", kwargs.get("name"))
+    _alias_repository(default_target_name = default_target_name, **kwargs)