rigortype 0.2.7 → 0.2.8

data/plugins/rigor-sorbet/lib/rigor/plugin/sorbet/catalog_walker.rb

@@ -8,35 +8,26 @@ require_relative "sig_parser"
 module Rigor
   module Plugin
     class Sorbet < Rigor::Plugin::Base
-      # Walks a parsed Prism program looking for
-      # `sig { ... }` / `sig do ... end` calls that immediately
-      # precede a `def` (or a `def self.foo` / `class << self;
-      # def foo; end`). Each recognised pair is parsed by
-      # {SigParser} and recorded in the {Catalog} under its
-      # qualified `(class_name, method_name, kind)` key.
+      # Walks a parsed Prism program looking for `sig { ... }` / `sig do ... end` calls that immediately
+      # precede a `def` (or a `def self.foo` / `class << self; def foo; end`). Each recognised pair is
+      # parsed by {SigParser} and recorded in the {Catalog} under its qualified `(class_name, method_name,
+      # kind)` key.
       #
-      # Anything we don't recognise (a stray `sig { ... }` not
-      # followed by a `def`, a `def` with no preceding `sig`,
-      # malformed sig blocks, etc.) is reported back to the
-      # caller through `parse_errors:` so the plugin can emit a
-      # `plugin.sorbet.parse-error` diagnostic. Walking is
-      # otherwise infallible — a bad sig block does not abort
-      # the catalog build for the rest of the file.
+      # Anything we don't recognise (a stray `sig { ... }` not followed by a `def`, a `def` with no
+      # preceding `sig`, malformed sig blocks, etc.) is reported back to the caller through
+      # `parse_errors:` so the plugin can emit a `plugin.sorbet.parse-error` diagnostic. Walking is
+      # otherwise infallible — a bad sig block does not abort the catalog build for the rest of the file.
       module CatalogWalker
-        # Detected error during walking. `kind` is one of:
-        # `:no_block` / `:empty_block` / `:missing_returns_or_void`
-        # / `:duplicate_sig` / `:dangling_sig`.
+        # Detected error during walking. `kind` is one of: `:no_block` / `:empty_block` /
+        # `:missing_returns_or_void` / `:duplicate_sig` / `:dangling_sig`.
         ParseError = Data.define(:kind, :node, :path)
 
         module_function
 
         # @param root [Prism::Node] the file's program node.
-        # @param catalog [Catalog] mutable; signatures are
-        #   recorded into it.
-        # @param path [String] file path used for diagnostic
-        #   provenance.
-        # @return [Array<ParseError>] errors observed during the
-        #   walk; empty when the file is sig-clean.
+        # @param catalog [Catalog] mutable; signatures are recorded into it.
+        # @param path [String] file path used for diagnostic provenance.
+        # @return [Array<ParseError>] errors observed during the walk; empty when the file is sig-clean.
         def walk(root:, catalog:, path:)
           state = State.new(catalog: catalog, path: path)
           walk_node(root, state, lexical_path: [], in_singleton_class: false)
@@ -64,9 +55,8 @@ module Rigor
           when Prism::StatementsNode
             walk_statements(node, state, lexical_path: lexical_path, in_singleton_class: in_singleton_class)
           when Prism::DefNode
-            # A `def` not preceded by a `sig` is fine; we just
-            # don't record anything for it. The interesting case
-            # is in `walk_statements`, which pairs sig+def.
+            # A `def` not preceded by a `sig` is fine; we just don't record anything for it. The
+            # interesting case is in `walk_statements`, which pairs sig+def.
           else
             node.compact_child_nodes.each do |child|
               walk_node(child, state, lexical_path: lexical_path, in_singleton_class: in_singleton_class)
@@ -92,13 +82,10 @@ module Rigor
           end
         end
 
-        # The pair-finding loop. Walks a `StatementsNode`'s
-        # children left-to-right; when it encounters a `sig`
-        # call, it remembers it and consumes the very next
-        # `def` / `def self.foo` as the target. Anything between
-        # a sig and its def (a comment is fine — comments aren't
-        # AST nodes — but a method call would be a problem)
-        # leaves the sig dangling.
+        # The pair-finding loop. Walks a `StatementsNode`'s children left-to-right; when it encounters a
+        # `sig` call, it remembers it and consumes the very next `def` / `def self.foo` as the target.
+        # Anything between a sig and its def (a comment is fine — comments aren't AST nodes — but a
+        # method call would be a problem) leaves the sig dangling.
         def walk_statements(statements, state, lexical_path:, in_singleton_class:)
           pending_sig = nil
 
