rubocop-dynamic_methods 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b25a5992bc7edae3c7c0160c0f43449309ec46607b70c09651dc87ad4908cb3d
+  data.tar.gz: 0277bc047e63ef53c97e1eef882359c7d601b249540703d915b691990e8dd868
+SHA512:
+  metadata.gz: 457b6361aaff81eeb9ebc37403d588b9a75612e1c8175f6ad93b4ad2eba11422983134b5c76867243933b0a22bb2a5e7852eee70fdb339363b320e2d54d5d011
+  data.tar.gz: 310ed2394f0beecbf6e241e1a16fa89b40d0cb178d80335fb9d2d41e6b5fc48e73716e605c6332f66bb93a5b466b8eb60fffa54dfc98895c037f907d3d38d4f4

data/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Changelog
+
+## [0.1.0] - 2026-11-13
+
+First release. rubocop-dynamic_methods finds methods that Ruby metaprogramming defines and writes them as plain `def`s, so a search for `def name` finds them.
+
+- `DynamicMethods/DefineMethod` reports `define_method` and `define_singleton_method`, and autocorrects them to `def name` and `def self.name`.
+- `DynamicMethods/StringEval` reports `class_eval`, `module_eval`, `instance_eval`, and `eval` with a string, and autocorrects a `class_eval` or `module_eval` string that holds only defs to those defs.
+- `DynamicMethods/MethodMissing` reports `def method_missing`.
+- `DynamicMethods/Delegation`, disabled by default, reports `delegate`, `delegate_missing_to`, `def_delegator`, and `def_delegators` with the names they define. It does not autocorrect, because a def is not the same method.
+- The autocorrection runs only when the defs are the same methods: a call directly in a class or module body, or in an `each` over a literal Array, a literal Hash, a constant set once to one of those before the loop, or the `keys` or `values` of such a Hash. An unfrozen constant counts only when no code between its assignment and the loop can change it. Otherwise the offense ends with `Not autocorrected:` and the reason.
+- A call in a branch of an `if` or `unless` in a class body is rewritten in that branch. An `if` that calls a bare `private` is refused with that reason.
+- The autocorrection is unsafe: it trusts that `define_method`, `class_eval`, and `Array#each` are Ruby's own.
+- A block of `class_eval`, `module_eval`, `class_exec`, `module_exec`, `Class.new`, `Module.new`, `Struct.new`, or `Data.define` counts as a class body. A block of any other method, such as `included do`, is refused with that reason.
+- A string eval whose code holds a string literal is not autocorrected when the file's `# frozen_string_literal:` setting differs from the code's own, because the literal would change between mutable and frozen.
+- A loop that also calls `alias_method`, `attr_*`, `private name`, `ruby2_keywords`, or other methods with the loop variable is unrolled: each call is copied once per value, and a name built from the loop variable becomes a Symbol. A loop that assigns a local, calls a bare `private`, or uses `next`, `break`, or `return` is refused with that reason.
+- A class method that defines methods (`def self.record(name)` with `define_method(name)` in it) is written out at each call in the same class body that gives it literal arguments, so `record :and_return` becomes `def and_return`. The class method stays. A define_method inside any other method says that only the method's callers know which names it defines.
+- A string eval that is not rewritten says what it evaluates: the defs a literal string holds, the def names an interpolated string makes (such as `#{name}?`), or the code it comes from. `instance_eval(&block)` is not reported, since it runs a block.
+- A `define_method` whose body is not a literal block says what the body is: a copy of a named method such as `Kernel#send`, a block passed in from the caller, `&:name`, or a lambda.
+- `bin/check-corpus ROOT` checks the autocorrection on a folder of unpacked gems without loading them.
+- A lint_roller plugin, for RuboCop 1.72 or later, on Ruby 3.2 or later.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 meganemura
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.ja.md

