rigortype 0.0.9 → 0.1.1

data/lib/rigor/inference/scope_indexer.rb

@@ -340,7 +340,7 @@ module Rigor
         accumulator.transform_values(&:freeze).freeze
       end
 
-      def walk_methods(node, qualified_prefix, in_singleton_class, accumulator) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def walk_methods(node, qualified_prefix, in_singleton_class, accumulator) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         return unless node.is_a?(Prism::Node)
 
         case node
@@ -359,6 +359,9 @@ module Rigor
         when Prism::DefNode
           record_def_method(node, qualified_prefix, in_singleton_class, accumulator)
           return
+        when Prism::AliasMethodNode
+          record_alias_method(node, qualified_prefix, in_singleton_class, accumulator)
+          return
         when Prism::CallNode
           record_define_method(node, qualified_prefix, in_singleton_class, accumulator) if node.name == :define_method
         end
@@ -390,6 +393,7 @@ module Rigor
       def build_discovered_def_nodes(root)
         accumulator = {}
         walk_def_nodes(root, [], false, accumulator)
+        apply_alias_def_nodes(root, accumulator)
         accumulator.transform_values(&:freeze).freeze
       end
 
@@ -436,6 +440,76 @@ module Rigor
         accumulator[class_name][def_node.name] = def_node
       end
 
+      # Registers the alias name in the `discovered_methods` table so
+      # `undefined-method` diagnostics are not emitted for calls to the
+      # aliased name. The kind mirrors the surrounding class context
+      # (instance inside a regular class body, singleton inside
+      # `class << self`).
+      def record_alias_method(alias_node, qualified_prefix, in_singleton_class, accumulator)
+        return if qualified_prefix.empty?
+        return unless alias_node.new_name.is_a?(Prism::SymbolNode)
+
+        class_name = qualified_prefix.join("::")
+        new_name = alias_node.new_name.unescaped.to_sym
+        kind = in_singleton_class ? :singleton : :instance
+        (accumulator[class_name] ||= {})[new_name] = kind
+      end
+
+      # Post-pass over the `def_nodes` accumulator: for every `alias`
+      # declaration inside a class body, if the original method name
+      # maps to a `Prism::DefNode`, register the new name pointing to
+      # the same node so inter-procedural return-type inference works
+      # for the aliased name.
+      def apply_alias_def_nodes(root, accumulator)
+        alias_map = collect_class_alias_map(root, [], {})
+        alias_map.each do |class_name, aliases|
+          class_defs = accumulator[class_name]
+          next unless class_defs
+
+          aliases.each do |new_name, old_name|
+            def_node = class_defs[old_name]
+            next unless def_node.is_a?(Prism::DefNode)
+
+            (accumulator[class_name] ||= {})[new_name] = def_node
+          end
+        end
+      end
+
+      # Builds a map `{class_name => {new_name_sym => old_name_sym}}` by
+      # walking the tree for `AliasMethodNode` nodes inside class bodies.
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def collect_class_alias_map(node, qualified_prefix, accumulator)
+        return accumulator unless node.is_a?(Prism::Node)
+
+        case node
+        when Prism::ClassNode, Prism::ModuleNode
+          name = qualified_name_for(node.constant_path)
+          if name
+            collect_class_alias_map(node.body, qualified_prefix + [name], accumulator) if node.body
+            return accumulator
+          end
+        when Prism::SingletonClassNode
+          return accumulator
+        when Prism::AliasMethodNode
+          record_alias_map_entry(node, qualified_prefix, accumulator)
+          return accumulator
+        end
+
+        node.compact_child_nodes.each { |child| collect_class_alias_map(child, qualified_prefix, accumulator) }
+        accumulator
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      def record_alias_map_entry(alias_node, qualified_prefix, accumulator)
+        return if qualified_prefix.empty?
+        return unless alias_node.new_name.is_a?(Prism::SymbolNode) && alias_node.old_name.is_a?(Prism::SymbolNode)
+
+        class_name = qualified_prefix.join("::")
+        new_name = alias_node.new_name.unescaped.to_sym
+        old_name = alias_node.old_name.unescaped.to_sym
+        (accumulator[class_name] ||= {})[new_name] = old_name
+      end
+
       def record_define_method(call_node, qualified_prefix, in_singleton_class, accumulator)
         return if qualified_prefix.empty?
         return if call_node.arguments.nil? || call_node.arguments.arguments.empty?
