rigortype 0.1.9 → 0.1.11

data/plugins/rigor-rbs-inline/lib/rigor/plugin/rbs_inline.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "rigor/plugin"
+
+# ADR-32 — bundled `rigor-rbs-inline` plugin.
+#
+# Synthesises RBS from project Ruby files that carry
+# rbs-inline-shaped comments (`#: () -> T`, `# @rbs name: T`,
+# `# @rbs return: T`, attribute `#:`, …) and contributes the
+# result to the analysis environment through the
+# `source_rbs_synthesizer:` manifest hook.
+#
+# By default (WD2) only files starting with the upstream
+# `# rbs_inline: enabled` magic comment are processed; a host
+# context can flip this off by setting `require_magic_comment:
+# false` in the plugin config (WD10).
+module Rigor
+  module Plugin
+    # The plugin gem requires `rbs/inline` at load time; without
+    # the upstream library the synthesizer can't do its job.
+    # Wrapped in a begin/rescue so the analyzer still loads if
+    # the user activated this plugin without installing the
+    # `rbs-inline` gem (loud-on-activation, fail-soft to no
+    # contribution).
+    begin
+      require "prism"
+      require "rbs/inline"
+      RBS_INLINE_AVAILABLE = true
+    rescue ::LoadError => e
+      warn(
+        "rigor-rbs-inline: failed to load `rbs/inline` " \
+        "(#{e.message}). The plugin will load but contribute no " \
+        "synthesised RBS. Install the `rbs-inline` gem to enable " \
+        "inline-RBS comment ingestion."
+      )
+      RBS_INLINE_AVAILABLE = false
+    end
+
+    class RbsInline < Rigor::Plugin::Base
+      # Synthesizer callable invoked once per project Ruby
+      # source file by `Environment.for_project` at env-build
+      # time. Returns the synthesised RBS source as a String,
+      # or `nil` when the file contributes nothing (no magic
+      # comment in the default mode, empty annotation set,
+      # parse error per WD6).
+      class Synthesizer
+        # @param require_magic_comment [Boolean] when `true`
+        #   (the default, WD2), only files with
+        #   `# rbs_inline: enabled` at the top are processed.
+        #   When `false` (WD10 host-context override), every
+        #   file is treated as if it carried the magic comment.
+        def initialize(require_magic_comment:)
+          @require_magic_comment = require_magic_comment
+          freeze
+        end
+
+        # Return value contract:
+        # - `String` (non-empty)         → successful synthesis
+        # - `nil`                        → no contribution
+        # - `[:error, message_string]`   → parse failed, surface
+        #   info diagnostic per ADR-32 WD6
+        def call(source_file_path)
+          return nil unless RBS_INLINE_AVAILABLE
+          return nil unless File.file?(source_file_path)
+
+          source = File.read(source_file_path)
+          return nil if source.empty?
+
+          result = ::Prism.parse(source)
+          # `opt_in: true` is rbs-inline's "require the magic
+          # comment" mode (per upstream parser.rb:62). The
+          # plugin's `require_magic_comment:` config knob maps
+          # directly onto it.
+          parsed = ::RBS::Inline::Parser.parse(result, opt_in: @require_magic_comment)
+          return nil if parsed.nil?
+
+          uses, decls, rbs_decls = parsed
+          rendered = ::RBS::Inline::Writer.write(uses, decls, rbs_decls)
+          return nil if rendered.nil? || rendered.strip.empty?
+
+          rendered
+        rescue ::StandardError => e
+          # WD6 fail-soft — surface a structured error tuple so
+          # the engine's `Environment.for_project` can emit a
+          # `source-rbs-synthesis-failed` info diagnostic
+          # naming the file + the upstream error message,
+          # without crashing analysis.
+          [:error, "#{e.class}: #{e.message.to_s.lines.first.to_s.strip}"]
+        end
+      end
+
+      manifest(
+        id: "rbs-inline",
+        version: "0.1.0",
+        description: "Ingests rbs-inline-shaped comments " \
+                     "(`# @rbs name: T`, `#: () -> T`, …) as RBS contributions.",
+        config_schema: { "require_magic_comment" => :boolean },
+        source_rbs_synthesizer: nil # set per-instance below
+      )
+
+      # Per-instance synthesizer — built from the manifest's
+      # default + the project's plugin config. The manifest
+      # `source_rbs_synthesizer:` is nil at the class level so
+      # the registry sees the instance's override (returned by
+      # `#manifest`, which `Plugin::Registry#source_rbs_synthesizers`
+      # consults via `plugin.manifest.source_rbs_synthesizer`).
+      #
+      # ADR-32 WD10 — `require_magic_comment` defaults to
+      # `true`. Setting it to `false` in `.rigor.yml` flips the
+      # synthesizer into "process every file" mode.
+      def initialize(services:, config: {})
+        super
+        @require_magic_comment = config.fetch("require_magic_comment", true) ? true : false
+        @synthesizer = Synthesizer.new(require_magic_comment: @require_magic_comment)
+        # Build the per-instance manifest eagerly (before
+        # `freeze`) so the registry's repeated reads return
+        # the same object and we don't need to mutate a
+        # frozen instance later.
+        base = self.class.manifest
+        @manifest_with_synth = build_manifest_with_synthesizer(base)
+        freeze
+      end
+
+      attr_reader :synthesizer
+
+      # Override the manifest-level `source_rbs_synthesizer:`
+      # (which is nil at the class level) with the per-instance
+      # synthesizer built from the merged config. The registry
+      # reads this through `plugin.manifest.source_rbs_synthesizer`.
+      def manifest
+        @manifest_with_synth
+      end
+
+      private
+
+      def build_manifest_with_synthesizer(base)
+        Rigor::Plugin::Manifest.new(
+          id: base.id,
+          version: base.version,
+          description: base.description,
+          protocols: base.protocols,
+          config_schema: base.config_schema,
+          produces: base.produces,
+          consumes: base.consumes,
+          owns_receivers: base.owns_receivers,
+          open_receivers: base.open_receivers,
+          type_node_resolvers: base.type_node_resolvers,
+          block_as_methods: base.block_as_methods,
+          heredoc_templates: base.heredoc_templates,
+          trait_registries: base.trait_registries,
+          external_files: base.external_files,
+          hkt_registrations: base.hkt_registrations,
+          hkt_definitions: base.hkt_definitions,
+          signature_paths: base.signature_paths,
+          protocol_contracts: base.protocol_contracts,
+          source_rbs_synthesizer: @synthesizer
+        )
+      end
+    end
+
+    Rigor::Plugin.register(RbsInline)
+  end
+end

