Add integration test

src/main/java/com/google/devtools/build/lib/bazel/rules/BazelRuleClassProvider.java

@@ -103,10 +103,10 @@
 import com.google.devtools.build.lib.rules.platform.PlatformRules;
 import com.google.devtools.build.lib.rules.proto.BazelProtoCommon;
 import com.google.devtools.build.lib.rules.proto.BazelProtoLibraryRule;
+import com.google.devtools.build.lib.rules.proto.BazelProtoToolchainRule;
 import com.google.devtools.build.lib.rules.proto.ProtoConfiguration;
 import com.google.devtools.build.lib.rules.proto.ProtoInfo;
 import com.google.devtools.build.lib.rules.proto.ProtoLangToolchainRule;
-import com.google.devtools.build.lib.rules.proto.ProtoToolchainRule;
 import com.google.devtools.build.lib.rules.python.PyInfo;
 import com.google.devtools.build.lib.rules.python.PyRuleClasses.PySymlink;
 import com.google.devtools.build.lib.rules.python.PyRuntimeInfo;
@@ -292,7 +292,7 @@ public void init(ConfiguredRuleClassProvider.Builder builder) {
           builder.addConfigurationFragment(new ProtoConfiguration.Loader());
           builder.addRuleDefinition(new BazelProtoLibraryRule());
           builder.addRuleDefinition(new ProtoLangToolchainRule());
-          builder.addRuleDefinition(new ProtoToolchainRule());
+          builder.addRuleDefinition(new BazelProtoToolchainRule());
 
           ProtoBootstrap bootstrap =
               new ProtoBootstrap(

src/main/java/com/google/devtools/build/lib/rules/proto/BazelProtoLibraryRule.java

@@ -33,16 +33,14 @@
  */
 public final class BazelProtoLibraryRule implements RuleDefinition {
 
-  private static final Label DEFAULT_PROTO_COMPILER =
-      Label.parseAbsoluteUnchecked("@com_google_protobuf//:protoc");
   private static final Attribute.LabelLateBoundDefault<?> PROTO_COMPILER =
       Attribute.LabelLateBoundDefault.fromTargetConfiguration(
           ProtoConfiguration.class,
-          DEFAULT_PROTO_COMPILER,
+          BazelProtoToolchainRule.DEFAULT_PROTO_COMPILER,
           (rule, attributes, protoConfig) ->
               protoConfig.protoCompiler() != null
                   ? protoConfig.protoCompiler()
-                  : DEFAULT_PROTO_COMPILER);
+                  : BazelProtoToolchainRule.DEFAULT_PROTO_COMPILER);
 
   @Override
   public RuleClass build(RuleClass.Builder builder, final RuleDefinitionEnvironment env) {

src/main/java/com/google/devtools/build/lib/rules/proto/BazelProtoToolchainRule.java

@@ -0,0 +1,12 @@
+package com.google.devtools.build.lib.rules.proto;
+
+import com.google.devtools.build.lib.cmdline.Label;
+
+public class BazelProtoToolchainRule extends ProtoToolchainRule {
+  static final Label DEFAULT_PROTO_COMPILER =
+      Label.parseAbsoluteUnchecked("@com_google_protobuf//:protoc");
+
+  public BazelProtoToolchainRule() {
+    super(DEFAULT_PROTO_COMPILER);
+  }
+}

src/main/java/com/google/devtools/build/lib/rules/proto/ProtoToolchain.java

@@ -16,6 +16,7 @@
 
 import com.google.devtools.build.lib.actions.MutableActionGraph.ActionConflictException;
 import com.google.devtools.build.lib.analysis.ConfiguredTarget;
+import com.google.devtools.build.lib.analysis.FilesToRunProvider;
 import com.google.devtools.build.lib.analysis.RuleConfiguredTargetBuilder;
 import com.google.devtools.build.lib.analysis.RuleConfiguredTargetFactory;
 import com.google.devtools.build.lib.analysis.RuleContext;
@@ -27,7 +28,10 @@ public class ProtoToolchain implements RuleConfiguredTargetFactory {
   @Override
   public ConfiguredTarget create(RuleContext ruleContext)
       throws ActionConflictException, RuleErrorException, InterruptedException {
-    ProtoToolchainInfo toolchain = new ProtoToolchainInfo();
+    FilesToRunProvider protoCompiler = ruleContext.getExecutablePrerequisite(":proto_compiler");
+
+    ProtoToolchainInfo toolchain = new ProtoToolchainInfo(protoCompiler);
+
     RuleConfiguredTargetBuilder builder =
         new RuleConfiguredTargetBuilder(ruleContext)
             .addNativeDeclaredProvider(toolchain)

src/main/java/com/google/devtools/build/lib/rules/proto/ProtoToolchainInfo.java

@@ -14,7 +14,9 @@
 
 package com.google.devtools.build.lib.rules.proto;
 
+import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableMap;
+import com.google.devtools.build.lib.analysis.FilesToRunProvider;
 import com.google.devtools.build.lib.analysis.platform.ToolchainInfo;
 import com.google.devtools.build.lib.concurrent.ThreadSafety.Immutable;
 import com.google.devtools.build.lib.skyframe.serialization.autocodec.AutoCodec;
@@ -25,9 +27,18 @@
  */
 @Immutable
 @AutoCodec
-public class ProtoToolchainInfo extends ToolchainInfo implements ProtoToolchainInfoApi {
+public class ProtoToolchainInfo extends ToolchainInfo implements ProtoToolchainInfoApi<FilesToRunProvider> {
+  private final FilesToRunProvider protoCompiler;
+
   @AutoCodec.Instantiator
-  public ProtoToolchainInfo() {
+  public ProtoToolchainInfo(FilesToRunProvider protoCompiler) {
     super(ImmutableMap.of());
+
+    this.protoCompiler = Preconditions.checkNotNull(protoCompiler);
+  }
+
+  @Override
+  public FilesToRunProvider getProtoCompiler() {
+    return protoCompiler;
   }
 }

src/main/java/com/google/devtools/build/lib/rules/proto/ProtoToolchainRule.java

@@ -14,16 +14,43 @@
 
 package com.google.devtools.build.lib.rules.proto;
 
+import static com.google.devtools.build.lib.packages.Attribute.attr;
+import static com.google.devtools.build.lib.packages.BuildType.LABEL;
+
+import com.google.common.base.Preconditions;
 import com.google.devtools.build.lib.analysis.BaseRuleClasses;
 import com.google.devtools.build.lib.analysis.RuleDefinition;
 import com.google.devtools.build.lib.analysis.RuleDefinitionEnvironment;
+import com.google.devtools.build.lib.analysis.config.ExecutionTransitionFactory;
+import com.google.devtools.build.lib.cmdline.Label;
+import com.google.devtools.build.lib.packages.Attribute;
 import com.google.devtools.build.lib.packages.RuleClass;
 
 /** Rule definition of the <code>proto_toolchain</code> rule. */
-public class ProtoToolchainRule implements RuleDefinition {
+class ProtoToolchainRule implements RuleDefinition {
+  static final String PROTO_COMPILER_ATTR_NAME = ":proto_compiler";
+
+  private final Label defaultProtoCompiler;
+
+  public ProtoToolchainRule(Label defaultProtoCompiler) {
+    this.defaultProtoCompiler = Preconditions.checkNotNull(defaultProtoCompiler);
+  }
+
   @Override
   public RuleClass build(RuleClass.Builder builder, final RuleDefinitionEnvironment env) {
     return builder
+        .add(
+            attr(PROTO_COMPILER_ATTR_NAME, LABEL)
+                .cfg(ExecutionTransitionFactory.create())
+                .exec()
+                .value(
+                    Attribute.LabelLateBoundDefault.fromTargetConfiguration(
+                        ProtoConfiguration.class,
+                        defaultProtoCompiler,
+                        (rule, attributes, protoConfig) ->
+                            protoConfig.protoCompiler() != null
+                                ? protoConfig.protoCompiler()
+                                : defaultProtoCompiler)))
         .requiresConfigurationFragments(ProtoConfiguration.class)
         .advertiseProvider(ProtoToolchainInfo.class)
         .build();

src/main/java/com/google/devtools/build/lib/starlarkbuildapi/proto/ProtoToolchainInfoApi.java

@@ -15,12 +15,20 @@
 package com.google.devtools.build.lib.starlarkbuildapi.proto;
 
 import com.google.devtools.build.docgen.annot.DocCategory;
+import com.google.devtools.build.lib.starlarkbuildapi.FilesToRunProviderApi;
 import com.google.devtools.build.lib.starlarkbuildapi.platform.ToolchainInfoApi;
 import net.starlark.java.annot.StarlarkBuiltin;
+import net.starlark.java.annot.StarlarkMethod;
 
 /** Provides access to information about the Protobuf toolchain rule. */
 @StarlarkBuiltin(
     name = "ProtoToolchainInfo",
     category = DocCategory.PROVIDER,
     doc = "Provides access to information about the Protobuf toolchain rule.")
-public interface ProtoToolchainInfoApi  extends ToolchainInfoApi {}
+public interface ProtoToolchainInfoApi<FilesToRunProviderT extends FilesToRunProviderApi> extends ToolchainInfoApi {
+  @StarlarkMethod(
+      name = "proto_compiler",
+      doc = "The <code>protoc</code> executable.",
+      structField = true)
+  FilesToRunProviderT getProtoCompiler();
+}

src/test/shell/bazel/bazel_proto_library_test.sh

@@ -681,4 +681,47 @@ EOF
   bazel build //h || fail "build failed"
 }
 
+function test_have_implicitly_defined_proto_toolchain() {
+  write_workspace ""
+
+  mkdir -p foo
+  cat > foo/BUILD <<EOF
+load(":write_proto_toolchain_info.bzl", "write_proto_toolchain_info")
+
+write_proto_toolchain_info(
+    name = "foo",
+)
+EOF
+
+  cat > foo/write_proto_toolchain_info.bzl <<EOF
+def _write_proto_toolchain_info_impl(ctx):
+    proto_toolchain = ctx.toolchains["@bazel_tools//tools/proto:toolchain_type"]
+
+    protoc_version = ctx.actions.declare_file("protoc_version.txt")
+    ctx.actions.run_shell(
+        outputs = [protoc_version],
+        tools = [
+            proto_toolchain.proto_compiler,
+        ],
+        command = proto_toolchain.proto_compiler.executable.path + " --version > " + protoc_version.path,
+    )
+
+    return [
+        DefaultInfo(
+            files = depset([protoc_version]),
+        ),
+    ]
+
+write_proto_toolchain_info = rule(
+    implementation = _write_proto_toolchain_info_impl,
+    toolchains = [
+        "@bazel_tools//tools/proto:toolchain_type",
+    ],
+)
+EOF
+
+  bazel build //foo || fail "build failed"
+  assert_contains "^libprotoc " bazel-bin/foo/protoc_version.txt
+}
+
 run_suite "Integration tests for proto_library"