@@ -0,0 +1,147 @@
+# rubocop-dynamic_methods
+
+Ruby のメタプログラミングで定義されたメソッドを見つける RuboCop の cop です。
+`paid?` が `define_method` や文字列 eval で作られていると、`def paid?` を検索しても何も見つかりません。
+読み手はまずコーディングエージェント、次に人です。
+この cop はそうしたメソッドを見つけ、ふつうの `def` に書き直します。
+
+```ruby
+# frozen_string_literal: true
+
+class Order
+  STATES = %i[draft paid].freeze
+
+  STATES.each do |state|
+    define_method(:"#{state}?") { @state == state }
+  end
+end
+```
+
+```sh
+$ rubocop -A --only DynamicMethods order.rb
+order.rb:7:5: C: [Corrected] DynamicMethods/DefineMethod: Define draft?, paid? with def, so a search for def name finds them.
+```
+
+```ruby
+# frozen_string_literal: true
+
+class Order
+  STATES = %i[draft paid].freeze
+
+  def draft?
+    @state == :draft
+  end
+
+  def paid?
+    @state == :paid
+  end
+end
+```
+
+## はじめかた
+
+```ruby
+# Gemfile
+gem "rubocop-dynamic_methods", require: false
+```
+
+```yaml
+# .rubocop.yml
+plugins:
+  - rubocop-dynamic_methods
+```
+
+RuboCop 1.72 以降と Ruby 3.2 以降で動きます。
+
+## cop の一覧
+
+| cop | 見つけるもの | 自動修正 |
+| --- | --- | --- |
+| `DynamicMethods/DefineMethod` | `define_method` と `define_singleton_method` | `def name` と `def self.name` に書き直す |
+| `DynamicMethods/StringEval` | 文字列を渡した `class_eval`、`module_eval`、`instance_eval`、`eval` | 文字列の中の def に書き直す |
+| `DynamicMethods/MethodMissing` | `def method_missing` | しない |
+| `DynamicMethods/Delegation`(初期値は無効) | `delegate`、`delegate_missing_to`、`def_delegator`、`def_delegators` | しない |
+
+`DynamicMethods/Delegation` は警告を出すだけです。
+委譲はよく使われる書き方で、def にすると同じメソッドにならないからです。
+Forwardable は private メソッドも呼べますし、どちらもどんな引数でも受け取ります。
+使うときは、`.rubocop.yml` の `DynamicMethods/Delegation` に `Enabled: true` を書きます。
+
+## 同じになるときだけ直す
+
+自動修正は、Ruby が同じメソッドを定義するときだけ def を書きます。
+同じとは、名前、引数、本体、公開範囲が同じことです。
+確かめられないときは、理由を書いた警告だけを出し、コードはそのままにします。
+
+```ruby
+class Feed
+  ELEMENTS = %w[title link]
+  include Parsing
+
+  ELEMENTS.each do |name|
+    class_eval <<~RUBY, __FILE__, __LINE__ + 1
+      def #{name}; @values[:#{name}]; end
+    RUBY
+  end
+end
+```
+
+```text
+feed.rb:6:5: C: DynamicMethods/StringEval: `class_eval` evaluates a string that defines methods named `#{name}`; write them with `def`, so a search finds them. Not autocorrected: `ELEMENTS` is not frozen, and `include Parsing` runs between its assignment and the loop.
+```
+
+理由は、次に def を書く人やエージェントに向けて書いています。
+
+RuboCop はソースを読むだけで実行しません。
+そのため、ソースだけで名前がすべて決まるときにだけ書き直せます。
+
+- 呼び出しがレシーバーなしか `self` で、クラスやモジュールの本体に直接あること。
+  `class_eval`、`module_eval`、`class_exec`、`module_exec`、`Class.new`、`Module.new`、`Struct.new`、`Data.define` のブロックも、クラスの本体として扱います。
+  そこでの def は、同じモジュールに、同じ公開範囲と定数の探し方で定義されるからです。
+  `included do` のような他のメソッドのブロックは扱いません。
+  どこに定義されるかは、そのブロックを実行するコードにしか分からないからです。
+  または、そこにあるリテラルの Array か Hash に対する `each` の中にあること。
+  そこにある `if` や `unless` の枝の中も同じに扱い、def は枝の中に書きます。
+  定数は、同じ本体の中でループより前に一度だけ、リテラルの Array か Hash を入れていればリテラルとして扱います。
+  `LIST.keys` と `LIST.values` も同じです。
+  freeze していないリストでは、代入からループまでの間に、def、リテラルの定数、`attr_reader :a` のような呼び出ししか置けません。
+  そうすれば、間でリストが変わることはないからです。
+  `Base::NAMES` のような他のモジュールの定数は書き直しません。
+  別のファイルで変えられるからです。
+- `def self.delegate_to_metadata(key)` のようにメソッドを定義するクラスメソッドは、同じクラスの本体でリテラルを渡して呼んでいる場所に展開します。
+  `delegate_to_metadata :file_path` は `def file_path` になります。
+  クラスメソッドそのものは、他から呼ばれるかもしれないので残します。
+  引数なしの `private` のあとの呼び出しは書き直しません。
+  他のメソッドの中で定義したメソッドは public になるからです。
+- そのループの中の他の呼び出し(`alias_method`、`attr_reader`、`private`、`ruby2_keywords` など)は、値ごとに、前の def のあとへ写します。
+  ループ変数から作った名前は、`alias_method :refute_text, :assert_text` のように Symbol にします。
+  ループがローカル変数に代入するとき、引数なしの `private` を呼ぶとき、`next`、`break`、`return` を使うときは書き直しません。
+  ブロックとクラスの本体では、これらの意味が違うからです。
+- ループの値をリテラルに置き換えるのは、読むたびに同じオブジェクトになるときだけです。
+  Symbol、小さい Integer、nil、true、false、そして `# frozen_string_literal: true` のもとでの String です。
+- ブロックが外側のローカル変数を共有しているときは書き直しません。
+  def では意味が変わるものを使っているときも書き直しません。
+  番号付きパラメーター、`it`、`yield`、`binding`、`local_variables`、`block_given?`、`eval`、引数なしの `super`、ループの外の `break` と `redo` です。
+  メソッドを抜ける `next` は `return` に書き直します。
+- 引数なしの `private`、`protected`、`module_function` のあとにある文字列 eval は書き直しません。
+  文字列 eval で作った def は、そこでも public になるからです。
+  文字列に def 以外のものがあるときも書き直しません。
+  文字列の中のコードに文字列リテラルがあり、ファイルの `# frozen_string_literal:` で freeze するかどうかが変わるときも書き直しません。
+  このマジックコメントは、文字列 eval でコンパイルするコードには効かないからです。
+
+自動修正は RuboCop でいう unsafe です。
+`define_method`、`class_eval`、`Array#each` が Ruby 本来のものだと仮定しているからです。
+`rubocop -A` で実行してください。
+
+決まりの全体は [docs/decisions/0001-exact-or-refused.md](docs/decisions/0001-exact-or-refused.md) にあります。
+
+## 書き直しの確かめ方
+
+`test/hegel/rewrite_test.rb` は hegeltest でクラスを作り、cop で直し、元のクラスと直したクラスを両方読み込みます。
+そして Ruby が答える内容を比べます。
+公開範囲ごとのメソッド名、引数、戻り値、呼び出しで設定されるインスタンス変数です。
+
+## ライセンス
+
+MIT です。
+[LICENSE](LICENSE) を見てください。