@@ -107,18 +94,15 @@ module Rigor
               record_def_with_sig(child, pending_sig, state, lexical_path, in_singleton_class)
               pending_sig = nil
             elsif pending_sig && attr_macro_call?(child)
-              # `sig { returns(T) }` above `attr_reader :name` /
-              # `attr_accessor` / `attr_writer` types the generated
-              # accessor(s). This is a first-class Sorbet idiom — not
-              # a dangling sig — so record the accessor signature(s)
-              # instead of warning.
+              # `sig { returns(T) }` above `attr_reader :name` / `attr_accessor` / `attr_writer` types
+              # the generated accessor(s). This is a first-class Sorbet idiom — not a dangling sig — so
+              # record the accessor signature(s) instead of warning.
               record_attr_with_sig(child, pending_sig, state, lexical_path, in_singleton_class)
               pending_sig = nil
             elsif pending_sig && (inner_def = visibility_wrapped_def(child))
-              # `sig { ... }` above `private def foo` /
-              # `private_class_method def self.foo` / `module_function
-              # def bar` — a visibility macro wrapping the very def the
-              # sig types. Record the inner def, not a dangling sig.
+              # `sig { ... }` above `private def foo` / `private_class_method def self.foo` /
+              # `module_function def bar` — a visibility macro wrapping the very def the sig types.
+              # Record the inner def, not a dangling sig.
               record_def_with_sig(inner_def, pending_sig, state, lexical_path, in_singleton_class)
               pending_sig = nil
             elsif sig_call?(child)
@@ -129,10 +113,8 @@ module Rigor
                 state.record_error(:dangling_sig, pending_sig)
                 pending_sig = nil
               end
-              # ADR-11 slice 8 — record `include` / `extend`
-              # declarations alongside the regular walk so the
-              # plugin's chain lookup can lift sigs declared
-              # on a mixed-in module to the host class.
+              # ADR-11 slice 8 — record `include` / `extend` declarations alongside the regular walk so
+              # the plugin's chain lookup can lift sigs declared on a mixed-in module to the host class.
               record_mixin_call(child, state, lexical_path) if mixin_call?(child) && !in_singleton_class
               walk_node(child, state, lexical_path: lexical_path, in_singleton_class: in_singleton_class)
             end
@@ -141,12 +123,9 @@ module Rigor
           state.record_error(:dangling_sig, pending_sig) if pending_sig
         end
 
-        # `include Foo` / `extend Foo` / `include Foo, Bar` —
-        # the `include` and `extend` mixin macros that Tapioca-
-        # generated DSL RBIs depend on. Recognised when the
-        # call has no explicit receiver (top-level inside a
-        # class body) and every argument is a constant
-        # reference.
+        # `include Foo` / `extend Foo` / `include Foo, Bar` — the `include` and `extend` mixin macros that
+        # Tapioca-generated DSL RBIs depend on. Recognised when the call has no explicit receiver
+        # (top-level inside a class body) and every argument is a constant reference.
         def mixin_call?(node)
           return false unless node.is_a?(Prism::CallNode)
           return false unless %i[include extend].include?(node.name)
@@ -191,12 +170,10 @@ module Rigor
           private_class_method public_class_method module_function
         ].freeze
 
-        # `private def foo` / `private_class_method def self.bar` /
-        # `module_function def baz` — a receiverless visibility macro
-        # whose single argument is the `def` it wraps. Returns the
-        # inner `Prism::DefNode` (so a preceding sig types it), or nil.
-        # The def's own receiver still drives instance-vs-singleton, so
-        # `private_class_method def self.bar` records as singleton.
+        # `private def foo` / `private_class_method def self.bar` / `module_function def baz` — a
+        # receiverless visibility macro whose single argument is the `def` it wraps. Returns the inner
+        # `Prism::DefNode` (so a preceding sig types it), or nil. The def's own receiver still drives
+        # instance-vs-singleton, so `private_class_method def self.bar` records as singleton.
         def visibility_wrapped_def(node)
           return nil unless node.is_a?(Prism::CallNode) && node.receiver.nil?
           return nil unless VISIBILITY_MACROS.include?(node.name)
