rigortype 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a6dc65f5d9bf7eb3cd87b6cd7b276f42a7c5e7c053b001017cb89a3e7c636d7
-  data.tar.gz: 7b70c37b3fe532121a0f3d76c67e07570b9a070155c63f6bcec7e612dfd15ea5
+  metadata.gz: 47346567152367cb408115b6a33214e43468f2255bd632b4894d8c68164b8ada
+  data.tar.gz: 407d5cda9e08342670a4eeb05ae2c565d398866174d292c586793cb213a77fdb
 SHA512:
-  metadata.gz: 167ca081df2d10e10b529014f53333cd34424a5fb68a88e2ab33a044eba9d72fa89fdf8b6c43e4cd5f3ee69b355f16d4d2762cbb8356e13649b55d4287aeb808
-  data.tar.gz: 3cbcffa0ce1d659512c42cfa608357b6d06dbc45b3769ca7719bfad4c021e3f165ff8a77a58fbde024768addd862b2c51170167ef46263aec04fb1656588f6cb
+  metadata.gz: f6ffecd573e1bbb387c861cbe3a6d909d217dfadef453a7a84339a4f7fd44e2c86dbbac54c8369298b56a2de3771c0f75c28cfe098cb895355a52155657f4f9d
+  data.tar.gz: 6f924aed4bc15581bae58ffa62a5d8194db3fabbdc3056f2b6cfc4f068f972063e0148f85df8b8ef3e5f5003fad35b4e9016e534ef604cbfc581d0cdab76bb7b

data/data/builtins/ruby_core/range.yml

@@ -33,8 +33,9 @@ classes:
         arity: -1
         defined_at: references/ruby/range.c:2851
         c_body_at: references/ruby/range.c:103
-        c_effects: []
-        purity: leaf
+        c_effects:
+        - mutate
+        purity: mutates_self
         rbs:
         - "(Elem from, Elem to, ?boolish exclude_end) -> void"
         rbs_at: references/rbs/core/range.rbs:608
@@ -44,8 +45,9 @@ classes:
         arity: 1
         defined_at: references/ruby/range.c:2852
         c_body_at: references/ruby/range.c:115
-        c_effects: []
-        purity: leaf
+        c_effects:
+        - mutate
+        purity: mutates_self
       "==":
         source: c
         cfunc: range_eq

data/data/builtins/ruby_core/string.yml

@@ -50,8 +50,9 @@ classes:
         arity: 1
         defined_at: references/ruby/string.c:12794
         c_body_at: references/ruby/string.c:6548
-        c_effects: []
-        purity: leaf
+        c_effects:
+        - mutate
+        purity: mutates_self
         rbs:
         - "(string other_string) -> self"
         rbs_at: references/rbs/core/string.rbs:4019
@@ -61,8 +62,9 @@ classes:
         arity: 1
         defined_at: references/ruby/string.c:12795
         c_body_at: references/ruby/string.c:6548
-        c_effects: []
-        purity: leaf
+        c_effects:
+        - mutate
+        purity: mutates_self
       "<=>":
         source: c
         cfunc: rb_str_cmp_m
@@ -1167,8 +1169,9 @@ classes:
         arity: -1
         defined_at: references/ruby/string.c:12904
         c_body_at: references/ruby/string.c:10172
-        c_effects: []
-        purity: leaf
+        c_effects:
+        - mutate
+        purity: mutates_self
         rbs:
         - "(nil) -> nil"
         - "(?string? separator) -> self?"
@@ -1223,8 +1226,9 @@ classes:
         arity: 1
         defined_at: references/ruby/string.c:12909
         c_body_at: references/ruby/string.c:11476
-        c_effects: []
-        purity: leaf
+        c_effects:
+        - mutate
+        purity: mutates_self
         rbs:
         - "(string suffix) -> self?"
         rbs_at: references/rbs/core/string.rbs:2664
@@ -1459,8 +1463,9 @@ classes:
         arity: 1
         defined_at: references/ruby/string.c:12937
         c_body_at: references/ruby/string.c:11563
-        c_effects: []
-        purity: leaf
+        c_effects:
+        - mutate
+        purity: mutates_self
         rbs:
         - "(encoding enc) -> self"
         rbs_at: references/rbs/core/string.rbs:3207