data/README.md

@@ -0,0 +1,124 @@
+# rubocop-dynamic_methods
+
+RuboCop cops for methods that Ruby metaprogramming defines.
+A reader, a coding agent first and a person second, searches for `def paid?` and finds nothing when `paid?` comes from `define_method` or a string eval.
+These cops find those methods and write them as plain `def`s.
+
+```ruby
+# frozen_string_literal: true
+
+class Order
+  STATES = %i[draft paid].freeze
+
+  STATES.each do |state|
+    define_method(:"#{state}?") { @state == state }
+  end
+end
+```
+
+```sh
+$ rubocop -A --only DynamicMethods order.rb
+order.rb:7:5: C: [Corrected] DynamicMethods/DefineMethod: Define draft?, paid? with def, so a search for def name finds them.
+```
+
+```ruby
+# frozen_string_literal: true
+
+class Order
+  STATES = %i[draft paid].freeze
+
+  def draft?
+    @state == :draft
+  end
+
+  def paid?
+    @state == :paid
+  end
+end
+```
+
+## Quick start
+
+```ruby
+# Gemfile
+gem "rubocop-dynamic_methods", require: false
+```
+
+```yaml
+# .rubocop.yml
+plugins:
+  - rubocop-dynamic_methods
+```
+
+The plugin needs RuboCop 1.72 or later and Ruby 3.2 or later.
+
+## The cops
+
+| Cop | Finds | Autocorrects |
+| --- | --- | --- |
+| `DynamicMethods/DefineMethod` | `define_method` and `define_singleton_method` | to `def name` and `def self.name` |
+| `DynamicMethods/StringEval` | `class_eval`, `module_eval`, `instance_eval`, and `eval` with a string | to the defs the string holds |
+| `DynamicMethods/MethodMissing` | `def method_missing` | no |
+| `DynamicMethods/Delegation` (disabled by default) | `delegate`, `delegate_missing_to`, `def_delegator`, `def_delegators` | no |
+
+`DynamicMethods/Delegation` only reports: delegation is common style, and a def is not the same method, because Forwardable reaches private methods and both take any arguments.
+Turn it on with `Enabled: true` under `DynamicMethods/Delegation` in `.rubocop.yml`.
+
+## Exact or not at all
+
+The autocorrection writes defs only when Ruby would define the same methods: the same names, parameters, bodies, and visibility.
+When it cannot be sure, the offense says why and the code stays as it is:
+
+```ruby
+class Feed
+  ELEMENTS = %w[title link]
+  include Parsing
+
+  ELEMENTS.each do |name|
+    class_eval <<~RUBY, __FILE__, __LINE__ + 1
+      def #{name}; @values[:#{name}]; end
+    RUBY
+  end
+end
+```
+
+```text
+feed.rb:6:5: C: DynamicMethods/StringEval: `class_eval` evaluates a string that defines methods named `#{name}`; write them with `def`, so a search finds them. Not autocorrected: `ELEMENTS` is not frozen, and `include Parsing` runs between its assignment and the loop.
+```
+
+The reason is written for whoever writes the defs next, an agent or a person.
+
+RuboCop reads the source and never runs it, so a rewrite is possible only when the source fixes every name:
+
+- The call has no receiver, or `self`, and sits directly in a class or module body, or in an `each` over a literal Array or Hash there.
+  A branch of an `if` or `unless` there counts too, and the def stays in the branch.
+  A block of `class_eval`, `module_eval`, `class_exec`, `module_exec`, `Class.new`, `Module.new`, `Struct.new`, or `Data.define` counts as a class body: a def there defines on the same module, with the same visibility and constants.
+  A block of any other method, such as `included do`, does not, because only the code that runs it knows where it defines.
+  A constant counts as a literal list when the same body sets it once, before the loop, to a literal Array or Hash, and `LIST.keys` and `LIST.values` count too.
+  If the list is not frozen, only defs, literal constants, and calls such as `attr_reader :a` may run between the assignment and the loop, so nothing can change the list.
+  A constant of another module, such as `Base::NAMES`, is refused, because another file can change it.
+- A class method that defines methods, such as `def self.delegate_to_metadata(key)`, is written out at each call in the same class body that gives it literal arguments: `delegate_to_metadata :file_path` becomes `def file_path`.
+  The class method stays for other callers.
+  A call after a bare `private` is refused, because a method that another method defines is public.
+- The other calls in such a loop, such as `alias_method`, `attr_reader`, `private`, or `ruby2_keywords`, are copied once per value, after the def they follow.
+  A name built from the loop variable becomes a Symbol, as in `alias_method :refute_text, :assert_text`.
+  The loop is refused when it assigns a local, calls a bare `private`, or uses `next`, `break`, or `return`, because a block and a class body treat those differently.
+- A loop value becomes a literal only when the literal is the same object on every read: a Symbol, a small Integer, nil, true, false, or a String under `# frozen_string_literal: true`.
+- A block is refused when it shares a local with the code around it, or uses something a def treats differently: numbered parameters, `it`, `yield`, `binding`, `local_variables`, `block_given?`, `eval`, `super` with no arguments, `break` or `redo` outside a loop.
+  A `next` that leaves the method becomes `return`.
+- A string eval is refused after a bare `private`, `protected`, or `module_function`, because the defs it makes are public even there.
+  It is also refused when the string holds more than defs, or holds a string literal that the file's `# frozen_string_literal:` comment would freeze or unfreeze: that comment does not reach code a string eval compiles.
+
+The autocorrection is unsafe in RuboCop's sense: it trusts that `define_method`, `class_eval`, and `Array#each` are Ruby's own. Run it with `rubocop -A`.
+
+[docs/decisions/0001-exact-or-refused.md](docs/decisions/0001-exact-or-refused.md) has the full rule.
+
+## How the rewrite is checked
+
+`test/hegel/rewrite_test.rb` generates classes with hegeltest, corrects them with the cops, loads the original and the corrected class, and compares what Ruby reports: the method names by visibility, the parameters, the return values, and the instance variables a call sets.
+
+## License
+
+MIT. See [LICENSE](LICENSE).
+
+[Japanese](README.ja.md)

