- Remove duplicate attribute semantics of 'paths' and 'imports': 'imports' (string_list) is

  the mechanism to pass '--proto_path' or '-I' args to protoc.
- BUILD file cleanup.

Author: pcj

bzl/base/class.bzl

@@ -54,42 +54,11 @@ def build_generated_filenames(lang, self):
             self["outs"] += [srcfile.rsplit('.', 1)[0] + ext]
 
 
-def build_paths(lang, self):
+def build_imports(lang, self):
     """Build the list of imports"""
     ctx = self["ctx"]
     if ctx:
-        self["paths"] = self.get("paths", []) + ctx.attr.paths
-
-def build_imports(lang, self):
-    """Copy any named proto files in the imports to the genfiles area to make visible to protoc.  Not sure this is necessary anymore."""
-    ctx = self["ctx"]
-    if not ctx:
-        fail("Bazel context is required for build_imports")
-    #print("ctx.attr.imports: %s" % type(ctx.attr.imports))
-    for target in ctx.attr.imports:
-        for srcfile in target.files:
-            #print("srcfile: %s" % srcfile.path)
-            dstfile = ctx.new_file(srcfile.path)
-            #dstfile = ctx.new_file(srcfile.path)
-            # By declaring that the proto action (happening later)
-            # depends on these files, we ensure that the
-            # CpImportToPackageGenfile action is run.  Without this
-            # linkage, bazel assumes the action isn't required.
-            self["requires"] += [dstfile]
-            if ctx.attr.verbose > 1:
-                print("Copying import %s --> %s" % (srcfile.path, dstfile.path))
-            ctx.action(mnemonic = "CpImportToPackageGenfiles",
-                       inputs = [srcfile],
-                       outputs = [dstfile],
-                       arguments = [srcfile.path, dstfile.path],
-                       command = "cp $1 $2")
-            # These probably need to be compiled also.  Nope: if you
-            # try this you get "inconsistent package names" from
-            # https://github.com/golang/protobuf/blob/1687f003bf0280bd6182a5a1c7241856b269a6c0/protoc-gen-go/generator/generator.go#L750
-            #self["srcs"] += [dstfile]
-
-            #self["go_plugin_options"] = self.get("go_plugin_options", []) + ["M" + srcfile.path + "="]
-    #self["paths"] += [self["outdir"]]
+        self["imports"] = self.get("imports", []) + ctx.attr.imports
 
 def build_plugin_out(name, key, lang, self):
     #print("build_plugin_out(%s, %s)" % (name, key))
@@ -164,7 +133,7 @@ def build_protobuf_invocation(lang, self):
 def build_protoc_command(lang, self):
     """Build a command list required for genrule execution"""
     self["cmd"] += ["$(location %s)" % self["protoc"]]
-    self["cmd"] += ["--proto_path=" + i for i in self["paths"]]
+    self["cmd"] += ["--proto_path=" + i for i in self["imports"]]
     self["cmd"] += self["args"]
     self["cmd"] += ["$(location " + proto + ")" for proto in self["protos"]]
 
