type-guessr 0.0.1 → 0.0.3

data/lib/type_guessr/core/ir.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "ir/nodes"

data/lib/type_guessr/core/logger.rb

@@ -1,18 +1,13 @@
 # frozen_string_literal: true
 
-require_relative "../../ruby_lsp/type_guessr/config"
+require_relative "config"
 
 module TypeGuessr
   module Core
     # Unified logging interface for TypeGuessr
     # Uses Config.debug? to control output
     module Logger
-      module_function
-
-      # Log debug message with optional context
-      # @param msg [String] the debug message
-      # @param context [Hash] optional context information
-      def debug(msg, context = {})
+      module_function def debug(msg, context = {})
         return unless debug_enabled?
 
         output = "[TypeGuessr:DEBUG] #{msg}"
@@ -23,20 +18,18 @@ module TypeGuessr
       # Log error message with optional exception
       # @param msg [String] the error message
       # @param exception [Exception, nil] optional exception for backtrace
-      def error(msg, exception = nil)
-        return unless debug_enabled?
-
+      module_function def error(msg, exception = nil)
         warn "[TypeGuessr:ERROR] #{msg}"
         return unless exception
 
         warn "  #{exception.class}: #{exception.message}"
-        warn exception.backtrace.first(5).map { |l| "    #{l}" }.join("\n")
+        warn exception.backtrace&.first(5)&.map { |l| "    #{l}" }&.join("\n")
       end
 
       # Check if debug mode is enabled
       # @return [Boolean] true if Config.debug? returns true
-      def debug_enabled?
-        RubyLsp::TypeGuessr::Config.debug?
+      module_function def debug_enabled?
+        TypeGuessr::Core::Config.debug?
       end
     end
   end

data/lib/type_guessr/core/node_context_helper.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require_relative "node_key_generator"
+
+module TypeGuessr
+  module Core
+    # Helper module for generating scope IDs and node hashes from Prism nodes and NodeContext.
+    # Extracted from Hover and TypeInferrer to eliminate code duplication.
+    #
+    # This module provides framework-agnostic utilities that bridge between ruby-lsp's
+    # NodeContext and TypeGuessr's IR node key format.
+    module NodeContextHelper
+      module_function def generate_scope_id(node_context, exclude_method: false)
+        class_path = node_context.nesting.map do |n|
+          n.is_a?(String) ? n : n.name.to_s
+        end.join("::")
+
+        method_name = exclude_method ? nil : node_context.surrounding_method
+
+        if method_name
+          "#{class_path}##{method_name}"
+        else
+          class_path
+        end
+      end
+
+      # Generate node_hash from Prism node to match IR node_hash format
+      # @param node [Prism::Node] The Prism node
+      # @param node_context [RubyLsp::NodeContext] The context (for block param detection and nesting)
+      # @return [String, nil] The node hash or nil for unsupported node types
+      module_function def generate_node_hash(node, node_context)
+        offset = node.location.start_offset
+        case node
+        when Prism::LocalVariableWriteNode, Prism::LocalVariableTargetNode
+          NodeKeyGenerator.local_write(node.name, offset)
+        when Prism::LocalVariableReadNode
+          NodeKeyGenerator.local_read(node.name, offset)
+        when Prism::InstanceVariableWriteNode, Prism::InstanceVariableTargetNode
+          NodeKeyGenerator.ivar_write(node.name, offset)
+        when Prism::InstanceVariableReadNode
+          NodeKeyGenerator.ivar_read(node.name, offset)
+        when Prism::ClassVariableWriteNode, Prism::ClassVariableTargetNode
+          NodeKeyGenerator.cvar_write(node.name, offset)
+        when Prism::ClassVariableReadNode
+          NodeKeyGenerator.cvar_read(node.name, offset)
+        when Prism::GlobalVariableWriteNode, Prism::GlobalVariableTargetNode
+          NodeKeyGenerator.global_write(node.name, offset)
+        when Prism::GlobalVariableReadNode
+          NodeKeyGenerator.global_read(node.name, offset)
+        when Prism::RequiredParameterNode, Prism::OptionalParameterNode, Prism::RestParameterNode,
+             Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode,
+             Prism::KeywordRestParameterNode, Prism::BlockParameterNode
+          # Check if this is a block parameter (parent is BlockParametersNode)
+          if block_parameter?(node, node_context)
+            index = block_parameter_index(node, node_context)
+            NodeKeyGenerator.bparam(index, offset)
+          else
+            NodeKeyGenerator.param(node.name, offset)
+          end
+        when Prism::ForwardingParameterNode
+          NodeKeyGenerator.param(:"...", offset)
+        when Prism::CallNode
+          # Use message_loc for accurate offset
+          call_offset = node.message_loc&.start_offset || offset
+          NodeKeyGenerator.call(node.name, call_offset)
+        when Prism::DefNode
+          # Use name_loc for accurate offset
+          def_offset = node.name_loc&.start_offset || offset
+          NodeKeyGenerator.def_node(node.name, def_offset)
+        when Prism::SelfNode
+          class_path = node_context.nesting.map do |n|
+            n.is_a?(String) ? n : n.name.to_s
+          end.join("::")
+          NodeKeyGenerator.self_node(class_path, offset)
+        end
+      end
+
+      # Check if a parameter node is inside a block (not a method definition)
+      # @param node [Prism::Node] The parameter node
+      # @param node_context [RubyLsp::NodeContext] The context
+      # @return [Boolean] true if inside a block
+      module_function def block_parameter?(node, node_context)
+        call_node = node_context.call_node
+        return false unless call_node&.block
+
+        # Check if this parameter is in the block's parameters
+        block_params = call_node.block.parameters&.parameters
+        return false unless block_params
+
+        all_params = collect_block_params(block_params)
+        all_params.include?(node)
+      end
+
+      # Get the index of a block parameter
+      # @param node [Prism::Node] The parameter node
+      # @param node_context [RubyLsp::NodeContext] The context
+      # @return [Integer] The parameter index
+      module_function def block_parameter_index(node, node_context)
+        call_node = node_context.call_node
+        return 0 unless call_node&.block
+
+        block_params = call_node.block.parameters&.parameters
+        return 0 unless block_params
+
+        all_params = collect_block_params(block_params)
+        all_params.index(node) || 0
+      end
+
+      # Collect all parameters from block parameters node
+      # Uses respond_to? guards for safety across different Prism versions
+      # @param block_params [Prism::ParametersNode] The block parameters
+      # @return [Array<Prism::Node>] All parameter nodes
+      module_function def collect_block_params(block_params)
+        params = []
+        params.concat(block_params.requireds) if block_params.respond_to?(:requireds)
+        params.concat(block_params.optionals) if block_params.respond_to?(:optionals)
+        params << block_params.rest if block_params.respond_to?(:rest) && block_params.rest
+        params.concat(block_params.posts) if block_params.respond_to?(:posts)
+        params.concat(block_params.keywords) if block_params.respond_to?(:keywords)
+        params << block_params.keyword_rest if block_params.respond_to?(:keyword_rest) && block_params.keyword_rest
+        params << block_params.block if block_params.respond_to?(:block) && block_params.block
+        params.compact
+      end
+    end
+  end
+end