data/config/default.yml

@@ -0,0 +1,24 @@
+DynamicMethods:
+  DocumentationBaseURL: https://github.com/meganemura/rubocop-dynamic_methods/blob/main/README.md
+
+DynamicMethods/DefineMethod:
+  Description: Define methods with `def` instead of `define_method`, so a search for `def name` finds them.
+  Enabled: true
+  SafeAutoCorrect: false
+  VersionAdded: '0.1'
+
+DynamicMethods/StringEval:
+  Description: Write the defs a string eval holds as code, so a search for `def name` finds them.
+  Enabled: true
+  SafeAutoCorrect: false
+  VersionAdded: '0.1'
+
+DynamicMethods/MethodMissing:
+  Description: Define the methods `method_missing` answers with `def`.
+  Enabled: true
+  VersionAdded: '0.1'
+
+DynamicMethods/Delegation:
+  Description: Report the methods `delegate` and Forwardable define, which a search for `def name` does not find.
+  Enabled: false
+  VersionAdded: '0.1'

data/lib/rubocop/cop/dynamic_methods/define_method.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module DynamicMethods
+      # Finds methods defined with `define_method` or `define_singleton_method`.
+      # A search for `def name` does not find them.
+      #
+      # The autocorrection writes a plain `def` when the result is the same
+      # method: the same name, parameters, body, and visibility. That holds
+      # for a call directly in a class or module body (or a block Ruby runs as
+      # one, such as `Class.new do`), or in an `each` over a
+      # literal list there. Otherwise the offense names the reason, and the
+      # method is left for a person or an agent to write.
+      #
+      # The autocorrection is unsafe: it trusts that `define_method` and
+      # `Array#each` are Ruby's own.
+      #
+      # @example
+      #   # bad
+      #   %i[draft paid].each do |state|
+      #     define_method(:"#{state}?") { @state == state }
+      #   end
+      #
+      #   # good
+      #   def draft?
+      #     @state == :draft
+      #   end
+      #
+      #   def paid?
+      #     @state == :paid
+      #   end
+      class DefineMethod < Base
+        extend AutoCorrector
+        include FrozenStringLiteral
+        include DynamicMethods::Reporting
+
+        RESTRICT_ON_SEND = %i[define_method define_singleton_method].freeze
+
+        def on_send(node)
+          return unless node.block_node || node.arguments?
+
+          statement = node.block_node || node
+          report(node, statement) do
+            raise RuboCop::DynamicMethods::Rewrite::Refusal, refusal(node) unless node.block_node && RuboCop::DynamicMethods::Rewrite.statement?(statement)
+          end
+        end
+
+        private
+
+        def refusal(node)
+          return "it defines the method on `#{node.receiver.source}`" unless RuboCop::DynamicMethods::Rewrite.implicit?(node)
+          return body_refusal(node.arguments[1]) if node.arguments.size > 1
+
+          "the body is not a block"
+        end
+
+        # What a body that is not a literal block is, so the reader knows
+        # what a def would have to do instead.
+        def body_refusal(body)
+          if body.block_pass_type?
+            inner = body.children.first
+            return "the body is `&#{inner.value.inspect}`, which calls `#{inner.value}` on the method's first argument" if inner&.sym_type?
+            return copied(inner) || "the body is the block in `#{inner&.source}`, which the code that runs this passes in"
+          end
+          return "the body is a lambda, not a block" if body.block_type? && body.send_node.lambda_or_proc?
+          copied(body) || "the body is `#{body.source}`, not a block"
+        end
+
+        # `Kernel.instance_method(:send)` or `Time.method(:now)`: the method is
+        # copied as it is, and a def would be a new method that calls it.
+        def copied(node)
+          return unless node&.send_type? && %i[instance_method method].include?(node.method_name) && node.first_argument
+          unless %i[sym str].include?(node.first_argument.type)
+            owner = node.receiver ? " of `#{node.receiver.source.delete_prefix("::")}`" : ""
+            return "it copies a method#{owner} chosen by `#{node.first_argument.source}`, as it is"
+          end
+
+          name = node.first_argument.value.to_s
+          name = "#{node.receiver.source.delete_prefix("::")}#{node.method?(:instance_method) ? "#" : "."}#{name}" if node.receiver
+          "it copies the method `#{name}` as it is, and a def would be a new method that calls it"
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/dynamic_methods/delegation.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module DynamicMethods
+      # Finds methods that delegation defines: ActiveSupport's `delegate` and
+      # `delegate_missing_to`, and Forwardable's `def_delegator` and
+      # `def_delegators`. A search for `def name` does not find them.
+      #
+      # It only reports, and it is disabled by default: delegation is common,
+      # accepted style, and a def is not the same method. Forwardable calls
+      # through `__send__`, so it reaches private methods, and both take any
+      # arguments where a def would name them.
+      #
+      # @example
+      #   # bad
+      #   delegate :name, :email, to: :user
+      #
+      #   # good
+      #   def name = user.name
+      #
+      #   def email = user.email
+      class Delegation < Base
+        RESTRICT_ON_SEND = %i[delegate delegate_missing_to def_delegator def_delegators
+                              def_instance_delegator def_instance_delegators].freeze
+
+        def on_send(node)
+          return unless node.receiver.nil? || node.receiver.self_type?
+          return unless node.arguments?
+
+          message = case node.method_name
+                    when :delegate then delegate(node)
+                    when :delegate_missing_to then missing(node)
+                    when :def_delegator, :def_instance_delegator then delegator(node)
+                    else delegators(node)
+                    end
+          add_offense(node.loc.selector, message:) if message
+        end
+
+        private
+
+        # `delegate :a, :b, to: :x, prefix: true` defines `x_a` and `x_b`.
+        def delegate(node)
+          options = node.last_argument if node.last_argument.hash_type?
+          target = option(options, :to)
+          return unless target
+
+          prefix = option(options, :prefix)
+          prefix = if prefix&.true_type? then literal(target)
+                   elsif prefix && %i[sym str].include?(prefix.type) then prefix.value.to_s
+                   elsif prefix && !prefix.false_type? then prefix.source
+                   end
+          methods = node.arguments.reject(&:hash_type?)
+          names = methods.map { |method| [prefix, literal(method)].compact.join("_") }
+          report(node.method_name, names, literal(target))
+        end
+
+        def missing(node)
+          "`delegate_missing_to` answers every method that `#{node.first_argument.source.delete_prefix(":")}` answers, " \
+            "through `method_missing`, so no search finds them. Define the ones callers use with `def`."
+        end
+
+        # `def_delegator :@x, :a, :b` defines `b`, or `a` when no alias is given.
+        def delegator(node)
+          accessor, method, name = node.arguments
+          return unless method
+
+          report(node.method_name, [literal(name || method)], literal(accessor))
+        end
+
+        def delegators(node)
+          accessor, *methods = node.arguments
+          return if methods.empty?
+
+          report(node.method_name, methods.map { literal(_1) }, literal(accessor))
+        end
+
+        def report(spell, names, target)
+          listed = names.map { _1.start_with?("the names in ") ? _1 : "`#{_1}`" }
+          listed = names.size > 3 ? "#{listed.first(3).join(", ")} and #{names.size - 3} more" : listed.join(", ")
+          one = names.size == 1 && !names.first.start_with?("the names in ")
+          "`#{spell}` defines #{listed}, which #{one ? "forwards" : "forward"} to `#{target}`; " \
+            "a search for `def name` does not find #{one ? "it" : "them"}."
+        end
+
+        def option(hash, key)
+          hash&.pairs&.find { _1.key.sym_type? && _1.key.value == key }&.value
+        end
+
+        # A name as written, or the code that makes it.
+        def literal(node)
+          return "the names in `#{node.children.first.source}`" if node.splat_type?
+
+          %i[sym str].include?(node.type) ? node.value.to_s : node.source
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/dynamic_methods/method_missing.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module DynamicMethods
+      # Finds `method_missing`. The methods it answers have no `def` at all,
+      # so no search finds them, and no rewrite can list them. Define each
+      # method it answers with `def`, or with a call this department can
+      # rewrite.
+      #
+      # @example
+      #   # bad
+      #   def method_missing(name, *args)
+      #     name.end_with?("?") ? @state == name.to_s.chomp("?").to_sym : super
+      #   end
+      #
+      #   # good
+      #   def draft? = @state == :draft
+      class MethodMissing < Base
+        MSG = "Define the methods `method_missing` answers with `def`, so a search for their names finds them."
+
+        def on_def(node)
+          add_offense(node.loc.name) if node.method?(:method_missing)
+        end
+        alias on_defs on_def
+      end
+    end
+  end
+end

