Make the Scala toolchain optional, improve protoc

Enables users defining custom Scala toolchains to avoid instantiating
any builtin compiler JAR repos or validating the Scala version, but
still use other builtin toolchains.

Adds the `scala` parameter to `scala_toolchains()` to control whether
it instantiates default Scala toolchains, and is `True` by default. The
Scala version check will now happen only when both `scala` and
`validate_scala_version` are `True`, which is essentially how the
previous API worked.

Removes the `if len(toolchains) == 0` check from
`_scala_toolchains_repo_impl`. Now that it's responsible for always
generating a (possibly empty) `@rules_scala_toolchains//protoc` package,
it's OK if there are no other toolchains.

Moves protoc toolchain targets from `@rules_scala_toolchains//protoc` to
`//protoc`. Experimenting with moving that toolchain to its own repo
showed that this makes `register_toolchains("@rules_scala//protoc:all")`
more robust by itself.

Prompted by:
bazel-contrib#1710 (comment)

Includes `README.md` updates:

- Bumps the `abseil-cpp` version in `README.md`
- Indicates that compiler flags are required when using Bazel 7.5.0 with
  newer versions of `protobuf` and `abseil-cpp`.

Adds `update_protoc_integrity.py` to `scripts/README.md`.

Author: mbland

README.md

@@ -75,7 +75,8 @@ load("@platforms//host:extension.bzl", "host_platform_repo")
 host_platform_repo(name = "host_platform")
 
 # This is optional, but still safe to include even when not using
-# `--incompatible_enable_proto_toolchain_resolution`.
+# `--incompatible_enable_proto_toolchain_resolution`. Requires calling
+# `scala_toolchains()`.
 register_toolchains("@rules_scala//protoc:all")
 
 load("@rules_java//java:rules_java_deps.bzl", "rules_java_dependencies")