data/plugins/rigor-rbs-inline/lib/rigor-rbs-inline.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# rigor-rbs-inline — ingests rbs-inline-shaped comments
+# (`# @rbs name: T`, `#: () -> T`, `# @rbs return: T`, attribute
+# `#:`, ivars, generics, override, …) as RBS contributions to
+# the analysis environment.
+#
+# Per ADR-32 the plugin gates per file on the upstream
+# `# rbs_inline: enabled` magic comment by default. A host
+# context that owns the entire analysis scope (e.g. the
+# ADR-29 browser playground) can set `require_magic_comment:
+# false` in the plugin config to skip the gate — every file
+# the synthesizer sees is treated as if it carried the magic
+# comment.
+#
+#     # .rigor.yml
+#     plugins:
+#       - id: rigor-rbs-inline
+#         config:
+#           require_magic_comment: false   # default true
+#
+# The plugin depends on the upstream `rbs-inline` gem; Rigor's
+# core `rigortype` gemspec stays zero-dep per ADR-0 / ADR-32 WD1.
+require_relative "rigor/plugin/rbs_inline"

data/plugins/rigor-rspec/lib/rigor/plugin/rspec/analyzer.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "scope_walker"
+
+module Rigor
+  module Plugin
+    class Rspec < Rigor::Plugin::Base
+      # Per-file walker that:
+      #
+      # 1. Collects every RSpec scope (each `RSpec.describe`
+      #    plus its nested `describe` / `context` blocks)
+      #    via {ScopeWalker}.
+      # 2. Reports duplicate `let(:name)` / `subject(:name)`
+      #    declarations within the same scope (the second
+      #    declaration wins at runtime — an easy
+      #    copy-paste bug).
+      # 3. Reports recursive self-references —
+      #    `let(:user) { user.something }` will infinite-loop
+      #    at runtime — an easy oversight.
+      module Analyzer
+        Diagnostic = Struct.new(:path, :line, :column, :severity, :rule, :message, keyword_init: true)
+
+        module_function
+
+        # @param path [String]
+        # @param root [Prism::Node]
+        # @return [Array<Diagnostic>]
+        def diagnose(path:, root:)
+          diagnostics = []
+          ScopeWalker.collect_scopes(root).each do |outer|
+            ScopeWalker.each_scope(outer) do |scope|
+              diagnostics.concat(duplicate_diagnostics(path, scope))
+              diagnostics.concat(self_reference_diagnostics(path, scope))
+            end
+          end
+          diagnostics
+        end
+
+        def duplicate_diagnostics(path, scope)
+          counts = Hash.new { |h, k| h[k] = [] }
+          scope.declarations.each { |decl| counts[decl.name] << decl }
+          counts.flat_map do |name, decls|
+            next [] if decls.size < 2
+
+            duplicate_diagnostics_for(path, name, decls)
+          end
+        end
+
+        def duplicate_diagnostics_for(path, name, decls)
+          # Report each subsequent occurrence; the first
+          # one is the "winner" only by literal source
+          # order, but RSpec lets the LAST declaration win
+          # at runtime, so flag everything after the first
+          # so the user can see the full list.
+          decls.drop(1).map do |decl|
+            Diagnostic.new(
+              path: path,
+              line: decl.location.start_line,
+              column: decl.location.start_column + 1,
+              severity: :warning,
+              rule: "duplicate-let",
+              message: "duplicate `#{decl.kind}(:#{name})` in this scope " \
+                       "(first declared at line #{decls.first.location.start_line}); " \
+                       "the last declaration wins at runtime"
+            )
+          end
+        end
+
+        def self_reference_diagnostics(path, scope)
+          scope.declarations.flat_map do |decl|
+            next [] unless self_references?(decl)
+
+            [self_reference_diagnostic(path, decl)]
+          end
+        end
+
+        # Walks the declaration's block body looking for a
+        # call to its own name with no explicit receiver.
+        # Returns true if at least one such call exists.
+        def self_references?(decl)
+          body = decl.block_node&.body
+          return false if body.nil?
+
+          contains_self_reference?(body, decl.name)
+        end
+
+        def contains_self_reference?(node, name)
+          return false unless node.is_a?(Prism::Node)
+          return true if node.is_a?(Prism::CallNode) && node.name == name && node.receiver.nil?
+
+          node.compact_child_nodes.any? { |child| contains_self_reference?(child, name) }
+        end
+
+        def self_reference_diagnostic(path, decl)
+          Diagnostic.new(
+            path: path,
+            line: decl.location.start_line,
+            column: decl.location.start_column + 1,
+            severity: :error,
+            rule: "self-reference",
+            message: "`#{decl.kind}(:#{decl.name})` references its own name `#{decl.name}` — " \
+                     "this will infinite-loop at runtime"
+          )
+        end
+      end
+    end
+  end
+end

