type-guessr 0.0.1

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "rbs"
+require_relative "../types"
+
+module TypeGuessr
+  module Core
+    module Converter
+      # Converts RBS types to internal type system
+      # Isolates RBS type dependencies from the core type inference logic
+      #
+      # This class only handles conversion (RBS → internal types).
+      # Type variable substitution is handled separately by Type#substitute.
+      class RBSConverter
+        # Convert RBS type to internal type system
+        # @param rbs_type [RBS::Types::t] the RBS type
+        # @return [Types::Type] internal type representation (TypeVariables preserved)
+        def convert(rbs_type)
+          case rbs_type
+          when RBS::Types::Variable
+            Types::TypeVariable.new(rbs_type.name)
+          when RBS::Types::ClassInstance
+            convert_class_instance(rbs_type)
+          when RBS::Types::ClassSingleton
+            # Class singleton type (e.g., singleton(String))
+            class_name = rbs_type.name.to_s.delete_prefix("::")
+            Types::SingletonType.new(class_name)
+          when RBS::Types::Union
+            convert_union(rbs_type)
+          when RBS::Types::Tuple
+            convert_tuple(rbs_type)
+          when RBS::Types::Bases::Bool
+            # bool is a type alias for TrueClass | FalseClass
+            Types::ClassInstance.new("bool")
+          when RBS::Types::Bases::Void
+            Types::ClassInstance.new("void")
+          when RBS::Types::Bases::Nil
+            Types::ClassInstance.new("NilClass")
+          when RBS::Types::Bases::Self
+            Types::SelfType.instance
+          when RBS::Types::Bases::Instance
+            # Cannot resolve without context - return Unknown
+            Types::Unknown.instance
+          else
+            # Unknown RBS type - return Unknown
+            Types::Unknown.instance
+          end
+        end
+
+        private
+
+        # Convert RBS ClassInstance to internal type
+        # @param rbs_type [RBS::Types::ClassInstance] RBS class instance
+        # @return [Types::Type] internal type
+        def convert_class_instance(rbs_type)
+          class_name = rbs_type.name.to_s.delete_prefix("::")
+
+          # Handle Array with type parameter
+          if class_name == "Array" && rbs_type.args.size == 1
+            element_type = convert(rbs_type.args.first)
+            return Types::ArrayType.new(element_type)
+          end
+
+          # For other generic types, return ClassInstance (ignore type args for now)
+          # TODO: Add HashType with key/value types in the future
+          Types::ClassInstance.new(class_name)
+        end
+
+        # Convert RBS Union to internal Union type
+        # @param rbs_type [RBS::Types::Union] RBS union type
+        # @return [Types::Union] internal union type
+        def convert_union(rbs_type)
+          types = rbs_type.types.map { |t| convert(t) }
+          Types::Union.new(types)
+        end
+
+        # Convert RBS Tuple to internal ArrayType
+        # Tuples like [K, V] are converted to Array[K | V]
+        # @param rbs_type [RBS::Types::Tuple] RBS tuple type
+        # @return [Types::ArrayType] internal array type with union element type
+        def convert_tuple(rbs_type)
+          element_types = rbs_type.types.map { |t| convert(t) }
+          Types::ArrayType.new(Types::Union.new(element_types))
+        end
+      end
+    end
+  end
+end

data/lib/type_guessr/core/index/location_index.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module TypeGuessr
+  module Core
+    module Index
+      # Key-based index for finding IR nodes by scope and content
+      # Provides O(1) lookup from node_key to IR node
+      class LocationIndex
+        def initialize
+          # Hash of node_key => node for O(1) lookup
+          @key_index = {}
+          # Hash of file_path => [node_keys] for file removal
+          @file_keys = {}
+        end
+
+        # Index an IR node with its scope_id
+        # @param file_path [String] Absolute file path
+        # @param node [TypeGuessr::Core::IR::Node] IR node to index
+        # @param scope_id [String] Scope identifier (e.g., "User#save")
+        def add(file_path, node, scope_id = "")
+          return unless node.loc
+
+          key = node.node_key(scope_id)
+          @key_index[key] = node
+          (@file_keys[file_path] ||= []) << key
+        end
+
+        # Finalize indexing (no-op, kept for API compatibility)
+        def finalize!
+          # No longer needed with key-based index
+        end
+
+        # Find IR node by its unique key
+        # @param node_key [String] The node key (scope_id + node_hash)
+        # @return [TypeGuessr::Core::IR::Node, nil] IR node or nil if not found
+        def find_by_key(node_key)
+          @key_index[node_key]
+        end
+
+        # Get all indexed nodes for a file
+        # @param file_path [String] Absolute file path
+        # @return [Array<TypeGuessr::Core::IR::Node>] All nodes in the file
+        def nodes_for_file(file_path)
+          keys = @file_keys[file_path] || []
+          keys.filter_map { |k| @key_index[k] }
+        end
+
+        # Remove all entries for a file
+        # @param file_path [String] Absolute file path
+        def remove_file(file_path)
+          @file_keys[file_path]&.each { |k| @key_index.delete(k) }
+          @file_keys.delete(file_path)
+        end
+
+        # Clear all indexed data
+        def clear
+          @key_index.clear
+          @file_keys.clear
+        end
+
+        # Get statistics about the index
+        # @return [Hash] Statistics hash
+        def stats
+          {
+            files_count: @file_keys.size,
+            total_nodes: @key_index.size
+          }
+        end
+      end
+    end
+  end
+end