rigortype 0.1.10 → 0.1.12

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

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "prism"
+
+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:
+      #
+      #   sig { params(x: T, y: T).returns(U) }
+      #   sig { void }
+      #   sig { abstract.params(...).returns(...) }
+      #   sig { override.params(...).void }
+      #   sig { type_parameters(:U).params(...).returns(...) }
+      #   sig do
+      #     params(...)
+      #     .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. Slice 1 wires the parsed structure
+      # into {MethodSignature}; later slices will start *acting*
+      # on the modifiers and `type_parameters`.
+      #
+      # 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.
+        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.
+        RUNTIME_ONLY_STEPS = %i[checked on_failure].freeze
+
+        ParseResult = Data.define(:return_type, :params, :modifiers, :void) do
+          def void? = void
+        end
+
+        ParseError = Data.define(:reason, :node)
+
+        module_function
+
+        # @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?
+
+          body = sig_call.block.body
+          chain_root = first_statement(body)
+          return ParseError.new(reason: :empty_block, node: sig_call) if chain_root.nil?
+
+          fold_chain(chain_root, sig_call)
+        end
+
+        def first_statement(body)
+          case body
+          when Prism::StatementsNode then body.body.first
+          else body
+          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.
+        def fold_chain(node, sig_call)
+          accumulator = { return_type: nil, params: {}, modifiers: [], void: false, terminus_kind: nil }
+          current = node
+
+          while current.is_a?(Prism::CallNode)
+            case current.name
+            when :returns
+              accumulator[:return_type] = TypeTranslator.translate(first_argument(current))
+              accumulator[:terminus_kind] ||= :returns
+            when :void
+              accumulator[:void] = true
+              accumulator[:terminus_kind] ||= :void
+            when :params
+              accumulator[:params].merge!(parse_params(current))
+            when :type_parameters
+              # Slice 1: recognise to suppress the degraded
+              # path; widen translation in slice 3.
+            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.
+              break
+            end
+            current = current.receiver
+          end
+
+          return ParseError.new(reason: :missing_returns_or_void, node: sig_call) if accumulator[:terminus_kind].nil?
+
+          ParseResult.new(
+            return_type: resolve_return_type(accumulator),
+            params: accumulator[:params].freeze,
+            modifiers: accumulator[:modifiers].uniq.freeze,
+            void: accumulator[:void]
+          )
+        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.
+        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).
+        def parse_params(call_node)
+          args = call_node.arguments&.arguments || []
+          first = args.first
+          return {} unless first.is_a?(Prism::KeywordHashNode)
+
+          first.elements.each_with_object({}) do |element, into|
+            next unless element.is_a?(Prism::AssocNode)
+            next unless element.key.is_a?(Prism::SymbolNode)
+
+            key = element.key.unescaped.to_sym
+            into[key] = TypeTranslator.translate(element.value)
+          end
+        end
+
+        def first_argument(call_node)
+          call_node.arguments&.arguments&.first
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+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.
+      #
+      # 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.
+      #
+      # Slice 5 of ADR-11 uses this purely at catalog-harvest
+      # time: `# typed: ignore` files are skipped entirely (the
+      # plugin records no sigs from them). The other levels are
+      # detected for forward compatibility but treated
+      # identically — per-call-site sigil honouring (e.g. only
+      # firing `T.let` recognition in `# typed: true`+ files)
+      # requires threading the file path through
+      # `flow_contribution_for`, which lives behind a future
+      # plugin-contract widening slice.
+      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.
+        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.
+        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.
+        def detect(contents)
+          return DEFAULT_LEVEL if contents.nil? || contents.empty?
+
+          contents.each_line.with_index do |line, index|
+            break if index >= MAX_HEAD_LINES
+
+            stripped = line.strip
+            next if stripped.empty?
+
+            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.
+            break unless stripped.start_with?("#")
+          end
+
+          DEFAULT_LEVEL
+        end
+
+        # @param level [Symbol]
+        # @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.
+        def enforced?(level)
+          %i[true strict strong].include?(level)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,323 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Plugin
+    class Sorbet < Rigor::Plugin::Base
+      # Maps Sorbet's type expressions (the AST inside a `sig`
+      # block's `params(...)` and `returns(...)` clauses) into
+      # Rigor's internal type carriers.
+      #
+      # Slice 1 covered the minimum vocabulary that lets a
+      # typical `sig { params(x: Integer).returns(String) }`
+      # round-trip; slice 3 widens it to cover the dense middle
+      # of Sorbet's surface — generic class applications
+      # (`T::Array[E]`, `T::Hash[K, V]`, etc.), class-object
+      # types (`T.class_of(C)`, `T::Class[T]`), tuples, and
+      # shapes:
+      #
+      # | Sorbet form              | Rigor carrier                            |
+      # | ------------------------ | ---------------------------------------- |
+      # | `Integer` etc.           | `Nominal["Integer"]`                     |
+      # | `::Foo::Bar`             | `Nominal["Foo::Bar"]`                    |
+      # | `T.untyped`              | `Dynamic[top]`                           |
+      # | `T.anything`             | `top`                                    |
+      # | `T.noreturn`             | `bot`                                    |
+      # | `T.nilable(X)`           | `Union[X, Constant[nil]]`                |
+      # | `T.any(A, B, ...)`       | `Union[A, B, ...]`                       |
+      # | `T.all(A, B, ...)`       | `Intersection[A, B, ...]`                |
+      # | `T::Boolean`             | `Union[Constant[true], Constant[false]]` |
+      # | `T::Array[E]`            | `Nominal["Array", [E]]`                  |
+      # | `T::Hash[K, V]`          | `Nominal["Hash", [K, V]]`                |
+      # | `T::Set[E]`              | `Nominal["Set", [E]]`                    |
+      # | `T::Range[E]`            | `Nominal["Range", [E]]`                  |
+      # | `T::Enumerable[E]`       | `Nominal["Enumerable", [E]]`             |
+      # | `T::Enumerator[E]`       | `Nominal["Enumerator", [E]]`             |
+      # | `T::Class[T]`            | `Singleton[T-class-name]` (lossy)        |
+      # | `T.class_of(C)`          | `Singleton[C]`                           |
+      # | `[A, B]` (tuple in sig)  | `Tuple[A, B]`                            |
+      # | `{a: A, b: B}` (shape)   | `HashShape{a: A, b: B}` (closed)         |
+      #
+      # Anything else (`T.proc`, `T.attached_class`,
+      # `T.self_type`, `T.type_parameter`, `T::Struct` / `T::Enum`
+      # subclasses, …) degrades to `Dynamic[top]`. The degraded
+      # path stays silent for now per ADR-11's slice plan; a
+      # later slice surfaces the gap as a `dynamic.sorbet.unsupported`
+      # diagnostic.
+      module TypeTranslator
+        BOOLEAN_NAME = "Boolean"
+
+        # `T::*` constants whose `[]` application maps directly
+        # onto a Rigor `Nominal` with the matching standard-
+        # library class name. Ordering matches the table above
+        # for ease of reading.
+        T_GENERIC_CLASSES = {
+          "Array" => "Array",
+          "Hash" => "Hash",
+          "Set" => "Set",
+          "Range" => "Range",
+          "Enumerable" => "Enumerable",
+          "Enumerator" => "Enumerator",
+          "Enumerator::Lazy" => "Enumerator::Lazy",
+          "Enumerator::Chain" => "Enumerator::Chain"
+        }.freeze
+
+        module_function
+
+        # @param node [Prism::Node, nil]
+        # @return [Rigor::Type] never `nil`; unrecognised forms
+        #   degrade to `Type::Combinator.untyped`.
+        def translate(node)
+          return Rigor::Type::Combinator.untyped if node.nil?
+
+          case node
+          when Prism::ConstantReadNode then translate_constant_read(node)
+          when Prism::ConstantPathNode then translate_constant_path(node)
+          when Prism::CallNode then translate_call(node)
+          when Prism::ArrayNode then translate_tuple(node)
+          when Prism::HashNode then translate_shape(node)
+          else degraded
+          end
+        end
+
+        # @param node [Prism::ConstantReadNode]
+        def translate_constant_read(node)
+          name = node.name.to_s
+          return Rigor::Type::Combinator.untyped if name.empty?
+
+          Rigor::Type::Combinator.nominal_of(name)
+        end
+
+        # @param node [Prism::ConstantPathNode]
+        def translate_constant_path(node)
+          name = constant_path_name(node)
+          return degraded if name.nil?
+
+          # Sorbet's `T::Boolean` is a special alias rather than a
+          # nominal class, expressed as the Boolean type alias.
+          return boolean_type if name == "T::Boolean"
+
+          Rigor::Type::Combinator.nominal_of(name)
+        end
+
+        # `Prism::CallNode` covers two distinct surfaces:
+        #
+        # 1. `T.something(...)` — `untyped` / `anything` /
+        #    `noreturn` / `nilable` / `any` / `all` / `class_of`.
+        # 2. `T::SomeClass[...]` — the `[]` method on a generic
+        #    `T::*` constant (slice 3 widening). Maps to
+        #    `Nominal[name, type_args]`.
+        def translate_call(node)
+          return translate_t_method(node) if sorbet_t_namespaced?(node.receiver)
+          return translate_t_subscript(node) if sorbet_subscript?(node)
+
+          degraded
+        end
+
+        # Handles the `T.foo(...)` family.
+        def translate_t_method(node)
+          case node.name
+          when :untyped then Rigor::Type::Combinator.untyped
+          when :anything then Rigor::Type::Combinator.top
+          when :noreturn then Rigor::Type::Combinator.bot
+          when :nilable then translate_nilable(node)
+          when :any then translate_any(node)
+          when :all then translate_all(node)
+          when :class_of then translate_class_of(node)
+          else degraded
+          end
+        end
+
+        def translate_nilable(node)
+          inner = first_argument(node)
+          return degraded if inner.nil?
+
+          Rigor::Type::Combinator.union(
+            translate(inner), Rigor::Type::Combinator.constant_of(nil)
+          )
+        end
+
+        def translate_any(node)
+          args = call_arguments(node)
+          return degraded if args.empty?
+
+          Rigor::Type::Combinator.union(*args.map { |arg| translate(arg) })
+        end
+
+        def translate_all(node)
+          args = call_arguments(node)
+          return degraded if args.empty?
+
+          Rigor::Type::Combinator.intersection(*args.map { |arg| translate(arg) })
+        end
+
+        # `T.class_of(C)` — singleton-class type for a single
+        # constant. Sorbet docs note `T.class_of(MyInterface)`
+        # rarely means what users expect (it's the singleton
+        # class of `MyInterface`, not "any class implementing
+        # the interface"); we honour the literal meaning here
+        # and translate to `Singleton[C]`.
+        def translate_class_of(node)
+          target = first_argument(node)
+          name = constant_path_name(target)
+          return degraded if name.nil?
+
+          Rigor::Type::Combinator.singleton_of(name)
+        end
+
+        # Handles `T::Array[E]`, `T::Hash[K, V]`, etc. The Prism
+        # AST for `T::Array[Integer]` is a `CallNode` whose
+        # receiver is the `T::Array` `ConstantPathNode` and
+        # whose `name` is `:[]`. `T::Class[T]` lands here too;
+        # we collapse it to `Singleton[name]` (a deliberate
+        # narrowing — `T::Class` is structurally generic in
+        # Sorbet, but Rigor's `Singleton` carries class identity
+        # only).
+        def translate_t_subscript(node)
+          base_name = sorbet_subscript_base(node.receiver)
+          args = call_arguments(node).map { |arg| translate(arg) }
+          mapped = T_GENERIC_CLASSES[base_name]
+
+          if mapped
+            Rigor::Type::Combinator.nominal_of(mapped, type_args: args)
+          elsif base_name == "Class"
+            translate_t_class_subscript(args)
+          else
+            degraded
+          end
+        end
+
+        # `T::Class[T]` — Sorbet's "any class object whose
+        # instances are at least `T`". Rigor has no exact
+        # analogue (Singleton names a specific class); the
+        # closest faithful translation is `Singleton[name]`
+        # when `T` is a constant, or `Singleton[Object]` for
+        # broader applications. Lossy translation; emitted as
+        # `dynamic.sorbet.degraded` once slice 3's diagnostic
+        # surface lands.
+        def translate_t_class_subscript(args)
+          inner = args.first
+          return Rigor::Type::Combinator.singleton_of("Class") if inner.nil?
+
+          case inner
+          when Rigor::Type::Nominal then Rigor::Type::Combinator.singleton_of(inner.class_name)
+          else Rigor::Type::Combinator.singleton_of("Class")
+          end
+        end
+
+        # Tuple types in `sig` position appear as bare array
+        # literals: `sig { returns([String, Integer]) }`. Each
+        # element is itself a type expression we translate
+        # recursively.
+        def translate_tuple(node)
+          elements = node.elements.map { |element| translate(element) }
+          Rigor::Type::Combinator.tuple_of(*elements)
+        end
+
+        # Shape types in `sig` position appear as bare hash
+        # literals with symbol keys:
+        # `sig { returns({a: Integer, b: String}) }`. Each
+        # value is a type expression; the resulting `HashShape`
+        # is closed (no extra keys allowed).
+        def translate_shape(node)
+          pairs = []
+          node.elements.each do |element|
+            next unless element.is_a?(Prism::AssocNode)
+            next unless element.key.is_a?(Prism::SymbolNode)
+
+            pairs << [element.key.unescaped.to_sym, translate(element.value)]
+          end
+          Rigor::Type::Combinator.hash_shape_of(pairs)
+        end
+
+        # Renders a constant-path node (`Foo::Bar`, `::Foo::Bar`)
+        # as a `::`-joined String. Mirrors the helper used by
+        # rigor-activerecord's ModelDiscoverer for parity.
+        def constant_path_name(node)
+          return nil if node.nil?
+
+          case node
+          when Prism::ConstantReadNode then node.name.to_s
+          when Prism::ConstantPathNode then constant_path_name_for_path(node)
+          end
+        end
+
+        def constant_path_name_for_path(node)
+          parts = []
+          current = node
+          while current.is_a?(Prism::ConstantPathNode)
+            parts.unshift(current.name.to_s)
+            current = current.parent
+          end
+          case current
+          when nil
+            "::#{parts.join('::')}"
+          when Prism::ConstantReadNode
+            "#{current.name}::#{parts.join('::')}"
+          end
+        end
+
+        def sorbet_t_namespaced?(receiver)
+          receiver.is_a?(Prism::ConstantReadNode) && receiver.name == :T
+        end
+
+        # `T::Array[Integer]` parses as `CallNode(receiver: T::Array, name: :[])`.
+        # The receiver is a `ConstantPathNode` rooted at the
+        # `T` constant.
+        def sorbet_subscript?(node)
+          node.name == :[] && sorbet_t_qualified?(node.receiver)
+        end
+
+        def sorbet_t_qualified?(node)
+          return false unless node.is_a?(Prism::ConstantPathNode)
+
+          # Walk to the root; require that it terminates at a
+          # `T` ConstantReadNode (not an absolute `::T`).
+          current = node
+          current = current.parent while current.is_a?(Prism::ConstantPathNode)
+          current.is_a?(Prism::ConstantReadNode) && current.name == :T
+        end
+
+        # Strips the leading `T::` from a `T::Foo::Bar`
+        # constant-path node, returning `"Foo::Bar"`. Returns
+        # nil for shapes that aren't `T`-rooted.
+        def sorbet_subscript_base(node)
+          return nil unless sorbet_t_qualified?(node)
+
+          parts = []
+          current = node
+          while current.is_a?(Prism::ConstantPathNode)
+            parts.unshift(current.name.to_s)
+            current = current.parent
+          end
+          parts.join("::")
+        end
+
+        def first_argument(node)
+          node.arguments&.arguments&.first
+        end
+
+        def call_arguments(node)
+          node.arguments&.arguments || []
+        end
+
+        def degraded
+          Rigor::Type::Combinator.untyped
+        end
+
+        # `T::Boolean` corresponds to the union of the singleton
+        # `true` / `false` values, matching how RBS's `bool`
+        # would translate. Built from `Constant[true]` /
+        # `Constant[false]` so the analyzer's flow-sensitive
+        # narrowing recognises the discriminating shape.
+        def boolean_type
+          Rigor::Type::Combinator.union(
+            Rigor::Type::Combinator.constant_of(true),
+            Rigor::Type::Combinator.constant_of(false)
+          )
+        end
+      end
+    end
+  end
+end