protostar 0.1.0.beta1

data/lib/protostar/lint/rules/field_number_reuse_risk.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Lint
+    module Rules
+      # FIELD_NUMBER_REUSE_RISK: A message with gaps in its field numbers that are not reserved
+      class FieldNumberReuseRisk < Rule
+        REASON = "A deleted field's number that is not reserved will be reused, and old data will decode as the new field."
+        EXPLANATION = <<~TEXT
+          When a field is deleted, its number is still in every message written before. If a later field takes the
+          number, old data decodes into it as if it were the new field: wrong values, or parse errors when the
+          types differ. `reserved` makes protoc refuse the number (and the name) for good.
+
+              message User {
+                string name = 1;
+                // email was 2
+                string phone = 3;
+              }
+
+          Fix: `reserved 2; reserved "email";`. If the gap was never used, reserving it costs nothing either.
+        TEXT
+
+        def check
+          context.each(:message) do |node, message|
+            numbers = message.fields.map(&:number)
+            next if numbers.empty?
+            covered = (numbers.map { |n| n..n } + message.reserved_ranges + message.extension_ranges +
+              [19_000..19_999]).sort_by(&:first)
+            gaps = []
+            next_free = 1
+            covered.each do |r|
+              break if next_free >= numbers.max
+              gaps << (next_free..[r.first - 1, numbers.max - 1].min) if r.first > next_free
+              next_free = [next_free, r.last + 1].max
+            end
+            next if gaps.empty?
+            text = gaps.map { |r| (r.size == 1) ? r.first.to_s : "#{r.first} to #{r.last}" }.join(", ")
+            report(node, :name, "`#{message.name}` skips field #{(gaps.sum(&:size) == 1) ? "number" : "numbers"} #{text} without reserving them",
+              label: "gaps in the numbering", help: "if fields were deleted there, add `reserved #{text};` and reserve their names")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protostar/lint/rules/field_numbers_hot_range.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Lint
+    module Rules
+      # FIELD_NUMBERS_HOT_RANGE: A message using field numbers above 15 while numbers 1 to 15 are free
+      class FieldNumbersHotRange < Rule
+        REASON = "Field numbers 1 to 15 take one byte on the wire and 16 to 2047 two, so the low ones are best kept for the most common fields."
+        EXPLANATION = <<~TEXT
+          A field's tag is its number and wire type in a varint: 1 to 15 fit in one byte, 16 to 2047 need two. In a
+          message with many fields, the frequently set ones should have the low numbers. This rule only notices
+          when 1 to 15 have free numbers or deprecated fields while higher numbers are in use; whether the high
+          fields are the frequent ones is a judgement it leaves to you.
+
+              message Event {
+                string id = 1;
+                string payload = 16;
+              }
+
+          Fix: give new frequent fields the free low numbers. Never renumber an existing field: that breaks the
+          wire format.
+        TEXT
+
+        def check
+          context.each(:message) do |node, message|
+            high = message.fields.select { |f| f.number > 15 }
+            next if high.empty?
+            used = message.fields.map(&:number)
+            covered = message.reserved_ranges + message.extension_ranges
+            free = (1..15).reject { |n| used.include?(n) || covered.any? { |r| r.cover?(n) } }
+            stale = message.fields.select { |f| f.number <= 15 && f.options.deprecated? }
+            next if free.empty? && stale.empty?
+            parts = []
+            parts << "#{numbers_text(free)} free" unless free.empty?
+            parts << "deprecated #{stale.map { |f| "`#{f.name}`" }.join(", ")}" unless stale.empty?
+            report(node, :name, "`#{message.name}` uses numbers above 15 with #{parts.join(" and ")} in the one-byte range",
+              label: "#{high.size} #{(high.size == 1) ? "field" : "fields"} above 15",
+              help: "give new, frequently set fields numbers from 1 to 15; do not renumber existing ones")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protostar/lint/rules/file_lower_snake_case.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Lint
+    module Rules
+      # FILE_LOWER_SNAKE_CASE: A file name that is not lower_snake_case
+      class FileLowerSnakeCase < Rule
+        REASON = "Generated file and module names follow the .proto's name; lower_snake_case works on every file system and in every language."
+        EXPLANATION = <<~TEXT
+          Code generators derive file, module and class names from the `.proto` file's name. Mixed case breaks on
+          case-insensitive file systems and reads oddly as a Python module or Go file.
+
+              acme/UserProfile.proto
+
+          Fix: rename the file to `acme/user_profile.proto` and update the imports.
+        TEXT
+
+        def check
+          base = ::File.basename(context.name, ".proto")
+          return if Naming.lower_snake?(base)
+          add("file name `#{::File.basename(context.name)}` is not lower_snake_case", [],
+            help: "rename the file `#{Naming.lower_snake(base)}.proto`")
+        end
+      end
+    end
+  end
+end