@@ -225,6 +226,10 @@ other toolchain registrations. It's safe to include even when not using
 register_toolchains("@rules_scala//protoc:all")
 ```
 
+Note that you _must_ call `scala_toolchains()` in `WORKSPACE`, even if all other
+toolchains are disabled (i.e., if using `scala_toolchains(scala = False)`). This
+isn't necessary under Bzlmod.
+
 #### Specifying additional `protoc` platforms
 
 Use the `protoc_platforms` parameter to specify additional [platforms][] if the
@@ -480,10 +485,41 @@ maximum available at the time of writing.
 | Bazel versions using Bzlmod<br/>(Coming soon! See bazelbuild/rules_scala#1482.) | 7.5.0, 8.x,<br/>`rolling`, `last_green` |
 | Bazel versions using `WORKSPACE` | 6.5.0, 7.5.0, 8.x<br/>(see the [notes on 6.5.0 compatibility](#6.5.0)) |
 | `protobuf` |  v30.1 |
-| `abseil-cpp` | 20250127.0 |
+| `abseil-cpp` | 20250127.1 |
 | `rules_java` | 8.11.0 |
 | `ScalaPB` | 1.0.0-alpha.1 |
 
+### Using a prebuilt `@com_google_protobuf//:protoc` or C++ compiler flags
+
+Newer versions of `abseil-cpp`, required by newer versions of
+`@com_google_protobuf//:protoc`, fail to compile under Bazel 6.5.0 and 7.5.0 by
+default. [protoc will also fail to build on Windows when using
+MSVC](#protoc-msvc). You will have to choose one of the following approaches to
+resolve this problem.
+
+You may use protocol compiler toolchainization with `protobuf` v29 or later to
+avoid recompiling `protoc`. You may want to enable this even if your build
+doesn't break, as it saves time by avoiding frequent `protoc` recompilation. See
+the [Using a precompiled protocol compiler](#protoc) section for details.
+
+Otherwise, if migrating to Bazel 8 isn't an immediate option, you will need to
+set the following compiler flags in `.bazelrc` per bazelbuild/rules_scala#1647:
+
+```txt
+common --enable_platform_specific_config
+
+common:linux --cxxopt=-std=c++17
+common:linux --host_cxxopt=-std=c++17
+common:macos --cxxopt=-std=c++17
+common:macos --host_cxxopt=-std=c++17
+common:windows --cxxopt=/std=c++17
+common:windows --host_cxxopt=/std=c++17
+```
+
+Note that this example uses `common:` config settings instead of `build:`. This
+seems to prevent invalidating the action cache between `bazel` runs, which
+improves performance.
+
 ## Usage with [bazel-deps](https://github.com/johnynek/bazel-deps)
 
 Bazel-deps allows you to generate bazel dependencies transitively for maven artifacts. Generally we don't want bazel-deps to fetch
@@ -711,23 +747,25 @@ In `WORKSPACE`, this `register_toolchains()` call must come before calling
 `scala_register_toolchains()` to ensure this toolchain takes precedence. The
 same exact call will also work in `MODULE.bazel`.
 
-### Disabling Scala version validation when defining a custom Scala toolchain
+### Disabling builtin Scala toolchains when defining custom Scala toolchains
 
 When [defining a 'scala_toolchain()' using custom compiler JARs](
 docs/scala_toolchain.md#b-defining-your-own-scala_toolchain), while using
-`scala_toolchains()` to instantiate other builtin toolchains, set
-`validate_scala_version = False`:
+`scala_toolchains()` to instantiate builtin toolchains (like the [protoc
+toolchain](#protoc)), set `scala = False`:
 
 ```py
 # WORKSPACE
 scala_toolchains(
-    validate_scala_version = False,
+    scala = False,
     # ...other toolchain parameters...
 )
 ```
 
-This differs from the previous API in two ways that avoided instantiating the
-default Scala compiler JAR repositories, and thus Scala version validation:
+This avoids instantiating the default Scala toolchain and compiler JAR
+repositories and a corresponding Scala version check, which may fail when
+defining a custom toolchain. It's equivalent to two ways in which the previous
+API avoided the same default behavior:
 
 - Calling `scala_repositories(load_jar_deps = False)` would instantiate only
     other `rules_scala` dependency repos (`rules_java`, `protobuf`, etc.) and
@@ -896,6 +934,29 @@ supporting Bazel + MSVC builds per:
 Enable [protocol compiler toolchainization](#protoc) to fix broken Windows
 builds by avoiding `@com_google_protobuf//:protoc` recompilation.
 
+### Minimum of `protobuf` v28
+
+`rules_scala` requires at least `protobuf` v28, which contains the
+`bazel/common/proto_common.bzl` required for [protocol compiler
+toolchain](#protoc) support. This file appeared in v27, and no `ScalaPB` release
+supports `protobuf` v25.6, v26, or v27.
+
+#### Using earlier `protobuf` versions
+
+If you can't update to `protobuf` v28 or later right now, you will need to patch:
+
+- `scala/toolchains.bzl`: remove `setup_protoc_toolchains()` references
+- `protoc/BUILD`: remove entirely
+
+Then build using Bazel 7 and the following maximum versions of key dependencies:
+
+| Dependency | Max compatible version | Reason |
+| :-: | :-: | :- |
+| `protobuf` | v25.5 | Maximum version supported by `ScalaPB` 0.11.17. |
+| `rules_java` | 7.12.4 | 8.x requires `protobuf` v27 and later. |
+| `rules_cc` | 0.0.9 | 0.0.10 requires Bazel 7 to define `CcSharedLibraryHintInfo`.<br/>0.0.13 requires at least `protobuf` v27.0. |
+| `ScalaPB` | 0.11.17<br/>(0.9.8 for Scala 2.11) | Later versions only support `protobuf` >= v28. |
+
 ### Embedded resource paths no longer begin with `external/<repo_name>`
 
 [Any program compiled with an external repo asset in its 'resources' attribute
@@ -1022,9 +1083,8 @@ not out of the box, and may break at any time.
 
 #### Maximum of `protobuf` v29
 
-First of all, you _must_ use `protobuf` v29 or earlier. `rules_scala` now uses
-v30 by default, which removes `py_proto_library` and other symbols that Bazel
-6.5.0 requires:
+You _must_ use `protobuf` v29 or earlier. `rules_scala` now uses v30 by default,
+which removes `py_proto_library` and other symbols that Bazel 6.5.0 requires:
 
 ```txt
 ERROR: Traceback (most recent call last):
@@ -1045,47 +1105,17 @@ ERROR: .../src/java/io/bazel/rulesscala/worker/BUILD:3:13:
   and referenced by '//src/java/io/bazel/rulesscala/worker:worker'
 ```
 
-#### Using a prebuilt `@com_google_protobuf//:protoc` or C++ compiler flags
-
-Newer versions of `@com_google_protobuf//:protoc` fail to compile under Bazel
-6.5.0 by default. You will have to choose one of the following approaches to
-resolve this problem, if migrating to Bazel 7 or 8 isn't an immediate option.
+#### Configuring the protocol compiler toolchain
 
-You may use protocol compiler toolchainization with `protobuf` v29 to avoid
-recompiling `protoc`. See the [Using a precompiled protocol compiler](#protoc)
-section for details.
+See [Using a prebuilt @com_google_protobuf//:protoc or C++ compiler
+flags][protoc-opts] for protocol compiler configuration requirements.
 
-Otherwise, per bazelbuild/rules_scala#1647, add the following flags to
-`.bazelrc` to compile the newer `abseil-cpp` versions used by newer `protobuf`
-versions:
+[protoc-opts]: #using-a-prebuilt-com_google_protobufprotoc-or-c-compiler-flags
 
-```txt
-common --enable_platform_specific_config
+#### Using older versions of `protobuf`
 
-common:linux --cxxopt=-std=c++17
-common:linux --host_cxxopt=-std=c++17
-common:macos --cxxopt=-std=c++17
-common:macos --host_cxxopt=-std=c++17
-common:windows --cxxopt=/std=c++17
-common:windows --host_cxxopt=/std=c++17
-```
-
-Note that this example uses `common:` config settings instead of `build:`. This
-seems to prevent invalidating the action cache between `bazel` runs, which
-improves performance.
-
-#### Using older `protobuf` versions
-
-If you have a dependency that requires `protobuf` version before v28, use the
-following maximum versions of key dependencies. Note that no `ScalaPB` release
-supports `protobuf` v25.6, v26, or v27.
-
-| Dependency | Max compatible version | Reason |
-| :-: | :-: | :- |
-| `protobuf` | v25.5 | Maximum version supported by `ScalaPB` 0.11.17. |
-| `rules_java` | 7.12.4 | 8.x requires `protobuf` v27 and later. |
-| `rules_cc` | 0.0.9 | 0.0.10 requires Bazel 7 to define `CcSharedLibraryHintInfo`.<br/>0.0.13 requires at least `protobuf` v27.0. |
-| `ScalaPB` | 0.11.17<br/>(0.9.8 for Scala 2.11) | Later versions only support `protobuf` >= v28. |
+See [Minimum of protobuf v28](#minimum-of-protobuf-v28) for details on using
+older versions of protobuf.
 
 ### `scala_proto` not supported for Scala 2.11
 

docs/scala_toolchain.md

@@ -103,29 +103,21 @@ register_toolchains("//toolchains:my_scala_toolchain")
 
 #### Step 3 (optional)
 
-If you use `scala_toolchains()` to instantiate other builtin toolchains, set
-`validate_scala_version = False`:
+If you use `scala_toolchains()` to instantiate other builtin toolchains like the
+precompiled proto compiler toolchain, set `scala = False`:
 
 ```py
 # WORKSPACE
 scala_toolchains(
-    validate_scala_version = False,
+    scala = False,
     # ...other toolchain parameters...
 )
 ```
 
-This prevents `rules_scala` from checking that the Scala versions specified via
-`scala_config` match the `scala_version` values from
-`third_party/repositories/scala_*.bzl`.
-
-`scala_toolchains()` uses these `scala_*.bzl` files to instantiate dependency
-JAR repositories required by the builtin toolchains. It always instantiates a
-default Scala toolchain, along with its compiler JAR repositories, since [most
-users expect this behavior][1633-comment]. (As always, calling
-`register_toolchains()` on your own toolchain in `MODULE.bazel`, or before
-`scala_register_toolchains()` in `WORKSPACE`, overrides the builtin toolchain.)
-
-[1633-comment]: https://github.com/bazelbuild/rules_scala/pull/1633#discussion_r1834378901
+Otherwise, `scala_toolchains()` will try to instantiate a default Scala
+toolchain and its compiler JAR dependency repositories. The build will then fail
+if the configured Scala version doesn't match the `scala_version` value in
+the corresponding `third_party/repositories/scala_*.bzl` file.
 
 ## Configuration options
 

protoc/BUILD

@@ -1,9 +1,24 @@
+load(
+    "@com_google_protobuf//bazel/toolchains:proto_lang_toolchain.bzl",
+    "proto_lang_toolchain",
+)
 load(
     "@com_google_protobuf//bazel/toolchains:proto_toolchain.bzl",
     "proto_toolchain",
 )
 load("@rules_scala_toolchains//protoc:platforms.bzl", "PROTOC_PLATFORMS")
 
+toolchain_type(
+    name = "toolchain_type",
+    visibility = ["//visibility:public"],
+)
+
+proto_lang_toolchain(
+    name = "protoc_scala_toolchain",
+    command_line = "unused-because-we-pass-protoc-to-scalapb",
+    toolchain_type = ":toolchain_type",
+)
+
 [
     proto_toolchain(
         name = platform,

protoc/private/protoc_toolchain.bzl

@@ -81,18 +81,6 @@ def setup_protoc_toolchains(repository_ctx, package):
 
 _PROTOC_TOOLCHAIN_BUILD = """
 load(":platforms.bzl", "PROTOC_PLATFORMS")
-load("@rules_proto//proto:defs.bzl", "proto_lang_toolchain")
-
-toolchain_type(
-    name = "toolchain_type",
-    visibility = ["//visibility:public"],
-)
-
-proto_lang_toolchain(
-    name = "protoc_scala_toolchain",
-    command_line = "unused-because-we-pass-protoc-to-scalapb",
-    toolchain_type = ":toolchain_type",
-)
 
 [
     alias(

scala/toolchains.bzl

@@ -36,6 +36,7 @@ def scala_toolchains(
         validate_scala_version = True,
         scala_compiler_srcjars = {},
         protoc_platforms = [],
+        scala = True,
         scalatest = False,
         junit = False,
         specs2 = False,
@@ -74,8 +75,9 @@ def scala_toolchains(
             `third_party/repositories/scala_*.bzl` file matching the Scala
             version.
         fetch_sources: whether to download dependency source jars
-        validate_scala_version: whether to check if the configured Scala version
-            matches the default version supported by rules_scala
+        validate_scala_version: Whether to check if the configured Scala
+            versions matches the default versions supported by rules_scala. Only
+            takes effect if `scala` is `True`.
         scala_compiler_srcjars: optional dictionary of Scala version string to
             compiler srcjar metadata dictionaries containing:
             - exactly one "label", "url", or "urls" key
@@ -86,6 +88,8 @@ def scala_toolchains(
             unspecified, will use the identifier matching the `HOST_CONSTRAINTS`
             from `@platforms//host:constraints.bzl`. Only takes effect when
             `--incompatible_enable_proto_toolchain_resolution` is `True`.
+        scala: whether to instantiate default Scala toolchains for configured
+            Scala versions
         scalatest: whether to instantiate the ScalaTest toolchain
         junit: whether to instantiate the JUnit toolchain
         specs2: whether to instantiate the Specs2 JUnit toolchain
@@ -152,10 +156,13 @@ def scala_toolchains(
         })
 
     for scala_version in SCALA_VERSIONS:
-        version_specific_artifact_ids = {
-            id: fetch_sources
-            for id in scala_version_artifact_ids(scala_version)
-        }
+        version_specific_artifact_ids = {}
+
+        if scala:
+            version_specific_artifact_ids.update({
+                id: fetch_sources
+                for id in scala_version_artifact_ids(scala_version)
+            })
 
         if scala_proto:
             version_specific_artifact_ids.update({
@@ -180,7 +187,7 @@ def scala_toolchains(
             fetch_sources_by_id = all_artifacts,
             # Note the internal macro parameter misspells "overriden".
             overriden_artifacts = overridden_artifacts,
-            validate_scala_version = validate_scala_version,
+            validate_scala_version = (scala and validate_scala_version),
         )
 
     scala_toolchains_repo(

scala/toolchains_repo.bzl

@@ -78,9 +78,6 @@ def _scala_toolchains_repo_impl(repository_ctx):
     if repo_attr.scalafmt:
         toolchains["scalafmt"] = _SCALAFMT_TOOLCHAIN_BUILD
 
-    if len(toolchains) == 0:
-        fail("no toolchains specified")
-
     for pkg, build in toolchains.items():
         repository_ctx.file(
             pkg + "/BUILD",

scala_proto/scala_proto_toolchain.bzl

@@ -6,14 +6,14 @@ load(
 load("@com_google_protobuf//bazel/common:proto_common.bzl", "proto_common")
 load("@rules_proto//proto:proto_common.bzl", "toolchains")
 
-_TOOLCHAIN_TYPE = Label("@rules_scala_toolchains//protoc:toolchain_type")
+_TOOLCHAIN_TYPE = Label("//protoc:toolchain_type")
 
 # Inspired by: https://github.com/protocolbuffers/protobuf/pull/19679
 def _protoc(ctx):
     if proto_common.INCOMPATIBLE_ENABLE_PROTO_TOOLCHAIN_RESOLUTION:
         toolchain = ctx.toolchains[_TOOLCHAIN_TYPE]
         if not toolchain:
-            fail("Protocol compiler toolchain could not be resolved.")
+            fail("Couldn't resolve protocol compiler for %s" % _TOOLCHAIN_TYPE)
         return toolchain.proto.proto_compiler.executable
     else:
         return ctx.attr.protoc[DefaultInfo].files_to_run.executable

scripts/README.md

@@ -116,3 +116,11 @@ The [bazelisk](https://github.com/bazelbuild/bazelisk) wrapper for Bazel uses
 `.bazelversion` files select a Bazel version. While `USE_BAZEL_VERSION` can
 also override the Bazel version, keeping the `.bazelversion` files synchronized
 helps avoid suprises when not using `USE_BAZEL_VERSION`.
+
+## [`update_protoc_integrity`](./update_protoc_integrity.py)
+
+Updates `protoc/private/protoc_integrity.bzl`.
+
+Upon a new release of
+[`protocolbuffers/protobuf`](https://github.com/protocolbuffers/protobuf/releases)
+add the new version to the `PROTOC_VERSIONS` at the top of this file and run it.