Bazel 8 + rules_java 8 updates, protoc toolchain

Bumps dependencies to versions that are compatible with both Bazel 7.5.0
and 8.0.0, and adds protocol compiler toolchainization in `//protoc` for
`protobuf` v29 and later.

Closes bazel-contrib#1652. Part of bazel-contrib#1482.

- ScalaPB jars: 0.11.17 => 1.0.0-alpha.1
- Scalafmt: 3.9.2 => 3.9.3
- `rules_python`: 0.38.0 => 1.2.0
- `rules_cc`: 0.0.9 => 0.1.1
- `rules_java`: 7.12.4 => 8.10.0
- `protobuf`: 21.7 => 30.0
- `rules_proto`: 6.0.2 => 7.1.0

Bazel 6 is officially unsupported as of this change and the upcoming
`rules_scala` 7.0.0 release. Updates `.bazelci/presubmit.yml` to bump
the `7.x` build to `last_rc`.

Registers a precompiled protocol compiler toolchain when
`--incompatible_enable_proto_toolchain_resolution` is `True`.
Otherwise, `register_toolchains(//protoc:all)` toolchains is a no-op, as
it will be empty.

`scripts/update_protoc_integrity.py` automatically updates
`scala/private/protoc/protoc_integrity.bzl`. The `protobuf` patch is the
`git diff` output from protocolbuffers/protobuf#19679, which also
inspired the updates to `scala_proto/scala_proto_toolchain.bzl`. The
`proto_lang_toolchain` call in the `BUILD` file generated by
`protoc/private/protoc_toolchain.bzl` was inspired by the `README` from:

- https://github.com/aspect-build/toolchains_protoc/

Loads `java_proto_library` from `com_google_protobuf`, replacing the
officially deprecated version from `rules_java`. Bumps Scalafmt to 3.9.3
out of convenience.

Updates to `README.md`, and updates to `WORKSPACE` and
`third_party/repositories` files precipitated by the dependency updates,
comprise the remainder of this change.

---

We're no longer planning to support Bazel 6 in the next major release
per @simuons's decision in:

- bazel-contrib#1482 (comment)

The plan is now to land the Bazel 7 and 8 compatibility updates first,
then land the Bzlmod change. This enables us to make only one new major
version release, instead of two (whereby the first release would've
continued supporting Bazel 6).

It turns out the two major version plan wouldn't've been possible.
Bazel 8 and `rules_java` 8 require `protobuf` >= v29, but this bump
caused Windows builds to break when compiling `protoc` in bazel-contrib#1710.
`src/google/protobuf/compiler/java/java_features.pb.h`, the path
specified in the error message, doesn't exist until `protobuf` v25.0.

@crt-31 and I found that this was related to the Windows/MSVC 260
character file path length limit.  What's more, the `protobuf` team
plans to drop MSVC support specifically because of this path length
limit.

The protocol compiler toolchain prevents `protoc` recompilation, which
fixes the Windows breakage while making all builds faster. Since Windows
builds break since at least `protobuf` v25, but `protoc`
toolchainization requires v29, the version bump and the `protoc`
toolchain must land together.

---

I tried several things to get protocol compiler toolchainization to work
with `protobuf` v28.2, described below. However, each path only led to
the same suffering described in the new "Why this requires `protobuf`
v29 or later" section of the README.

I discovered along the way that `protobuf` v30 isn't compatible with
Bazel 6.5.0 at all. I added an explanation to the "Limited Bazel 6.5.0
compatibility" section of `README.md`.

---

I experimented with using `protobuf` v28.2, `rules_proto` 6.0.2, and
`rules_java` 7.12.4 and 8.10.0. I updated the `protobuf` patch for v28.2
with the following statements:

```py
load("//bazel/common:proto_common.bzl", "proto_common")
load("@rules_proto//proto:proto_common.bzl", "toolchains")

_PROTO_TOOLCHAIN = "@rules_proto//proto:toolchain_type"
_PROTO_TOOLCHAIN_ATTR = "INCOMPATIBLE_ENABLE_PROTO_TOOLCHAIN_RESOLUTION"
_PROTOC_TOOLCHAINS = toolchains.use_toolchain(_PROTO_TOOLCHAIN)

def _protoc_files_to_run(ctx):
    if getattr(proto_common, _PROTO_TOOLCHAIN_ATTR, False):
```