@@ -209,9 +186,8 @@ module Rigor
 
         ATTR_MACROS = %i[attr_reader attr_writer attr_accessor].freeze
 
-        # `attr_reader :a, :b` / `attr_writer` / `attr_accessor` —
-        # a receiverless attribute macro whose arguments are all
-        # symbol literals (the only shape a preceding `sig` types).
+        # `attr_reader :a, :b` / `attr_writer` / `attr_accessor` — a receiverless attribute macro whose
+        # arguments are all symbol literals (the only shape a preceding `sig` types).
         def attr_macro_call?(node)
           return false unless node.is_a?(Prism::CallNode) && node.receiver.nil?
           return false unless ATTR_MACROS.include?(node.name)
@@ -220,11 +196,9 @@ module Rigor
           !args.nil? && !args.empty? && args.all?(Prism::SymbolNode)
         end
 
-        # Records the method signature(s) a `sig` contributes to the
-        # accessor(s) it precedes: the reader `name` and/or the
-        # writer `name=`, each carrying the sig's `returns(...)`
-        # type. `attr_reader` emits the reader, `attr_writer` the
-        # writer, `attr_accessor` both — for every symbol argument.
+        # Records the method signature(s) a `sig` contributes to the accessor(s) it precedes: the reader
+        # `name` and/or the writer `name=`, each carrying the sig's `returns(...)` type. `attr_reader`
+        # emits the reader, `attr_writer` the writer, `attr_accessor` both — for every symbol argument.
         def record_attr_with_sig(attr_node, sig_call, state, lexical_path, in_singleton_class)
           parsed = SigParser.parse(sig_call)
           if parsed.is_a?(SigParser::ParseError)
@@ -273,10 +247,8 @@ module Rigor
           in_singleton_class || def_node.receiver.is_a?(Prism::SelfNode)
         end
 
-        # Resolves a constant-path node (`Foo::Bar`,
-        # `::Foo::Bar`) to its dot-separated name. Returns nil
-        # for the rare dynamic-prefix shape so the walker
-        # doesn't guess a qualified name in that case.
+        # Resolves a constant-path node (`Foo::Bar`, `::Foo::Bar`) to its dot-separated name. Returns nil
+        # for the rare dynamic-prefix shape so the walker doesn't guess a qualified name in that case.
         def qualified_name_for(node)
           case node
           when Prism::ConstantReadNode then node.name.to_s

data/plugins/rigor-sorbet/lib/rigor/plugin/sorbet/method_signature.rb

@@ -3,19 +3,15 @@
 module Rigor
   module Plugin
     class Sorbet < Rigor::Plugin::Base
-      # Frozen description of one Sorbet `sig` block as parsed by
-      # {SigParser}. Holds the return type, parameter shape, and
-      # modifier list. Call-site argument-type checking and
-      # override-compatibility validation are deferred; only the
-      # return-type contribution is active.
+      # Frozen description of one Sorbet `sig` block as parsed by {SigParser}. Holds the return type,
+      # parameter shape, and modifier list. Call-site argument-type checking and override-compatibility
+      # validation are deferred; only the return-type contribution is active.
       #
-      # `kind` distinguishes `def foo` (`:instance`) from
-      # `def self.foo` / `class << self; def foo; end`
+      # `kind` distinguishes `def foo` (`:instance`) from `def self.foo` / `class << self; def foo; end`
       # (`:singleton`).
       #
-      # `modifiers` records the `sig`-level flags observed:
-      # `:abstract`, `:override`, `:overridable`, `:final`.
-      # Currently stored but not acted on.
+      # `modifiers` records the `sig`-level flags observed: `:abstract`, `:override`, `:overridable`,
+      # `:final`. Currently stored but not acted on.
       MethodSignature = Data.define(
         :class_name, :method_name, :kind, :params, :return_type, :modifiers
       )

data/plugins/rigor-sorbet/lib/rigor/plugin/sorbet/sig_parser.rb

