fix(rust): service-only libs, plugin order, output_mappings for path-mismatched pkgs

Three independent failures surfaced by running protoc-gen-prost,
protoc-gen-prost-serde, and protoc-gen-tonic together across a real
monorepo:

1. Service-only proto_libraries (no messages/enums) caused tonic to
   error with "Tried to insert into file that doesn't exist": tonic
   appends client/server code into prost's {package}.rs at the
   @@protoc_insertion_point(module) marker, but ProtocGenProstPlugin
   skipped libraries with no messages or enums. shouldApply and
   outputs now also fire on HasServices() so prost emits a stub .rs
   for tonic to insert into. Two new tests in protoc-gen-prost_test.

2. Plugin order was non-deterministic: BUILD.bazel attr ordering
   (preserved by bazel-gazelle's standard list-merge) put tonic
   before prost, so tonic's insertion ran before prost created its
   target file — yielding the "Tried to insert into file that
   doesn't exist" / "Tried to write the same file twice" pair.
   proto_compile.bzl now sorts plugins by name inside the rule impl,
   so protoc CLI ordering is independent of attr ordering.

3. proto packages whose path doesn't match the bazel package dir
   (e.g. "trumid.common.auth" living at //trumid/common/auth/proto,
   or "grpc.health.v1" living at //thirdparty/.../grpc/health/v1)
   failed with `mv: ... No such file or directory` because prost
   writes to its proto-package-derived path while proto_compile.bzl
   expected the output at the bazel pkg. The output_mappings
   computation in proto_rust_library.ProvideRule only handled the
   Rust-keyword-escape case (e.g. google.type → google/r#type).
   Generalized: emit mappings whenever RustProtocOutputDir(pkg)
   differs from pc.Rel, regardless of whether keywords are involved.
   Extracted RustProtocOutputDir helper; existing
   RustKeywordEscapeMappings retained for back-compat with the
   exposed Starlark function.

Author: pcj

pkg/plugin/neoeinstein/prost/protoc-gen-prost.go

@@ -92,10 +92,15 @@ func needsCompileWellKnownTypes(opts []string, ownPackages map[string]bool) bool
 	return false
 }
 
-// shouldApply returns true if the library has files with messages or enums.
+// shouldApply returns true if the library has any file with messages, enums,
+// or services. Services are included because protoc-gen-tonic's generated
+// code is inserted into prost's {package}.rs at the @@protoc_insertion_point
+// marker (see protoc-gen-prost's append_to_file mechanism). If prost isn't
+// invoked, the file doesn't exist and tonic's insert fails with
+// "Tried to insert into file that doesn't exist".
 func (p *ProtocGenProstPlugin) shouldApply(lib protoc.ProtoLibrary) bool {
 	for _, f := range lib.Files() {
-		if f.HasMessages() || f.HasEnums() {
+		if f.HasMessages() || f.HasEnums() || f.HasServices() {
 			return true
 		}
 	}
@@ -105,12 +110,17 @@ func (p *ProtocGenProstPlugin) shouldApply(lib protoc.ProtoLibrary) bool {
 // outputs computes the output files for the plugin. Prost generates one .rs
 // file per proto package, named {proto_package}.rs. The path includes the
 // file's directory so that mergeSources can handle the rel stripping.
+//
+// Packages contributed by service-only files (no messages/enums) are
+// included — prost still emits a stub .rs containing the
+// @@protoc_insertion_point(module) marker, which tonic relies on to inject
+// its client/server code via append_to_file.
 func (p *ProtocGenProstPlugin) outputs(lib protoc.ProtoLibrary) []string {
 	seen := make(map[string]bool)
 	outputs := make([]string, 0)
 
 	for _, f := range lib.Files() {
-		if !(f.HasMessages() || f.HasEnums()) {
+		if !(f.HasMessages() || f.HasEnums() || f.HasServices()) {
 			continue
 		}
 		pkg := f.Package()

pkg/plugin/neoeinstein/prost/protoc-gen-prost_test.go

@@ -42,6 +42,39 @@ func TestProtocGenProstPlugin(t *testing.T) {
 			),
 			SkipIntegration: true,
 		},
+		"service only - emits stub .rs for tonic to insert into": {
+			// Without this case the protoc plugin chain breaks: tonic
+			// appends its client/server code at the @@protoc_insertion_point
+			// in {package}.rs, and protoc errors with
+			// "Tried to insert into file that doesn't exist" if prost
+			// hasn't created that file first.
+			Input: "package example.v1;\nservice Greeter { rpc Hello(Req) returns (Resp); }\nmessage Req {}\nmessage Resp {}",
+			Directives: plugintest.WithDirectives(
+				"proto_plugin", "protoc-gen-prost implementation neoeinstein:prost:protoc-gen-prost",
+			),
+			PluginName: "protoc-gen-prost",
+			Configuration: plugintest.WithConfiguration(
+				plugintest.WithLabel(t, "@build_stack_rules_proto//plugin/neoeinstein/prost:protoc-gen-prost"),
+				plugintest.WithOutputs("example.v1.rs"),
+			),
+			SkipIntegration: true,
+		},
+		"service only - no messages": {
+			// Same as above but the proto has no messages/enums of its own
+			// (could be e.g. a separate proto_library that imports its
+			// request/response types from a sibling). Prost still has to
+			// emit the .rs stub so tonic's append succeeds.
+			Input: "package example.v1;\nimport \"google/protobuf/empty.proto\";\nservice Pinger { rpc Ping(google.protobuf.Empty) returns (google.protobuf.Empty); }",
+			Directives: plugintest.WithDirectives(
+				"proto_plugin", "protoc-gen-prost implementation neoeinstein:prost:protoc-gen-prost",
+			),
+			PluginName: "protoc-gen-prost",
+			Configuration: plugintest.WithConfiguration(
+				plugintest.WithLabel(t, "@build_stack_rules_proto//plugin/neoeinstein/prost:protoc-gen-prost"),
+				plugintest.WithOutputs("example.v1.rs"),
+			),
+			SkipIntegration: true,
+		},
 		"no package - skipped": {
 			Input: "message Foo {}",
 			Directives: plugintest.WithDirectives(

pkg/protoc/rust_keywords.go

@@ -62,24 +62,50 @@ var rustKeywords = map[string]bool{
 	"yield":    true,
 }
 
+// RustProtocOutputDir returns the directory that protoc-gen-prost (and its
+// siblings) will write outputs into for a given proto package, with Rust
+// keyword segments escaped via the r# prefix.
+//
+// Examples:
+//   - "google.type"                    → "google/r#type"
+//   - "trumid.common.auth"             → "trumid/common/auth"
+//   - ""                                → ""
+//
+// Note this is independent of the bazel package location — protoc-gen-prost
+// always derives the output path from the proto package name unless given
+// flat_output_dir=true. Use the result to compare against pc.Rel and decide
+// whether output_mappings are needed.
+func RustProtocOutputDir(pkg string) string {
+	if pkg == "" {
+		return ""
+	}
+	segments := strings.Split(pkg, ".")
+	for i, seg := range segments {
+		if rustKeywords[seg] {
+			segments[i] = "r#" + seg
+		}
+	}
+	return strings.Join(segments, "/")
+}
+
 // RustKeywordEscapeMappings computes output mappings needed when
 // protoc-gen-prost escapes Rust keywords with the r# prefix in directory paths.
 //
 // For example, proto package "google.type" causes prost to write files to
 // "google/r#type/" instead of "google/type/". This function returns a mapping
 // from each declared output filename to the actual prost output path.
 //
-// Returns an empty map if no package segments are Rust keywords.
+// Returns an empty map if no package segments are Rust keywords. Callers who
+// also need to handle the more general case of proto-package path differing
+// from the bazel package path should use RustProtocOutputDir directly.
 func RustKeywordEscapeMappings(pkg string, outputs []string) map[string]string {
 	if pkg == "" || len(outputs) == 0 {
 		return nil
 	}
 
-	segments := strings.Split(pkg, ".")
-
 	// Check if any segment is a Rust keyword.
 	needsEscape := false
-	for _, seg := range segments {
+	for _, seg := range strings.Split(pkg, ".") {
 		if rustKeywords[seg] {
 			needsEscape = true
 			break
@@ -89,17 +115,7 @@ func RustKeywordEscapeMappings(pkg string, outputs []string) map[string]string {
 		return nil
 	}
 
-	// Build the escaped directory path.
-	escaped := make([]string, len(segments))
-	for i, seg := range segments {
-		if rustKeywords[seg] {
-			escaped[i] = "r#" + seg
-		} else {
-			escaped[i] = seg
-		}
-	}
-	escapedDir := strings.Join(escaped, "/")
-
+	escapedDir := RustProtocOutputDir(pkg)
 	mappings := make(map[string]string, len(outputs))
 	for _, output := range outputs {
 		base := path.Base(output)

pkg/rule/rules_rust/proto_rust_library.go

@@ -1,6 +1,7 @@
 package rules_rust
 
 import (
+	"path"
 	"strings"
 
 	"github.com/bazelbuild/bazel-gazelle/label"
@@ -57,16 +58,32 @@ func (s *protoRustLibrary) ProvideRule(cfg *protoc.LanguageRuleConfig, pc *proto
 		return nil
 	}
 
-	// Compute Rust keyword escape mappings for proto packages containing
-	// Rust reserved keywords (e.g., "google.type" → prost writes to
-	// "google/r#type/" instead of "google/type/").
+	// Compute output_mappings whenever the directory protoc-gen-prost writes
+	// to (derived from the proto package name, with Rust keyword segments
+	// r#-escaped) differs from the bazel package the rule lives in. Two
+	// distinct causes:
+	//
+	//   1. Rust keyword escapes — proto package "google.type" → prost writes
+	//      to "google/r#type/" while the bazel pkg is "google/type".
+	//
+	//   2. Proto package path simply differs from bazel package path —
+	//      e.g. proto package "trumid.common.auth" living at bazel pkg
+	//      "trumid/common/auth/proto", or "grpc.health.v1" living at
+	//      "thirdparty/protobuf/grpc/src/main/protobuf/grpc/health/v1".
+	//      Without a mapping, proto_compile.bzl's rename step looks for the
+	//      output at <bazel-bin>/<bazel_pkg>/<file>.rs and fails with
+	//      `mv: ... No such file or directory`.
 	if files := pc.Library.Files(); len(files) > 0 {
 		pkg := files[0].Package().Name
-		for output, escapedPath := range protoc.RustKeywordEscapeMappings(pkg, outputs) {
+		protocDir := protoc.RustProtocOutputDir(pkg)
+		if protocDir != "" && protocDir != pc.Rel {
 			if pc.Mappings == nil {
 				pc.Mappings = make(map[string]string)
 			}
-			pc.Mappings[output] = escapedPath
+			for _, output := range outputs {
+				base := path.Base(output)
+				pc.Mappings[base] = path.Join(protocDir, base)
+			}
 		}
 	}
 

rules/proto_compile.bzl

@@ -159,8 +159,21 @@ def _proto_compile_impl(ctx):
     # const <ProtoInfo> primary proto provider (for descriptor path resolution)
     primary_proto_info = proto_infos[0]
 
-    # const <list<ProtoPluginInfo>> plugins to be applied
-    plugins = [plugin[ProtoPluginInfo] for plugin in ctx.attr.plugins]
+    # const <list<ProtoPluginInfo>> plugins to be applied. Sort by plugin name
+    # so protoc invocation order is deterministic and independent of attr
+    # ordering. This matters when plugins use protoc's @@protoc_insertion_point
+    # mechanism — e.g. protoc-gen-tonic inserts client/server code at the
+    # `module` insertion point of protoc-gen-prost's {package}.rs output. If
+    # tonic runs before prost, the insertion target doesn't exist yet and
+    # protoc fails with "Tried to insert into file that doesn't exist" (and
+    # then "Tried to write the same file twice" when prost's subsequent
+    # create collides with the failed-insertion entry). Alphabetical sort
+    # puts protoc-gen-prost before protoc-gen-tonic, satisfying the
+    # producer-before-consumer ordering this protocol requires.
+    plugins = sorted(
+        [plugin[ProtoPluginInfo] for plugin in ctx.attr.plugins],
+        key = lambda p: p.name,
+    )
 
     # const <dict<string,string>>
     outs = {_plugin_label_key(Label(k)): v for k, v in ctx.attr.outs.items()}