bazel: Imitate native rule behavior with java_grpc_library

BUILD.bazel

@@ -12,15 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-load(":java_grpc_library.bzl", "java_grpc_library")
-
-java_proto_library(
-    name = "api_proto_java",
-    deps = ["@com_google_protobuf//:api_proto"],
-)
+load("//java_grpc_library:def.bzl", "java_grpc_library")
 
 java_grpc_library(
     name = "java_grpc_library__external_repo_test",
-    srcs = ["@com_google_protobuf//:api_proto"],
-    deps = [":api_proto_java"],
+    deps = ["@com_google_protobuf//:api_proto"],
 )

alts/BUILD.bazel

@@ -1,4 +1,4 @@
-load("//:java_grpc_library.bzl", "java_grpc_library")
+load("//java_grpc_library:def.bzl", "java_grpc_library")
 
 java_library(
     name = "alts_internal",
@@ -7,7 +7,6 @@ java_library(
     ]),
     deps = [
         ":handshaker_java_grpc",
-        ":handshaker_java_proto",
         "//core",
         "//core:internal",
         "//netty",
@@ -73,13 +72,7 @@ proto_library(
     ],
 )
 
-java_proto_library(
-    name = "handshaker_java_proto",
-    deps = [":handshaker_proto"],
-)
-
 java_grpc_library(
     name = "handshaker_java_grpc",
-    srcs = [":handshaker_proto"],
-    deps = [":handshaker_java_proto"],
+    deps = [":handshaker_proto"],
 )

grpclb/BUILD.bazel