data/lib/rigor/analysis/check_rules/always_truthy_condition_collector.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Analysis
+    module CheckRules
+      # Walks a parse tree and collects every `IfNode` / `UnlessNode`
+      # whose predicate folds to a `Type::Constant` AND is NOT
+      # disqualified by the rule's conservative envelope.
+      #
+      # The companion rule (`flow.always-truthy-condition`) is
+      # the inferred-constant counterpart to
+      # `flow.unreachable-branch` (which only fires on syntactic
+      # literals). The literal-only rule was the v0.1.2 first-cut
+      # because Rigor's incomplete loop / mutation / RBS-strictness
+      # modelling produces inferred constants that look real but
+      # are pragmatically false-positives. This collector adds two
+      # surgical skips to bring the inferred-constant case in
+      # without resurfacing those false positives:
+      #
+      # - **Inside a loop / block**: predicates nested inside
+      #   `WhileNode` / `UntilNode` / `ForNode` / `BlockNode`
+      #   ancestors. Mutation tracking through loop bodies is
+      #   incomplete (`shift = 0; loop { shift += 7 }` keeps
+      #   `shift` at `Constant<7>` per the analyzer), so a
+      #   `Constant<bool>` predicate inside the loop body is
+      #   suspect.
+      # - **Defensive predicate calls**: `.nil?` / `.empty?` /
+      #   `.zero?` / `.any?` / `.none?` / `.all?`. These read
+      #   like the user explicitly checking for a runtime
+      #   condition that the type system already proves can't
+      #   happen — Rigor's strict-on-returns RBS often disagrees
+      #   with the user's defensive check (e.g. `Module#name`
+      #   returns `String` per RBS but anonymous classes really
+      #   do return `nil`). Skipping these forms keeps the rule
+      #   useful for genuine logic errors without faulting
+      #   defensive code.
+      #
+      # Also skipped (so the literal-only `unreachable-branch`
+      # rule doesn't double-fire alongside this one):
+      #
+      # - Predicates whose direct AST shape is a literal
+      #   (`TrueNode` / `FalseNode` / `NilNode` / numeric / string
+      #   / symbol / regexp).
+      class AlwaysTruthyConditionCollector
+        DEFENSIVE_PREDICATES = %i[nil? empty? zero? any? none? all? respond_to?].freeze
+        LOOP_OR_BLOCK_NODE_CLASSES = [
+          Prism::WhileNode, Prism::UntilNode, Prism::ForNode, Prism::BlockNode
+        ].freeze
+        LITERAL_PREDICATE_NODE_CLASSES = [
+          Prism::TrueNode, Prism::FalseNode, Prism::NilNode,
+          Prism::IntegerNode, Prism::FloatNode,
+          Prism::StringNode, Prism::SymbolNode, Prism::RegularExpressionNode
+        ].freeze
+
+        Result = Data.define(:node, :polarity)
+
+        # @return [Array<Result>] one entry per qualifying
+        #   predicate. Empty when the tree carries no firing
+        #   predicates.
+        def initialize(scope_index)
+          @scope_index = scope_index
+          @results = []
+        end
+
+        def collect(root)
+          walk(root, in_loop_or_block: false)
+          @results.freeze
+        end
+
+        private
+
+        def walk(node, in_loop_or_block:)
+          return unless node.is_a?(Prism::Node)
+
+          collect_predicate(node) if conditional_node?(node) && !in_loop_or_block
+
+          child_in_loop_or_block = in_loop_or_block || enters_loop_or_block?(node)
+          node.compact_child_nodes.each { |child| walk(child, in_loop_or_block: child_in_loop_or_block) }
+        end
+
+        def conditional_node?(node)
+          node.is_a?(Prism::IfNode) || node.is_a?(Prism::UnlessNode)
+        end
+
+        def enters_loop_or_block?(node)
+          LOOP_OR_BLOCK_NODE_CLASSES.any? { |klass| node.is_a?(klass) }
+        end
+
+        def collect_predicate(node)
+          predicate = node.predicate
+          return if literal_predicate?(predicate)
+          return if defensive_predicate?(predicate)
+
+          scope = @scope_index[node]
+          return if scope.nil?
+
+          predicate_type = scope.type_of(predicate)
+          return unless predicate_type.is_a?(Type::Constant)
+
+          polarity = predicate_type.value.nil? || predicate_type.value == false ? :falsey : :truthy
+          @results << Result.new(node: predicate, polarity: polarity)
+        end
+
+        def literal_predicate?(predicate)
+          LITERAL_PREDICATE_NODE_CLASSES.any? { |klass| predicate.is_a?(klass) }
+        end
+
+        def defensive_predicate?(predicate)
+          predicate.is_a?(Prism::CallNode) && DEFENSIVE_PREDICATES.include?(predicate.name)
+        end
+      end
+    end
+  end
+end