@@ -7,10 +7,8 @@ require_relative "type_translator"
 module Rigor
   module Plugin
     class Sorbet < Rigor::Plugin::Base
-      # Mini-interpreter for the chained-call expression that
-      # makes up a Sorbet `sig` block. The block body is always
-      # a single expression — Sorbet's docs (`sigs.md`) show the
-      # full grammar:
+      # Mini-interpreter for the chained-call expression that makes up a Sorbet `sig` block. The block
+      # body is always a single expression — Sorbet's docs (`sigs.md`) show the full grammar:
       #
       #   sig { params(x: T, y: T).returns(U) }
       #   sig { void }
@@ -22,26 +20,20 @@ module Rigor
       #     .returns(...)
       #   end
       #
-      # The parser walks the chain right-to-left, gathering
-      # whatever it recognises (`params` / `returns` / `void` /
-      # `abstract` / `override` / `overridable` / `final` /
-      # `type_parameters` / `checked` / `on_failure`) into a
-      # frozen result hash stored in {MethodSignature}. Modifiers
-      # and `type_parameters` are recorded but not yet acted on.
+      # The parser walks the chain right-to-left, gathering whatever it recognises (`params` / `returns` /
+      # `void` / `abstract` / `override` / `overridable` / `final` / `type_parameters` / `checked` /
+      # `on_failure`) into a frozen result hash stored in {MethodSignature}. Modifiers and
+      # `type_parameters` are recorded but not yet acted on.
       #
-      # The parser is intentionally tolerant — unknown chain
-      # nodes degrade to "the rest of the chain is opaque" rather
-      # than raising. The plugin emits a diagnostic
-      # (`plugin.sorbet.parse-error`) only when the entire chain
-      # fails to yield either a `returns` or a `void`.
+      # The parser is intentionally tolerant — unknown chain nodes degrade to "the rest of the chain is
+      # opaque" rather than raising. The plugin emits a diagnostic (`plugin.sorbet.parse-error`) only when
+      # the entire chain fails to yield either a `returns` or a `void`.
       module SigParser
-        # Modifiers we recognise at any position in the chain.
-        # Stored in `:modifiers` on the parse result.
+        # Modifiers we recognise at any position in the chain. Stored in `:modifiers` on the parse result.
         RECOGNISED_MODIFIERS = %i[abstract override overridable final].freeze
 
-        # Sorbet runtime-only chain steps. Recognised so the
-        # parser doesn't degrade the whole sig when it sees them,
-        # but their payload is intentionally discarded.
+        # Sorbet runtime-only chain steps. Recognised so the parser doesn't degrade the whole sig when it
+        # sees them, but their payload is intentionally discarded.
         RUNTIME_ONLY_STEPS = %i[checked on_failure].freeze
 
         ParseResult = Data.define(:return_type, :params, :modifiers, :void) do
@@ -52,8 +44,7 @@ module Rigor
 
         module_function
 
-        # @param sig_call [Prism::CallNode] the `sig { ... }` /
-        #   `sig do ... end` call.
+        # @param sig_call [Prism::CallNode] the `sig { ... }` / `sig do ... end` call.
         # @return [ParseResult, ParseError]
         def parse(sig_call)
           return ParseError.new(reason: :no_block, node: sig_call) if sig_call.block.nil?
@@ -72,11 +63,9 @@ module Rigor
           end
         end
 
-        # Walks the chain bottom-up. Each chain link is a
-        # `Prism::CallNode` whose receiver is the next link;
-        # `params` / `returns` / `void` may appear at any
-        # position, so we accumulate their effect into a
-        # mutable hash and freeze on the way out.
+        # Walks the chain bottom-up. Each chain link is a `Prism::CallNode` whose receiver is the next
+        # link; `params` / `returns` / `void` may appear at any position, so we accumulate their effect
+        # into a mutable hash and freeze on the way out.
         def fold_chain(node, sig_call)
           accumulator = { return_type: nil, params: {}, modifiers: [], void: false, terminus_kind: nil }
           current = node
@@ -92,15 +81,13 @@ module Rigor
             when :params
               accumulator[:params].merge!(parse_params(current))
             when :type_parameters