@@ -1,4 +1,4 @@
-load("//:java_grpc_library.bzl", "java_grpc_library")
+load("//java_grpc_library:def.bzl", "java_grpc_library")
 
 java_library(
     name = "grpclb",
@@ -8,7 +8,6 @@ java_library(
     visibility = ["//visibility:public"],
     deps = [
         ":load_balancer_java_grpc",
-        ":load_balancer_java_proto",
         "//core",
         "//core:internal",
         "//core:util",
@@ -29,13 +28,7 @@ proto_library(
     ],
 )
 
-java_proto_library(
-    name = "load_balancer_java_proto",
-    deps = [":load_balancer_proto"],
-)
-
 java_grpc_library(
     name = "load_balancer_java_grpc",
-    srcs = [":load_balancer_proto"],
-    deps = [":load_balancer_java_proto"],
+    deps = [":load_balancer_proto"],
 )

java_grpc_library.bzl

@@ -90,6 +90,13 @@ def java_grpc_library(name, srcs, deps, flavor=None,
     visibility: (list) the visibility list
     **kwargs: Passed through to generated targets
   """
+
+  print("Deprecated. Please update your load path to @io_grpc_grpc_java//java_grpc_library:def.bzl "
+        + "for the new implementation which mirrors the native rule interface "
+        + "({repo}//{package})".format(
+            repo = native.repository_name(),
+            package = native.package_name(),
+        ))
   if flavor == None:
     flavor = "normal"
 

java_grpc_library/BUILD.bazel

@@ -0,0 +1,52 @@
+load(":toolchain.bzl", "grpc_proto_toolchain")
+
+package(default_visibility = ["//visibility:public"])
+
+grpc_proto_toolchain(
+    name = "toolchain",
+    grpc_plugin = "//compiler:grpc_java_plugin",
+    grpc_plugin_opts = select({
+        "//protobuf-lite:android": ["lite"],
+        "//conditions:default": [],
+    }),
+    java_plugin = select({
+        "//protobuf-lite:android": "@com_google_protobuf_javalite//:protoc_gen_javalite",
+        "//conditions:default": None,
+    }),
+    output_prefix = select({
+        "//protobuf-lite:android": "lib{name}-grpc-lite",
+        "//conditions:default": "lib{name}-grpc",
+    }),
+    protoc = "@com_google_protobuf//:protoc",
+    single_jar = select({
+        "//protobuf-lite:android": True,
+        "//conditions:default": False,
+    }),
+    exports = [
+        "@io_grpc_grpc_java//core",
+        "@io_grpc_grpc_java//stub",
+    ] + select({
+        "//protobuf-lite:android": ["@com_google_protobuf_javalite//:protobuf_java_lite"],
+        "//conditions:default": ["@com_google_protobuf//:protobuf_java"],
+    }),
+    runtime_deps = select({
+        "//protobuf-lite:android": ["@io_grpc_grpc_java//okhttp"],
+        "//conditions:default": ["@io_grpc_grpc_java//netty"],
+    }),
+    deps = [
+        "@com_google_errorprone_error_prone_annotations//jar",
+        "@com_google_guava_guava//jar",
+        "@io_grpc_grpc_java//core",
+        "@io_grpc_grpc_java//stub",
+        "@javax_annotation_javax_annotation_api//jar",
+    ] + select({
+        "//protobuf-lite:android": [
+            "@com_google_protobuf_javalite//:protobuf_java_lite",
+            "@io_grpc_grpc_java//protobuf-lite",
+        ],
+        "//conditions:default": [
+            "@com_google_protobuf//:protobuf_java",
+            "@io_grpc_grpc_java//protobuf",
+        ],
+    }),
+)

java_grpc_library/def.bzl

@@ -0,0 +1,149 @@
+load(":toolchain.bzl", "GrpcProtoInfo")
+
+_GRPC_TOOLCHAIN = "//java_grpc_library:toolchain"
+
+_AspectInfo = provider()
+
+def _aspect_impl(target, ctx):
+    # proto_info = target[ProtoInfo] # TODO: update provider when ProtoInfo is a real thing
+    proto_info = target.proto
+    tc = ctx.attr._toolchain[platform_common.ToolchainInfo]
+    transitive_compiled_jars = [t[_AspectInfo].compiled_jars for t in ctx.rule.attr.deps]
+
+    # return (and merge) transitive deps if there are no sources to compile
+    if len(proto_info.direct_sources) == 0:
+        java_info = java_common.merge([dep[JavaInfo] for dep in ctx.rule.attr.deps])
+        grpc_info = tc.merge([dep[GrpcProtoInfo] for dep in ctx.rule.attr.deps])
+        compiled_jars = depset(transitive = transitive_compiled_jars)
+        return struct(
+            proto_java = java_info,
+            providers = [
+                java_info,
+                grpc_info,
+                _AspectInfo(compiled_jars = depset(transitive = transitive_compiled_jars)),
+            ],
+        )
+
+    # Compile protos to srcs
+    compiled_jar = tc.declare_file(ctx, ".jar")
+    java_srcs = tc.declare_file(ctx, "-java-sources.jar")
+    grpc_srcs = tc.declare_file(ctx, "-grpc-sources.jar")
+    source_jars = [grpc_srcs, java_srcs]
+    grpc_info = tc.compile_proto(
+        ctx,
+        output_grpc_jar = grpc_srcs,
+        output_java_jar = java_srcs,
+        proto_info = proto_info,
+        deps = [t[GrpcProtoInfo] for t in ctx.rule.attr.deps],
+    )
+
+    # Compile srcs to jars
+    java_info = tc.compile_srcjars(
+        ctx,
+        source_jars = source_jars,
+        output_jar = compiled_jar,
+        deps = [t[JavaInfo] for t in ctx.rule.attr.deps],
+    )
+    return struct(
+        proto_java = java_info,
+        providers = [
+            grpc_info,
+            java_info,
+            _AspectInfo(compiled_jars = depset(
+                direct = [compiled_jar],
+                transitive = transitive_compiled_jars,
+            )),
+        ],
+    )
+
+_protocompiler_aspect = aspect(
+    _aspect_impl,
+    # provide 'proto_java' legacy provider so IntelliJ plugin is happy :-\
+    provides = ["proto_java", JavaInfo, GrpcProtoInfo],
+    attr_aspects = ["deps"],
+    fragments = ["java", "android"],
+    attrs = {
+        "_toolchain": attr.label(
+            providers = [platform_common.ToolchainInfo],
+            default = Label(_GRPC_TOOLCHAIN),
+        ),
+    },
+)
+
+def _rule_impl(ctx):
+    tc = ctx.attr._toolchain[platform_common.ToolchainInfo]
+    if ctx.attr.single_jar == "auto":
+        single_jar = tc.single_jar
+    elif ctx.attr.single_jar == "yes":
+        single_jar = True
+    elif ctx.attr.single_jar == "no":
+        single_jar = False
+    else:
+        fail("Unreachable.")
+
+    if single_jar:
+        # Aggregate all sources and compile a new JavaInfo. This is really
+        # not ideal, but is here for compatibility reasons (Android dex'ing
+        # aspect, I'm looking at you..)
+        compiled_jar = tc.declare_file(ctx, ".jar")
+        grpc_info = tc.merge([t[GrpcProtoInfo] for t in ctx.attr.deps])
+        java_info = tc.compile_srcjars(
+            ctx,
+            source_jars = grpc_info.source_jars.to_list(),
+            output_jar = compiled_jar,
+            exports = [dep[JavaInfo] for dep in tc.exports],
+        )
+        runfiles = ctx.runfiles(files = [compiled_jar])
+        for dep in tc.deps + tc.runtime_deps:
+            runfiles = dep.default_runfiles.merge(runfiles)
+        return [
+            java_info,
+            DefaultInfo(
+                files = depset(direct = [compiled_jar]),
+                runfiles = runfiles,
+            ),
+        ]
+    else:
+        # merge & return the aspect-generated JavaInfos
+        java_info = java_common.merge([
+            dep[JavaInfo]
+            for dep in ctx.attr.deps + tc.exports
+        ])
+        compiled_jars = depset(transitive = [t[_AspectInfo].compiled_jars for t in ctx.attr.deps])
+        runfiles = ctx.runfiles(transitive_files = compiled_jars)
+        for dep in tc.deps + tc.runtime_deps:
+            runfiles = dep.default_runfiles.merge(runfiles)
+        return [
+            java_info,
+            DefaultInfo(
+                files = compiled_jars,
+                runfiles = runfiles,
+            ),
+        ]
+    fail("Unreachable.")
+
+java_grpc_library = rule(
+    _rule_impl,
+    provides = [JavaInfo],
+    fragments = ["android", "java"],
+    attrs = {
+        "deps": attr.label_list(
+            providers = [
+                ["proto"],
+                # TODO: enable when ProtoInfo is real
+                #[ProtoInfo],
+            ],
+            aspects = [_protocompiler_aspect],
+            mandatory = True,
+        ),
+        "single_jar": attr.string(
+            values = ["yes", "no", "auto"],
+            default = "auto",
+            doc = "Combine generated code from all transitive deps into a single compiled jar instead of individual jars per transitive dependency. This is less efficient, but may be necessary for some rules whose aspects don't properly propagate along this rule's transitive dependencies.",
+        ),
+        "_toolchain": attr.label(
+            providers = [platform_common.ToolchainInfo],
+            default = Label(_GRPC_TOOLCHAIN),
+        ),
+    },
+)