data/lib/rubocop/cop/dynamic_methods/reporting.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module DynamicMethods
+      # The offense both rewriting cops add: the names a rewrite defines, or
+      # the reason there is none, which tells an agent what to write by hand.
+      module Reporting
+        def on_new_investigation
+          @rewrite = nil
+          @corrected_ranges = nil
+          super
+        end
+
+        private
+
+        def report(node, statement)
+          plan = begin
+            yield
+            rewrite.plan(statement)
+          rescue RuboCop::DynamicMethods::Rewrite::Refusal => e
+            e
+          end
+          if plan.is_a?(Exception)
+            add_offense(node.loc.selector, message: "#{message_for(node, nil)} Not autocorrected: #{plan.message}.")
+          elsif corrected_ranges.include?(plan.range)
+            add_offense(node.loc.selector, message: message_for(node, plan))
+          else
+            corrected_ranges << plan.range
+            add_offense(node.loc.selector, message: message_for(node, plan)) do |corrector|
+              plan.edits.each { |range, text| corrector.replace(range, text) }
+            end
+          end
+        end
+
+        def message_for(_node, plan)
+          return "Define this method with `def`, so a search for its name finds it." if plan.nil?
+
+          names = plan.names.map { "`#{_1}`" }
+          "Define #{names.size > 3 ? "#{names.first(3).join(", ")} and #{names.size - 3} more" : names.join(", ")} with `def`, so a search for `def name` finds #{names.size == 1 ? "it" : "them"}."
+        end
+
+        def rewrite
+          @rewrite ||= RuboCop::DynamicMethods::Rewrite.new(
+            processed_source,
+            ruby_version: target_ruby_version,
+            frozen_strings: frozen_string_literals_enabled?
+          )
+        end
+
+        def corrected_ranges
+          @corrected_ranges ||= []
+        end
+      end
+    end
+  end
+end