rigortype 0.0.9 → 0.1.1

data/data/builtins/ruby_core/proc.yml

@@ -277,7 +277,7 @@ classes:
     singleton_methods: {}
     undefined: []
   SystemStackError:
-    parent: rb_eException
+    parent: Exception
     defined_at: references/ruby/proc.c:4593
     includes: []
     constants: {}

data/data/builtins/ruby_core/time.yml

@@ -684,7 +684,7 @@ classes:
         body_kind: composed
         cexpr_target:
         prelude_at: references/ruby/timev.rb:440
-        purity: unknown
+        purity: dispatch
         arity: -1
         cfunc:
         defined_at: references/ruby/timev.rb:440
@@ -726,7 +726,7 @@ classes:
         body_kind: composed
         cexpr_target:
         prelude_at: references/ruby/timev.rb:270
-        purity: unknown
+        purity: dispatch
         arity: -1
         cfunc:
         defined_at: references/ruby/timev.rb:270
@@ -739,7 +739,7 @@ classes:
         body_kind: composed
         cexpr_target:
         prelude_at: references/ruby/timev.rb:329
-        purity: unknown
+        purity: dispatch
         arity: -2
         cfunc:
         defined_at: references/ruby/timev.rb:329

data/lib/rigor/analysis/check_rules.rb

@@ -42,19 +42,25 @@ module Rigor
     # the first preview; later slices broaden it.
     # rubocop:disable Metrics/ModuleLength
     module CheckRules
-      # Stable identifiers for each rule. Used by the
-      # configuration `disable:` list and the in-source
-      # `# rigor:disable <rule>` suppression comment system
-      # to identify diagnostics by category. Rule identifiers
-      # are kebab-case strings; new rules MUST register here
-      # so user configuration can refer to them.
-      RULE_UNDEFINED_METHOD = "undefined-method"
-      RULE_WRONG_ARITY = "wrong-arity"
-      RULE_ARGUMENT_TYPE = "argument-type-mismatch"
-      RULE_NIL_RECEIVER = "possible-nil-receiver"
-      RULE_DUMP_TYPE = "dump-type"
-      RULE_ASSERT_TYPE = "assert-type"
-      RULE_ALWAYS_RAISES = "always-raises"
+      # Canonical identifiers for each rule. Per ADR-8 §
+      # "Diagnostic ID family hierarchy", rule names are
+      # `family.rule-name` two-segment strings; the families
+      # group diagnostics by where they originate
+      # (`call.*` for call-site rules, `flow.*` for flow-analysis
+      # proofs, `assert.*` for runtime-assertion rules,
+      # `dump.*` for debug helpers, `def.*` for method-definition
+      # rules). Used by the configuration `disable:` list and the
+      # in-source `# rigor:disable <rule>` suppression comment
+      # system; new rules MUST register here so user configuration
+      # can refer to them.
+      RULE_UNDEFINED_METHOD = "call.undefined-method"
+      RULE_WRONG_ARITY = "call.wrong-arity"
+      RULE_ARGUMENT_TYPE = "call.argument-type-mismatch"
+      RULE_NIL_RECEIVER = "call.possible-nil-receiver"
+      RULE_DUMP_TYPE = "dump.type"
+      RULE_ASSERT_TYPE = "assert.type-mismatch"
+      RULE_ALWAYS_RAISES = "flow.always-raises"
+      RULE_RETURN_TYPE = "def.return-type-mismatch"
 
       ALL_RULES = [
         RULE_UNDEFINED_METHOD,
@@ -63,9 +69,46 @@ module Rigor
         RULE_NIL_RECEIVER,
         RULE_DUMP_TYPE,
         RULE_ASSERT_TYPE,
-        RULE_ALWAYS_RAISES
+        RULE_ALWAYS_RAISES,
+        RULE_RETURN_TYPE
       ].freeze
 