data/lib/rigor/analysis/check_rules/dead_assignment_collector.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Analysis
+    module CheckRules
+      # Walks a parse tree and collects every `LocalVariableWriteNode`
+      # inside a `DefNode` body whose target name is **never read**
+      # within the same body.
+      #
+      # The collector is the read-side companion to the
+      # `def.dead-assignment` rule. v0.1.2 ships the narrowest
+      # envelope that catches the most common typo / refactoring-
+      # leftover shape ("wrote and never used") without surfacing
+      # false positives:
+      #
+      # - Only `Prism::DefNode` bodies are scanned. Top-level
+      #   scripts and class-body assignments are skipped — their
+      #   variable surface bleeds across requires / introspection
+      #   in ways the rule cannot reason about.
+      # - Only plain `LocalVariableWriteNode` writes are
+      #   considered. Operator-writes (`x += 1`), and-/or-writes
+      #   (`x ||= 1`), and `MultiWriteNode` destructures (`a, b =
+      #   foo`) are skipped because their write semantics are
+      #   intertwined with reads or with a wider tuple binding.
+      # - The "is this name ever read" question is answered by
+      #   any `LocalVariableReadNode` anywhere in the def
+      #   subtree — so a closure capture, a `return x`, a
+      #   block-call argument, an interpolated string all count
+      #   as a read.
+      # - A write whose name starts with `_` is skipped per the
+      #   Ruby convention that `_` / `_foo` declares
+      #   "intentionally unused".
+      # - The last statement of a def body is skipped — Ruby's
+      #   implicit return treats `def foo; x = 1; end` as
+      #   returning `1`, so the trailing write is intentional.
+      class DeadAssignmentCollector
+        # Returns `Array<{def_class:, def_name:, write_node:}>`
+        # — one entry per dead-assignment write. Empty when
+        # the tree has no qualifying writes.
+        def initialize(scope_index)
+          @scope_index = scope_index
+          @results = []
+        end
+
+        def collect(root)
+          walk_for_def_nodes(root)
+          @results.freeze
+        end
+
+        private
+
+        def walk_for_def_nodes(node)
+          return unless node.is_a?(Prism::Node)
+
+          collect_def_assignments(node) if node.is_a?(Prism::DefNode)
+          node.compact_child_nodes.each { |child| walk_for_def_nodes(child) }
+        end
+
+        def collect_def_assignments(def_node)
+          body = def_node.body
+          return if body.nil?
+
+          read_names = gather_read_names(body)
+          last_node = trailing_statement(body)
+
+          gather_write_nodes(body).each do |write|
+            next if write.equal?(last_node)
+            next if write.name.to_s.start_with?("_")
+            next if read_names.include?(write.name)
+
+            @results << { def_node: def_node, write_node: write }
+          end
+        end
+
+        def gather_read_names(node, accumulator = Set.new)
+          return accumulator unless node.is_a?(Prism::Node)
+
+          accumulator << node.name if node.is_a?(Prism::LocalVariableReadNode)
+          # Operator/and/or-writes implicitly read the prior
+          # binding — count them too so `x = 1; x ||= 2; x` /
+          # similar shapes don't trip the rule.
+          accumulator << node.name if reading_assignment?(node)
+
+          node.compact_child_nodes.each { |child| gather_read_names(child, accumulator) }
+          accumulator
+        end
+
+        def reading_assignment?(node)
+          node.is_a?(Prism::LocalVariableOperatorWriteNode) ||
+            node.is_a?(Prism::LocalVariableAndWriteNode) ||
+            node.is_a?(Prism::LocalVariableOrWriteNode)
+        end
+
+        def gather_write_nodes(node, accumulator = [])
+          return accumulator unless node.is_a?(Prism::Node)
+
+          accumulator << node if node.is_a?(Prism::LocalVariableWriteNode)
+          # Don't recurse into nested DefNodes — their bodies
+          # carry their own dead-assignment scope and the
+          # outer walker visits them separately.
+          return accumulator if node.is_a?(Prism::DefNode) && !accumulator.last.equal?(node)
+
+          node.compact_child_nodes.each { |child| gather_write_nodes(child, accumulator) }
+          accumulator
+        end
+
+        # Returns the final statement of a body node, descending
+        # into wrappers Ruby preserves verbatim (`begin ... end`
+        # blocks). Used to skip the implicit-return write at the
+        # tail of a method body.
+        def trailing_statement(body)
+          case body
+          when Prism::StatementsNode then body.body.last
+          when Prism::BeginNode
+            body.statements ? trailing_statement(body.statements) : nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rigor/analysis/check_rules/ivar_write_collector.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Rigor
+  module Analysis
+    module CheckRules
+      # Walks a parse tree and collects every
+      # `Prism::InstanceVariableWriteNode` inside an instance
+      # method body of a `Prism::ClassNode` / `Prism::ModuleNode`,
+      # grouped by (class qualified name, ivar name).
+      #
+      # The collector is the read-side companion to
+      # `Inference::ScopeIndexer#build_class_ivar_index`. The
+      # indexer unions the rvalue types into a single per-ivar
+      # carrier; this collector preserves the per-write list so
+      # the `def.ivar-write-mismatch` rule can compare each
+      # write's concrete class against the first.
+      #
+      # Skipped on purpose:
+      #
+      # - Singleton-method bodies (`def self.foo`). Their ivars
+      #   live on the class object, not on instances.
+      # - Class-body ivar writes outside any def — the
+      #   `Module#@var` surface is a separate slice the engine
+      #   doesn't yet model.
+      # - Nested classes / modules / defs inside a method body
+      #   are barriers, mirroring the indexer's
+      #   `IVAR_BARRIER_NODES` policy.
+      class IvarWriteCollector
+        BARRIER_NODES = [Prism::DefNode, Prism::ClassNode, Prism::ModuleNode].freeze
+        private_constant :BARRIER_NODES
+
+        # Returns `Hash[class_name (String) => Hash[ivar_name
+        # (Symbol) => Array<{node:, type:}>]]`. Empty when the
+        # tree has no qualifying writes.
+        def initialize(scope_index)
+          @scope_index = scope_index
+          @accumulator = {}
+        end
+
+        def collect(root)
+          walk(root, [])
+          @accumulator.transform_values(&:freeze).freeze
+        end
+
+        private
+
+        def walk(node, qualified_prefix)
+          return unless node.is_a?(Prism::Node)
+
+          case node
+          when Prism::ClassNode, Prism::ModuleNode
+            name = qualified_name_for(node.constant_path)
+            if name
+              walk(node.body, qualified_prefix + [name]) if node.body
+              return
+            end
+          when Prism::DefNode
+            collect_def_writes(node, qualified_prefix)
+            return
+          end
+
+          node.compact_child_nodes.each { |child| walk(child, qualified_prefix) }
+        end
+
+        def collect_def_writes(def_node, qualified_prefix)
+          return if def_node.body.nil? || qualified_prefix.empty?
+          return if def_node.receiver.is_a?(Prism::SelfNode)
+
+          class_name = qualified_prefix.join("::")
+          gather_writes(def_node.body, class_name)
+        end
+
+        def gather_writes(node, class_name)
+          return unless node.is_a?(Prism::Node)
+
+          record_write(node, class_name) if node.is_a?(Prism::InstanceVariableWriteNode)
+          return if BARRIER_NODES.any? { |klass| node.is_a?(klass) }
+
+          node.compact_child_nodes.each { |child| gather_writes(child, class_name) }
+        end
+
+        def record_write(node, class_name)
+          scope = @scope_index[node]
+          return if scope.nil?
+
+          rvalue_type = scope.type_of(node.value)
+          @accumulator[class_name] ||= {}
+          @accumulator[class_name][node.name] ||= []
+          @accumulator[class_name][node.name] << { node: node, type: rvalue_type }
+        end
+
+        # Same shape resolution as `ScopeIndexer.qualified_name_for`
+        # (single-segment ConstantReadNode and dotted
+        # ConstantPathNode). Inlined here to keep the collector
+        # self-contained — the rule lives outside the indexer's
+        # private surface.
+        def qualified_name_for(constant_path_node)
+          case constant_path_node
+          when Prism::ConstantReadNode then constant_path_node.name.to_s
+          when Prism::ConstantPathNode then render_constant_path(constant_path_node)
+          end
+        end
+
+        def render_constant_path(node)
+          prefix =
+            case node.parent
+            when Prism::ConstantReadNode then "#{node.parent.name}::"
+            when Prism::ConstantPathNode then "#{render_constant_path(node.parent)}::"
+            else ""
+            end
+          "#{prefix}#{node.name}"
+        end
+      end
+    end
+  end
+end