type-guessr 0.0.2 → 0.0.4

data/lib/type_guessr/core/converter/call_converter.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module TypeGuessr
+  module Core
+    module Converter
+      # Method call, block, and call-related helper methods for PrismConverter
+      class PrismConverter
+        private def convert_call(prism_node, context)
+          # Convert receiver - if nil and inside a class, create implicit SelfNode
+          receiver_node = if prism_node.receiver
+                            convert(prism_node.receiver, context)
+                          elsif context.current_class_name
+                            IR::SelfNode.new(
+                              context.current_class_name,
+                              context.in_singleton_method,
+                              [],
+                              convert_loc(prism_node.location)
+                            )
+                          end
+
+          args = prism_node.arguments&.arguments&.map { |arg| convert(arg, context) } || []
+
+          has_block = !prism_node.block.nil?
+
+          # Track method call on receiver for method-based type inference
+          if variable_node?(receiver_node) && receiver_node.called_methods.none? { |cm| cm.name == prism_node.name }
+            receiver_node.called_methods << build_called_method(prism_node)
+          end
+
+          # Handle container mutating methods (Hash#[]=, Array#[]=, Array#<<)
+          receiver_node = handle_container_mutation(prism_node, receiver_node, args, context) if container_mutating_method?(prism_node.name, receiver_node)
+
+          # Use message_loc for method name position to match hover lookup
+          call_loc = convert_loc(prism_node.message_loc || prism_node.location)
+          call_node = IR::CallNode.new(
+            prism_node.name, receiver_node, args, [], nil, has_block, [], call_loc
+          )
+
+          # Handle block if present (but not block arguments like &block)
+          if prism_node.block.is_a?(Prism::BlockNode)
+            block_body = convert_block(prism_node.block, call_node, context)
+            # Update block_body and has_block on mutable Struct
+            call_node.block_body = block_body
+            call_node.has_block = true
+          end
+
+          call_node
+        end
+
+        # Check if node is any variable node (for method call tracking)
+        private def variable_node?(node)
+          node.is_a?(IR::LocalWriteNode) ||
+            node.is_a?(IR::LocalReadNode) ||
+            node.is_a?(IR::InstanceVariableWriteNode) ||
+            node.is_a?(IR::InstanceVariableReadNode) ||
+            node.is_a?(IR::ClassVariableWriteNode) ||
+            node.is_a?(IR::ClassVariableReadNode) ||
+            node.is_a?(IR::ParamNode) ||
+            node.is_a?(IR::BlockParamSlot)
+        end
+
+        # Build CalledMethod with signature information from Prism CallNode
+        private def build_called_method(prism_node)
+          positional_count, has_splat, keywords = extract_call_signature(prism_node)
+
+          IR::CalledMethod.new(
+            name: prism_node.name,
+            positional_count: has_splat ? nil : positional_count,
+            keywords: keywords
+          )
+        end
+
+        # Extract positional count, splat presence, and keywords from call arguments
+        # @return [Array(Integer, Boolean, Array<Symbol>)] [positional_count, has_splat, keywords]
+        private def extract_call_signature(prism_node)
+          arguments = prism_node.arguments&.arguments || []
+          positional_count = 0
+          has_splat = false
+          keywords = []
+
+          arguments.each do |arg|
+            case arg
+            when Prism::SplatNode
+              has_splat = true
+            when Prism::KeywordHashNode
+              extract_keywords_from_hash(arg, keywords)
+            else
+              positional_count += 1
+            end
+          end
+
+          [positional_count, has_splat, keywords]
+        end
+
+        # Extract keyword argument names from KeywordHashNode
+        private def extract_keywords_from_hash(hash_node, keywords)
+          hash_node.elements.each do |element|
+            next unless element.is_a?(Prism::AssocNode)
+
+            key = element.key
+            keywords << key.value.to_sym if key.is_a?(Prism::SymbolNode)
+          end
+        end
+
+        # Extract IR param nodes from a Prism parameter node
+        # Handles destructuring (MultiTargetNode) by flattening nested params
+        private def extract_param_nodes(param, kind, context, default_value: nil)
+          case param
+          when Prism::MultiTargetNode
+            # Destructuring parameter like (a, b) - extract all nested params
+            param.lefts.flat_map { |p| extract_param_nodes(p, kind, context) } +
+              param.rights.flat_map { |p| extract_param_nodes(p, kind, context) }
+          when Prism::RequiredParameterNode, Prism::OptionalParameterNode
+            param_node = IR::ParamNode.new(param.name, kind, default_value, [], convert_loc(param.location))
+            context.register_variable(param.name, param_node)
+            [param_node]
+          else
+            []
+          end
+        end
+
+        private def convert_block(block_node, call_node, context)
+          # Create block parameter slots and register them in context
+          block_context = context.fork(:block)
+
+          if block_node.parameters.is_a?(Prism::BlockParametersNode)
+            parameters_node = block_node.parameters.parameters
+            if parameters_node
+              # Collect all parameters in order
+              params = []
+              params.concat(parameters_node.requireds) if parameters_node.requireds
+              params.concat(parameters_node.optionals) if parameters_node.optionals
+
+              params.each_with_index do |param, index|
+                param_name, param_loc = case param
+                                        when Prism::RequiredParameterNode
+                                          [param.name, param.location]
+                                        when Prism::OptionalParameterNode
+                                          [param.name, param.location]
+                                        when Prism::MultiTargetNode
+                                          # Destructuring parameters like |a, (b, c)|
+                                          # For now, skip complex cases
+                                          next
+                                        else
+                                          next
+                                        end
+
+                slot = IR::BlockParamSlot.new(index, call_node, [], convert_loc(param_loc))
+                call_node.block_params << slot
+                block_context.register_variable(param_name, slot)
+              end
+            end
+          end
+
+          # Convert block body and return it for block return type inference
+          block_node.body ? convert(block_node.body, block_context) : nil
+        end
+      end
+    end
+  end
+end

