type-guessr 0.0.1

data/lib/type_guessr/core/rbs_provider.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+require "singleton"
+require "rbs"
+require_relative "types"
+require_relative "logger"
+require_relative "converter/rbs_converter"
+
+module TypeGuessr
+  module Core
+    # RBSProvider loads and queries RBS signature information
+    # Provides lazy loading of RBS environment for method signatures
+    # Uses RBSConverter to convert RBS types to internal type system
+    class RBSProvider
+      include Singleton
+
+      # Represents a method signature from RBS
+      class Signature
+        attr_reader :method_type
+
+        def initialize(method_type)
+          @method_type = method_type
+        end
+      end
+
+      def initialize
+        @env = nil
+        @loader = nil
+        @converter = Converter::RBSConverter.new
+      end
+
+      # Preload RBS environment (for eager loading during addon activation)
+      # @return [self]
+      def preload
+        ensure_environment_loaded
+        self
+      end
+
+      # Get method signatures for a class and method name
+      # @param class_name [String] the class name
+      # @param method_name [String] the method name
+      # @return [Array<Signature>] array of method signatures
+      def get_method_signatures(class_name, method_name)
+        ensure_environment_loaded
+
+        # Build the type name
+        type_name = build_type_name(class_name)
+
+        # Check if class exists in RBS before building (avoids RuntimeError for project classes)
+        return [] unless @env.class_decl?(type_name)
+
+        # Use RBS::DefinitionBuilder to get method definitions
+        builder = RBS::DefinitionBuilder.new(env: @env)
+        definition = builder.build_instance(type_name)
+
+        # Get the method definition
+        method_def = definition.methods[method_name.to_sym]
+        return [] unless method_def
+
+        # Return all method types (overloads)
+        method_def.method_types.map { |mt| Signature.new(mt) }
+      rescue RBS::NoTypeFoundError, RBS::NoSuperclassFoundError, RBS::NoMixinFoundError => _e
+        # Class not found in RBS
+        []
+      rescue StandardError => e
+        # If anything goes wrong, return empty array
+        Logger.error("RBSProvider error", e)
+        []
+      end
+
+      # Get the return type of a method call with overload resolution
+      # @param class_name [String] the receiver class name
+      # @param method_name [String] the method name
+      # @param arg_types [Array<Types::Type>] argument types for overload matching
+      # @return [Types::Type] the return type (Unknown if not found)
+      def get_method_return_type(class_name, method_name, arg_types = [])
+        signatures = get_method_signatures(class_name, method_name)
+        return Types::Unknown.instance if signatures.empty?
+
+        # Find best matching overload based on argument types
+        best_match = find_best_overload(signatures, arg_types)
+        return_type = best_match.method_type.type.return_type
+
+        @converter.convert(return_type)
+      end
+
+      # Get block parameter types for a method
+      # @param class_name [String] the receiver class name
+      # @param method_name [String] the method name
+      # @return [Array<Types::Type>] array of block parameter types (empty if no block)
+      def get_block_param_types(class_name, method_name)
+        block_sig = find_block_signature(class_name, method_name)
+        return [] unless block_sig
+
+        extract_block_param_types(block_sig)
+      end
+
+      # Get class method signatures (singleton methods like File.read, Array.new)
+      # @param class_name [String] the class name
+      # @param method_name [String] the method name
+      # @return [Array<Signature>] array of method signatures
+      def get_class_method_signatures(class_name, method_name)
+        ensure_environment_loaded
+
+        # Build the type name
+        type_name = build_type_name(class_name)
+
+        # Check if class exists in RBS before building (avoids RuntimeError for project classes)
+        return [] unless @env.class_decl?(type_name)
+
+        # Use RBS::DefinitionBuilder to get singleton method definitions
+        builder = RBS::DefinitionBuilder.new(env: @env)
+        definition = builder.build_singleton(type_name)
+
+        # Get the method definition
+        method_def = definition.methods[method_name.to_sym]
+        return [] unless method_def
+
+        # Return all method types (overloads)
+        method_def.method_types.map { |mt| Signature.new(mt) }
+      rescue RBS::NoTypeFoundError, RBS::NoSuperclassFoundError, RBS::NoMixinFoundError => _e
+        # Class not found in RBS
+        []
+      rescue StandardError => e
+        # If anything goes wrong, return empty array
+        Logger.error("RBSProvider class method error", e)
+        []
+      end
+
+      # Get the return type of a class method call
+      # @param class_name [String] the class name
+      # @param method_name [String] the method name
+      # @param arg_types [Array<Types::Type>] the argument types
+      # @return [Types::Type] the return type (Unknown if not found)
+      def get_class_method_return_type(class_name, method_name, arg_types = [])
+        signatures = get_class_method_signatures(class_name, method_name)
+        return Types::Unknown.instance if signatures.empty?
+
+        # Find best matching overload based on argument types
+        best_match = find_best_overload(signatures, arg_types)
+        return_type = best_match.method_type.type.return_type
+
+        @converter.convert(return_type)
+      end
+
+      private
+
+      # Find a method signature that has a block
+      # @param class_name [String] the receiver class name
+      # @param method_name [String] the method name
+      # @return [RBS::MethodType, nil] the method type with block, or nil
+      def find_block_signature(class_name, method_name)
+        signatures = get_method_signatures(class_name, method_name)
+        return nil if signatures.empty?
+
+        # Find the signature with a block
+        sig_with_block = signatures.find { |s| s.method_type.block }
+        sig_with_block&.method_type
+      end
+
+      # Extract block parameter types from a method type
+      # @param method_type [RBS::MethodType] the method type
+      # @param substitutions [Hash{Symbol => Types::Type}] type variable substitutions (e.g., { Elem: Integer })
+      # @return [Array<Types::Type>] array of parameter types
+      def extract_block_param_types(method_type, substitutions: {})
+        return [] unless method_type.block
+
+        block_func = method_type.block.type
+        block_func.required_positionals.flat_map do |param|
+          # Handle Tuple types (e.g., [K, V] in Hash#each) by flattening
+          raw_types = if param.type.is_a?(RBS::Types::Tuple)
+                        param.type.types.map { |t| @converter.convert(t) }
+                      else
+                        [@converter.convert(param.type)]
+                      end
+          # Apply substitutions after conversion
+          raw_types.map { |t| t.substitute(substitutions) }
+        end
+      end
+
+      def ensure_environment_loaded
+        return if @env
+
+        @loader = RBS::EnvironmentLoader.new
+
+        # Add optional library paths if they exist
+        # loader.add(path: Pathname("sig")) if Dir.exist?("sig")
+
+        # Load environment (this automatically loads core/stdlib)
+        @env = RBS::Environment.from_loader(@loader).resolve_type_names
+      rescue StandardError => e
+        Logger.error("Failed to load RBS environment", e)
+        # Fallback to empty environment
+        @env = RBS::Environment.new
+      end
+
+      def build_type_name(class_name)
+        # Parse class name to handle namespaced classes like "Foo::Bar"
+        parts = class_name.split("::")
+        namespace_parts = parts[0...-1]
+        name = parts.last
+
+        namespace = if namespace_parts.empty?
+                      RBS::Namespace.root
+                    else
+                      RBS::Namespace.parse(namespace_parts.join("::"))
+                    end
+
+        RBS::TypeName.new(name: name.to_sym, namespace: namespace)
+      end
+
+      # Find the best matching overload for given argument types
+      # @param signatures [Array<Signature>] available overloads
+      # @param arg_types [Array<Types::Type>] argument types
+      # @return [Signature] best matching signature (first if no match)
+      def find_best_overload(signatures, arg_types)
+        return signatures.first if arg_types.empty?
+
+        # Score each overload
+        scored = signatures.map do |sig|
+          score = calculate_overload_score(sig.method_type, arg_types)
+          [sig, score]
+        end
+
+        # Return best scoring overload, or first if all scores are 0
+        best = scored.max_by { |_sig, score| score }
+        best[1].positive? ? best[0] : signatures.first
+      end
+
+      # Calculate match score for an overload
+      # @param method_type [RBS::MethodType] the method type
+      # @param arg_types [Array<Types::Type>] argument types
+      # @return [Integer] score (higher = better match)
+      def calculate_overload_score(method_type, arg_types)
+        func = method_type.type
+        required = func.required_positionals
+        optional = func.optional_positionals
+        rest = func.rest_positionals
+
+        # Check argument count
+        min_args = required.size
+        max_args = rest ? Float::INFINITY : required.size + optional.size
+        return 0 unless arg_types.size.between?(min_args, max_args)
+
+        # Score each argument match
+        score = 0
+        arg_types.each_with_index do |arg_type, i|
+          param = if i < required.size
+                    required[i]
+                  elsif i < required.size + optional.size
+                    optional[i - required.size]
+                  else
+                    rest
+                  end
+
+          break unless param
+
+          score += type_match_score(arg_type, param.type)
+        end
+
+        score
+      end
+
+      # Calculate match score between our type and RBS parameter type
+      # @param our_type [Types::Type] our type representation
+      # @param rbs_type [RBS::Types::t] RBS type
+      # @return [Integer] score (0 = no match, 1 = weak match, 2 = exact match)
+      def type_match_score(our_type, rbs_type)
+        case rbs_type
+        when RBS::Types::ClassInstance
+          # Exact class match
+          class_name = rbs_type.name.to_s.delete_prefix("::")
+          return 2 if types_match_class?(our_type, class_name)
+
+          0
+        when RBS::Types::Union
+          # Check if our type matches any member
+          max_score = rbs_type.types.map { |t| type_match_score(our_type, t) }.max || 0
+          max_score.positive? ? 1 : 0
+        else
+          # Unknown RBS type - give weak match to avoid penalizing
+          1
+        end
+      end
+
+      # Check if our type matches a class name
+      # @param our_type [Types::Type] our type
+      # @param class_name [String] class name to match
+      # @return [Boolean] true if types match
+      def types_match_class?(our_type, class_name)
+        case our_type
+        when Types::ClassInstance
+          our_type.name == class_name
+        when Types::ArrayType
+          class_name == "Array"
+        when Types::HashShape
+          class_name == "Hash"
+        else
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module TypeGuessr
+  module Core
+    module Registry
+      # Stores and retrieves project method definitions
+      # Supports inheritance chain traversal when ancestry_provider 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
+
+        # @param ancestry_provider [Proc, nil] Returns ancestors for inheritance lookup
+        def initialize(ancestry_provider: nil)
+          @methods = {} # { "ClassName" => { "method_name" => DefNode } }
+          @ancestry_provider = ancestry_provider
+        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)
+          @methods[class_name] ||= {}
+          @methods[class_name][method_name] = def_node
+        end
+
+        # Look up a method definition (with inheritance chain traversal)
+        # @param class_name [String] Class name
+        # @param method_name [String] Method name
+        # @return [IR::DefNode, nil] Method definition node or nil
+        def lookup(class_name, method_name)
+          # Try current class first
+          result = @methods.dig(class_name, method_name)
+          return result if result
+
+          # Traverse ancestor chain if provider available
+          return nil unless @ancestry_provider
+
+          ancestors = @ancestry_provider.call(class_name)
+          ancestors.each do |ancestor_name|
+            next if ancestor_name == class_name # Skip self
+
+            result = @methods.dig(ancestor_name, method_name)
+            return result if result
+          end
+
+          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)
+        def methods_for_class(class_name)
+          (@methods[class_name] || {}).freeze
+        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]
+        def search(pattern)
+          results = []
+          @methods.each do |class_name, methods|
+            methods.each do |method_name, def_node|
+              full_name = "#{class_name}##{method_name}"
+              results << [class_name, method_name, def_node] if full_name.include?(pattern)
+            end
+          end
+          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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module TypeGuessr
+  module Core
+    module Registry
+      # Stores and retrieves instance/class variable write nodes
+      # Supports inheritance chain traversal for instance variables when ancestry_provider is set
+      class VariableRegistry
+        # Callback for getting class ancestors
+        # @return [Proc, nil] A proc that takes class_name and returns array of ancestor names
+        attr_accessor :ancestry_provider
+
+        # @param ancestry_provider [Proc, nil] Returns ancestors for inheritance lookup
+        def initialize(ancestry_provider: nil)
+          @instance_variables = {} # { "ClassName" => { :@name => WriteNode } }
+          @class_variables = {}    # { "ClassName" => { :@@name => WriteNode } }
+          @ancestry_provider = ancestry_provider
+        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]
+        def register_instance_variable(class_name, name, write_node)
+          return unless class_name
+
+          @instance_variables[class_name] ||= {}
+          # First write wins (preserves consistent behavior)
+          @instance_variables[class_name][name] ||= write_node
+        end
+
+        # Look up an instance variable write (with inheritance chain traversal)
+        # @param class_name [String]
+        # @param name [Symbol]
+        # @return [IR::InstanceVariableWriteNode, nil]
+        def lookup_instance_variable(class_name, name)
+          return nil unless class_name
+
+          # Try current class first
+          result = @instance_variables.dig(class_name, name)
+          return result if result
+
+          # Traverse ancestor chain if provider available
+          return nil unless @ancestry_provider
+
+          ancestors = @ancestry_provider.call(class_name)
+          ancestors.each do |ancestor_name|
+            next if ancestor_name == class_name # Skip self
+
+            result = @instance_variables.dig(ancestor_name, name)
+            return result if result
+          end
+
+          nil
+        end
+
+        # Register a class variable write
+        # @param class_name [String]
+        # @param name [Symbol] (e.g., :@@count)
+        # @param write_node [IR::ClassVariableWriteNode]
+        def register_class_variable(class_name, name, write_node)
+          return unless class_name
+
+          @class_variables[class_name] ||= {}
+          # First write wins
+          @class_variables[class_name][name] ||= write_node
+        end
+
+        # Look up a class variable write
+        # @param class_name [String]
+        # @param name [Symbol]
+        # @return [IR::ClassVariableWriteNode, nil]
+        def lookup_class_variable(class_name, name)
+          return nil unless class_name
+
+          @class_variables.dig(class_name, name)
+        end
+
+        # Clear all registered variables
+        def clear
+          @instance_variables.clear
+          @class_variables.clear
+        end
+      end
+    end
+  end
+end