data/lib/protostar/lint/rules/import_no_public.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Lint
+    module Rules
+      # IMPORT_NO_PUBLIC: An `import public`
+      class ImportNoPublic < Rule
+        REASON = "`import public` makes a file re-export another's types, which hides real dependencies and makes moving types hard."
+        EXPLANATION = <<~TEXT
+          `import public "b.proto";` in a.proto lets every file that imports a.proto use b.proto's types without
+          importing it. It exists for moving types between files; as a habit it hides who depends on what, and not
+          every language supports it.
+
+              import public "acme/common.proto";
+
+          Fix: import the file directly wherever its types are used.
+        TEXT
+
+        def check
+          context.ast.public_dependency.each do |index|
+            name = context.ast.dependency[index]
+            add("import of `#{name}` is public", [context.span_at([3, index], label: "re-exports `#{name}`")].compact,
+              help: "import `#{name}` directly in the files that use it")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protostar/lint/rules/import_no_weak.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Lint
+    module Rules
+      # IMPORT_NO_WEAK: An `import weak`
+      class ImportNoWeak < Rule
+        REASON = "Weak imports are an internal Google feature that most implementations do not support."
+        EXPLANATION = <<~TEXT
+          `import weak` lets a file use types from a file that might not be linked in. Only some C++ and Java
+          builds honour it, and edition 2024 removed it in favour of `import option`.
+
+              import weak "acme/debug.proto";
+
+          Fix: use a plain import (or `import option` for files that only provide options, from edition 2024).
+        TEXT
+
+        def check
+          context.ast.weak_dependency.each do |index|
+            name = context.ast.dependency[index]
+            add("import of `#{name}` is weak", [context.span_at([3, index], label: "weak")].compact,
+              help: "use a plain `import`")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protostar/lint/rules/import_used.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Lint
+    module Rules
+      # IMPORT_USED: An import nothing in the file uses
+      class ImportUsed < Rule
+        REASON = "An unused import is a dependency in the build graph that does nothing but slow it down and mislead readers."
+        EXPLANATION = <<~TEXT
+          protoc warns about these too; with this rule on, the warning is reported once, under this rule. An
+          import is used when a type, extension or option from it (or from what it imports publicly) is named in
+          the file.
+
+              import "google/protobuf/timestamp.proto";
+              message A { string id = 1; }
+
+          Fix: remove the import.
+        TEXT
+        CLAIMS = ["V0703"].freeze
+
+        def check
+          context.warnings.each do |warning|
+            next unless warning.code == "V0703"
+            name = warning.message[/\AImport (.*) is unused\.\z/, 1]
+            spans = warning.spans.map { |s| s.primary? ? s.with_label("unused") : s }
+            spans = [Diagnostics::Span.new(warning.line, warning.column, label: "unused")] if spans.empty? && warning.line
+            add("import `#{name}` is unused", spans, help: "remove the import")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protostar/lint/rules/message_pascal_case.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Lint
+    module Rules
+      # MESSAGE_PASCAL_CASE: A message name that is not PascalCase
+      class MessagePascalCase < Rule
+        REASON = "Messages become classes; PascalCase is what every style guide and generator expects."
+        EXPLANATION = <<~TEXT
+          Message names turn into class names in generated code.
+
+              message user_profile {}
+
+          Fix: `message UserProfile {}`, and update the fields and files that refer to it.
+        TEXT
+
+        def check
+          context.each(:message) do |node, message|
+            next if Naming.pascal?(message.name)
+            report(node, :name, "message `#{message.name}` is not PascalCase", label: "not PascalCase",
+              help: "name it `#{Naming.pascal(message.name)}` and update what refers to it")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protostar/lint/rules/no_deprecated_features.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Lint
+    module Rules
+      # NO_DEPRECATED_FEATURES: A feature or option deprecated in the file's edition
+      class NoDeprecatedFeatures < Rule
+        REASON = "Deprecated features will be removed in a later edition; the warning says what replaces them."
+        EXPLANATION = <<~TEXT
+          protoc warns when a file uses a feature or option its edition deprecates, with the replacement in the
+          message. With this rule on, that warning is reported once, under this rule.
+
+              edition = "2024";
+              option features.(pb.cpp).legacy_closed_enum = true;
+
+          Fix: follow the deprecation message.
+        TEXT
+        CLAIMS = ["V0507"].freeze
+
+        def check
+          context.warnings.each do |warning|
+            next unless warning.code == "V0507"
+            name, edition, reason = warning.message.match(/\A(.*) has been deprecated in edition (\w+): (.*)\z/m)&.captures
+            next unless name
+            spans = option_span(name.split(".").last) ||
+              warning.spans.map { |s| s.primary? ? s.with_label("deprecated") : s }
+            add("`#{name}` is deprecated since edition #{edition}", spans, help: reason)
+          end
+        end
+
+        private
+
+        # protoc reports against the element; the option that sets the
+        # feature is the more useful place to point
+        def option_span(feature)
+          pattern = /\bfeatures\b[^;=\]]*\b#{Regexp.escape(feature)}\b[^;,\]]*/
+          context.source.lines.each_with_index do |line, i|
+            match = line.match(pattern)
+            next unless match
+            before = line[0, match.begin(0)]
+            return nil if before.include?("\t")
+            from = before.bytesize + 1
+            return [Diagnostics::Span.new(i + 1, from, i + 1, from + match[0].rstrip.bytesize, label: "deprecated")]
+          end
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/protostar/lint/rules/no_groups.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Lint
+    module Rules
+      # NO_GROUPS: A proto2 `group` field
+      class NoGroups < Rule
+        REASON = "Groups are a proto2 relic most languages' tooling handles badly; a message field says the same thing."
+        EXPLANATION = <<~TEXT
+          A group declares a nested message and a field of that type at once, encoded with start and end tags
+          instead of a length. Most code generators and JSON mappings treat them as an oddity, proto3 does not
+          have them, and editions only keep the encoding (`features.message_encoding = DELIMITED`).
+
+              message SearchResponse {
+                repeated group Result = 1 {
+                  optional string url = 2;
+                }
+              }
+
+          Fix: in a new schema, declare `message Result` and a `repeated Result result = 1;` field. For data already
+          written, switching changes the wire format; move the file to editions and keep the field DELIMITED.
+        TEXT
+
+        def check
+          context.each(:field) do |node, field|
+            next unless node.type == :TYPE_GROUP
+            report(node, :type, "field `#{field.name}` is a group", label: "group",
+              help: "declare `message #{field.message_type.name}` and a field of that type")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protostar/lint/rules/oneof_lower_snake_case.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Lint
+    module Rules
+      # ONEOF_LOWER_SNAKE_CASE: A oneof name that is not lower_snake_case
+      class OneofLowerSnakeCase < Rule
+        REASON = "Oneof names become accessors and enum cases in generated code, derived on the assumption they are lower_snake_case."
+        EXPLANATION = <<~TEXT
+              oneof PaymentMethod { string card = 1; string iban = 2; }
+
+          Fix: `oneof payment_method { ... }`. `--fix` renames it when nothing else in the file mentions it.
+        TEXT
+
+        def check
+          context.each(:oneof) do |node, oneof|
+            next if Naming.lower_snake?(oneof.name)
+            wanted = Naming.lower_snake(oneof.name)
+            span = context.span(node, :name)
+            report(node, :name, "oneof `#{oneof.name}` is not lower_snake_case", span: span, label: "not lower_snake_case",
+              help: "name it `#{wanted}`", fix: rename(span, oneof.name, wanted))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protostar/lint/rules/package_defined.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Lint
+    module Rules
+      # PACKAGE_DEFINED: A file without a `package`
+      class PackageDefined < Rule
+        REASON = "A file without a package puts every type it declares in the global namespace, where any other file can clash with it."
+        EXPLANATION = <<~TEXT
+          Type names are global within a program. Without a package, `message User` is just `User`, and the first
+          other schema with a `User` breaks the build, or worse, the link.
+
+              syntax = "proto3";
+              message User {}
+
+          Fix: add `package acme.users.v1;` after the syntax line, matching the file's directory.
+        TEXT
+
+        def check
+          return unless context.file.package.empty?
+          span = context.span_at(Context::PATHS[:syntax]) || context.span_at(Context::PATHS[:edition])
+          add("file `#{context.name}` has no package", span ? [span.with_label("no `package` follows")] : [],
+            help: "add a `package` statement, e.g. `package acme.v1;`")
+        end
+      end
+    end
+  end
+end