data/lib/type_guessr/core/converter/container_mutation_converter.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+module TypeGuessr
+  module Core
+    module Converter
+      # Container mutation methods (Hash#[]=, Array#[]=, Array#<<) for PrismConverter
+      class PrismConverter
+        # Check if node is a local variable node (for indexed assignment)
+        private def local_variable_node?(node)
+          node.is_a?(IR::LocalWriteNode) || node.is_a?(IR::LocalReadNode)
+        end
+
+        private def extract_literal_type(ir_node)
+          case ir_node
+          when IR::LiteralNode
+            ir_node.type
+          else
+            Types::Unknown.instance
+          end
+        end
+
+        private def widen_to_hash_type(original_type, key_arg, value_type)
+          # When mixing key types, widen to generic HashType
+          new_key_type = infer_key_type(key_arg)
+
+          case original_type
+          when Types::HashShape
+            # HashShape with symbol keys + non-symbol key -> widen to Hash[Symbol | NewKeyType, ValueUnion]
+            original_key_type = Types::ClassInstance.for("Symbol")
+            original_value_types = original_type.fields.values.uniq
+            all_value_types = (original_value_types + [value_type]).uniq
+
+            combined_key_type = Types::Union.new([original_key_type, new_key_type].uniq)
+            combined_value_type = all_value_types.size == 1 ? all_value_types.first : Types::Union.new(all_value_types)
+
+            Types::HashType.new(combined_key_type, combined_value_type)
+          when Types::HashType
+            # Already a HashType, just union the key and value types
+            combined_key_type = union_types(original_type.key_type, new_key_type)
+            combined_value_type = union_types(original_type.value_type, value_type)
+            Types::HashType.new(combined_key_type, combined_value_type)
+          else
+            Types::HashType.new(new_key_type, value_type)
+          end
+        end
+
+        private def union_types(type1, type2)
+          return type2 if type1.nil? || type1.is_a?(Types::Unknown)
+          return type1 if type2.nil? || type2.is_a?(Types::Unknown)
+          return type1 if type1 == type2
+
+          types = []
+          types += type1.is_a?(Types::Union) ? type1.types : [type1]
+          types += type2.is_a?(Types::Union) ? type2.types : [type2]
+          Types::Union.new(types.uniq)
+        end
+
+        private def infer_key_type(key_arg)
+          case key_arg
+          when Prism::SymbolNode
+            Types::ClassInstance.for("Symbol")
+          when Prism::StringNode
+            Types::ClassInstance.for("String")
+          when Prism::IntegerNode
+            Types::ClassInstance.for("Integer")
+          else
+            Types::Unknown.instance
+          end
+        end
+
+        # Check if method is a container mutating method
+        private def container_mutating_method?(method, receiver_node)
+          return false unless local_variable_node?(receiver_node)
+
+          receiver_type = get_receiver_type(receiver_node)
+          return false unless receiver_type
+
+          case method
+          when :[]= then hash_like?(receiver_type) || array_like?(receiver_type)
+          when :<<  then array_like?(receiver_type)
+          else false
+          end
+        end
+
+        # Get receiver's current type
+        private def get_receiver_type(receiver_node)
+          return nil unless receiver_node.respond_to?(:write_node)
+
+          write_node = receiver_node.write_node
+          return nil unless write_node
+          return nil unless write_node.respond_to?(:value)
+
+          value = write_node.value
+          return nil unless value.respond_to?(:type)
+
+          value.type
+        end
+
+        # Check if type is hash-like
+        private def hash_like?(type)
+          type.is_a?(Types::HashShape) || type.is_a?(Types::HashType)
+        end
+
+        # Check if type is array-like
+        private def array_like?(type)
+          type.is_a?(Types::ArrayType) || type.is_a?(Types::TupleType)
+        end
+
+        # Handle container mutation by creating new LocalWriteNode with merged type
+        private def handle_container_mutation(prism_node, receiver_node, args, context)
+          merged_type = compute_merged_type(receiver_node, prism_node.name, args, prism_node)
+          return receiver_node unless merged_type
+
+          # Block scope + outer variable → widen TupleType to ArrayType
+          is_outer_var = context.scope_type == :block && !context.owns_variable?(receiver_node.name)
+          merged_type = widen_tuple_to_array(merged_type) if is_outer_var
+
+          # Create new LiteralNode with merged type
+          value_node = IR::LiteralNode.new(merged_type, nil, nil, [], receiver_node.loc)
+
+          # Create new LocalWriteNode with merged type
+          new_write = IR::LocalWriteNode.new(
+            receiver_node.name, value_node, receiver_node.called_methods, convert_loc(prism_node.location)
+          )
+
+          # Register for next line references
+          context.register_variable(receiver_node.name, new_write)
+
+          # Propagate widened type to parent context (so it's visible after block)
+          context.register_variable_in_parent(receiver_node.name, new_write) if is_outer_var
+
+          # Create new LocalReadNode pointing to new write_node
+          new_read = IR::LocalReadNode.new(
+            receiver_node.name, new_write, receiver_node.called_methods, receiver_node.loc
+          )
+
+          # Register the newly created nodes in location_index
+          if context.location_index
+            context.location_index.add(context.file_path, value_node, context.scope_id)
+            context.location_index.add(context.file_path, new_write, context.scope_id)
+            context.location_index.add(context.file_path, new_read, context.scope_id)
+          end
+
+          new_read
+        end
+
+        # Compute merged type for container mutation
+        private def compute_merged_type(receiver_node, method, args, prism_node)
+          original_type = get_receiver_type(receiver_node)
+          return nil unless original_type
+
+          case method
+          when :[]=
+            if hash_like?(original_type)
+              compute_hash_assignment_type(original_type, args, prism_node)
+            elsif array_like?(original_type)
+              compute_array_assignment_type(original_type, args)
+            end
+          when :<<
+            compute_array_append_type(original_type, args) if array_like?(original_type)
+          end
+        end
+
+        # Compute Hash type after indexed assignment
+        private def compute_hash_assignment_type(original_type, args, prism_node)
+          return nil unless args.size == 2
+
+          key_arg = prism_node.arguments.arguments[0]
+          value_type = extract_literal_type(args[1])
+
+          case original_type
+          when Types::HashShape
+            if key_arg.is_a?(Prism::SymbolNode)
+              # Symbol key → keep HashShape, add field
+              key_name = key_arg.value.to_sym
+              Types::HashShape.new(original_type.fields.merge(key_name => value_type))
+            else
+              # Non-symbol key → widen to HashType
+              widen_to_hash_type(original_type, key_arg, value_type)
+            end
+          when Types::HashType
+            # Empty hash (Unknown types) + symbol key → becomes HashShape with one field
+            if empty_hash_type?(original_type) && key_arg.is_a?(Prism::SymbolNode)
+              key_name = key_arg.value.to_sym
+              Types::HashShape.new({ key_name => value_type })
+            else
+              key_type = infer_key_type(key_arg)
+              Types::HashType.new(
+                union_types(original_type.key_type, key_type),
+                union_types(original_type.value_type, value_type)
+              )
+            end
+          end
+        end
+
+        # Check if HashType is empty (has Unknown types)
+        private def empty_hash_type?(hash_type)
+          (hash_type.key_type.nil? || hash_type.key_type.is_a?(Types::Unknown)) &&
+            (hash_type.value_type.nil? || hash_type.value_type.is_a?(Types::Unknown))
+        end
+
+        # Compute Array type after indexed assignment
+        private def compute_array_assignment_type(original_type, args)
+          return nil unless args.size == 2
+
+          value_type = extract_literal_type(args[1])
+          case original_type
+          when Types::TupleType
+            Types::TupleType.new(original_type.element_types + [value_type])
+          else
+            combined = union_types(original_type.element_type, value_type)
+            Types::ArrayType.new(combined)
+          end
+        end
+
+        # Compute Array type after << operator
+        private def compute_array_append_type(original_type, args)
+          return nil unless args.size == 1
+
+          value_type = extract_literal_type(args[0])
+          case original_type
+          when Types::TupleType
+            Types::TupleType.new(original_type.element_types + [value_type])
+          else
+            combined = union_types(original_type.element_type, value_type)
+            Types::ArrayType.new(combined)
+          end
+        end
+
+        # Widen TupleType to ArrayType (for block mutations where position info is meaningless)
+        private def widen_tuple_to_array(type)
+          return type unless type.is_a?(Types::TupleType)
+
+          unique = type.element_types.uniq
+          elem = unique.size == 1 ? unique.first : Types::Union.new(unique)
+          Types::ArrayType.new(elem)
+        end
+      end
+    end
+  end
+end