-              # Recognised to suppress the degraded path;
-              # payload intentionally discarded (deferred).
+              # Recognised to suppress the degraded path; payload intentionally discarded (deferred).
             when *RECOGNISED_MODIFIERS
               accumulator[:modifiers] << current.name
             when *RUNTIME_ONLY_STEPS
               # Discard payload; runtime-only.
             else
-              # Unknown chain link — stop folding and treat
-              # whatever we accumulated so far as the result.
+              # Unknown chain link — stop folding and treat whatever we accumulated so far as the result.
               break
             end
             current = current.receiver
@@ -116,20 +103,16 @@ module Rigor
           )
         end
 
-        # `void` and `returns(T)` share the slot; if both are
-        # present (unusual but parseable), `returns(T)` wins
-        # because Sorbet's static side treats `void` as
-        # "discard the value" — when the user explicitly named
-        # `T`, that's the more informative shape.
+        # `void` and `returns(T)` share the slot; if both are present (unusual but parseable), `returns(T)`
+        # wins because Sorbet's static side treats `void` as "discard the value" — when the user
+        # explicitly named `T`, that's the more informative shape.
         def resolve_return_type(accumulator)
           accumulator[:return_type] || Rigor::Type::Combinator.untyped
         end
 
-        # `params(x: Integer, y: T.nilable(String))` — extracts
-        # the `KeywordHashNode` AST and translates each value.
-        # The result is `{ Symbol => Rigor::Type }`. Splat /
-        # double-splat / unrecognised keys degrade silently
-        # (slice 1 behaviour).
+        # `params(x: Integer, y: T.nilable(String))` — extracts the `KeywordHashNode` AST and translates
+        # each value. The result is `{ Symbol => Rigor::Type }`. Splat / double-splat / unrecognised keys
+        # degrade silently (slice 1 behaviour).
         def parse_params(call_node)
           args = call_node.arguments&.arguments || []
           first = args.first

data/plugins/rigor-sorbet/lib/rigor/plugin/sorbet/sigil_detector.rb

@@ -3,49 +3,36 @@
 module Rigor
   module Plugin
     class Sorbet < Rigor::Plugin::Base
-      # Reads Sorbet's `# typed: <level>` magic comment from the
-      # head of a file. Sorbet's own contract (per
-      # [`static.md`](https://sorbet.org/docs/static)) requires
-      # the sigil to appear at the top of the file before any
-      # Ruby code. We're slightly more lenient here — the sigil
-      # may appear after a few comment / blank lines (matching
-      # what Sorbet itself accepts in practice) but we stop
-      # scanning once we hit a non-comment, non-blank line.
+      # Reads Sorbet's `# typed: <level>` magic comment from the head of a file. Sorbet's own contract (per
+      # [`static.md`](https://sorbet.org/docs/static)) requires the sigil to appear at the top of the file
+      # before any Ruby code. We're slightly more lenient here — the sigil may appear after a few comment
+      # / blank lines (matching what Sorbet itself accepts in practice) but we stop scanning once we hit a
+      # non-comment, non-blank line.
       #
-      # Recognised levels: `:ignore` / `:false` / `:true` /
-      # `:strict` / `:strong`. Falls back to `:false` (Sorbet's
-      # default) when no sigil is present, matching how Sorbet
-      # treats sigil-less files.
+      # Recognised levels: `:ignore` / `:false` / `:true` / `:strict` / `:strong`. Falls back to `:false`
+      # (Sorbet's default) when no sigil is present, matching how Sorbet treats sigil-less files.
       #
-      # ADR-11 slice 5 uses this at catalog-harvest time:
-      # `# typed: ignore` files are skipped entirely; other
-      # levels gate both sig contributions (`:true`/`:strict`/
-      # `:strong` only) and per-call assertion recognition
-      # (`T.let` / `T.cast` / `T.must` / etc.) via
-      # `Sorbet#assertion_enforced_here?`.
+      # ADR-11 slice 5 uses this at catalog-harvest time: `# typed: ignore` files are skipped entirely;
+      # other levels gate both sig contributions (`:true`/`:strict`/`:strong` only) and per-call assertion
+      # recognition (`T.let` / `T.cast` / `T.must` / etc.) via `Sorbet#assertion_enforced_here?`.
       module SigilDetector