+      # Backward-compat alias table (ADR-8 § "Backward
+      # compatibility"). Existing user code with
+      # `# rigor:disable undefined-method` /
+      # `disable: [undefined-method]` keeps working — the
+      # legacy unprefixed identifiers map to their canonical
+      # `family.rule-name` form here. Removing the aliases is
+      # a future ADR once user code has migrated; until then,
+      # both spellings resolve identically.
+      LEGACY_RULE_ALIASES = {
+        "undefined-method" => RULE_UNDEFINED_METHOD,
+        "wrong-arity" => RULE_WRONG_ARITY,
+        "argument-type-mismatch" => RULE_ARGUMENT_TYPE,
+        "possible-nil-receiver" => RULE_NIL_RECEIVER,
+        "dump-type" => RULE_DUMP_TYPE,
+        "assert-type" => RULE_ASSERT_TYPE,
+        "always-raises" => RULE_ALWAYS_RAISES
+      }.freeze
+
+      # Family wildcard — a `<family>` token in a suppression
+      # comment or `disable:` list disables every rule whose
+      # canonical id starts with `<family>.`. Per ADR-8 § "1".
+      RULE_FAMILIES = %w[call flow assert dump def].freeze
+
+      # Resolves a user-supplied rule token (`undefined-method`,
+      # `call.undefined-method`, or the family wildcard `call`)
+      # to the set of canonical rule identifiers it disables.
+      # Returns `nil` for `"all"` (the existing wildcard meaning
+      # "every rule"), or for unknown tokens.
+      def self.resolve_rule_token(token)
+        return nil if token == "all"
+        return [LEGACY_RULE_ALIASES.fetch(token)] if LEGACY_RULE_ALIASES.key?(token)
+        return ALL_RULES.select { |r| r.start_with?("#{token}.") } if RULE_FAMILIES.include?(token)
+
+        ALL_RULES.include?(token) ? [token] : []
+      end
+
       module_function
 
       # Yields diagnostics for every unrecognised method call on
@@ -78,35 +121,31 @@ module Rigor
       # @param root [Prism::Node]
       # @param scope_index [Hash{Prism::Node => Rigor::Scope}]
       # @return [Array<Rigor::Analysis::Diagnostic>]
-      def diagnose(path:, root:, scope_index:, comments: [], disabled_rules: []) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def diagnose(path:, root:, scope_index:, comments: [], disabled_rules: [])
         diagnostics = []
         Source::NodeWalker.each(root) do |node|
-          next unless node.is_a?(Prism::CallNode)
-
-          diagnostic = undefined_method_diagnostic(path, node, scope_index)
-          diagnostics << diagnostic if diagnostic
-
-          arity_diagnostic = wrong_arity_diagnostic(path, node, scope_index)
-          diagnostics << arity_diagnostic if arity_diagnostic
-
-          arg_type_diagnostic = argument_type_diagnostic(path, node, scope_index)
-          diagnostics << arg_type_diagnostic if arg_type_diagnostic
-
-          nil_diagnostic = nil_receiver_diagnostic(path, node, scope_index)
-          diagnostics << nil_diagnostic if nil_diagnostic
-
-          dump_diagnostic = dump_type_diagnostic(path, node, scope_index)
-          diagnostics << dump_diagnostic if dump_diagnostic
-
-          assert_diagnostic = assert_type_diagnostic(path, node, scope_index)
-          diagnostics << assert_diagnostic if assert_diagnostic
-
-          raises_diagnostic = always_raises_diagnostic(path, node, scope_index)
-          diagnostics << raises_diagnostic if raises_diagnostic
+          if node.is_a?(Prism::CallNode)
+            diagnostics.concat(call_node_diagnostics(path, node, scope_index))
+          elsif node.is_a?(Prism::DefNode)
+            return_diagnostic = return_type_mismatch_diagnostic(path, node, scope_index)
+            diagnostics << return_diagnostic if return_diagnostic
+          end
         end
         filter_suppressed(diagnostics, comments: comments, disabled_rules: disabled_rules)
       end
 
+      def call_node_diagnostics(path, node, scope_index)
+        [
+          undefined_method_diagnostic(path, node, scope_index),
+          wrong_arity_diagnostic(path, node, scope_index),
+          argument_type_diagnostic(path, node, scope_index),
+          nil_receiver_diagnostic(path, node, scope_index),
+          dump_type_diagnostic(path, node, scope_index),
+          assert_type_diagnostic(path, node, scope_index),
+          always_raises_diagnostic(path, node, scope_index)
+        ].compact
+      end
+
       # v0.0.2 #6 — diagnostic suppression. Two kinds of
       # suppression compose:
       #