@@ -219,7 +188,6 @@ CLASS = struct(
     build_generated_filenames = build_generated_filenames,
     build_imports = build_imports,
     build_inputs = build_inputs,
-    build_paths = build_paths,
     build_tools = build_tools,
     build_protobuf_invocation = build_protobuf_invocation,
     build_protobuf_out = build_protobuf_out,

bzl/cpp/rules.bzl

@@ -12,7 +12,6 @@ def cc_proto_library(
     grpc_plugin_options = [],
     imports = [],
     lang = CPP,
-    paths = [],
     protobuf_plugin_options = [],
     protobuf_plugin = None,
     proto_compile = cc_proto_compile,
@@ -35,7 +34,6 @@ def cc_proto_library(
   args["gen_protobuf_" + lang.name + "_plugin"] = protobuf_plugin
   args["gen_" + lang.name + "_plugin_options"] = protobuf_plugin_options
   args["gen_grpc_" + lang.name + "_plugin"] = grpc_plugin
-  args["paths"] = paths
   args["protoc"] = protoc
   args["protos"] = srcs
   args["verbose"] = verbose

bzl/go/class.bzl

@@ -15,7 +15,7 @@ def _build_grpc_out(lang, self):
 
 
 def _build_imports(lang, self):
-    """@Override: Copy any named proto files in the imports to the genfiles area to make visible to protoc.  Not sure this is necessary anymore."""
+    """@Override: for all transitive packages source file names, provide import mapping."""
     invokesuper("build_imports", lang, self)
 
     ctx = self["ctx"]

bzl/go/rules.bzl

@@ -12,7 +12,6 @@ def go_proto_library(
     grpc_plugin_options = [],
     imports = [],
     lang = GO,
-    paths = [],
     protobuf_plugin_options = [],
     protobuf_plugin = None,
     proto_compile = go_proto_compile,
@@ -35,7 +34,6 @@ def go_proto_library(
   args["gen_protobuf_" + lang.name + "_plugin"] = protobuf_plugin
   args["gen_" + lang.name + "_plugin_options"] = protobuf_plugin_options
   args["gen_grpc_" + lang.name + "_plugin"] = grpc_plugin
-  args["paths"] = paths
   args["protoc"] = protoc
   args["protos"] = srcs
   args["verbose"] = verbose

bzl/java/rules.bzl

@@ -11,7 +11,6 @@ def java_proto_library(
     grpc_plugin_options = [],
     imports = [],
     lang = JAVA,
-    paths = [],
     protobuf_plugin_options = [],
     protobuf_plugin = None,
     proto_compile = java_proto_compile,
@@ -34,7 +33,6 @@ def java_proto_library(
   args["gen_protobuf_" + lang.name + "_plugin"] = protobuf_plugin
   args["gen_" + lang.name + "_plugin_options"] = protobuf_plugin_options
   args["gen_grpc_" + lang.name + "_plugin"] = grpc_plugin
-  args["paths"] = paths
   args["protoc"] = protoc
   args["protos"] = srcs
   args["verbose"] = verbose

bzl/protoc.bzl

@@ -55,7 +55,6 @@ def protoc_genrule(name,
     "gendir": outdir,
     "outdir": outdir,
     "protos": protos,
-    "paths": paths,
     "protoc": protoc,
     "protobuf_plugin": protobuf_plugin,
     "protobuf_plugin_options": protobuf_plugin_options,
@@ -81,7 +80,7 @@ def protoc_genrule(name,
 
     invoke("build_generated_filenames", lang, self)
     invoke("build_tools", lang, self)
-    invoke("build_paths", lang, self)
+    invoke("build_imports", lang, self)
     invoke("build_protobuf_invocation", lang, self)
     invoke("build_protobuf_out", lang, self)
     if with_grpc:
@@ -119,7 +118,7 @@ def _execute_rule(self):
   #self["args"] += ["--descriptor_set_out=%s" % (descriptor_set_file.path)]
 
   arglist = list(set(self["args"]))
-  pathlist = ["--proto_path=" + i for i in set(self["paths"])]
+  pathlist = ["--proto_path=" + i for i in set(self["imports"])]
 
   arguments = arglist + pathlist + srcfiles
   inputs = list(set(self["requires"]))
@@ -171,9 +170,9 @@ def _build_source_files(ctx, self):
       self["srcs"] += [srcfile]
       self["srcfilenames"] += [srcfile.short_path]
 
-  # This is the key to enable imports: protoc can see the entire
-  # source tree from the workspace root.
-  self["paths"] += ["."]
+  # This is the key for protoc to see the entire source tree from the
+  # workspace root.
+  self["imports"] += ["."]
 
 def _protoc_rule_impl(ctx):
 
@@ -189,7 +188,6 @@ def _protoc_rule_impl(ctx):
     "gendir": gendir,
     "outdir": outdir,
     "imports": [],
-    "paths": [],
     "args": [],
     "srcs": [],
     "srcfilenames": [],
@@ -200,7 +198,6 @@ def _protoc_rule_impl(ctx):
     "with_grpc": getattr(ctx.attr, "with_grpc", False),
     #"descriptor_set_file": descriptor_set_file,
     "transitive_imports": [],
-    "transitive_paths": [],
     "transitive_packages": {},
     "transitive_requires": [],
     "transitive_srcs": [],
@@ -209,7 +206,6 @@ def _protoc_rule_impl(ctx):
   # Propogate proto deps:
   for dep in ctx.attr.deps:
     self["transitive_imports"] += dep.proto.transitive_imports
-    self["transitive_paths"] += dep.proto.transitive_paths
     self["transitive_packages"] += dep.proto.transitive_packages
     self["transitive_requires"] += dep.proto.transitive_requires
     self["transitive_srcs"] += dep.proto.transitive_srcs
@@ -230,7 +226,6 @@ def _protoc_rule_impl(ctx):
 
     invoke("build_generated_files", lang, self)
     invoke("build_imports", lang, self)
-    invoke("build_paths", lang, self)
     invoke("build_protobuf_invocation", lang, self)
     invoke("build_protobuf_out", lang, self)
     if self["with_grpc"]:
@@ -254,14 +249,12 @@ def _protoc_rule_impl(ctx):
     proto=struct(
 
       imports = self["imports"],
-      paths = self["paths"],
       packages = self["packages"],
       srcs = set(self["srcs"]),
       requires = self["requires"],
 
       transitive_requires = self["requires"] + self["transitive_requires"],
       transitive_imports = self["imports"] + self["transitive_imports"],
-      transitive_paths = self["paths"] + self["transitive_paths"],
       transitive_packages = self["packages"] + self["transitive_packages"],
       transitive_srcs = self["srcs"] + self["transitive_srcs"],
     ),
@@ -289,18 +282,8 @@ def implement(spec):
 
   attrs["deps"] = attr.label_list(providers = ["proto"])
 
-  # Options to be passed to protoc as --proto_path.  Differs from
-  # imports in that these are raw strings rather than labels.
-  attrs["paths"] = attr.string_list()
-
-  # Protos that should be made available for proto imports.  These are
-  # not added as options but rather copied over to the sandbox where
-  # protoc is run, making them available for import. TODO: is this
-  # really needed?  Test it by using the descriptor protos from
-  # google/protobuf.
-  attrs["imports"] = attr.label_list(
-    allow_files = FileType([".proto"]),
-  )
+  # Options to be passed to protoc as --proto_path.
+  attrs["imports"] = attr.string_list()
 
   # The list of files the rule generates.  How is this actually being
   # used?

examples/helloworld/cpp/BUILD

@@ -1,10 +1,6 @@
 package(default_visibility = ["//visibility:public"])
 
-load("//bzl:cpp/rules.bzl", "cc_proto_library", "cc_proto_compile")
-load(
-    "//bzl:cpp/class.bzl",
-    CPP = "CLASS",
-)
+load("//bzl:cpp/class.bzl", CPP = "CLASS")
 
 cc_test(
     name = "test",

examples/helloworld/go/client/BUILD

@@ -1,26 +1,10 @@
 package(default_visibility = ["//visibility:public"])
 
 load("@io_bazel_rules_go//go:def.bzl", "go_binary")
-load(
-    "//bzl:go/class.bzl",
-    GO = "CLASS",
-)
-load("//bzl:go/rules.bzl", "go_proto_compile", "go_proto_library")
+load("//bzl:go/class.bzl", GO = "CLASS")
 
 go_binary(
     name = "client",
     srcs = ["main.go"],
     deps = ["//examples/helloworld/proto:go"] + GO.grpc.compile_deps,
 )
-
-# # if you depend on this rule, the proto sources get copied to the
-# # namespace of the calling BUILD file (examples/helloworld/go/client),
-# # affecting the go "import" naming.
-# go_proto_library(
-#     name = 'protolib',
-#     protos = [
-#         '//examples/helloworld/proto:srcs',
-#     ],
-#     with_grpc = True,
-#     verbose = 0,
-# )

examples/helloworld/go/greeter_test/BUILD

@@ -1,10 +1,7 @@
 package(default_visibility = ["//visibility:public"])
 
 load("@io_bazel_rules_go//go:def.bzl", "go_test")
-load(
-    "//bzl:go/class.bzl",
-    GO = "CLASS",
-)
+load("//bzl:go/class.bzl", GO = "CLASS")
 
 go_test(
     name = "greeter_test",

examples/helloworld/go/server/BUILD

@@ -1,10 +1,7 @@
 package(default_visibility = ["//visibility:public"])
 
 load("@io_bazel_rules_go//go:def.bzl", "go_binary", "go_library")
-load(
-    "//bzl:go/class.bzl",
-    GO = "CLASS",
-)
+load("//bzl:go/class.bzl", GO = "CLASS")
 
 go_binary(
     name = "server",