I updated `protoc/private/protoc_toolchain.bzl` to use `proto_common` from `rules_proto`.

I also created a `rules_proto` 6.0.2 patch for `proto_toolchain()` to
fix a "no such package: //proto" breakage:

```diff
 6.0.2 patch for `proto_toolchain()`:

```diff
diff --git i/proto/private/rules/proto_toolchain.bzl w/proto/private/rules/proto_toolchain.bzl
index a091b80..def2699 100644
--- i/proto/private/rules/proto_toolchain.bzl
+++ w/proto/private/rules/proto_toolchain.bzl
@@ -33,7 +33,7 @@ def proto_toolchain(*, name, proto_compiler, exec_compatible_with = []):

     native.toolchain(
         name = name + "_toolchain",
-        toolchain_type = "//proto:toolchain_type",
+        toolchain_type = Label("//proto:toolchain_type"),
         exec_compatible_with = exec_compatible_with,
         target_compatible_with = [],
         toolchain = name,

```

I tried adding combinations of the following
`--incompatible_autoload_externally` flag values to .bazelrc`:

```txt
common --incompatible_autoload_externally=+@protobuf,+@rules_java
```

Nothing worked.

---

After the `protobuf` v29 bump, and before the ScalaPB 1.0.0-alpha.1
bump, `scala_proto` targets would fail with the following error:

```txt
ERROR: .../external/com_google_protobuf/src/google/protobuf/BUILD.bazel:23:14:
  ProtoScalaPBRule
  external/com_google_protobuf/src/google/protobuf/any_proto_jvm_extra_protobuf_generator_scalapb.srcjar
  failed: (Exit 1): scalapb_worker failed:
  error executing ProtoScalaPBRule command
  (from target @@com_google_protobuf//src/google/protobuf:any_proto)
  bazel-out/.../bin/src/scala/scripts/scalapb_worker
    ... (remaining 2 arguments skipped)

--jvm_extra_protobuf_generator_out:
  java.lang.NoSuchMethodError:
  'java.lang.Object com.google.protobuf.DescriptorProtos$FieldOptions.getExtension(com.google.protobuf.GeneratedMessage$GeneratedExtension)'
    at scalapb.compiler.DescriptorImplicits$ExtendedFieldDescriptor.fieldOptions(DescriptorImplicits.scala:329)
  [ ...snip... ]

java.lang.RuntimeException: Exit with code 1
    at scala.sys.package$.error(package.scala:30)
    at scripts.ScalaPBWorker$.work(ScalaPBWorker.scala:44)
    at io.bazel.rulesscala.worker.Worker.persistentWorkerMain(Worker.java:96)
    at io.bazel.rulesscala.worker.Worker.workerMain(Worker.java:49)
    at scripts.ScalaPBWorker$.main(ScalaPBWorker.scala:39)
    at scripts.ScalaPBWorker.main(ScalaPBWorker.scala)

ERROR: .../external/com_google_protobuf/src/google/protobuf/BUILD.bazel:23:14
  Building source jar external/com_google_protobuf/src/google/protobuf/any_proto_scalapb-src.jar
  failed: (Exit 1): scalapb_worker failed:
  error executing ProtoScalaPBRule command
  (from target @@com_google_protobuf//src/google/protobuf:any_proto)
  bazel-out/darwin_arm64-opt-exec-ST-a828a81199fe/bin/src/scala/scripts/scalapb_worker
    ... (remaining 2 arguments skipped)
```

Author: mbland

.bazelci/presubmit.yml

@@ -29,16 +29,17 @@ tasks:
     # Install xmllint
     - sudo apt update && sudo apt install --reinstall libxml2-utils -y
     - "./test_rules_scala.sh"
-  test_rules_scala_linux_latest:
-    name: "./test_rules_scala (latest Bazel)"
+  # Switch `last_rc` to `last_green` once Bzlmod lands.
+  # https://github.com/bazelbuild/rules_scala/issues/1482
+  test_rules_scala_linux_last_rc:
+    name: "./test_rules_scala (last_rc Bazel)"
     platform: ubuntu2004
-    # Restore `bazel: latest` once Bazel 8 compatibility lands (#1625, #1652).
-    bazel: 7.x
+    bazel: last_rc
     shell_commands:
     # Install xmllint
     - sudo apt update && sudo apt install --reinstall libxml2-utils -y
     - echo "build --enable_workspace" >> .bazelrc
-    - "./test_rules_scala.sh || buildkite-agent annotate --style 'warning' \"Optional build with latest Bazel version failed, [see here](${BUILDKITE_BUILD_URL}#${BUILDKITE_JOB_ID}) (It is not mandatory but worth checking)\""
+    - "./test_rules_scala.sh || buildkite-agent annotate --style 'warning' \"Optional build with last_rc Bazel version failed, [see here](${BUILDKITE_BUILD_URL}#${BUILDKITE_JOB_ID}) (It is not mandatory but worth checking)\""
   test_rules_scala_macos:
     name: "./test_rules_scala"
     platform: macos

.bazelrc

@@ -1,9 +1,14 @@
+# Switch to --noenable_workspace when Bzlmod lands.
+# https://github.com/bazelbuild/rules_scala/issues/1482
+common --enable_workspace --noenable_bzlmod
+
+# Remove once proto toolchainization becomes the default
+# - https://bazel.build/reference/command-line-reference#flag--incompatible_enable_proto_toolchain_resolution
+# - https://docs.google.com/document/d/1CE6wJHNfKbUPBr7-mmk_0Yo3a4TaqcTPE0OWNuQkhPs/edit
+common --incompatible_enable_proto_toolchain_resolution
+
 build --enable_platform_specific_config
 
 #Windows needs --worker_quit_after_build due to workers not being shut down when the compiler tools need to be rebuilt (resulting in 'file in use' errors). See Bazel Issue#10498.
 
 build:windows --worker_quit_after_build --enable_runfiles 
-
-# Switch to --noenable_workspace when Bzlmod lands.
-# https://github.com/bazelbuild/rules_scala/issues/1482
-common --enable_workspace --noenable_bzlmod

.scalafmt.conf

@@ -1,4 +1,4 @@
-version = "3.9.2"
+version = "3.9.3"
 runner.dialect = scala213
 align.openParenCallSite = false
 align.openParenDefnSite = false

README.md

@@ -65,13 +65,20 @@ load("@rules_scala//scala:deps.bzl", "rules_scala_dependencies")
 
 rules_scala_dependencies()
 
-# In `rules_scala` 7.x, `scala/deps.bzl` imports `rules_java` 7.x. This
-# statement will change for `rules_scala` 8.x, which will use `rules_java` 8.x.
-load(
-    "@rules_java//java:repositories.bzl",
-    "rules_java_dependencies",
-    "rules_java_toolchains",
-)
+# Only include the next two statements if using
+# `--incompatible_enable_proto_toolchain_resolution`.
+# See the "Using a precompiled protocol compiler" section below.
+load("@platforms//host:extension.bzl", "host_platform_repo")
+
+# Instantiates the `@host_platform` repo to work around:
+# - https://github.com/bazelbuild/bazel/issues/22558
+host_platform_repo(name = "host_platform")
+
+# This is optional, but still safe to include even when not using
+# `--incompatible_enable_proto_toolchain_resolution`.
+register_toolchains("@rules_scala//protoc:all")
+
+load("@rules_java//java:rules_java_deps.bzl", "rules_java_dependencies")
 
 rules_java_dependencies()
 
@@ -81,13 +88,11 @@ bazel_skylib_workspace()
 
 # If you need a specific `rules_python` version, specify it here.
 # Otherwise you may get the version defined in the `com_google_protobuf` repo.
-# We use 0.38.0 to maintain compatibility with the combination of `protobuf`,
-# `rules_cc`, and related dependencies. This will change in rules_scala 7.0.0.
 http_archive(
     name = "rules_python",
-    sha256 = "ca2671529884e3ecb5b79d6a5608c7373a82078c3553b1fa53206e6b9dddab34",
-    strip_prefix = "rules_python-0.38.0",
-    url = "https://github.com/bazelbuild/rules_python/releases/download/0.38.0/rules_python-0.38.0.tar.gz",
+    sha256 = "2ef40fdcd797e07f0b6abda446d1d84e2d9570d234fddf8fcd2aa262da852d1c",
+    strip_prefix = "rules_python-1.2.0",
+    url = "https://github.com/bazelbuild/rules_python/releases/download/1.2.0/rules_python-1.2.0.tar.gz",
 )
 
 load("@rules_python//python:repositories.bzl", "py_repositories")
@@ -103,6 +108,8 @@ load("@com_google_protobuf//:protobuf_deps.bzl", "protobuf_deps")
 
 protobuf_deps()
 
+load("@rules_java//java:repositories.bzl", "rules_java_toolchains")
+
 rules_java_toolchains()
 
 load("@rules_proto//proto:repositories.bzl", "rules_proto_dependencies")
@@ -187,6 +194,163 @@ load(
 )
 ```
 
+### <a id="protoc"></a>Using a precompiled protocol compiler
+
+`rules_scala` now supports the
+[`--incompatible_enable_proto_toolchain_resolution`][] flag when using
+[`protobuf` v29 or later](#why-proto-v29). When using this flag with the
+`MODULE.bazel` or `WORKSPACE` configurations below, `rules_scala` will use a
+precompiled protocol compiler binary by default.
+
+[`--incompatible_enable_proto_toolchain_resolution`]: https://bazel.build/reference/command-line-reference#flag--incompatible_enable_proto_toolchain_resolution
+
+__Windows builds now require using `protobuf` v29 or later with the precompiled
+protocol compiler toolchain.__ See the [Windows MSVC builds of protobuf broken
+by default](#protoc-msvc) section below for details.
+
+#### Common setup
+
+To set the flag in your `.bazelrc` file:
+
+```txt
+common --incompatible_enable_proto_toolchain_resolution
+```
+
+In both `MODULE.bazel` and `WORKSPACE`, add the following statement _before_ any
+other toolchain registrations. It's safe to include even when not using
+`--incompatible_enable_proto_toolchain_resolution`.
+
+```py
+# MODULE.bazel or WORKSPACE
+register_toolchains("@rules_scala//protoc:all")
+```
+
+#### Temporary required `protobuf` patch
+
+At the moment, enabling protocol compiler toolchainization requires applying
+[protoc/0001-protobuf-19679-rm-protoc-dep.patch][]. It is the `git diff` output
+from the branch used to create protocolbuffers/protobuf#19679. Without it, a
+transitive dependency on `@com_google_protobuf//:protoc` remains, causing
+`protoc` to recompile even with the precompiled toolchain registered first.
+
+[protoc/0001-protobuf-19679-rm-protoc-dep.patch]: ./protoc/0001-protobuf-19679-rm-protoc-dep.patch
+
+If and when `protobuf` merges that pull request, or applies an equivalent fix,
+this patch will no longer be necessary.
+
+#### Bzlmod setup
+
+Applying the `protobuf` patch requires using [`single_version_override`][],
+which also requires that the patch be a regular file in your own repo. In other
+words, neither `@rules_scala//protoc:0001-protobuf-19679-rm-protoc-dep.patch`
+nor an [`alias`][] to it will work.
+
+[`single_version_override`]: https://bazel.build/rules/lib/globals/module#single_version_override
+[`alias`]: https://bazel.build/reference/be/general#alias
+
+Assuming you've copied the patch to a file called `protobuf.patch` in the root
+package of your repository, add the following to your `MODULE.bazel`:
+
+```py
+# MODULE.bazel
+
+# Required for protocol compiler toolchainization until resolution of
+# protocolbuffers/protobuf#19679.
+bazel_dep(
+    name = "protobuf",
+    version = "30.0",
+    repo_name = "com_google_protobuf",
+)
+
+single_version_override(
+    module_name = "protobuf",
+    version = "30.0",
+    patches = ["//:protobuf.patch"],
+    patch_strip = 1,
+)
+```
+
+#### `WORKSPACE` setup
+
+[`scala/deps.bzl`](./scala/deps.bzl) already applies the `protobuf` patch by
+default. If you need to apply it yourself, you can also copy it to your repo as
+described in the Bzlmod setup above. Then follow the example in `scala/deps.bzl`
+to apply it in your own `http_archive` call.
+
+However, `WORKSPACE` must include the `host_platform_repo` snippet from
+[Getting started](#getting-started) to work around bazelbuild/bazel#22558:
+
+```py
+# WORKSPACE
+load("@platforms//host:extension.bzl", "host_platform_repo")
+
+# Instantiates the `@host_platform` repo to work around:
+# - https://github.com/bazelbuild/bazel/issues/22558
+host_platform_repo(name = "host_platform")
+```
+
+#### <a id="why-proto-v29"></a>Why this requires `protobuf` v29 or later
+
+Using `--incompatible_enable_proto_toolchain_resolution` with versions of
+`protobuf` before v29 causes build failures due to a missing internal Bazel
+dependency.
+
+Bazel's builtin `bazel_java_proto_aspect` transitively depends on a toolchain
+with a [`toolchain_type`][] of `@rules_java//java/proto:toolchain_type`.
+Experimentation with `protobuf` v28.2 using both Bazel 6.5.0 and 7.5.0 led to
+the following error:
+
+```txt
+ERROR: .../external/bazel_tools/src/main/protobuf/BUILD:28:15:
+  in @@_builtins//:common/java/proto/java_proto_library.bzl%bazel_java_proto_aspect
+  aspect on proto_library rule
+  @@bazel_tools//src/main/protobuf:worker_protocol_proto:
+
+Traceback (most recent call last):
+  File "/virtual_builtins_bzl/common/java/proto/java_proto_library.bzl",
+    line 53, column 53, in _bazel_java_proto_aspect_impl
+  File "/virtual_builtins_bzl/common/proto/proto_common.bzl",
+    line 364, column 17, in _find_toolchain
+Error in fail: No toolchains registered for
+  '@rules_java//java/proto:toolchain_type'.
+
+ERROR: Analysis of target
+  '@@bazel_tools//src/main/protobuf:worker_protocol_proto' failed
+```
+
+See bazelbuild/rules_scala#1710 for details of the experiment.
+
+For `protobuf` v29.0, protocolbuffers/protobuf#18308 added the
+[`@protobuf//bazel/private/toolchains`][proto-private-tc] package and updated
+`protobuf_deps()` from `@protobuf//:protobuf_deps.bzl` to register it:
+
+```py
+native.register_toolchains("//bazel/private/toolchains:all")
+```
+
+[`toolchain_type`]: https://bazel.build/extending/toolchains#writing-rules-toolchains
+[proto-private-tc]: https://github.com/protocolbuffers/protobuf/blob/v29.0/bazel/private/toolchains/BUILD.bazel
+
+protocolbuffers/protobuf#18435 then introduced
+[`java_source_toolchain_bazel7`][java-proto-tc] with the required
+`toolchain_type`.
+
+[java-proto-tc]: https://github.com/protocolbuffers/protobuf/blob/v29.0/bazel/private/toolchains/BUILD.bazel#L50-L74
+
+#### More background on protocol compiler toolchainization
+
+- [Proto Toolchainisation Design Doc](
+    https://docs.google.com/document/d/1CE6wJHNfKbUPBr7-mmk_0Yo3a4TaqcTPE0OWNuQkhPs/edit)
+
+- [bazelbuild/bazel#7095: Protobuf repo recompilation sensitivity](
+    https://github.com/bazelbuild/bazel/issues/7095)
+
+- [bazelbuild/rules_proto#179: Implement proto toolchainisation](
+    https://github.com/bazelbuild/rules_proto/issues/179)
+
+- [rules_proto 6.0.0 release notes mentioning Protobuf Toolchainization](
+    https://github.com/bazelbuild/rules_proto/releases/tag/6.0.0)
+
 ### Persistent workers
 
 To run with a persistent worker (much faster), add the following to
@@ -646,6 +810,24 @@ http_archive(
 )
 ```
 
+### <a id="protoc-msvc"></a>Windows MSVC builds of `protobuf` broken by default
+
+MSVC builds of recent `protobuf` versions started failing, as first noted in
+bazelbuild/rules_scala#1710. On top of that, `protobuf` is planning to stop
+supporting Bazel + MSVC builds per:
+
+- [protocolbuffers/protobuf#12947: src build on windows not working](
+    https://github.com/protocolbuffers/protobuf/issues/12947)
+
+- [protobuf.dev News Announcements for Version 30.x:Poison MSVC + Bazel](
+    https://protobuf.dev/news/v30/#poison-msvc--bazel)
+
+- [protocolbuffers/protobuf#20085: Breaking Change: Dropping support for
+    Bazel+MSVC](https://github.com/protocolbuffers/protobuf/issues/20085)
+
+Enable [protocol compiler toolchainization](#protoc) to fix broken Windows
+builds by avoiding `@com_google_protobuf//:protoc` recompilation.
+
 ### Embedded resource paths no longer begin with `external/<repo_name>`
 
 [Any program compiled with an external repo asset in its 'resources' attribute
@@ -768,9 +950,39 @@ with Bazel 6.5.0 won't work at all because [Bazel 6.5.0 doesn't support
 https://github.com/bazelbuild/rules_scala/issues/1482#issuecomment-2515496234).
 
 At the moment, `WORKSPACE` builds mostly continue to work with Bazel 6.5.0, but
-not out of the box, and may break at any time.  Per bazelbuild/rules_scala#1647,
-you must add the following flags to `.bazelrc`, required by the newer
-`abseil-cpp` version used by `protobuf`:
+not out of the box, and may break at any time. You will have to choose one of
+the following approaches to resolve `protobuf` compatibility issues.
+
+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:
+
+```txt
+ERROR: Traceback (most recent call last):
+  File ".../external/bazel_tools/src/main/protobuf/BUILD",
+  line 1, column 46, in <toplevel>
+    load("@com_google_protobuf//:protobuf.bzl", "py_proto_library")
+
+Error: file '@com_google_protobuf//:protobuf.bzl'
+  does not contain symbol 'py_proto_library'
+
+ERROR: .../src/java/io/bazel/rulesscala/worker/BUILD:3:13:
+  no such target '@bazel_tools//src/main/protobuf:worker_protocol_java_proto':
+  target 'worker_protocol_java_proto'
+  not declared in package 'src/main/protobuf'
+  defined by .../external/bazel_tools/src/main/protobuf/BUILD
+  (Tip: use `query "@bazel_tools//src/main/protobuf:*"`
+    to see all the targets in that package)
+  and referenced by '//src/java/io/bazel/rulesscala/worker:worker'
+```
+
+You may use protocol compiler toolchainization with `protobuf` v29 to avoid
+recompiling `protoc`. See the [Using a precompiled protocol compiler](#protoc)
+section for details.
+
+Otherwise, per bazelbuild/rules_scala#1647, add the following flags to
+`.bazelrc` to compile the newer `abseil-cpp` versions used by newer `protobuf`
+versions:
 
 ```txt
 common --enable_platform_specific_config

WORKSPACE

@@ -5,11 +5,19 @@ load("//scala:deps.bzl", "rules_scala_dependencies")
 
 rules_scala_dependencies()
 
-load(
-    "@rules_java//java:repositories.bzl",
-    "rules_java_dependencies",
-    "rules_java_toolchains",
-)
+# Only include the next two statements if using
+# `--incompatible_enable_proto_toolchain_resolution`.
+load("@platforms//host:extension.bzl", "host_platform_repo")
+
+# Instantiates the `@host_platform` repo to work around:
+# - https://github.com/bazelbuild/bazel/issues/22558
+host_platform_repo(name = "host_platform")
+
+# This is optional, but still safe to include even when not using
+# `--incompatible_enable_proto_toolchain_resolution`.
+register_toolchains("//protoc:all")
+
+load("@rules_java//java:rules_java_deps.bzl", "rules_java_dependencies")
 
 rules_java_dependencies()
 
@@ -19,9 +27,9 @@ bazel_skylib_workspace()
 
 http_archive(
     name = "rules_python",
-    sha256 = "ca2671529884e3ecb5b79d6a5608c7373a82078c3553b1fa53206e6b9dddab34",
-    strip_prefix = "rules_python-0.38.0",
-    url = "https://github.com/bazelbuild/rules_python/releases/download/0.38.0/rules_python-0.38.0.tar.gz",
+    sha256 = "2ef40fdcd797e07f0b6abda446d1d84e2d9570d234fddf8fcd2aa262da852d1c",
+    strip_prefix = "rules_python-1.2.0",
+    url = "https://github.com/bazelbuild/rules_python/releases/download/1.2.0/rules_python-1.2.0.tar.gz",
 )
 
 load("@rules_python//python:repositories.bzl", "py_repositories")
@@ -32,6 +40,8 @@ load("@com_google_protobuf//:protobuf_deps.bzl", "protobuf_deps")
 
 protobuf_deps()
 
+load("@rules_java//java:repositories.bzl", "rules_java_toolchains")
+
 rules_java_toolchains()
 
 load("@rules_proto//proto:repositories.bzl", "rules_proto_dependencies")