-        # Sorbet's strictness-level names. Stored as symbols to
-        # match the analyzer's existing convention for level
-        # identifiers; the `:true` / `:false` symbols here are
-        # level *names* (the textual sigil values) and are
-        # intentionally distinct from the `true` / `false`
-        # boolean literals.
+        # Sorbet's strictness-level names. Stored as symbols to match the analyzer's existing convention
+        # for level identifiers; the `:true` / `:false` symbols here are level *names* (the textual sigil
+        # values) and are intentionally distinct from the `true` / `false` boolean literals.
         VALID_LEVELS = %i[ignore false true strict strong].freeze
         DEFAULT_LEVEL = :false # rubocop:disable Lint/BooleanSymbol
         SIGIL_REGEX = /\A\s*#\s*typed\s*:\s*(ignore|false|true|strict|strong)\s*\z/
 
-        # Cap on how many lines we scan before giving up. Sorbet
-        # doesn't formally specify a cap, but the sigil
-        # convention is "near the top of the file"; 10 lines is
-        # generous and bounds the parse cost on enormous files.
+        # Cap on how many lines we scan before giving up. Sorbet doesn't formally specify a cap, but the
+        # sigil convention is "near the top of the file"; 10 lines is generous and bounds the parse cost
+        # on enormous files.
         MAX_HEAD_LINES = 10
 
         module_function
 
         # @param contents [String] raw file contents.
-        # @return [Symbol] one of {VALID_LEVELS}; defaults to
-        #   {DEFAULT_LEVEL} for sigil-less or malformed-sigil
-        #   files.
+        # @return [Symbol] one of {VALID_LEVELS}; defaults to {DEFAULT_LEVEL} for sigil-less or
+        #   malformed-sigil files.
         def detect(contents)
           return DEFAULT_LEVEL if contents.nil? || contents.empty?
 
@@ -57,9 +44,8 @@ module Rigor
 
             match = SIGIL_REGEX.match(stripped)
             return match[1].to_sym if match
-            # First non-blank line that isn't a sigil-shaped
-            # comment ends the scan: Sorbet's parser stops at
-            # the first directive-or-code line.
+            # First non-blank line that isn't a sigil-shaped comment ends the scan: Sorbet's parser stops
+            # at the first directive-or-code line.
             break unless stripped.start_with?("#")
           end
 
@@ -67,27 +53,20 @@ module Rigor
         end
 
         # @param level [Symbol]
-        # @return [Boolean] true when `# typed: ignore`. The
-        #   harvest pipeline calls this to short-circuit
+        # @return [Boolean] true when `# typed: ignore`. The harvest pipeline calls this to short-circuit
         #   walking the file's AST.
         def ignored?(level)
           level == :ignore
         end
 
-        # @return [Boolean] true when `level` is at or above the
-        #   `# typed: true` mark. Used by the
-        #   `enforce_sigil` config gate (default `true`): with
-        #   the gate on, only files marked `:true` / `:strict` /
-        #   `:strong` contribute their sigs to the catalog. The
-        #   `:false` (and sigil-less) levels still get walked
-        #   (so RBI files outside the project can be loaded
-        #   regardless), but their sig-derived narrowing is
-        #   suppressed — matching how Sorbet itself only
-        #   enforces type errors at `# typed: true`+. Assertion
-        #   recognisers (`T.let` / `T.cast` / `T.must` /
-        #   `T.bind` / `T.assert_type!`) are NOT gated by this:
-        #   the user wrote them deliberately, so the
-        #   recogniser still fires regardless of sigil.
+        # @return [Boolean] true when `level` is at or above the `# typed: true` mark. Used by the
+        #   `enforce_sigil` config gate (default `true`): with the gate on, only files marked `:true` /
+        #   `:strict` / `:strong` contribute their sigs to the catalog. The `:false` (and sigil-less)
+        #   levels still get walked (so RBI files outside the project can be loaded regardless), but their
+        #   sig-derived narrowing is suppressed — matching how Sorbet itself only enforces type errors at
+        #   `# typed: true`+. Assertion recognisers (`T.let` / `T.cast` / `T.must` / `T.bind` /
+        #   `T.assert_type!`) are NOT gated by this: the user wrote them deliberately, so the recogniser
+        #   still fires regardless of sigil.
         def enforced?(level)
           %i[true strict strong].include?(level)
         end