data/plugins/rigor-rspec/lib/rigor/plugin/rspec/let_scope_index.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require "prism"
+
+require_relative "scope_walker"
+
+module Rigor
+  module Plugin
+    class Rspec < Rigor::Plugin::Base
+      # Per-file index of RSpec scope hierarchy. Each
+      # describe scope carries:
+      #
+      # - `outer_range`: `Range[Integer]` of line numbers
+      #   covered by the describe's block body (start_line..end_line).
+      # - `describe_const`: the model constant string named in
+      #   `RSpec.describe SomeModel do` / `describe SomeModel do`,
+      #   or `nil` when the describe's first arg is a String
+      #   (`describe ".foo"`).
+      # - `lets`: `Hash{Symbol => Prism::BlockNode}` of `let(:name)
+      #   { ... }` and `subject(:name) { ... }` declarations.
+      #   `:subject` is the key for the implicit `subject { ... }`.
+      #
+      # Pillar 2 Slice 2 — used by the plugin's
+      # `flow_contribution_for` hook to bind `let`-named
+      # method-shape calls inside `it` bodies to the let
+      # block's inferred type.
+      class LetScopeIndex
+        Record = Struct.new(:outer_range, :describe_const, :lets, keyword_init: true) do
+          def contains?(line) = outer_range.cover?(line)
+          def let?(name) = lets.key?(name.to_sym)
+          def let_block(name) = lets[name.to_sym]
+        end
+
+        attr_reader :records
+
+        def initialize(records)
+          @records = records.freeze
+          freeze
+        end
+
+        # Returns every record whose outer_range contains the
+        # given line, ordered from outermost to innermost. The
+        # innermost wins on `let` name collisions per Ruby's
+        # method-resolution order (RSpec nested `let` shadows
+        # the outer `let`).
+        def records_at(line)
+          @records.select { |rec| rec.contains?(line) }
+        end
+
+        # Resolves a `let` name at the given line by walking
+        # records innermost to outermost.
+        # @return [Prism::BlockNode, nil]
+        def let_block_at(line, name)
+          name_sym = name.to_sym
+          records_at(line).reverse.each do |rec|
+            return rec.let_block(name_sym) if rec.let?(name_sym)
+          end
+          nil
+        end
+
+        # Resolves the `describe`-anchor constant name at the
+        # given line. The innermost describe with a constant
+        # anchor wins; describe-with-String anchors are skipped.
+        # @return [String, nil]
+        def describe_const_at(line)
+          records_at(line).reverse.each do |rec|
+            return rec.describe_const if rec.describe_const
+          end
+          nil
+        end
+
+        # Builds an index from a parsed root node.
+        def self.build(root)
+          records = []
+          collect(root, anchor: nil, accumulator: records)
+          new(records)
+        end
+
+        def self.collect(node, anchor:, accumulator:)
+          return unless node.is_a?(Prism::Node)
+
+          if describe_call?(node)
+            record = build_record(node, anchor)
+            accumulator << record
+            if node.block&.body
+              collect(node.block.body, anchor: record.describe_const || anchor, accumulator: accumulator)
+            end
+            return
+          end
+
+          node.compact_child_nodes.each do |child|
+            collect(child, anchor: anchor, accumulator: accumulator)
+          end
+        end
+
+        def self.build_record(describe_call, parent_anchor)
+          block_body = describe_call.block.body
+          start_line = block_body&.location&.start_line || describe_call.location.start_line
+          end_line = block_body&.location&.end_line || describe_call.block.location.end_line
+
+          Record.new(
+            outer_range: (start_line..end_line),
+            describe_const: describe_call_const(describe_call) || parent_anchor,
+            lets: collect_lets(describe_call.block.body)
+          )
+        end
+
+        def self.describe_call?(node)
+          return false unless node.is_a?(Prism::CallNode)
+          return false unless ScopeWalker::SCOPE_METHODS.include?(node.name) || node.name == :describe
+          return false unless node.block.is_a?(Prism::BlockNode)
+
+          # `RSpec.describe ...` has receiver = RSpec; bare
+          # `describe ... do` has nil receiver. Accept both.
+          node.receiver.nil? || describe_receiver?(node.receiver)
+        end
+
+        def self.describe_receiver?(receiver)
+          case receiver
+          when Prism::ConstantReadNode then receiver.name == :RSpec
+          when Prism::ConstantPathNode then receiver.name == :RSpec && receiver.parent.nil?
+          else false
+          end
+        end
+
+        def self.describe_call_const(describe_call)
+          first_arg = describe_call.arguments&.arguments&.first
+          render_const(first_arg)
+        end
+
+        def self.render_const(node)
+          case node
+          when Prism::ConstantReadNode then node.name.to_s
+          when Prism::ConstantPathNode
+            parts = []
+            current = node
+            while current.is_a?(Prism::ConstantPathNode)
+              parts.unshift(current.name.to_s)
+              current = current.parent
+            end
+            case current
+            when nil then "::#{parts.join('::')}"
+            when Prism::ConstantReadNode then "#{current.name}::#{parts.join('::')}"
+            end
+          end
+        end
+
+        # Walks the describe's body shallowly: collects every
+        # top-level `let(:name) { ... }` / `subject(:name) { ... }`
+        # / `subject { ... }` declaration. Does NOT recurse into
+        # nested describe / context blocks — those have their
+        # own record built by `collect` above.
+        def self.collect_lets(body)
+          return {} unless body.is_a?(Prism::Node)
+
+          lets = {}
+          statements_of(body).each do |stmt|
+            decl = let_declaration(stmt)
+            next if decl.nil?
+
+            lets[decl[:name]] = decl[:block]
+          end
+          lets.freeze
+        end
+
+        def self.statements_of(node)
+          case node
+          when Prism::StatementsNode then node.body
+          else [node]
+          end
+        end
+
+        def self.let_declaration(node)
+          return nil unless node.is_a?(Prism::CallNode)
+          return nil unless node.receiver.nil?
+          return nil unless %i[let let! subject].include?(node.name)
+          return nil unless node.block.is_a?(Prism::BlockNode)
+
+          name = let_declaration_name(node)
+          return nil if name.nil?
+
+          { name: name, block: node.block }
+        end
+
+        def self.let_declaration_name(call_node)
+          first_arg = call_node.arguments&.arguments&.first
+          if first_arg.nil?
+            # `subject { ... }` with no name — implicit :subject.
+            return :subject if call_node.name == :subject
+
+            return nil
+          end
+          return nil unless first_arg.is_a?(Prism::SymbolNode)
+
+          first_arg.unescaped.to_sym
+        end
+      end
+    end
+  end
+end