data/lib/type_guessr/core/node_key_generator.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module TypeGuessr
+  module Core
+    # Generates unique node keys for IR nodes and Prism node lookups.
+    # Single source of truth for node key format to ensure consistency
+    # between IR node generation and hover/type inference lookups.
+    module NodeKeyGenerator
+      module_function def local_write(name, offset) = "local_write:#{name}:#{offset}"
+      module_function def local_read(name, offset) = "local_read:#{name}:#{offset}"
+      module_function def ivar_write(name, offset) = "ivar_write:#{name}:#{offset}"
+      module_function def ivar_read(name, offset) = "ivar_read:#{name}:#{offset}"
+      module_function def cvar_write(name, offset) = "cvar_write:#{name}:#{offset}"
+      module_function def cvar_read(name, offset) = "cvar_read:#{name}:#{offset}"
+      module_function def global_write(name, offset) = "global_write:#{name}:#{offset}"
+      module_function def global_read(name, offset) = "global_read:#{name}:#{offset}"
+      module_function def param(name, offset) = "param:#{name}:#{offset}"
+      module_function def bparam(index, offset) = "bparam:#{index}:#{offset}"
+      module_function def call(method, offset) = "call:#{method}:#{offset}"
+      module_function def def_node(name, offset) = "def:#{name}:#{offset}"
+      module_function def self_node(class_name, offset) = "self:#{class_name}:#{offset}"
+      module_function def return_node(offset) = "return:#{offset}"
+      module_function def merge(offset) = "merge:#{offset}"
+      module_function def or_node(offset) = "or:#{offset}"
+      module_function def literal(type_name, offset) = "lit:#{type_name}:#{offset}"
+      module_function def constant(name, offset) = "const:#{name}:#{offset}"
+      module_function def narrow(kind, offset) = "narrow:#{kind}:#{offset}"
+      module_function def class_module(name, offset) = "class:#{name}:#{offset}"
+    end
+  end
+end