data/lib/type_guessr/core/converter/context.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require_relative "../ir"
+
+module TypeGuessr
+  module Core
+    module Converter
+      class PrismConverter
+        # Context for tracking variable bindings during conversion
+        class Context
+          attr_reader :variables, :file_path, :location_index, :method_registry, :ivar_registry, :cvar_registry
+          attr_accessor :current_class, :current_method, :in_singleton_method
+
+          def initialize(parent = nil, file_path: nil, location_index: nil,
+                         method_registry: nil, ivar_registry: nil, cvar_registry: nil)
+            @parent = parent
+            @variables = {} # name => node
+            @instance_variables = {} # @name => node (only for class-level context)
+            @narrowed_ivars = {} # @name => narrowed node (method-level, does not pollute class-level)
+            @constants = {} # name => dependency node (for constant alias tracking)
+            @scope_type = nil # :class, :method, :block, :top_level
+            @current_class = nil
+            @current_method = nil
+            @in_singleton_method = false
+
+            # Index/registry references (inherited from parent or set directly)
+            @file_path = file_path || parent&.file_path
+            @location_index = location_index || parent&.location_index
+            @method_registry = method_registry || parent&.method_registry
+            @ivar_registry = ivar_registry || parent&.ivar_registry
+            @cvar_registry = cvar_registry || parent&.cvar_registry
+          end
+
+          def register_variable(name, node)
+            @variables[name] = node
+          end
+
+          def lookup_variable(name)
+            @variables[name] || @parent&.lookup_variable(name)
+          end
+
+          # Register an instance variable at the class level
+          # Instance variables are shared across all methods in a class
+          def register_instance_variable(name, node)
+            if @scope_type == :class
+              @instance_variables[name] = node
+            elsif @parent
+              @parent.register_instance_variable(name, node)
+            else
+              # Top-level instance variable, store locally
+              @instance_variables[name] = node
+            end
+          end
+
+          # Narrow an instance variable's type within the current method scope
+          # Does not pollute the class-level ivar definition
+          def narrow_instance_variable(name, node)
+            @narrowed_ivars[name] = node
+          end
+
+          # Lookup an instance variable, checking narrowed ivars first
+          def lookup_instance_variable(name)
+            return @narrowed_ivars[name] if @narrowed_ivars.key?(name)
+
+            if @scope_type == :class
+              @instance_variables[name]
+            elsif @parent
+              @parent.lookup_instance_variable(name)
+            else
+              @instance_variables[name]
+            end
+          end
+
+          # Register a constant's dependency node for alias tracking
+          def register_constant(name, dependency_node)
+            @constants[name] = dependency_node
+          end
+
+          # Lookup a constant's dependency node (for alias resolution)
+          def lookup_constant(name)
+            @constants[name] || @parent&.lookup_constant(name)
+          end
+
+          def fork(scope_type)
+            child = Context.new(self)
+            child.instance_variable_set(:@scope_type, scope_type)
+            child.current_class = current_class_name
+            child.current_method = current_method_name
+            child.in_singleton_method = @in_singleton_method
+            child
+          end
+
+          def scope_type
+            @scope_type || @parent&.scope_type
+          end
+
+          # Get the current class name (from this context or parent)
+          def current_class_name
+            @current_class || @parent&.current_class_name
+          end
+
+          # Get the current method name (from this context or parent)
+          def current_method_name
+            @current_method || @parent&.current_method_name
+          end
+
+          # Generate scope_id for node lookup (e.g., "User#save" or "User" or "")
+          # For singleton methods, uses "<Class:ClassName>" format to match RubyIndexer convention
+          def scope_id
+            base_class_path = current_class_name || ""
+            class_path = if @in_singleton_method
+                           # Singleton methods use "<Class:ClassName>" suffix
+                           parent_name = IR.extract_last_name(base_class_path) || "Object"
+                           base_class_path.empty? ? "<Class:Object>" : "#{base_class_path}::<Class:#{parent_name}>"
+                         else
+                           base_class_path
+                         end
+            method_name = current_method_name
+            if method_name
+              "#{class_path}##{method_name}"
+            else
+              class_path
+            end
+          end
+
+          # Check if a variable is defined in this context (not inherited from parent)
+          def owns_variable?(name)
+            @variables.key?(name)
+          end
+
+          # Register a variable in the parent context (for block mutation propagation)
+          def register_variable_in_parent(name, node)
+            @parent&.register_variable(name, node)
+          end
+
+          # Get variables that were defined/modified in this context (not from parent)
+          def local_variables
+            @variables.keys
+          end
+        end
+      end
+    end
+  end
+end