@@ -478,7 +552,7 @@ module Rigor
         when Prism::ModuleNode, Prism::ClassNode
           return if record_class_or_module?(node, qualified_prefix, identity_table, discovered)
         when Prism::ConstantWriteNode
-          return if record_data_define_constant?(node, qualified_prefix, identity_table, discovered)
+          return if record_meta_new_constant?(node, qualified_prefix, identity_table, discovered)
         end
 
         node.compact_child_nodes.each do |child|
@@ -499,17 +573,23 @@ module Rigor
         true
       end
 
-      # Recognises `Const = Data.define(*Symbol) [do ... end]` and registers
-      # `Const` (qualified by the surrounding class/module path) as a
-      # discovered class. `Const.new(...)` then resolves to a fresh
-      # `Nominal[Const]` via `meta_new`, instead of the un-narrowed
-      # `Dynamic[top]` returned by the default `Class#new` envelope.
+      # Recognises class-creating meta calls at constant-write rvalue
+      # position and registers `Const` (qualified by the surrounding
+      # class/module path) as a discovered class. `Const.new(...)`
+      # then resolves to a fresh `Nominal[Const]` via `meta_new`,
+      # instead of the un-narrowed `Dynamic[top]` returned by the
+      # default `Class#new` envelope.
       #
-      # The Data.define block body, if present, is recursed into so any
-      # nested class/module declarations in the override block (rare but
-      # legal) still feed the discovered table.
-      def record_data_define_constant?(node, qualified_prefix, identity_table, discovered)
-        return false unless data_define_call?(node.value)
+      # Two recognised meta forms:
+      #
+      # - `Const = Data.define(*Symbol) [do ... end]`
+      # - `Const = Struct.new(*Symbol [, keyword_init: ...]) [do ... end]`
+      #
+      # The block body, if present, is recursed into so any nested
+      # class/module declarations in the override block (rare but legal)
+      # still feed the discovered table.
+      def record_meta_new_constant?(node, qualified_prefix, identity_table, discovered)
+        return false unless data_define_call?(node.value) || struct_new_call?(node.value)
 
         full = (qualified_prefix + [node.name.to_s]).join("::")
         discovered[full] = Type::Combinator.singleton_of(full)
@@ -525,18 +605,46 @@ module Rigor
       def data_define_call?(node)
         return false unless node.is_a?(Prism::CallNode)
         return false unless node.name == :define
-        return false unless data_constant_receiver?(node.receiver)
+        return false unless meta_constant_receiver?(node.receiver, :Data)
 
         args = node.arguments&.arguments || []
         args.all?(Prism::SymbolNode)
       end
 
-      def data_constant_receiver?(node)
+      # Recognises `Struct.new(*Symbol)` and
+      # `Struct.new(*Symbol, keyword_init: <expr>)` at constant-write
+      # rvalue position. A trailing `KeywordHashNode` (the
+      # `keyword_init: ...` form) is accepted but does not contribute
+      # to member discovery; every other argument MUST be a
+      # `Prism::SymbolNode`. At least one Symbol member is required —
+      # `Struct.new()` is a degenerate form callers don't typically use.
+      def struct_new_call?(node)
+        return false unless meta_call_with_name?(node, :Struct, :new)
+
+        args = node.arguments&.arguments || []
+        positional = struct_new_positionals(args)
+        return false if positional.nil? || positional.empty?
+
+        positional.all?(Prism::SymbolNode)
+      end
+
+      def meta_call_with_name?(node, receiver_name, method_name)
+        return false unless node.is_a?(Prism::CallNode)
+        return false unless node.name == method_name
+
+        meta_constant_receiver?(node.receiver, receiver_name)
+      end
+
+      def struct_new_positionals(args)
+        args.last.is_a?(Prism::KeywordHashNode) ? args[0..-2] : args
+      end
+
+      def meta_constant_receiver?(node, expected_name)
         case node
         when Prism::ConstantReadNode
-          node.name == :Data
+          node.name == expected_name
         when Prism::ConstantPathNode
-          node.parent.nil? && node.name == :Data
+          node.parent.nil? && node.name == expected_name
         end
       end