From 8d09a4d73e3fb3dccd7dfd50c170f9c98836171a Mon Sep 17 00:00:00 2001 From: Adam Liddell Date: Fri, 17 Sep 2021 18:25:48 +0000 Subject: [PATCH] Drop transitive aspect-based compilation. Closes #137 --- android/android_grpc_compile.bzl | 47 +-- android/android_proto_compile.bzl | 46 +-- c/c_proto_compile.bzl | 46 +-- cpp/cpp_grpc_compile.bzl | 47 +-- cpp/cpp_proto_compile.bzl | 46 +-- csharp/csharp_grpc_compile.bzl | 47 +-- csharp/csharp_proto_compile.bzl | 46 +-- d/d_proto_compile.bzl | 46 +-- defs.bzl | 9 +- doc/doc_docbook_compile.bzl | 46 +-- doc/doc_html_compile.bzl | 46 +-- doc/doc_json_compile.bzl | 46 +-- doc/doc_markdown_compile.bzl | 46 +-- fsharp/fsharp_grpc_compile.bzl | 46 +-- fsharp/fsharp_proto_compile.bzl | 46 +-- go/go_grpc_compile.bzl | 47 +-- go/go_proto_compile.bzl | 46 +-- grpc-gateway/gateway_grpc_compile.bzl | 48 +-- grpc-gateway/gateway_openapiv2_compile.bzl | 46 +-- internal/common.bzl | 19 - internal/compile.bzl | 389 +++++++----------- internal/providers.bzl | 15 +- java/java_grpc_compile.bzl | 47 +-- java/java_proto_compile.bzl | 46 +-- js/js_grpc_node_compile.bzl | 49 +-- js/js_grpc_web_compile.bzl | 48 +-- js/js_proto_compile.bzl | 47 +-- objc/objc_grpc_compile.bzl | 47 +-- objc/objc_proto_compile.bzl | 46 +-- php/php_grpc_compile.bzl | 47 +-- php/php_proto_compile.bzl | 46 +-- python/python_grpc_compile.bzl | 47 +-- python/python_grpclib_compile.bzl | 47 +-- python/python_proto_compile.bzl | 46 +-- ruby/ruby_grpc_compile.bzl | 47 +-- ruby/ruby_proto_compile.bzl | 46 +-- rust/rust_grpc_compile.bzl | 47 +-- rust/rust_proto_compile.bzl | 46 +-- scala/scala_grpc_compile.bzl | 46 +-- scala/scala_proto_compile.bzl | 46 +-- swift/swift_grpc_compile.bzl | 47 +-- swift/swift_proto_compile.bzl | 46 +-- .../transitive_compilation/BUILD.bazel | 23 -- .../transitive_compilation/WORKSPACE | 24 -- .../transitive_compilation/demo.proto | 5 - .../transitive_compilation/main.cc | 5 - tools/rulegen/common.go | 50 +-- 47 files changed, 187 insertions(+), 2120 deletions(-) delete mode 100644 test_workspaces/transitive_compilation/BUILD.bazel delete mode 100644 test_workspaces/transitive_compilation/WORKSPACE delete mode 100644 test_workspaces/transitive_compilation/demo.proto delete mode 100644 test_workspaces/transitive_compilation/main.cc diff --git a/android/android_grpc_compile.bzl b/android/android_grpc_compile.bzl index 6f08e09b..75fb81ef 100644 --- a/android/android_grpc_compile.bzl +++ b/android/android_grpc_compile.bzl @@ -1,55 +1,17 @@ """Generated definition of android_grpc_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for android_grpc_compile -android_grpc_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//android:javalite_plugin"), - Label("//android:grpc_javalite_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "android_grpc_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +android_grpc_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [android_grpc_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -61,10 +23,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def android_grpc_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/android/android_proto_compile.bzl b/android/android_proto_compile.bzl index 11a19926..faf4ee29 100644 --- a/android/android_proto_compile.bzl +++ b/android/android_proto_compile.bzl @@ -1,54 +1,17 @@ """Generated definition of android_proto_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for android_proto_compile -android_proto_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//android:javalite_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "android_proto_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +android_proto_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [android_proto_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -59,10 +22,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def android_proto_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/c/c_proto_compile.bzl b/c/c_proto_compile.bzl index a4f8d731..1cc00668 100644 --- a/c/c_proto_compile.bzl +++ b/c/c_proto_compile.bzl @@ -1,54 +1,17 @@ """Generated definition of c_proto_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for c_proto_compile -c_proto_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//c:upb_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "c_proto_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +c_proto_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [c_proto_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -59,10 +22,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def c_proto_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/cpp/cpp_grpc_compile.bzl b/cpp/cpp_grpc_compile.bzl index 76fb4757..b0b1b150 100644 --- a/cpp/cpp_grpc_compile.bzl +++ b/cpp/cpp_grpc_compile.bzl @@ -1,55 +1,17 @@ """Generated definition of cpp_grpc_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for cpp_grpc_compile -cpp_grpc_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//cpp:cpp_plugin"), - Label("//cpp:grpc_cpp_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "cpp_grpc_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +cpp_grpc_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [cpp_grpc_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -61,10 +23,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def cpp_grpc_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/cpp/cpp_proto_compile.bzl b/cpp/cpp_proto_compile.bzl index c14b0ca2..4c66487f 100644 --- a/cpp/cpp_proto_compile.bzl +++ b/cpp/cpp_proto_compile.bzl @@ -1,54 +1,17 @@ """Generated definition of cpp_proto_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for cpp_proto_compile -cpp_proto_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//cpp:cpp_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "cpp_proto_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +cpp_proto_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [cpp_proto_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -59,10 +22,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def cpp_proto_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/csharp/csharp_grpc_compile.bzl b/csharp/csharp_grpc_compile.bzl index efb6cd18..f9714657 100644 --- a/csharp/csharp_grpc_compile.bzl +++ b/csharp/csharp_grpc_compile.bzl @@ -1,55 +1,17 @@ """Generated definition of csharp_grpc_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for csharp_grpc_compile -csharp_grpc_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//csharp:csharp_plugin"), - Label("//csharp:grpc_csharp_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "csharp_grpc_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +csharp_grpc_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [csharp_grpc_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -61,10 +23,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def csharp_grpc_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/csharp/csharp_proto_compile.bzl b/csharp/csharp_proto_compile.bzl index 088d1896..e4a1fa11 100644 --- a/csharp/csharp_proto_compile.bzl +++ b/csharp/csharp_proto_compile.bzl @@ -1,54 +1,17 @@ """Generated definition of csharp_proto_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for csharp_proto_compile -csharp_proto_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//csharp:csharp_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "csharp_proto_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +csharp_proto_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [csharp_proto_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -59,10 +22,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def csharp_proto_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/d/d_proto_compile.bzl b/d/d_proto_compile.bzl index c504e95e..ad2a292c 100644 --- a/d/d_proto_compile.bzl +++ b/d/d_proto_compile.bzl @@ -1,54 +1,17 @@ """Generated definition of d_proto_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for d_proto_compile -d_proto_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//d:d_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "d_proto_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +d_proto_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [d_proto_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -59,10 +22,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def d_proto_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/defs.bzl b/defs.bzl index ce1feeaa..f01256cd 100644 --- a/defs.bzl +++ b/defs.bzl @@ -1,19 +1,16 @@ """Top level definition exports for rules_proto_grpc.""" -load("//internal:compile.bzl", _proto_compile_aspect_attrs = "proto_compile_aspect_attrs", _proto_compile_aspect_impl = "proto_compile_aspect_impl", _proto_compile_attrs = "proto_compile_attrs", _proto_compile_impl = "proto_compile_impl") +load("//internal:compile.bzl", _proto_compile_attrs = "proto_compile_attrs", _proto_compile_impl = "proto_compile_impl") load("//internal:plugin.bzl", _proto_plugin = "proto_plugin") -load("//internal:providers.bzl", _ProtoCompileInfo = "ProtoCompileInfo", _ProtoLibraryAspectNodeInfo = "ProtoLibraryAspectNodeInfo", _ProtoPluginInfo = "ProtoPluginInfo") +load("//internal:providers.bzl", _ProtoCompileInfo = "ProtoCompileInfo", _ProtoPluginInfo = "ProtoPluginInfo") # Export providers ProtoPluginInfo = _ProtoPluginInfo -ProtoLibraryAspectNodeInfo = _ProtoLibraryAspectNodeInfo ProtoCompileInfo = _ProtoCompileInfo # Export plugin rule proto_plugin = _proto_plugin -# Export compile and aspect rules +# Export compile rule implementation and attrs proto_compile_attrs = _proto_compile_attrs -proto_compile_aspect_attrs = _proto_compile_aspect_attrs proto_compile_impl = _proto_compile_impl -proto_compile_aspect_impl = _proto_compile_aspect_impl diff --git a/doc/doc_docbook_compile.bzl b/doc/doc_docbook_compile.bzl index 27280c71..623af28c 100644 --- a/doc/doc_docbook_compile.bzl +++ b/doc/doc_docbook_compile.bzl @@ -1,54 +1,17 @@ """Generated definition of doc_docbook_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for doc_docbook_compile -doc_docbook_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//doc:docbook_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "doc_docbook_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +doc_docbook_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [doc_docbook_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -59,10 +22,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def doc_docbook_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/doc/doc_html_compile.bzl b/doc/doc_html_compile.bzl index 530e47fc..16083926 100644 --- a/doc/doc_html_compile.bzl +++ b/doc/doc_html_compile.bzl @@ -1,54 +1,17 @@ """Generated definition of doc_html_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for doc_html_compile -doc_html_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//doc:html_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "doc_html_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +doc_html_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [doc_html_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -59,10 +22,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def doc_html_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/doc/doc_json_compile.bzl b/doc/doc_json_compile.bzl index 43240840..2a7a113f 100644 --- a/doc/doc_json_compile.bzl +++ b/doc/doc_json_compile.bzl @@ -1,54 +1,17 @@ """Generated definition of doc_json_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for doc_json_compile -doc_json_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//doc:json_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "doc_json_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +doc_json_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [doc_json_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -59,10 +22,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def doc_json_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/doc/doc_markdown_compile.bzl b/doc/doc_markdown_compile.bzl index 33377b55..291d3a13 100644 --- a/doc/doc_markdown_compile.bzl +++ b/doc/doc_markdown_compile.bzl @@ -1,54 +1,17 @@ """Generated definition of doc_markdown_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for doc_markdown_compile -doc_markdown_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//doc:markdown_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "doc_markdown_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +doc_markdown_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [doc_markdown_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -59,10 +22,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def doc_markdown_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/fsharp/fsharp_grpc_compile.bzl b/fsharp/fsharp_grpc_compile.bzl index dd0a7f38..24c13de9 100644 --- a/fsharp/fsharp_grpc_compile.bzl +++ b/fsharp/fsharp_grpc_compile.bzl @@ -1,54 +1,17 @@ """Generated definition of fsharp_grpc_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for fsharp_grpc_compile -fsharp_grpc_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//fsharp:grpc_fsharp_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "fsharp_grpc_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +fsharp_grpc_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [fsharp_grpc_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -59,10 +22,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def fsharp_grpc_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/fsharp/fsharp_proto_compile.bzl b/fsharp/fsharp_proto_compile.bzl index 792592da..5c744e2a 100644 --- a/fsharp/fsharp_proto_compile.bzl +++ b/fsharp/fsharp_proto_compile.bzl @@ -1,54 +1,17 @@ """Generated definition of fsharp_proto_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for fsharp_proto_compile -fsharp_proto_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//fsharp:fsharp_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "fsharp_proto_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +fsharp_proto_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [fsharp_proto_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -59,10 +22,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def fsharp_proto_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/go/go_grpc_compile.bzl b/go/go_grpc_compile.bzl index c99b22aa..b6c964cd 100644 --- a/go/go_grpc_compile.bzl +++ b/go/go_grpc_compile.bzl @@ -1,55 +1,17 @@ """Generated definition of go_grpc_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for go_grpc_compile -go_grpc_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//go:go_plugin"), - Label("//go:grpc_go_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "go_grpc_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +go_grpc_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [go_grpc_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -61,10 +23,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def go_grpc_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/go/go_proto_compile.bzl b/go/go_proto_compile.bzl index 23cb805b..e2b84ca8 100644 --- a/go/go_proto_compile.bzl +++ b/go/go_proto_compile.bzl @@ -1,54 +1,17 @@ """Generated definition of go_proto_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for go_proto_compile -go_proto_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//go:go_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "go_proto_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +go_proto_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [go_proto_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -59,10 +22,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def go_proto_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/grpc-gateway/gateway_grpc_compile.bzl b/grpc-gateway/gateway_grpc_compile.bzl index 018507c3..707c3de2 100644 --- a/grpc-gateway/gateway_grpc_compile.bzl +++ b/grpc-gateway/gateway_grpc_compile.bzl @@ -1,56 +1,17 @@ """Generated definition of gateway_grpc_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for gateway_grpc_compile -gateway_grpc_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//grpc-gateway:grpc_gateway_plugin"), - Label("//go:grpc_go_plugin"), - Label("//go:go_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "gateway_grpc_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +gateway_grpc_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [gateway_grpc_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -63,10 +24,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def gateway_grpc_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/grpc-gateway/gateway_openapiv2_compile.bzl b/grpc-gateway/gateway_openapiv2_compile.bzl index 245eef5a..abf96216 100644 --- a/grpc-gateway/gateway_openapiv2_compile.bzl +++ b/grpc-gateway/gateway_openapiv2_compile.bzl @@ -1,54 +1,17 @@ """Generated definition of gateway_openapiv2_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for gateway_openapiv2_compile -gateway_openapiv2_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//grpc-gateway:openapiv2_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "gateway_openapiv2_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +gateway_openapiv2_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [gateway_openapiv2_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -59,10 +22,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def gateway_openapiv2_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/internal/common.bzl b/internal/common.bzl index 30039718..ceaa5568 100644 --- a/internal/common.bzl +++ b/internal/common.bzl @@ -136,25 +136,6 @@ def php_path(s): """ return "/".join([capitalize(c) for c in s.split("/")]) -def get_int_attr(attr, name): - """ - Get an attr as an int from a string, with fallbacks. - - Args: - attr: The attr object from ctx. - name: The attr name to load. - - Returns: - The attr value as an int. - - """ - value = getattr(attr, name) - if value == "": - return 0 - if value == "None": - return 0 - return int(value) - def get_output_filename(src_file, pattern, proto_info): """ Build the predicted filename for file generated by the given plugin. diff --git a/internal/compile.bzl b/internal/compile.bzl index 1e7d08ae..bdc690fd 100644 --- a/internal/compile.bzl +++ b/internal/compile.bzl @@ -5,26 +5,25 @@ load( "//internal:common.bzl", "copy_file", "descriptor_proto_path", - "get_int_attr", "get_output_filename", "get_package_root", "strip_path_prefix", ) -load("//internal:providers.bzl", "ProtoCompileInfo", "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo") +load("//internal:providers.bzl", "ProtoCompileInfo", "ProtoPluginInfo") load("//internal:protoc.bzl", "build_protoc_args") proto_compile_attrs = { - # Deps and protos attrs are added per-rule, as it depends on aspect name + "protos": attr.label_list( + mandatory = True, + providers = [ProtoInfo], + doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", + ), "options": attr.string_list_dict( doc = "Extra options to pass to plugins, as a dict of plugin label -> list of strings. The key * can be used exclusively to apply to all plugins", ), "verbose": attr.int( doc = "The verbosity level. Supported values and results are 1: *show command*, 2: *show command and sandbox after running protoc*, 3: *show command and sandbox before and after running protoc*, 4. *show env, command, expected outputs and sandbox before and after running protoc*", ), - "verbose_string": attr.string( - doc = "String version of the verbose string, used for aspect", - default = "0", - ), "prefix_path": attr.string( doc = "Path to prefix to the generated files in the output directory", ), @@ -33,27 +32,17 @@ proto_compile_attrs = { ), } -proto_compile_aspect_attrs = { - "verbose_string": attr.string( - doc = "String version of the verbose string, used for aspect", - values = ["", "None", "0", "1", "2", "3", "4"], - default = "0", - ), -} - -def common_compile(ctx, proto_infos): +def proto_compile_impl(ctx): """ - Common implementation of protoc setup and compilation action generation. + Common implementation function for lang_*_compile rules. Args: ctx: The Bazel rule execution context object. - proto_infos: The ProtoInfo providers to load direct sources from. Returns: - Struct with fields: - - output_root: The root of the generated files, relative to workspace root - - output_files: Any files generated by the plugins - - output_dirs: ANy directories generated by the plugins + Providers: + - ProtoCompileInfo + - DefaultInfo """ @@ -62,68 +51,56 @@ def common_compile(ctx, proto_infos): ### # Load attrs - verbose = get_int_attr(ctx.attr, "verbose_string") # Integer verbosity level + proto_infos = [dep[ProtoInfo] for dep in ctx.attr.protos] + verbose = ctx.attr.verbose plugins = [plugin[ProtoPluginInfo] for plugin in ctx.attr._plugins] - # Load toolchain + # Load toolchain and tools protoc_toolchain_info = ctx.toolchains[str(Label("//protobuf:toolchain_type"))] protoc = protoc_toolchain_info.protoc_executable fixer = protoc_toolchain_info.fixer_executable # The directory where the outputs will be generated, relative to the package. - # TODO(4.0.0): Remove _prefix branch - if hasattr(ctx.attr, "_prefix"): - # Aspect driven compilation, we must put different rules in different subdirs, since - # a commonly used proto file may be hit by multiple aspects that may overlap with plugins - # and would otherwise try to touch the same file. This also contains verbose_string for the - # same reason. - rel_output_root = "{}/{}_verb{}".format(ctx.label.name, ctx.attr._prefix, verbose) - else: - # Direct compilation. The directory can be named exactly as the label of the rule, since - # there is no chance of overlap. A temporary dir is used here to allow output directories - # that may need to be merged later - rel_output_root = "_rpg_premerge_" + ctx.label.name - # TODO(4.0.0): Apply prefix root directly here? - #if ctx.attr.prefix_path: - # rel_output_root += "/" + ctx.attr.prefix_path + # A temporary dir is used here to allow output directories that may need to be merged later + rel_premerge_root = "_rpg_premerge_" + ctx.label.name - # The full path to the output root, relative to the workspace - output_root = get_package_root(ctx) + "/" + rel_output_root + # The full path to the pre-merge output root, relative to the workspace + premerge_root = get_package_root(ctx) + "/" + rel_premerge_root - # The lists of generated files and directories that we expect to be produced. - output_files = [] - output_dirs = [] + # The lists of generated files and directories that we expect to be produced, in their pre-merge + # locations + premerge_files = [] + premerge_dirs = [] + + # Convert options dict to label keys + plugin_labels = [plugin.label for plugin in plugins] + per_plugin_options = { + Label(plugin_label): options + for plugin_label, options in ctx.attr.options.items() + if plugin_label != "*" + } # If plugin options are provided, check they are only for the plugins available or * - # TODO(4.0.0): Remove check for options in attr, it should always be there when not aspect per_plugin_options = {} # Dict of plugin label to options string list all_plugin_options = [] # Options applied to all plugins, from the '*' key - if hasattr(ctx.attr, "options"): - # Convert options dict to label keys - plugin_labels = [plugin.label for plugin in plugins] - per_plugin_options = { - Label(plugin_label): options - for plugin_label, options in ctx.attr.options.items() - if plugin_label != "*" - } - # Only allow '*' by itself - if "*" in ctx.attr.options: - if len(ctx.attr.options) > 1: - fail("The options attr on target {} cannot contain '*' and other labels. Use either '*' or labels".format(ctx.label)) - all_plugin_options = ctx.attr.options["*"] + # Only allow '*' by itself + if "*" in ctx.attr.options: + if len(ctx.attr.options) > 1: + fail("The options attr on target {} cannot contain '*' and other labels. Use either '*' or labels".format(ctx.label)) + all_plugin_options = ctx.attr.options["*"] - # Check all labels match a plugin in use - for plugin_label in per_plugin_options: - if plugin_label not in plugin_labels: - fail("The options attr on target {} contains a plugin label {} for a plugin that does not exist on this rule. The available plugins are {} ".format(ctx.label, plugin_label, plugin_labels)) + # Check all labels match a plugin in use + for plugin_label in per_plugin_options: + if plugin_label not in plugin_labels: + fail("The options attr on target {} contains a plugin label {} for a plugin that does not exist on this rule. The available plugins are {} ".format(ctx.label, plugin_label, plugin_labels)) ### ### Setup plugins ### - # Each plugin is isolated to its own execution of protoc, as plugins may have differing exclusions that cannot be - # expressed in a single protoc execution for all plugins. + # Each plugin is isolated to its own execution of protoc, as plugins may have differing + # exclusions that cannot be expressed in a single protoc execution for all plugins. for plugin in plugins: ### @@ -148,8 +125,8 @@ def common_compile(ctx, proto_infos): proto.dirname.endswith(exclusion) or proto.path.endswith(exclusion) for exclusion in plugin.exclusions ]) or proto in protos: - # When using import_prefix, the ProtoInfo.direct_sources list appears to contain duplicate records, - # the final check 'proto in protos' removes these. See + # When using import_prefix, the ProtoInfo.direct_sources list appears to contain + # duplicate records, the final check 'proto in protos' removes these. See # https://github.com/bazelbuild/bazel/issues/9127 continue @@ -159,7 +136,7 @@ def common_compile(ctx, proto_infos): # Add per-proto outputs for pattern in plugin.outputs: plugin_outputs.append(ctx.actions.declare_file("{}/{}".format( - rel_output_root, + rel_premerge_root, get_output_filename(proto, pattern, proto_info), ))) @@ -170,38 +147,40 @@ def common_compile(ctx, proto_infos): if len(protos) == 0: if verbose > 2: print( - 'Skipping plugin "{}" for "{}" as all proto files have been excluded'.format(plugin.name, ctx.label), + 'Skipping plugin "{}" for "{}" as all proto files have been excluded'.format( + plugin.name, ctx.label + ), ) # buildifier: disable=print continue - # Append current plugin outputs to global outputs before looking at per-plugin outputs; these are manually added - # globally as there may be srcjar outputs. - output_files.extend(plugin_outputs) + # Append current plugin outputs to global outputs before looking at per-plugin outputs; + # these are manually added globally as there may be srcjar outputs. + premerge_files.extend(plugin_outputs) ### ### Declare per-plugin outputs ### - # Some protoc plugins generate a set of output files (like python) while others generate a single 'archive' file - # that contains the individual outputs (like java). Jar outputs are gathered as a special case as we need to - # post-process them to have a 'srcjar' extension (java_library rules don't accept source jars with a 'jar' - # extension). + # Some protoc plugins generate a set of output files (like python) while others generate a + # single 'archive' file that contains the individual outputs (like java). Jar outputs are + # gathered as a special case as we need to post-process them to have a 'srcjar' extension + # (java_library rules don't accept source jars with a 'jar' extension). out_file = None if plugin.out: # Define out file out_file = ctx.actions.declare_file("{}/{}".format( - rel_output_root, + rel_premerge_root, plugin.out.replace("{name}", ctx.label.name), )) plugin_outputs.append(out_file) if not out_file.path.endswith(".jar"): # Add output direct to global outputs - output_files.append(out_file) + premerge_files.append(out_file) else: # Create .srcjar from .jar for global outputs - output_files.append(copy_file( + premerge_files.append(copy_file( ctx, out_file, "{}.srcjar".format(out_file.basename.rpartition(".")[0]), @@ -212,31 +191,34 @@ def common_compile(ctx, proto_infos): ### Declare plugin output directory if required ### - # Some plugins outputs a structure that cannot be predicted from the input file paths alone. For these plugins, - # we simply declare the directory. + # Some plugins outputs a structure that cannot be predicted from the input file paths alone. + # For these plugins, we simply declare the directory. if plugin.output_directory: - out_file = ctx.actions.declare_directory(rel_output_root + "/" + "_plugin_" + plugin.name) + out_file = ctx.actions.declare_directory(rel_premerge_root + "/" + "_plugin_" + plugin.name) plugin_outputs.append(out_file) - output_dirs.append(out_file) + premerge_dirs.append(out_file) ### ### Build command ### # Determine the outputs expected by protoc. - # When plugin.empty_template is not set, protoc will output directly to the final targets. When set, we will - # direct the plugin outputs to a temporary folder, then use the fixer executable to write to the final targets. + # When plugin.empty_template is not set, protoc will output directly to the final targets. + # When set, we will direct the plugin outputs to a temporary folder, then use the fixer + # executable to write to the final targets. if plugin.empty_template: # Create path list for fixer - fixer_paths_file = ctx.actions.declare_file(rel_output_root + "/" + "_plugin_fixer_manifest_" + plugin.name + ".txt") + fixer_paths_file = ctx.actions.declare_file(rel_premerge_root + "/" + "_plugin_fixer_manifest_" + plugin.name + ".txt") ctx.actions.write(fixer_paths_file, "\n".join([ - file.path.partition(output_root + "/")[2] # Path of the file relative to the output root + file.path.partition(premerge_root + "/")[2] # Path of the file relative to the output root for file in plugin_outputs ])) # Create output directory for protoc to write into - fixer_dir = ctx.actions.declare_directory(rel_output_root + "/" + "_plugin_fixed_" + plugin.name) + fixer_dir = ctx.actions.declare_directory( + rel_premerge_root + "/" + "_plugin_fixed_" + plugin.name + ) out_arg = fixer_dir.path plugin_protoc_outputs = [fixer_dir] @@ -248,20 +230,23 @@ def common_compile(ctx, proto_infos): fixer_paths_file.path, plugin.empty_template.path, fixer_dir.path, - output_root, + premerge_root, ], - progress_message = "Applying fixer for {} plugin on target {}".format(plugin.name, ctx.label), + progress_message = "Applying fixer for {} plugin on target {}".format( + plugin.name, ctx.label + ), executable = fixer, ) else: # No fixer, protoc writes files directly if out_file and "QUIRK_OUT_PASS_ROOT" not in plugin.quirks: - # Single output file, pass the full file name to out arg, unless QUIRK_OUT_PASS_ROOT quirk is in use + # Single output file, pass the full file name to out arg, unless QUIRK_OUT_PASS_ROOT + # quirk is in use out_arg = out_file.path else: # No single output (or QUIRK_OUT_PASS_ROOT enabled), pass root dir - out_arg = output_root + out_arg = premerge_root plugin_protoc_outputs = plugin_outputs # Build argument list for protoc execution @@ -277,10 +262,12 @@ def common_compile(ctx, proto_infos): args.add_all(args_list) # Add import roots and files if required by plugin - # By default we pass just the descriptors and the proto paths, but these may not contain all of the comments - # etc from the source files + # By default we pass just the descriptors and the proto paths, but these may not contain + # all of the comments etc from the source files if "QUIRK_DIRECT_MODE" in plugin.quirks: - args.add_all(["--proto_path=" + proto_info.proto_source_root for proto_info in proto_infos]) + args.add_all([ + "--proto_path=" + proto_info.proto_source_root for proto_info in proto_infos + ]) cmd_inputs += protos # Add source proto files as descriptor paths @@ -292,7 +279,7 @@ def common_compile(ctx, proto_infos): ### mnemonic = "ProtoCompile" - command = ("mkdir -p '{}' && ".format(output_root)) + protoc.path + " $@" # $@ is replaced with args list + command = ("mkdir -p '{}' && ".format(premerge_root)) + protoc.path + " $@" # $@ is replaced with args list inputs = cmd_inputs tools = [protoc] + ([plugin.tool_executable] if plugin.tool_executable else []) @@ -327,124 +314,73 @@ def common_compile(ctx, proto_infos): outputs = plugin_protoc_outputs, use_default_shell_env = plugin.use_built_in_shell_environment, input_manifests = cmd_input_manifests, - progress_message = "Compiling protoc outputs for {} plugin on target {}".format(plugin.name, ctx.label), + progress_message = "Compiling protoc outputs for {} plugin on target {}".format( + plugin.name, ctx.label + ), ) - # Bundle output - return struct( - output_root = output_root, - output_files = output_files, - output_dirs = output_dirs, - ) - -def proto_compile_impl(ctx): - """ - Common implementation function for lang_*_compile rules. - - Args: - ctx: The Bazel rule execution context object. - - Returns: - Providers: - - ProtoCompileInfo - - DefaultInfo - - """ - - # Check attrs make sense - if ctx.attr.protos and ctx.attr.deps: # TODO(4.0.0): Remove - fail("Inputs provided to both 'protos' and 'deps' attrs of target {}. Use exclusively 'protos' or 'deps'".format(ctx.label)) - - if ctx.attr.deps and ctx.attr.options: # TODO(4.0.0): Remove - fail("Options cannot be provided in transitive compilation mode with 'deps' attr of target {}. Use 'protos' mode to pass 'options'".format(ctx.label)) - - if ctx.attr.deps and ctx.attr.extra_protoc_args: # TODO(4.0.0): Remove - fail("Extra protoc args cannot be provided in transitive compilation mode with 'deps' attr of target {}. Use 'protos' mode to pass 'extra_protoc_args'".format(ctx.label)) - - # Select mode - if ctx.attr.protos: - # Direct compilation mode, build protoc actions here rather than in aspect - compile_out = common_compile(ctx, [dep[ProtoInfo] for dep in ctx.attr.protos]) - - # Spoof the outputs we'd get from aspect - # TODO(4.0.0): Remove - output_files_dicts = [{compile_out.output_root: depset(compile_out.output_files)}] - output_dirs = depset(compile_out.output_dirs) - - elif ctx.attr.deps: - # Transitive mode using aspect compilation. DEPRECATED - # TODO(4.0.0): Remove this section - print("Inputs provided to 'deps' attr of target {}. Consider replacing with 'protos' attr to avoid transitive compilation. See https://rules-proto-grpc.aliddell.com/en/latest/transitivity.html".format(ctx.label)) # buildifier: disable=print - - # Aggregate all output files and dirs created by the aspect as it has walked the deps - output_files_dicts = [dep[ProtoLibraryAspectNodeInfo].output_files for dep in ctx.attr.deps] - output_dirs = depset(transitive = [ - dep[ProtoLibraryAspectNodeInfo].output_dirs - for dep in ctx.attr.deps - ]) - - else: - # Mode undetermined - fail("No inputs provided to 'protos' attr of target {}".format(ctx.label)) - - # Build outputs - final_output_files = {} - final_output_files_list = [] - final_output_dirs = depset() + # Build final output defaults for merged locations + output_root = get_package_root(ctx) + "/" + ctx.label.name + output_files = depset() + output_dirs = depset() prefix_path = ctx.attr.prefix_path - # TODO(4.0.0): The below can be simplified and prefix path applied directly to output root - if output_dirs: - # If we have any output dirs specified, we declare a single output - # directory and merge all files in one go. This is necessary to prevent - # path prefix conflicts + # Merge outputs + if premerge_dirs: + # If we have any output dirs specified, we declare a single output directory and merge all + # files in one go. This is necessary to prevent path prefix conflicts # Declare single output directory dir_name = ctx.label.name if prefix_path: dir_name = dir_name + "/" + prefix_path new_dir = ctx.actions.declare_directory(dir_name) - final_output_dirs = depset(direct = [new_dir]) + output_dirs = depset(direct = [new_dir]) # Build copy command for directory outputs - # Use cp {}/. rather than {}/* to allow for empty output directories from a plugin (e.g when no service exists, - # so no files generated) + # Use cp {}/. rather than {}/* to allow for empty output directories from a plugin (e.g when + # no service exists, so no files generated) command_parts = ["mkdir -p {} && cp -r {} '{}'".format( - " ".join(["'" + d.path + "'" for d in output_dirs.to_list()]), # We need to be sure that the dirs exist, see: https://github.com/bazelbuild/bazel/issues/6393 - " ".join(["'" + d.path + "/.'" for d in output_dirs.to_list()]), + # We need to be sure that the dirs exist, see: + # https://github.com/bazelbuild/bazel/issues/6393 + " ".join(["'" + d.path + "'" for d in premerge_dirs]), + " ".join(["'" + d.path + "/.'" for d in premerge_dirs]), new_dir.path, )] # Extend copy command with file outputs - command_input_files = [] - for output_files_dict in output_files_dicts: - for root, files in output_files_dict.items(): - for file in files.to_list(): - # Strip root from file path - path = strip_path_prefix(file.path, root) + command_input_files = premerge_dirs + for file in premerge_files: + # Strip pre-merge root from file path + path = strip_path_prefix(file.path, premerge_root) - # Prefix path is contained in new_dir.path created above and - # used below + # Prefix path is contained in new_dir.path created above and + # used below - # Add command to copy file to output - command_input_files.append(file) - command_parts.append("cp '{}' '{}'".format( - file.path, - "{}/{}".format(new_dir.path, path), - )) + # Add command to copy file to output + command_input_files.append(file) + command_parts.append("cp '{}' '{}'".format( + file.path, "{}/{}".format(new_dir.path, path), + )) # Add debug options if ctx.attr.verbose > 1: - command_parts = command_parts + ["echo '\n##### SANDBOX AFTER MERGING DIRECTORIES'", "find . -type l"] + command_parts = command_parts + [ + "echo '\n##### SANDBOX AFTER MERGING DIRECTORIES'", "find . -type l" + ] if ctx.attr.verbose > 2: - command_parts = ["echo '\n##### SANDBOX BEFORE MERGING DIRECTORIES'", "find . -type l"] + command_parts + command_parts = [ + "echo '\n##### SANDBOX BEFORE MERGING DIRECTORIES'", "find . -type l" + ] + command_parts if ctx.attr.verbose > 0: - print("Directory merge command: {}".format(" && ".join(command_parts))) # buildifier: disable=print + print( + "Directory merge command: {}".format(" && ".join(command_parts)) + ) # buildifier: disable=print # Copy directories and files to shared output directory in one action ctx.actions.run_shell( mnemonic = "CopyDirs", - inputs = depset(direct = command_input_files, transitive = [output_dirs]), + inputs = command_input_files, outputs = [new_dir], command = " && ".join(command_parts), progress_message = "copying directories and files to {}".format(new_dir.path), @@ -452,84 +388,39 @@ def proto_compile_impl(ctx): else: # Otherwise, if we only have output files, build the output tree by - # aggregating files created by aspect into one directory + # aggregating files into one directory - output_root = get_package_root(ctx) + "/" + ctx.label.name + output_files = [] + for file in premerge_files: + # Strip pre-merge root from file path + path = strip_path_prefix(file.path, premerge_root) - for output_files_dict in output_files_dicts: - for root, files in output_files_dict.items(): - for file in files.to_list(): - # Strip root from file path - path = strip_path_prefix(file.path, root) + # Prepend prefix path if given + if prefix_path: + path = prefix_path + "/" + path - # Prepend prefix path if given - if prefix_path: - path = prefix_path + "/" + path + # Copy file to output + output_files.append(copy_file( + ctx, + file, + "{}/{}".format(ctx.label.name, path), + )) - # Copy file to output - final_output_files_list.append(copy_file( - ctx, - file, - "{}/{}".format(ctx.label.name, path), - )) - - final_output_files[output_root] = depset(direct = final_output_files_list) + output_files = depset(direct = output_files) # Create depset containing all outputs - all_outputs = depset(direct = final_output_files_list + final_output_dirs.to_list()) + all_outputs = depset(direct = output_files.to_list() + output_dirs.to_list()) # Create default and proto compile providers return [ ProtoCompileInfo( label = ctx.label, - output_files = final_output_files, - output_dirs = final_output_dirs, + output_root = output_root, + output_files = output_files, + output_dirs = output_dirs, ), DefaultInfo( files = all_outputs, runfiles = ctx.runfiles(transitive_files = all_outputs), ), ] - -def proto_compile_aspect_impl(target, ctx): - """ - Common implementation function for lang_*_compile aspects. - - Args: - target: The aspect target. - ctx: The Bazel rule execution context object. - - Returns: - Providers: - - ProtoLibraryAspectNodeInfo - - """ - - # Load ProtoInfo of the current node - if ProtoInfo not in target: # Skip non-proto targets, which we may get intermingled prior to deps deprecation - return [] - proto_info = target[ProtoInfo] - - # Build protoc compile actions - compile_out = common_compile(ctx, [proto_info]) - - # Generate providers - transitive_infos = [dep[ProtoLibraryAspectNodeInfo] for dep in ctx.rule.attr.deps] - output_files_dict = {} - if compile_out.output_files: - output_files_dict[compile_out.output_root] = depset(direct = compile_out.output_files) - - transitive_output_dirs = [] - for transitive_info in transitive_infos: - output_files_dict.update(**transitive_info.output_files) - transitive_output_dirs.append(transitive_info.output_dirs) - - return [ - ProtoLibraryAspectNodeInfo( - output_root = compile_out.output_root, - direct_output_files = depset(direct = compile_out.output_files), - direct_output_dirs = depset(direct = compile_out.output_dirs), - output_files = output_files_dict, - output_dirs = depset(direct = compile_out.output_dirs, transitive = transitive_output_dirs), - ), - ] diff --git a/internal/providers.bzl b/internal/providers.bzl index 5797ebb8..f154ec09 100644 --- a/internal/providers.bzl +++ b/internal/providers.bzl @@ -19,18 +19,9 @@ ProtoPluginInfo = provider(fields = { "quirks": "List of plugin quirks that toggle behaviours in compilation", }) -ProtoLibraryAspectNodeInfo = provider( - fields = { - "output_root": "The root directory that direct (non-transitive) outputs were written to, as a string", - "direct_output_files": "The files generated by this aspect only, as a depset", - "direct_output_dirs": "The directories generated by this aspect only, as a depset", - "output_files": "The files generated by this aspect and its transitive dependencies, as a dict of depsets indexed by the root directory", - "output_dirs": "The directories generated by this aspect and its transitive dependencies, as a depset", - }, -) - ProtoCompileInfo = provider(fields = { "label": "label object", - "output_files": "The files generated by this rule, as a dict of depsets indexed by the root directory", - "output_dirs": "The directories generated by this rule and its transitive dependencies, as a depset", + "output_root": "The roots of the generated files and directories, as a string", + "output_files": "The files generated by this rule, as a depset", + "output_dirs": "The directories generated by this rule, as a depset", }) diff --git a/java/java_grpc_compile.bzl b/java/java_grpc_compile.bzl index e670dbfe..202da3ce 100644 --- a/java/java_grpc_compile.bzl +++ b/java/java_grpc_compile.bzl @@ -1,55 +1,17 @@ """Generated definition of java_grpc_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for java_grpc_compile -java_grpc_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//java:java_plugin"), - Label("//java:grpc_java_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "java_grpc_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +java_grpc_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [java_grpc_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -61,10 +23,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def java_grpc_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/java/java_proto_compile.bzl b/java/java_proto_compile.bzl index 054750e9..9986ac0e 100644 --- a/java/java_proto_compile.bzl +++ b/java/java_proto_compile.bzl @@ -1,54 +1,17 @@ """Generated definition of java_proto_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for java_proto_compile -java_proto_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//java:java_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "java_proto_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +java_proto_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [java_proto_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -59,10 +22,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def java_proto_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/js/js_grpc_node_compile.bzl b/js/js_grpc_node_compile.bzl index c8311622..abde3f89 100644 --- a/js/js_grpc_node_compile.bzl +++ b/js/js_grpc_node_compile.bzl @@ -1,57 +1,17 @@ """Generated definition of js_grpc_node_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for js_grpc_node_compile -js_grpc_node_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//js:js_plugin"), - Label("//js:ts_plugin"), - Label("//js:grpc_node_plugin"), - Label("//js:grpc_node_ts_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "js_grpc_node_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +js_grpc_node_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [js_grpc_node_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -65,10 +25,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def js_grpc_node_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/js/js_grpc_web_compile.bzl b/js/js_grpc_web_compile.bzl index 511133e0..255055ce 100644 --- a/js/js_grpc_web_compile.bzl +++ b/js/js_grpc_web_compile.bzl @@ -1,56 +1,17 @@ """Generated definition of js_grpc_web_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for js_grpc_web_compile -js_grpc_web_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//js:js_plugin"), - Label("//js:ts_plugin"), - Label("//js:grpc_web_js_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "js_grpc_web_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +js_grpc_web_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [js_grpc_web_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -63,10 +24,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def js_grpc_web_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/js/js_proto_compile.bzl b/js/js_proto_compile.bzl index cec631c0..10dcdf13 100644 --- a/js/js_proto_compile.bzl +++ b/js/js_proto_compile.bzl @@ -1,55 +1,17 @@ """Generated definition of js_proto_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for js_proto_compile -js_proto_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//js:js_plugin"), - Label("//js:ts_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "js_proto_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +js_proto_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [js_proto_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -61,10 +23,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def js_proto_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/objc/objc_grpc_compile.bzl b/objc/objc_grpc_compile.bzl index 806c210f..81c3b0bc 100644 --- a/objc/objc_grpc_compile.bzl +++ b/objc/objc_grpc_compile.bzl @@ -1,55 +1,17 @@ """Generated definition of objc_grpc_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for objc_grpc_compile -objc_grpc_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//objc:objc_plugin"), - Label("//objc:grpc_objc_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "objc_grpc_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +objc_grpc_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [objc_grpc_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -61,10 +23,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def objc_grpc_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/objc/objc_proto_compile.bzl b/objc/objc_proto_compile.bzl index 06070060..2232603f 100644 --- a/objc/objc_proto_compile.bzl +++ b/objc/objc_proto_compile.bzl @@ -1,54 +1,17 @@ """Generated definition of objc_proto_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for objc_proto_compile -objc_proto_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//objc:objc_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "objc_proto_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +objc_proto_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [objc_proto_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -59,10 +22,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def objc_proto_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/php/php_grpc_compile.bzl b/php/php_grpc_compile.bzl index 6dae2e63..622744f8 100644 --- a/php/php_grpc_compile.bzl +++ b/php/php_grpc_compile.bzl @@ -1,55 +1,17 @@ """Generated definition of php_grpc_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for php_grpc_compile -php_grpc_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//php:php_plugin"), - Label("//php:grpc_php_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "php_grpc_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +php_grpc_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [php_grpc_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -61,10 +23,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def php_grpc_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/php/php_proto_compile.bzl b/php/php_proto_compile.bzl index c2157d52..be5ccfb5 100644 --- a/php/php_proto_compile.bzl +++ b/php/php_proto_compile.bzl @@ -1,54 +1,17 @@ """Generated definition of php_proto_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for php_proto_compile -php_proto_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//php:php_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "php_proto_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +php_proto_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [php_proto_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -59,10 +22,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def php_proto_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/python/python_grpc_compile.bzl b/python/python_grpc_compile.bzl index 61dd55bb..8a637a31 100644 --- a/python/python_grpc_compile.bzl +++ b/python/python_grpc_compile.bzl @@ -1,55 +1,17 @@ """Generated definition of python_grpc_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for python_grpc_compile -python_grpc_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//python:python_plugin"), - Label("//python:grpc_python_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "python_grpc_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +python_grpc_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [python_grpc_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -61,10 +23,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def python_grpc_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/python/python_grpclib_compile.bzl b/python/python_grpclib_compile.bzl index 547f7325..23cb3066 100644 --- a/python/python_grpclib_compile.bzl +++ b/python/python_grpclib_compile.bzl @@ -1,55 +1,17 @@ """Generated definition of python_grpclib_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for python_grpclib_compile -python_grpclib_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//python:python_plugin"), - Label("//python:grpclib_python_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "python_grpclib_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +python_grpclib_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [python_grpclib_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -61,10 +23,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def python_grpclib_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/python/python_proto_compile.bzl b/python/python_proto_compile.bzl index 07dff88c..c0fb9218 100644 --- a/python/python_proto_compile.bzl +++ b/python/python_proto_compile.bzl @@ -1,54 +1,17 @@ """Generated definition of python_proto_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for python_proto_compile -python_proto_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//python:python_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "python_proto_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +python_proto_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [python_proto_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -59,10 +22,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def python_proto_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/ruby/ruby_grpc_compile.bzl b/ruby/ruby_grpc_compile.bzl index e0139946..c3be3ae0 100644 --- a/ruby/ruby_grpc_compile.bzl +++ b/ruby/ruby_grpc_compile.bzl @@ -1,55 +1,17 @@ """Generated definition of ruby_grpc_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for ruby_grpc_compile -ruby_grpc_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//ruby:ruby_plugin"), - Label("//ruby:grpc_ruby_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "ruby_grpc_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +ruby_grpc_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [ruby_grpc_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -61,10 +23,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def ruby_grpc_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/ruby/ruby_proto_compile.bzl b/ruby/ruby_proto_compile.bzl index ee508658..b645ad2e 100644 --- a/ruby/ruby_proto_compile.bzl +++ b/ruby/ruby_proto_compile.bzl @@ -1,54 +1,17 @@ """Generated definition of ruby_proto_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for ruby_proto_compile -ruby_proto_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//ruby:ruby_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "ruby_proto_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +ruby_proto_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [ruby_proto_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -59,10 +22,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def ruby_proto_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/rust/rust_grpc_compile.bzl b/rust/rust_grpc_compile.bzl index 17c12e6d..2d5cf694 100644 --- a/rust/rust_grpc_compile.bzl +++ b/rust/rust_grpc_compile.bzl @@ -1,55 +1,17 @@ """Generated definition of rust_grpc_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for rust_grpc_compile -rust_grpc_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//rust:rust_plugin"), - Label("//rust:grpc_rust_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "rust_grpc_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +rust_grpc_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [rust_grpc_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -61,10 +23,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def rust_grpc_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/rust/rust_proto_compile.bzl b/rust/rust_proto_compile.bzl index d385f925..89061e26 100644 --- a/rust/rust_proto_compile.bzl +++ b/rust/rust_proto_compile.bzl @@ -1,54 +1,17 @@ """Generated definition of rust_proto_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for rust_proto_compile -rust_proto_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//rust:rust_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "rust_proto_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +rust_proto_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [rust_proto_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -59,10 +22,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def rust_proto_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/scala/scala_grpc_compile.bzl b/scala/scala_grpc_compile.bzl index 1961ce2d..d2b8a998 100644 --- a/scala/scala_grpc_compile.bzl +++ b/scala/scala_grpc_compile.bzl @@ -1,54 +1,17 @@ """Generated definition of scala_grpc_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for scala_grpc_compile -scala_grpc_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//scala:grpc_scala_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "scala_grpc_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +scala_grpc_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [scala_grpc_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -59,10 +22,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def scala_grpc_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/scala/scala_proto_compile.bzl b/scala/scala_proto_compile.bzl index a23d0f36..8a13c1da 100644 --- a/scala/scala_proto_compile.bzl +++ b/scala/scala_proto_compile.bzl @@ -1,54 +1,17 @@ """Generated definition of scala_proto_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for scala_proto_compile -scala_proto_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//scala:scala_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "scala_proto_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +scala_proto_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [scala_proto_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -59,10 +22,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def scala_proto_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/swift/swift_grpc_compile.bzl b/swift/swift_grpc_compile.bzl index 94f59b08..8d09ee51 100644 --- a/swift/swift_grpc_compile.bzl +++ b/swift/swift_grpc_compile.bzl @@ -1,55 +1,17 @@ """Generated definition of swift_grpc_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for swift_grpc_compile -swift_grpc_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//swift:swift_plugin"), - Label("//swift:grpc_swift_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "swift_grpc_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +swift_grpc_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [swift_grpc_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -61,10 +23,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def swift_grpc_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/swift/swift_proto_compile.bzl b/swift/swift_proto_compile.bzl index 3c3e90eb..de11744e 100644 --- a/swift/swift_proto_compile.bzl +++ b/swift/swift_proto_compile.bzl @@ -1,54 +1,17 @@ """Generated definition of swift_proto_compile.""" -load("@rules_proto//proto:defs.bzl", "ProtoInfo") load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for swift_proto_compile -swift_proto_compile_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [ - Label("//swift:swift_plugin"), - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "swift_proto_compile_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +swift_proto_compile = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [swift_proto_compile_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [ @@ -59,10 +22,3 @@ _rule = rule( ), toolchains = [str(Label("//protobuf:toolchain_type"))], ) - -# Create macro for converting attrs and passing to compile -def swift_proto_compile(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - ) diff --git a/test_workspaces/transitive_compilation/BUILD.bazel b/test_workspaces/transitive_compilation/BUILD.bazel deleted file mode 100644 index 0993df58..00000000 --- a/test_workspaces/transitive_compilation/BUILD.bazel +++ /dev/null @@ -1,23 +0,0 @@ -load("@rules_proto//proto:defs.bzl", "proto_library") -load("@rules_cc//cc:defs.bzl", "cc_test") -load("@rules_proto_grpc//cpp:defs.bzl", "cpp_grpc_library") - -package(default_visibility = ["//visibility:private"]) - -# Test that old style transitive compilation works - -proto_library( - name = "proto_lib", - srcs = ["demo.proto"], -) - -cpp_grpc_library( - name = "cpp_lib", - deps = ["proto_lib"], -) - -cc_test( - name = "test", - srcs = ["main.cc"], - deps = ["cpp_lib"], -) diff --git a/test_workspaces/transitive_compilation/WORKSPACE b/test_workspaces/transitive_compilation/WORKSPACE deleted file mode 100644 index 187e5d4e..00000000 --- a/test_workspaces/transitive_compilation/WORKSPACE +++ /dev/null @@ -1,24 +0,0 @@ -local_repository( - name = "rules_proto_grpc", - path = "../../", -) - -load("@rules_proto_grpc//:repositories.bzl", "rules_proto_grpc_repos", "rules_proto_grpc_toolchains") - -rules_proto_grpc_toolchains() - -rules_proto_grpc_repos() - -load("@rules_proto//proto:repositories.bzl", "rules_proto_dependencies", "rules_proto_toolchains") - -rules_proto_dependencies() - -rules_proto_toolchains() - -load("@rules_proto_grpc//python:repositories.bzl", "python_repos") - -python_repos() - -load("@com_github_grpc_grpc//bazel:grpc_deps.bzl", "grpc_deps") - -grpc_deps() diff --git a/test_workspaces/transitive_compilation/demo.proto b/test_workspaces/transitive_compilation/demo.proto deleted file mode 100644 index 09b3edee..00000000 --- a/test_workspaces/transitive_compilation/demo.proto +++ /dev/null @@ -1,5 +0,0 @@ -syntax = "proto3"; - -message demo { - bool field = 1; -} diff --git a/test_workspaces/transitive_compilation/main.cc b/test_workspaces/transitive_compilation/main.cc deleted file mode 100644 index 7e6189e4..00000000 --- a/test_workspaces/transitive_compilation/main.cc +++ /dev/null @@ -1,5 +0,0 @@ -#include "demo.pb.h" - -int main () { - return demo().ByteSizeLong(); -} diff --git a/tools/rulegen/common.go b/tools/rulegen/common.go index 16e15943..0ec7c36e 100644 --- a/tools/rulegen/common.go +++ b/tools/rulegen/common.go @@ -54,55 +54,18 @@ var libraryRuleAttrs = append(append([]*Attr(nil), compileRuleAttrs...), []*Attr }...) -var compileRuleTemplate = mustTemplate(`load("@rules_proto//proto:defs.bzl", "ProtoInfo") -load( +var compileRuleTemplate = mustTemplate(`load( "//:defs.bzl", - "ProtoLibraryAspectNodeInfo", "ProtoPluginInfo", - "proto_compile_aspect_attrs", - "proto_compile_aspect_impl", "proto_compile_attrs", "proto_compile_impl", ) -# Create aspect for {{ .Rule.Name }} -{{ .Rule.Name }}_aspect = aspect( - implementation = proto_compile_aspect_impl, - provides = [ProtoLibraryAspectNodeInfo], - attr_aspects = ["deps"], - attrs = dict( - proto_compile_aspect_attrs, - _plugins = attr.label_list( - doc = "List of protoc plugins to apply", - providers = [ProtoPluginInfo], - default = [{{ range .Rule.Plugins }} - Label("{{ . }}"),{{ end }} - ], - ), - _prefix = attr.string( - doc = "String used to disambiguate aspects when generating outputs", - default = "{{ .Rule.Name }}_aspect", - ), - ), - toolchains = [str(Label("//protobuf:toolchain_type"))], -) - # Create compile rule -_rule = rule( +{{ .Rule.Name }} = rule( implementation = proto_compile_impl, attrs = dict( proto_compile_attrs, - protos = attr.label_list( - mandatory = False, # TODO: set to true in 4.0.0 when deps removed below - providers = [ProtoInfo], - doc = "List of labels that provide the ProtoInfo provider (such as proto_library from rules_proto)", - ), - deps = attr.label_list( - mandatory = False, - providers = [ProtoInfo, ProtoLibraryAspectNodeInfo], - aspects = [{{ .Rule.Name }}_aspect], - doc = "DEPRECATED: Use protos attr", - ), _plugins = attr.label_list( providers = [ProtoPluginInfo], default = [{{ range .Rule.Plugins }} @@ -112,14 +75,7 @@ _rule = rule( ), ), toolchains = [str(Label("//protobuf:toolchain_type"))], -) - -# Create macro for converting attrs and passing to compile -def {{ .Rule.Name }}(**kwargs): - _rule( - verbose_string = "{}".format(kwargs.get("verbose", 0)), - **kwargs - )`) +)`) // When editing, note that Go and gateway do not use this snippet and have their own local version var argsForwardingSnippet = `**{