data/lib/type_guessr/core/signature_provider.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require_relative "types"
+
+module TypeGuessr
+  module Core
+    # SignatureProvider aggregates multiple type sources for method signature lookups
+    # Uses priority-based resolution: first non-Unknown result wins
+    #
+    # @example
+    #   provider = SignatureProvider.new
+    #   provider.add_provider(ProjectRBSProvider.new, priority: :high)
+    #   provider.add_provider(RBSProvider.instance)
+    #
+    #   return_type = provider.get_method_return_type("String", "upcase")
+    class SignatureProvider
+      # @param providers [Array<#get_method_return_type>] Providers in priority order (first = highest)
+      def initialize(providers = [])
+        @providers = providers.dup
+      end
+
+      # Add a provider to the chain
+      # @param provider [#get_method_return_type] Provider implementing the signature protocol
+      # @param priority [:high, :low] Priority level (:high = first, :low = last)
+      def add_provider(provider, priority: :low)
+        case priority
+        when :high
+          @providers.unshift(provider)
+        when :low
+          @providers.push(provider)
+        end
+      end
+
+      # Get instance method return type with overload resolution
+      # @param class_name [String] Class name (e.g., "String", "Array")
+      # @param method_name [String] Method name (e.g., "upcase", "map")
+      # @param arg_types [Array<Types::Type>] Argument types for overload matching
+      # @return [Types::Type] Return type (Unknown if not found in any provider)
+      def get_method_return_type(class_name, method_name, arg_types = [])
+        @providers.each do |provider|
+          result = provider.get_method_return_type(class_name, method_name, arg_types)
+          return result unless result.is_a?(Types::Unknown)
+        end
+        Types::Unknown.instance
+      end
+
+      # Get class method return type (e.g., File.read, Array.new)
+      # @param class_name [String] Class name
+      # @param method_name [String] Method name
+      # @param arg_types [Array<Types::Type>] Argument types for overload matching
+      # @return [Types::Type] Return type (Unknown if not found in any provider)
+      def get_class_method_return_type(class_name, method_name, arg_types = [])
+        @providers.each do |provider|
+          result = provider.get_class_method_return_type(class_name, method_name, arg_types)
+          return result unless result.is_a?(Types::Unknown)
+        end
+        Types::Unknown.instance
+      end
+
+      # Get block parameter types for a method
+      # @param class_name [String] Class name
+      # @param method_name [String] Method name
+      # @return [Array<Types::Type>] Block parameter types (empty if no block or not found)
+      def get_block_param_types(class_name, method_name)
+        @providers.each do |provider|
+          result = provider.get_block_param_types(class_name, method_name)
+          return result unless result.empty?
+        end
+        []
+      end
+
+      # Get method signatures for hover display
+      # @param class_name [String] Class name
+      # @param method_name [String] Method name
+      # @return [Array<Signature>] Method signatures (empty if not found)
+      def get_method_signatures(class_name, method_name)
+        @providers.each do |provider|
+          next unless provider.respond_to?(:get_method_signatures)
+
+          result = provider.get_method_signatures(class_name, method_name)
+          return result unless result.empty?
+        end
+        []
+      end
+
+      # Get class method signatures for hover display (e.g., File.exist?, Dir.pwd)
+      # @param class_name [String] Class name
+      # @param method_name [String] Method name
+      # @return [Array<Signature>] Method signatures (empty if not found)
+      def get_class_method_signatures(class_name, method_name)
+        @providers.each do |provider|
+          next unless provider.respond_to?(:get_class_method_signatures)
+
+          result = provider.get_class_method_signatures(class_name, method_name)
+          return result unless result.empty?
+        end
+        []
+      end
+    end
+  end
+end

