type-guessr 0.0.2 → 0.0.3

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

@@ -12,6 +12,12 @@ module TypeGuessr
       # This class only handles conversion (RBS → internal types).
       # Type variable substitution is handled separately by Type#substitute.
       class RBSConverter
+        # @param class_type_params [Hash{String => Array<Symbol>}] class-level type parameter names
+        #   e.g., { "Set" => [:A], "Enumerator" => [:Elem, :Return] }
+        def initialize(class_type_params = {})
+          @class_type_params = class_type_params
+        end
+
         # Convert RBS type to internal type system
         # @param rbs_type [RBS::Types::t] the RBS type
         # @return [Types::Type] internal type representation (TypeVariables preserved)
@@ -69,7 +75,15 @@ module TypeGuessr
             return Types::RangeType.new(element_type)
           end
 
-          # For other generic types, return ClassInstance (ignore type args for now)
+          # For other generic types, build type_params hash from class definition
+          param_names = @class_type_params[class_name]
+          if param_names && rbs_type.args.any?
+            type_params = param_names.zip(rbs_type.args).to_h do |name, arg|
+              [name, arg ? convert(arg) : Types::Unknown.instance]
+            end
+            return Types::ClassInstance.for(class_name, type_params)
+          end
+
           Types::ClassInstance.for(class_name)
         end
 

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module TypeGuessr
+  module Core
+    module Converter
+      # Node registration and location conversion methods for PrismConverter
+      class PrismConverter
+        private def convert_loc(prism_location)
+          prism_location.start_offset
+        end
+
+        # Register node in location_index and registries during conversion
+        # This eliminates the need for a separate tree traversal after conversion
+        private def register_node(node, context)
+          return unless context.location_index
+
+          case node
+          when IR::DefNode
+            # DefNode uses singleton-adjusted method_scope for registration
+            method_scope = singleton_scope_for(context.current_class_name || "", singleton: node.singleton)
+            context.location_index.add(context.file_path, node, method_scope)
+            register_method(node, context)
+
+            # Register params (created directly, not via convert)
+            # Use method scope with method name for params
+            param_scope = method_scope.empty? ? "##{node.name}" : "#{method_scope}##{node.name}"
+            node.params&.each do |param|
+              context.location_index.add(context.file_path, param, param_scope)
+            end
+          when IR::ClassModuleNode
+            # ClassModuleNode uses parent scope for registration
+            context.location_index.add(context.file_path, node, context.scope_id)
+            register_class_module(node, context)
+          when IR::CallNode
+            context.location_index.add(context.file_path, node, context.scope_id)
+            # Register block params (created directly, not via convert)
+            node.block_params&.each do |param|
+              context.location_index.add(context.file_path, param, context.scope_id)
+            end
+          when IR::InstanceVariableWriteNode
+            context.location_index.add(context.file_path, node, context.scope_id)
+            context.ivar_registry&.register(node.class_name, node.name, node, file_path: context.file_path)
+          when IR::ClassVariableWriteNode
+            context.location_index.add(context.file_path, node, context.scope_id)
+            context.cvar_registry&.register(node.class_name, node.name, node, file_path: context.file_path)
+          else
+            # All other nodes (MergeNode, LiteralNode, etc.)
+            context.location_index.add(context.file_path, node, context.scope_id)
+          end
+        end
+
+        # Register method in method_registry
+        # Only registers top-level methods; class methods are handled by register_class_module
+        private def register_method(node, context)
+          return unless context.method_registry
+
+          # Only register top-level methods (no class context)
+          return unless (context.current_class_name || "").empty?
+
+          context.method_registry.register("", node.name.to_s, node, file_path: context.file_path)
+        end
+
+        # Register methods from a class/module in method_registry
+        private def register_class_module(node, context)
+          return unless context.method_registry
+
+          # Build the full class path from parent context + node name
+          parent_path = context.current_class_name || ""
+          class_path = parent_path.empty? ? node.name : "#{parent_path}::#{node.name}"
+
+          # Register each method in the class (nested classes are handled recursively via convert)
+          node.methods&.each do |method|
+            next if method.is_a?(IR::ClassModuleNode)
+
+            method_scope = singleton_scope_for(class_path, singleton: method.singleton)
+            context.method_registry.register(method_scope, method.name.to_s, method, file_path: context.file_path)
+
+            # module_function: also register as singleton method
+            if method.module_function
+              singleton_scope = singleton_scope_for(class_path, singleton: true)
+              context.method_registry.register(singleton_scope, method.name.to_s, method, file_path: context.file_path)
+            end
+          end
+        end
+
+        # Build singleton class scope for method registration/lookup
+        # Singleton methods use "<Class:ClassName>" suffix to match RubyIndexer convention
+        # @param scope [String] Base scope (e.g., "RBS::Environment")
+        # @param singleton [Boolean] Whether the method is a singleton method
+        # @return [String] Scope with singleton class suffix if applicable
+        private def singleton_scope_for(scope, singleton:)
+          return scope unless singleton
+
+          parent_name = IR.extract_last_name(scope) || "Object"
+          scope.empty? ? "<Class:Object>" : "#{scope}::<Class:#{parent_name}>"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+module TypeGuessr
+  module Core
+    module Converter
+      # Variable read/write and compound assignment methods for PrismConverter
+      class PrismConverter
+        private def convert_local_variable_write(prism_node, context)
+          value_node = convert(prism_node.value, context)
+          write_node = IR::LocalWriteNode.new(prism_node.name, value_node, [], convert_loc(prism_node.location))
+          context.register_variable(prism_node.name, write_node)
+          write_node
+        end
+
+        private def convert_local_variable_read(prism_node, context)
+          # Look up the most recent assignment
+          write_node = context.lookup_variable(prism_node.name)
+
+          IR::LocalReadNode.new(
+            prism_node.name,
+            write_node,
+            # Share called_methods array for method-based inference
+            # nil case: rescue binding (=> e), pattern matching binding, etc. (not yet implemented)
+            write_node&.called_methods || [],
+            convert_loc(prism_node.location)
+          )
+        end
+
+        private def convert_instance_variable_write(prism_node, context)
+          value_node = convert(prism_node.value, context)
+          class_name = context.current_class_name
+
+          write_node = IR::InstanceVariableWriteNode.new(
+            prism_node.name,
+            class_name,
+            value_node,
+            # Share called_methods with value node for type propagation
+            # nil case: value is an unhandled node type (convert() returns nil)
+            value_node&.called_methods || [],
+            convert_loc(prism_node.location)
+          )
+          # Register at class level so it's visible across methods
+          context.register_instance_variable(prism_node.name, write_node)
+          write_node
+        end
+
+        private def convert_instance_variable_read(prism_node, context)
+          # Look up from class level first
+          write_node = context.lookup_instance_variable(prism_node.name)
+
+          IR::InstanceVariableReadNode.new(
+            prism_node.name,
+            context.current_class_name,
+            write_node,
+            # Share called_methods array for method-based inference
+            # nil case: instance variable read before any assignment in current file
+            write_node&.called_methods || [],
+            convert_loc(prism_node.location)
+          )
+        end
+
+        private def convert_class_variable_write(prism_node, context)
+          value_node = convert(prism_node.value, context)
+
+          write_node = IR::ClassVariableWriteNode.new(
+            prism_node.name,
+            context.current_class_name,
+            value_node,
+            # Share called_methods with value node for type propagation
+            # nil case: value is an unhandled node type (e.g., LambdaNode)
+            value_node&.called_methods || [],
+            convert_loc(prism_node.location)
+          )
+          context.register_variable(prism_node.name, write_node)
+          write_node
+        end
+
+        private def convert_class_variable_read(prism_node, context)
+          write_node = context.lookup_variable(prism_node.name)
+
+          IR::ClassVariableReadNode.new(
+            prism_node.name,
+            context.current_class_name,
+            write_node,
+            # Share called_methods array for method-based inference
+            # nil case: class variable read before any assignment in current file
+            write_node&.called_methods || [],
+            convert_loc(prism_node.location)
+          )
+        end
+
+        # Compound assignment: x ||= value
+        # Result type is union of original and new value type
+        private def convert_local_variable_or_write(prism_node, context)
+          convert_or_write(prism_node, context, :local)
+        end
+
+        # Compound assignment: x &&= value
+        # Result type is union of original and new value type
+        private def convert_local_variable_and_write(prism_node, context)
+          convert_and_write(prism_node, context, :local)
+        end
+
+        # Compound assignment: x += value, x -= value, etc.
+        # Result type depends on the operator method return type
+        private def convert_local_variable_operator_write(prism_node, context)
+          convert_operator_write(prism_node, context, :local)
+        end
+
+        private def convert_instance_variable_or_write(prism_node, context)
+          convert_or_write(prism_node, context, :instance)
+        end
+
+        private def convert_instance_variable_and_write(prism_node, context)
+          convert_and_write(prism_node, context, :instance)
+        end
+
+        private def convert_instance_variable_operator_write(prism_node, context)
+          convert_operator_write(prism_node, context, :instance)
+        end
+
+        # Generic ||= handler
+        # x ||= value means: if x is nil/false, x = value, else keep x
+        # Uses OrNode to apply truthiness filtering (removes nil/false from LHS)
+        private def convert_or_write(prism_node, context, kind)
+          original_node = lookup_by_kind(prism_node.name, kind, context)
+          value_node = convert(prism_node.value, context)
+
+          or_node = if original_node
+                      IR::OrNode.new(
+                        original_node,
+                        value_node,
+                        [],
+                        convert_loc(prism_node.location)
+                      )
+                    else
+                      value_node
+                    end
+
+          write_node = create_write_node(prism_node.name, kind, or_node, context, prism_node.location)
+          register_by_kind(prism_node.name, write_node, kind, context)
+          write_node
+        end
+
+        # Generic &&= handler
+        # x &&= value means: if x is truthy, x = value, else keep x
+        # Type is union of original type and value type
+        private def convert_and_write(prism_node, context, kind)
+          original_node = lookup_by_kind(prism_node.name, kind, context)
+          value_node = convert(prism_node.value, context)
+
+          # Create merge node for union type (original | value)
+          branches = []
+          branches << original_node if original_node
+          branches << value_node
+
+          merge_node = if branches.size == 1
+                         branches.first
+                       else
+                         IR::MergeNode.new(
+                           branches,
+                           [],
+                           convert_loc(prism_node.location)
+                         )
+                       end
+
+          write_node = create_write_node(prism_node.name, kind, merge_node, context, prism_node.location)
+          register_by_kind(prism_node.name, write_node, kind, context)
+          write_node
+        end
+
+        # Generic operator write handler (+=, -=, *=, etc.)
+        # x += value is equivalent to x = x.+(value)
+        # Type is the return type of the operator method
+        private def convert_operator_write(prism_node, context, kind)
+          original_node = lookup_by_kind(prism_node.name, kind, context)
+          value_node = convert(prism_node.value, context)
+
+          # Create a call node representing x.operator(value)
+          call_node = IR::CallNode.new(
+            prism_node.binary_operator, original_node, [value_node], [], nil, false, [], convert_loc(prism_node.location)
+          )
+
+          # Create write node with call result as value
+          write_node = create_write_node(prism_node.name, kind, call_node, context, prism_node.location)
+          register_by_kind(prism_node.name, write_node, kind, context)
+          write_node
+        end
+
+        # Helper to create the appropriate write node type based on kind
+        private def create_write_node(name, kind, value, context, location)
+          loc = convert_loc(location)
+          case kind
+          when :local
+            IR::LocalWriteNode.new(name, value, [], loc)
+          when :instance
+            IR::InstanceVariableWriteNode.new(name, context.current_class_name, value, [], loc)
+          when :class
+            IR::ClassVariableWriteNode.new(name, context.current_class_name, value, [], loc)
+          end
+        end
+
+        # Helper to lookup variable by kind
+        private def lookup_by_kind(name, kind, context)
+          case kind
+          when :instance
+            context.lookup_instance_variable(name)
+          else
+            context.lookup_variable(name)
+          end
+        end
+
+        # Helper to register variable by kind
+        private def register_by_kind(name, node, kind, context)
+          case kind
+          when :instance
+            context.register_instance_variable(name, node)
+          else
+            context.register_variable(name, node)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/type_guessr/core/converter.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative "converter/prism_converter"
+require_relative "converter/rbs_converter"

data/lib/type_guessr/core/index.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "index/location_index"