data/lib/protostar/lint/rules/package_directory_match.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Lint
+    module Rules
+      # PACKAGE_DIRECTORY_MATCH: A file whose directory does not match its package
+      class PackageDirectoryMatch < Rule
+        REASON = "When `acme.users.v1` lives in `acme/users/v1/`, a type's file can be found from its name, by people and by tools."
+        EXPLANATION = <<~TEXT
+          Import paths and packages are separate namespaces; keeping them aligned is what lets you find
+          `acme.users.v1.User` in `acme/users/v1/`. The check looks at where the file is on disk, so it does not
+          depend on the include path.
+
+              // proto/users.proto
+              package acme.users.v1;
+
+          Fix: move the file to `proto/acme/users/v1/users.proto` (the include path being `proto`).
+        TEXT
+
+        def check
+          package = context.file.package
+          return if package.empty?
+          wanted = package.tr(".", "/")
+          dir = ::File.dirname(context.disk_path || context.name)
+          return if dir == wanted || dir.end_with?("/#{wanted}")
+          add("package `#{package}` is not in a `#{wanted}` directory",
+            [context.span_at(Context::PATHS[:package], label: "expects `#{wanted}/`")].compact,
+            help: "move the file into a `#{wanted}/` directory")
+        end
+      end
+    end
+  end
+end