data/lib/type_guessr/core/type_simplifier.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "types"
+
+module TypeGuessr
+  module Core
+    # Simplifies types by unwrapping single-element unions and
+    # unifying parent/child class relationships
+    class TypeSimplifier
+      # @param ancestry_provider [Proc, nil] A proc that takes class_name and returns array of ancestor names
+      def initialize(ancestry_provider: nil)
+        @ancestry_provider = ancestry_provider
+      end
+
+      # Simplify a type
+      # @param type [Types::Type] The type to simplify
+      # @return [Types::Type] The simplified type
+      def simplify(type)
+        case type
+        when Types::Union
+          simplify_union(type)
+        else
+          type
+        end
+      end
+
+      private
+
+      def simplify_union(union)
+        types = union.types
+
+        # 1. Single element: unwrap
+        return types.first if types.size == 1
+
+        # 2. Filter to most general types (remove children when parent is present)
+        types = filter_to_most_general_types(types) if @ancestry_provider
+
+        # 3. Check again after filtering
+        return types.first if types.size == 1
+
+        # 4. Multiple elements remain: create new Union
+        Types::Union.new(types)
+      end
+
+      # Filter out types whose ancestor is also in the list
+      # @param types [Array<Types::Type>] List of types
+      # @return [Array<Types::Type>] Filtered list with only the most general types
+      def filter_to_most_general_types(types)
+        # Extract class names from ClassInstance types
+        class_names = types.filter_map do |t|
+          t.name if t.is_a?(Types::ClassInstance)
+        end
+
+        types.reject do |type|
+          next false unless type.is_a?(Types::ClassInstance)
+
+          ancestors = @ancestry_provider.call(type.name)
+          # Check if any ancestor (excluding self) is also in the list
+          ancestors.any? { |ancestor| ancestor != type.name && class_names.include?(ancestor) }
+        end
+      end
+    end
+  end
+end