data/lib/type_guessr/core/registry/class_variable_registry.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module TypeGuessr
+  module Core
+    module Registry
+      # Stores and retrieves class variable write nodes
+      # No inheritance chain traversal (class variables are class-scoped)
+      class ClassVariableRegistry
+        def initialize
+          @variables = {} # { "ClassName" => { :@@name => WriteNode } }
+          @file_entries = {} # { file_path => [[class_name, name], ...] }
+        end
+
+        # Register a class variable write
+        # @param class_name [String] Class name
+        # @param name [Symbol] Variable name (e.g., :@@count)
+        # @param write_node [IR::ClassVariableWriteNode]
+        # @param file_path [String, nil] Source file path for tracking
+        def register(class_name, name, write_node, file_path: nil)
+          return unless class_name
+
+          @variables[class_name] ||= {}
+          return if @variables[class_name].key?(name) # first write wins
+
+          @variables[class_name][name] = write_node
+
+          return unless file_path
+
+          @file_entries[file_path] ||= []
+          @file_entries[file_path] << [class_name, name]
+        end
+
+        # Remove all entries registered from a specific file
+        # @param file_path [String] Source file path
+        def remove_file(file_path)
+          entries = @file_entries.delete(file_path)
+          return unless entries
+
+          entries.each do |class_name, name|
+            @variables[class_name]&.delete(name)
+            @variables.delete(class_name) if @variables[class_name] && @variables[class_name].empty?
+          end
+        end
+
+        # Look up a class variable write
+        # @param class_name [String]
+        # @param name [Symbol]
+        # @return [IR::ClassVariableWriteNode, nil]
+        def lookup(class_name, name)
+          return nil unless class_name
+
+          @variables.dig(class_name, name)
+        end
+
+        # Clear all registered variables
+        def clear
+          @variables.clear
+          @file_entries.clear
+        end
+      end
+    end
+  end
+end

data/lib/type_guessr/core/registry/instance_variable_registry.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module TypeGuessr
+  module Core
+    module Registry
+      # Stores and retrieves instance variable write nodes
+      # Supports inheritance chain traversal when code_index is set
+      class InstanceVariableRegistry
+        # Adapter for getting class ancestors (must respond to #ancestors_of)
+        # @return [#ancestors_of, nil] Adapter that returns array of ancestor names
+        attr_accessor :code_index
+
+        # @param code_index [#ancestors_of, nil] Adapter for inheritance lookup
+        def initialize(code_index: nil)
+          @variables = {} # { "ClassName" => { :@name => WriteNode } }
+          @file_entries = {} # { file_path => [[class_name, name], ...] }
+          @code_index = code_index
+        end
+
+        # Register an instance variable write
+        # @param class_name [String] Class name
+        # @param name [Symbol] Variable name (e.g., :@recipe)
+        # @param write_node [IR::InstanceVariableWriteNode]
+        # @param file_path [String, nil] Source file path for tracking
+        def register(class_name, name, write_node, file_path: nil)
+          return unless class_name
+
+          @variables[class_name] ||= {}
+          return if @variables[class_name].key?(name) # first write wins
+
+          @variables[class_name][name] = write_node
+
+          return unless file_path
+
+          @file_entries[file_path] ||= []
+          @file_entries[file_path] << [class_name, name]
+        end
+
+        # Remove all entries registered from a specific file
+        # @param file_path [String] Source file path
+        def remove_file(file_path)
+          entries = @file_entries.delete(file_path)
+          return unless entries
+
+          entries.each do |class_name, name|
+            @variables[class_name]&.delete(name)
+            @variables.delete(class_name) if @variables[class_name] && @variables[class_name].empty?
+          end
+        end
+
+        # Look up an instance variable write (with inheritance chain traversal)
+        # @param class_name [String]
+        # @param name [Symbol]
+        # @return [IR::InstanceVariableWriteNode, nil]
+        def lookup(class_name, name)
+          return nil unless class_name
+
+          # Try current class first
+          result = @variables.dig(class_name, name)
+          return result if result
+
+          # Traverse ancestor chain if code_index available
+          return nil unless @code_index
+
+          ancestors = @code_index.ancestors_of(class_name)
+          ancestors.each do |ancestor_name|
+            next if ancestor_name == class_name # Skip self
+
+            result = @variables.dig(ancestor_name, name)
+            return result if result
+          end
+
+          nil
+        end
+
+        # Clear all registered variables
+        def clear
+          @variables.clear
+          @file_entries.clear
+        end
+      end
+    end
+  end
+end

data/lib/type_guessr/core/registry/method_registry.rb

@@ -4,25 +4,56 @@ module TypeGuessr
   module Core
     module Registry
       # Stores and retrieves project method definitions
-      # Supports inheritance chain traversal when ancestry_provider is set
+      # Supports inheritance chain traversal when code_index is set
       class MethodRegistry
-        # Callback for getting class ancestors
-        # @return [Proc, nil] A proc that takes class_name and returns array of ancestor names
-        attr_accessor :ancestry_provider
+        # Adapter for getting class ancestors (must respond to #ancestors_of)
+        # @return [#ancestors_of, nil] Adapter that returns array of ancestor names
+        attr_accessor :code_index
 