data/lib/protostar/lint/rules/package_lower_snake_case.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Lint
+    module Rules
+      # PACKAGE_LOWER_SNAKE_CASE: A package name that is not lower_snake_case
+      class PackageLowerSnakeCase < Rule
+        REASON = "Packages become namespaces in every language; lower_snake_case components map cleanly onto all of them."
+        EXPLANATION = <<~TEXT
+          `package Acme.UserService;` turns into namespaces, modules and directories, some case-sensitive and some
+          not.
+
+              package Acme.Users;
+
+          Fix: `package acme.users;`. Every file that names a type with the package has to change too.
+        TEXT
+
+        def check
+          package = context.file.package
+          return if package.empty? || package.split(".").all? { |part| Naming.lower_snake?(part) }
+          wanted = package.split(".").map { |part| Naming.lower_snake(part) }.join(".")
+          add("package `#{package}` is not lower_snake_case",
+            [context.span_at(Context::PATHS[:package], label: "not lower_snake_case")].compact, help: "use `#{wanted}`")
+        end
+      end
+    end
+  end
+end

data/lib/protostar/lint/rules/package_same_directory.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Lint
+    module Rules
+      # PACKAGE_SAME_DIRECTORY: Files in one directory that declare different packages
+      class PackageSameDirectory < Rule
+        REASON = "One package per directory keeps the package-to-directory mapping one to one."
+        EXPLANATION = <<~TEXT
+          Two packages in one directory mean the directory says nothing about where a type lives, and many
+          generators (Go's in particular) cannot put both in one output package.
+
+              // acme/a.proto
+              package acme.a;
+              // acme/b.proto
+              package acme.b;
+
+          Fix: move one of the files, or give them the same package.
+        TEXT
+
+        def check
+          dir = directory(context)
+          peers = context.all.select { |other| directory(other) == dir }
+          packages = peers.map { |other| other.file.package }.uniq
+          return if packages.size < 2 || context.file.package == packages.first
+          add("files in `#{dir}` declare packages `#{packages.join("`, `")}`",
+            [context.span_at(Context::PATHS[:package], label: "differs from `#{packages.first}`")].compact,
+            help: "keep one package per directory")
+        end
+
+        private
+
+        def directory(context)
+          ::File.dirname(context.disk_path || context.name)
+        end
+      end
+    end
+  end
+end

data/lib/protostar/lint/rules/package_version_suffix.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Lint
+    module Rules
+      # PACKAGE_VERSION_SUFFIX: A package without a version as its last component
+      class PackageVersionSuffix < Rule
+        REASON = "A version in the package (`acme.users.v1`) lets a breaking change live next to the old API instead of replacing it."
+        EXPLANATION = <<~TEXT
+          Once clients depend on a package, breaking changes have to go in a new one. Naming the first `v1` makes
+          `v2` the obvious next step. Accepted suffixes: `v1`, `v1beta1`, `v1alpha`, `v1test`, `v1p1beta1` and the
+          like.
+
+              package acme.users;
+
+          Fix: `package acme.users.v1;`.
+        TEXT
+
+        VERSION = /\Av\d+(?:(?:alpha|beta)\d*|test\w*|p\d+(?:alpha|beta)\d*)?\z/
+
+        def check
+          package = context.file.package
+          return if package.empty? || package.split(".").last.match?(VERSION)
+          add("package `#{package}` has no version suffix",
+            [context.span_at(Context::PATHS[:package], label: "no version")].compact,
+            help: "add one, e.g. `#{package}.v1`")
+        end
+      end
+    end
+  end
+end

data/lib/protostar/lint/rules/reserved_names_with_numbers.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Lint
+    module Rules
+      # RESERVED_NAMES_WITH_NUMBERS: A message or enum that reserves numbers but no names, or names but no numbers
+      class ReservedNamesWithNumbers < Rule
+        REASON = "A deleted field needs both its number and its name reserved: the number for the binary format, the name for JSON and text."
+        EXPLANATION = <<~TEXT
+          The binary format identifies a field by number, JSON and the text format by name. Reserving only the
+          number lets a new field take the old name, and old JSON then fills it; reserving only the name lets a new
+          field take the number, and old binary data fills it.
+
+              message User {
+                reserved 2;
+                string name = 1;
+              }
+
+          Fix: reserve both, `reserved 2; reserved "email";` (`reserved email;` in editions).
+        TEXT
+
+        def check
+          context.each(:message) { |node, message| check_element(node, message, "fields", 9, 10) }
+          context.each(:enum) { |node, enum| check_element(node, enum, "values", 4, 5) }
+        end
+
+        private
+
+        def check_element(node, element, what, range_field, name_field)
+          numbers = node.reserved_range
+          names = node.reserved_name
+          if !numbers.empty? && names.empty?
+            report(numbers[0], :number, "`#{element.name}` reserves #{what} by number but not by name",
+              label: "number only", help: "reserve the deleted #{what}' names too")
+          elsif numbers.empty? && !names.empty?
+            report(node, :name, "`#{element.name}` reserves #{what} by name but not by number",
+              span: context.span_at(node.path + [name_field]), label: "name only",
+              help: "reserve the deleted #{what}' numbers too")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protostar/lint/rules/rpc_pascal_case.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Lint
+    module Rules
+      # RPC_PASCAL_CASE: An rpc name that is not PascalCase
+      class RpcPascalCase < Rule
+        REASON = "RPCs become methods in every language's stubs, converted from PascalCase."
+        EXPLANATION = <<~TEXT
+              rpc get_user(GetUserRequest) returns (GetUserResponse);
+
+          Fix: `rpc GetUser(...)`.
+        TEXT
+
+        def check
+          context.each(:method) do |node, rpc|
+            next if Naming.pascal?(rpc.name)
+            report(node, :name, "rpc `#{rpc.name}` is not PascalCase", label: "not PascalCase",
+              help: "name it `#{Naming.pascal(rpc.name)}`")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protostar/lint/rules/rpc_request_response_unique.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Lint
+    module Rules
+      # RPC_REQUEST_RESPONSE_UNIQUE: A message used as the request or response of more than one rpc
+      class RpcRequestResponseUnique < Rule
+        REASON = "Requests and responses shared between RPCs will need to diverge, and then cannot."
+        EXPLANATION = <<~TEXT
+          Two RPCs that take the same request are tied together: a field one of them needs appears in the other's
+          API too. The same goes for responses, and for a message used as one RPC's request and another's response.
+
+              rpc GetUser(UserRequest) returns (User);
+              rpc DeleteUser(UserRequest) returns (User);
+
+          Fix: give each RPC its own `<Rpc>Request` and `<Rpc>Response`.
+        TEXT
+
+        def check
+          first = {}
+          context.each(:service) do |service_node, service|
+            service.rpcs.each_with_index do |rpc, i|
+              node = service_node.rpcs[i]
+              [[rpc.input_type, :input_type, "request"], [rpc.output_type, :output_type, "response"]].each do |type, kind, role|
+                if (earlier = first[type.full_name])
+                  other_node, other_kind, other_rpc, other_role = earlier
+                  report(node, kind, "`#{type.name}` is the #{role} of `#{rpc.name}` and already the #{other_role} of `#{other_rpc}`",
+                    label: "used again", related: [[other_node, other_kind, "first used here"]],
+                    help: "give `#{rpc.name}` a `#{Naming.pascal(rpc.name)}#{role.capitalize}` of its own")
+                else
+                  first[type.full_name] = [node, kind, rpc.name, role]
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protostar/lint/rules/rpc_request_standard_name.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Protostar
+  module Lint
+    module Rules
+      # RPC_REQUEST_STANDARD_NAME: An rpc whose request is not `<Rpc>Request`
+      class RpcRequestStandardName < Rule
+        REASON = "A request message of its own per RPC can grow fields without touching any other RPC."
+        EXPLANATION = <<~TEXT
+          An RPC that takes `User` or `google.protobuf.Empty` cannot add a parameter later without changing that
+          shared type for everyone. `GetUserRequest` (or `UserServiceGetUserRequest`) belongs to `GetUser` alone.
+
+              rpc GetUser(UserId) returns (User);
+
+          Fix: `rpc GetUser(GetUserRequest) returns (GetUserResponse);`.
+        TEXT
+
+        def check
+          context.each(:service) do |service_node, service|
+            service.rpcs.each_with_index do |rpc, i|
+              base = Naming.pascal(rpc.name)
+              wanted = ["#{base}Request", "#{service.name}#{base}Request"]
+              next if wanted.include?(rpc.input_type.name)
+              report(service_node.rpcs[i], :input_type, "request of `#{rpc.name}` is `#{rpc.input_type.name}`, not `#{wanted[0]}`",
+                label: "not `#{wanted[0]}`", help: "take a `#{wanted[0]}` message of its own")
+            end
+          end
+        end
+      end
+    end
+  end
+end