@@ -125,7 +164,7 @@ module Rigor
       # silence away.
       def filter_suppressed(diagnostics, comments:, disabled_rules:)
         suppressions = parse_suppression_comments(comments)
-        disabled = disabled_rules.to_set(&:to_s)
+        disabled = expand_rule_tokens(disabled_rules)
 
         diagnostics.reject do |diagnostic|
           rule = diagnostic.rule
@@ -137,7 +176,7 @@ module Rigor
         end
       end
 
-      SUPPRESSION_PATTERN = /#\s*rigor:disable\s+(?<rules>[\w,\s-]+)/
+      SUPPRESSION_PATTERN = /#\s*rigor:disable\s+(?<rules>[\w.,\s-]+)/
       private_constant :SUPPRESSION_PATTERN
 
       def parse_suppression_comments(comments)
@@ -148,11 +187,29 @@ module Rigor
           next if match.nil?
 
           rules = match[:rules].to_s.split(/[\s,]+/).reject(&:empty?)
-          rules.each { |rule| result[comment.location.start_line] << rule }
+          rules.each { |token| result[comment.location.start_line].merge(expand_token(token)) }
         end
         result
       end
 
+      # Expands a list of user-supplied rule tokens into the
+      # canonical-id set per ADR-8 § "Backward compatibility".
+      # `disabled_rules` accepts unprefixed legacy names
+      # (`undefined-method`), canonical names
+      # (`call.undefined-method`), and family wildcards (`call`).
+      def expand_rule_tokens(tokens)
+        Array(tokens).each_with_object(Set.new) do |token, set|
+          set.merge(expand_token(token.to_s))
+        end
+      end
+
+      def expand_token(token)
+        return ["all"] if token == "all"
+
+        resolved = resolve_rule_token(token)
+        resolved.nil? || resolved.empty? ? [token] : resolved
+      end
+
       # rubocop:disable Metrics/ClassLength
       class << self
         private
@@ -792,6 +849,137 @@ module Rigor
             severity: :error
           )
         end