data/plugins/rigor-rspec/lib/rigor/plugin/rspec/let_type_resolver.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "prism"
+require "rigor/type"
+
+module Rigor
+  module Plugin
+    class Rspec < Rigor::Plugin::Base
+      # Pillar 2 Slice 2 — resolves the runtime type of a
+      # `let(:name) { body }` or `subject(:name) { body }`
+      # block by pattern-matching its body's tail expression.
+      #
+      # Recognised body shapes (floor):
+      #
+      # - `ConstantClass.new(...)` → `Nominal[ConstantClass]`
+      # - `Foo::Bar.new(...)` → `Nominal[Foo::Bar]`
+      # - `described_class.new(...)` → `Nominal[<describe const>]`
+      #   when the surrounding describe block has a constant
+      #   anchor.
+      # - `create(:factory)` / `build(:factory)` /
+      #   `build_stubbed(:factory)` / `attributes_for(:factory)`
+      #   → `Nominal[<factory.model_class>]` when the
+      #   `:factory_index` ADR-9 fact is available and the
+      #   factory name is known.
+      # - `FactoryBot.create(:factory)` etc. — same as the
+      #   implicit-receiver factorybot form.
+      #
+      # Returns `nil` for any other body shape. Multi-statement
+      # bodies use the LAST statement (the block's return
+      # value).
+      module LetTypeResolver
+        FACTORYBOT_ENTRY_METHODS = %i[
+          create build build_stubbed attributes_for
+          create_list build_list build_stubbed_list
+        ].freeze
+
+        module_function
+
+        # @param block_node [Prism::BlockNode]
+        # @param describe_const [String, nil]
+        # @param factory_index [Object, nil] something
+        #   responding to `find(factory_name)` and returning
+        #   an entry that responds to `model_class`.
+        # @param environment [Rigor::Environment, nil]
+        # @return [Rigor::Type, nil]
+        def resolve(block_node, describe_const:, factory_index:, environment:)
+          tail = body_tail(block_node)
+          return nil if tail.nil?
+
+          nominal_for_call(
+            tail,
+            describe_const: describe_const,
+            factory_index: factory_index,
+            environment: environment
+          )
+        end
+
+        def body_tail(block_node)
+          body = block_node.body
+          return nil if body.nil?
+
+          case body
+          when Prism::StatementsNode
+            body.body.last
+          else
+            body
+          end
+        end
+
+        def nominal_for_call(node, describe_const:, factory_index:, environment:)
+          return nil unless node.is_a?(Prism::CallNode)
+
+          # `<Const>.new(...)` / `<ConstPath>.new(...)`
+          if node.name == :new && const_receiver?(node.receiver)
+            class_name = render_const(node.receiver)
+            return nominal_for(class_name, environment: environment) if class_name
+          end
+
+          # `described_class.new(...)`
+          if node.name == :new && described_class_receiver?(node.receiver)
+            return nil if describe_const.nil?
+
+            return nominal_for(describe_const, environment: environment)
+          end
+
+          # `create(:name)` / `build(:name)` / `FactoryBot.create(:name)` / `*_list`
+          factorybot_nominal(node, factory_index: factory_index, environment: environment)
+        end
+
+        def factorybot_nominal(call_node, factory_index:, environment:)
+          return nil if factory_index.nil?
+          return nil unless factorybot_call?(call_node)
+
+          factory_name = factorybot_first_arg(call_node)
+          return nil if factory_name.nil?
+
+          entry = factory_index.find(factory_name)
+          return nil if entry.nil?
+
+          model_class = entry.respond_to?(:model_class) ? entry.model_class : nil
+          return nil if model_class.nil?
+
+          nominal_for(model_class, environment: environment)
+        end
+
+        # Recognises both `create(:name)` (implicit receiver,
+        # via `include FactoryBot::Syntax::Methods`) and the
+        # explicit `FactoryBot.create(:name)` /
+        # `FactoryGirl.create(:name)` (legacy) forms.
+        def factorybot_call?(call_node)
+          return false unless FACTORYBOT_ENTRY_METHODS.include?(call_node.name)
+
+          recv = call_node.receiver
+          recv.nil? || factorybot_constant?(recv)
+        end
+
+        def factorybot_constant?(node)
+          case node
+          when Prism::ConstantReadNode then %i[FactoryBot FactoryGirl].include?(node.name)
+          when Prism::ConstantPathNode
+            node.parent.nil? && %i[FactoryBot FactoryGirl].include?(node.name)
+          else false
+          end
+        end
+
+        def factorybot_first_arg(call_node)
+          first_arg = call_node.arguments&.arguments&.first
+          case first_arg
+          when Prism::SymbolNode then first_arg.unescaped
+          when Prism::StringNode then first_arg.unescaped
+          end
+        end
+
+        def const_receiver?(node)
+          node.is_a?(Prism::ConstantReadNode) || node.is_a?(Prism::ConstantPathNode)
+        end
+
+        def described_class_receiver?(node)
+          node.is_a?(Prism::CallNode) && node.name == :described_class && node.receiver.nil?
+        end
+
+        def render_const(node)
+          case node
+          when Prism::ConstantReadNode then node.name.to_s
+          when Prism::ConstantPathNode
+            parts = []
+            current = node
+            while current.is_a?(Prism::ConstantPathNode)
+              parts.unshift(current.name.to_s)
+              current = current.parent
+            end
+            case current
+            when nil then "::#{parts.join('::')}"
+            when Prism::ConstantReadNode then "#{current.name}::#{parts.join('::')}"
+            end
+          end
+        end
+
+        def nominal_for(class_name, environment:)
+          if environment
+            environment.nominal_for_name(class_name) ||
+              Rigor::Type::Combinator.nominal_of(class_name)
+          else
+            Rigor::Type::Combinator.nominal_of(class_name)
+          end
+        end
+      end
+    end
+  end
+end