-        # @param ancestry_provider [Proc, nil] Returns ancestors for inheritance lookup
-        def initialize(ancestry_provider: nil)
+        # @param code_index [#ancestors_of, nil] Adapter for inheritance lookup
+        def initialize(code_index: nil)
           @methods = {} # { "ClassName" => { "method_name" => DefNode } }
-          @ancestry_provider = ancestry_provider
+          @file_entries = {} # { file_path => [[class_name, method_name], ...] }
+          @entry_sources = {} # { [class_name, method_name] => Set[file_path, ...] }
+          @code_index = code_index
         end
 
         # Register a method definition
         # @param class_name [String] Class name (empty string for top-level)
         # @param method_name [String] Method name
         # @param def_node [IR::DefNode] Method definition node
-        def register(class_name, method_name, def_node)
+        # @param file_path [String, nil] Source file path for tracking
+        def register(class_name, method_name, def_node, file_path: nil)
           @methods[class_name] ||= {}
           @methods[class_name][method_name] = def_node
+
+          return unless file_path
+
+          @file_entries[file_path] ||= []
+          @file_entries[file_path] << [class_name, method_name]
+          key = [class_name, method_name]
+          @entry_sources[key] ||= Set.new
+          @entry_sources[key] << file_path
+        end
+
+        # Remove all method entries registered from a specific file
+        # @param file_path [String] Source file path
+        def remove_file(file_path)
+          entries = @file_entries.delete(file_path)
+          return unless entries
+
+          entries.each do |class_name, method_name|
+            key = [class_name, method_name]
+            sources = @entry_sources[key]
+            next unless sources
+
+            sources.delete(file_path)
+            next unless sources.empty?
+
+            @entry_sources.delete(key)
+            @methods[class_name]&.delete(method_name)
+            @methods.delete(class_name) if @methods[class_name] && @methods[class_name].empty?
+          end
         end
 
         # Look up a method definition (with inheritance chain traversal)
@@ -34,10 +65,10 @@ module TypeGuessr
           result = @methods.dig(class_name, method_name)
           return result if result
 
-          # Traverse ancestor chain if provider available
-          return nil unless @ancestry_provider
+          # Traverse ancestor chain if code_index available
+          return nil unless @code_index
 
-          ancestors = @ancestry_provider.call(class_name)
+          ancestors = @code_index.ancestors_of(class_name)
           ancestors.each do |ancestor_name|
             next if ancestor_name == class_name # Skip self
 
@@ -48,12 +79,6 @@ module TypeGuessr
           nil
         end
 
-        # Get all registered class names
-        # @return [Array<String>] List of class names (frozen)
-        def registered_classes
-          @methods.keys.freeze
-        end
-
         # Get all methods for a specific class (direct methods only)
         # @param class_name [String] Class name
         # @return [Hash<String, IR::DefNode>] Methods hash (frozen)
@@ -61,6 +86,27 @@ module TypeGuessr
           (@methods[class_name] || {}).freeze
         end
 
+        # Iterate over all registered methods
+        # @yield [class_name, method_name, def_node]
+        def each_entry(&block)
+          return enum_for(:each_entry) unless block
+
+          @methods.each do |class_name, methods_hash|
+            methods_hash.each do |method_name, def_node|
+              block.call(class_name, method_name, def_node)
+            end
+          end
+        end
+
+        # Get the source file path for a registered method
+        # @param class_name [String] Class name
+        # @param method_name [String] Method name
+        # @return [String, nil] File path or nil
+        def source_file_for(class_name, method_name)
+          sources = @entry_sources[[class_name, method_name]]
+          sources&.first
+        end
+
         # Search for methods matching a pattern
         # @param pattern [String] Search pattern (partial match on "ClassName#method_name")
         # @return [Array<Array>] Array of [class_name, method_name, def_node]
@@ -75,30 +121,11 @@ module TypeGuessr
           results
         end
 
-        # Get all methods available on a class (including inherited)
-        # @param class_name [String]
-        # @return [Set<String>] Method names
-        def all_methods_for_class(class_name)
-          # Start with directly defined methods
-          class_methods = (@methods[class_name]&.keys || []).to_set
-
-          # Add inherited methods if ancestry_provider is available
-          return class_methods unless @ancestry_provider
-
-          ancestors = @ancestry_provider.call(class_name)
-          ancestors.each do |ancestor_name|
-            next if ancestor_name == class_name # Skip self
-
-            ancestor_methods = @methods[ancestor_name]&.keys || []
-            class_methods.merge(ancestor_methods)
-          end
-
-          class_methods
-        end
-
         # Clear all registered methods
         def clear
           @methods.clear
+          @file_entries.clear
+          @entry_sources.clear
         end
       end
     end