+
+        # ADR-8 § "`def.return-type-mismatch` rule" — flags a
+        # `def m(...) ... end` whose body's last expression's
+        # type cannot satisfy the RBS-declared return type.
+        # Conservative envelope (v0.1.x first cut):
+        #
+        # - Skips methods without an RBS declaration. The rule
+        #   has no contract to compare against for source-only
+        #   methods.
+        # - Skips methods whose enclosing class isn't a
+        #   `Type::Singleton` self_type that we can name (top-
+        #   level / module-level methods land outside the rule).
+        # - Skips methods whose body's last expression is
+        #   absent or types as `Dynamic[top]` (the analyzer's
+        #   fail-soft fallback) — emitting on `Dynamic[top]`
+        #   would be noise.
+        # - Compares the inferred body type against the
+        #   declared return via `accepts?`:
+        #     :yes   → silent
+        #     :no    → emit at :error (severity_profile may
+        #              re-stamp; default `balanced` keeps the
+        #              authored severity).
+        #     :maybe → emit at :warning. Promoted to :error
+        #              under `severity_profile: strict` per
+        #              ADR-8 § "Severity profile".
+        def return_type_mismatch_diagnostic(path, def_node, scope_index) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+          return nil if def_node.body.nil?
+
+          last_expr = body_last_expression(def_node.body)
+          return nil if last_expr.nil?
+
+          inner_scope = scope_index[last_expr] || scope_index[def_node.body] || scope_index[def_node]
+          return nil if inner_scope.nil?
+
+          declared = declared_return_type(def_node, scope_index)
+          return nil if declared.nil?
+
+          inferred = inner_scope.type_of(last_expr)
+          return nil if dynamic_top?(inferred)
+
+          severity = compare_return(declared, inferred)
+          return nil if severity.nil?
+
+          build_return_type_mismatch_diagnostic(path, def_node, declared, inferred, severity)
+        end
+
+        # The body of a `def` is the last `Prism::StatementsNode`
+        # child (or a single expression for one-liner defs).
+        # Take the last statement; that's the implicit return.
+        def body_last_expression(body)
+          case body
+          when Prism::StatementsNode then body.body.last
+          when Prism::BeginNode then body_last_expression(body.statements)
+          else body
+          end
+        end
+
+        # Pulls the declared RBS return type for the def. The
+        # enclosing class name comes from the def's scope's
+        # `self_type`; the method name is on the def itself.
+        # `def self.foo` is a singleton method — dispatched
+        # through `Reflection.singleton_method_definition`;
+        # plain `def foo` uses `instance_method_definition`.
+        # Method overloads contribute their union of declared
+        # return types (any one of them satisfying the body
+        # silences the rule).
+        def declared_return_type(def_node, scope_index)
+          scope = scope_index[def_node]
+          return nil if scope.nil?
+
+          self_type = scope.self_type
+          return nil unless self_type.respond_to?(:class_name)
+
+          method_def =
+            if def_node.receiver.nil?
+              Reflection.instance_method_definition(self_type.class_name, def_node.name, scope: scope)
+            else
+              Reflection.singleton_method_definition(self_type.class_name, def_node.name, scope: scope)
+            end
+          return nil if method_def.nil?
+
+          declared_return_union(method_def, scope.environment)
+        end
+
+        def declared_return_union(method_def, _environment)
+          translated = method_def.method_types.filter_map do |mt|
+            Inference::RbsTypeTranslator.translate(
+              mt.type.return_type,
+              self_type: nil, instance_type: nil, type_vars: {}
+            )
+          rescue StandardError
+            nil
+          end
+          return nil if translated.empty?
+
+          translated.size == 1 ? translated.first : Type::Combinator.union(*translated)
+        end
+
+        def dynamic_top?(type)
+          type.is_a?(Type::Dynamic) || (type.respond_to?(:top?) && type.top?.yes?)
+        end
+
+        # Returns the severity to emit at, or nil to stay
+        # silent. The first-cut implementation only fires on
+        # proven (`:no`) mismatches; `:maybe` is treated as
+        # silent until the analyzer's narrowing becomes precise
+        # enough to avoid noise on common patterns (`{}` →
+        # declared `Hash[K, V]`, `Set.new` → declared
+        # `Set[Symbol]`, …). ADR-8's promise to emit on
+        # `:maybe` under `severity_profile: strict` is
+        # deferred to a follow-up that lands together with the
+        # narrowing precision improvements.
+        def compare_return(declared, inferred)
+          result = declared.accepts(inferred)
+          return :error if result.no?
+
+          nil
+        end
+
+        def build_return_type_mismatch_diagnostic(path, def_node, declared, inferred, severity)
+          location = def_node.name_loc || def_node.location
+          Diagnostic.new(
+            rule: RULE_RETURN_TYPE,
+            path: path,
+            line: location.start_line,
+            column: location.start_column + 1,
+            message: "return-type mismatch on `#{def_node.name}': " \
+                     "declared #{declared.describe(:short)}, inferred #{inferred.describe(:short)}",
+            severity: severity
+          )
+        end
       end
       # rubocop:enable Metrics/ClassLength
     end

data/lib/rigor/analysis/diagnostic.rb

@@ -64,8 +64,22 @@ module Rigor
         }
       end
 
+      # Text rendering for `rigor check`. The qualified rule
+      # identifier (per ADR-2 § "Plugin Diagnostic Provenance" —
+      # `plugin.<id>.<rule>`, `rbs_extended.<rule>`,
+      # `generated.<provider>.<rule>`) is appended in brackets
+      # whenever the diagnostic carries a non-default `source_family`,
+      # so plugin / RBS::Extended / generated provenance is visible
+      # in the standard text output without changing the layout for
+      # built-in rules. Slice 5 (v0.1.0) wires this surface.
       def to_s
-        "#{path}:#{line}:#{column}: #{severity}: #{message}"
+        base = "#{path}:#{line}:#{column}: #{severity}: #{message}"
+        return base if source_family == DEFAULT_SOURCE_FAMILY
+
+        qualified = qualified_rule
+        return base if qualified.nil?
+
+        "#{base} [#{qualified}]"
       end
     end
   end