type-guessr 0.0.1 → 0.0.3

data/lib/type_guessr/core/type_simplifier.rb

@@ -7,9 +7,12 @@ module TypeGuessr
     # 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
+      # Maximum number of types in a Union before considering it too ambiguous
+      MAX_ELEMENT_IN_UNION = 3
+
+      # @param code_index [#ancestors_of, nil] Adapter for inheritance lookup
+      def initialize(code_index: nil)
+        @code_index = code_index
       end
 
       # Simplify a type
@@ -24,28 +27,28 @@ module TypeGuessr
         end
       end
 
-      private
-
-      def simplify_union(union)
+      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
+        # 2. Remove subclass types when parent class is also present
+        types = remove_subclass_types(types) if @code_index
 
         # 3. Check again after filtering
         return types.first if types.size == 1
 
+        return Types::Unknown.instance if types.size > MAX_ELEMENT_IN_UNION
+
         # 4. Multiple elements remain: create new Union
         Types::Union.new(types)
       end
 
-      # Filter out types whose ancestor is also in the list
+      # Remove types whose ancestor is also in the list (e.g., remove Integer when Numeric is present)
       # @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)
+      # @return [Array<Types::Type>] Filtered list with subclass types removed
+      private def remove_subclass_types(types)
         # Extract class names from ClassInstance types
         class_names = types.filter_map do |t|
           t.name if t.is_a?(Types::ClassInstance)
@@ -54,7 +57,7 @@ module TypeGuessr
         types.reject do |type|
           next false unless type.is_a?(Types::ClassInstance)
 
-          ancestors = @ancestry_provider.call(type.name)
+          ancestors = @code_index.ancestors_of(type.name)
           # Check if any ancestor (excluding self) is also in the list
           ancestors.any? { |ancestor| ancestor != type.name && class_names.include?(ancestor) }
         end

data/lib/type_guessr/core/types.rb

@@ -36,9 +36,15 @@ module TypeGuessr
         # Get type variable substitutions for this type
         # Used for substituting type variables in block parameters
         # @return [Hash{Symbol => Type}] type variable substitutions (e.g., { Elem: Integer, K: Symbol, V: String })
-        def type_variable_substitutions
+        def type_parameter_bindings
           {}
         end
+
+        # Readable inspect output for debugging
+        # @return [String]
+        def inspect
+          "#<#{self.class.name.split("::").last}>"
+        end
       end
 
       # Unknown type - no information available
@@ -50,32 +56,87 @@ module TypeGuessr
         end
       end
 
+      # Unguessed type - type exists but has not been inferred yet
+      # Used for lazy gem inference: method signatures are cached with
+      # Unguessed return/param types until background inference completes.
+      class Unguessed < Type
+        include Singleton
+
+        def to_s
+          "unguessed"
+        end
+      end
+
       # ClassInstance - instance of a class
+      # @param type_params [Hash{Symbol => Type}, nil] type parameters (e.g., { A: String } for Set[String])
       class ClassInstance < Type
-        attr_reader :name
+        CACHE = {} # rubocop:disable Style/MutableConstant
+        GENERIC_CACHE = {} # rubocop:disable Style/MutableConstant
+
+        # Factory method that caches instances for reuse
+        # @param name [String] The class name
+        # @param type_params [Hash{Symbol => Type}, nil] type parameters
+        # @return [ClassInstance] Cached or new instance
+        def self.for(name, type_params = nil)
+          if type_params.nil?
+            CACHE[name] ||= new(name).freeze
+          else
+            key = [name, type_params]
+            GENERIC_CACHE[key] ||= new(name, type_params).freeze
+          end
+        end
 
-        def initialize(name)
+        attr_reader :name, :type_params
+
+        def initialize(name, type_params = nil)
           super()
           @name = name
+          @type_params = type_params&.freeze
         end
 
         def eql?(other)
-          super && @name == other.name
+          super && @name == other.name && @type_params == other.type_params
         end
 
         def hash
-          [self.class, @name].hash
+          [self.class, @name, @type_params].hash
         end
 
         def to_s
-          case @name
-          when "NilClass" then "nil"
-          when "TrueClass" then "true"
-          when "FalseClass" then "false"
-          else @name
+          base = case @name
+                 when "NilClass" then "nil"
+                 when "TrueClass" then "true"
+                 when "FalseClass" then "false"
+                 else @name
+                 end
+          if @type_params&.any?
+            "#{base}[#{@type_params.values.join(", ")}]"
+          else
+            base
+          end
+        end
+
+        def inspect
+          if @type_params&.any?
+            "#<ClassInstance:#{@name}[#{@type_params.map { |k, v| "#{k}=#{v.inspect}" }.join(", ")}]>"
+          else
+            "#<ClassInstance:#{@name}>"
           end
         end
 
+        def type_parameter_bindings
+          @type_params || {}
+        end
+
+        def substitute(substitutions)
+          return self if @type_params.nil? || @type_params.empty?
+
+          new_params = @type_params.transform_values { |t| t.substitute(substitutions) }
+          return self if new_params == @type_params
+
+          ClassInstance.new(@name, new_params)
+        end
+
         def rbs_class_name
           @name
         end
@@ -102,6 +163,10 @@ module TypeGuessr
           "singleton(#{@name})"
         end
 
+        def inspect
+          "#<SingletonType:#{@name}>"
+        end
+
         def rbs_class_name
           @name
         end
@@ -111,7 +176,7 @@ module TypeGuessr
       class Union < Type
         attr_reader :types
 
-        def initialize(types, cutoff: RubyLsp::TypeGuessr::Config.union_cutoff)
+        def initialize(types, cutoff: 10)
           super()
           @types = normalize(types, cutoff)
         end
@@ -130,13 +195,19 @@ module TypeGuessr
         def to_s
           if bool_type?
             "bool"
+          elsif nullable_bool_type?
+            "bool?"
           elsif optional_type?
-            "?#{non_nil_type}"
+            "#{non_nil_type}?"
           else
             @types.map(&:to_s).sort.join(" | ")
           end
         end
 
+        def inspect
+          "#<Union:#{@types.join("|")}>"
+        end
+
         def substitute(substitutions)
           new_types = @types.map { |t| t.substitute(substitutions) }
           return self if new_types.zip(@types).all? { |new_t, old_t| new_t.equal?(old_t) }
@@ -144,9 +215,7 @@ module TypeGuessr
           Union.new(new_types)
         end
 
-        private
-
-        def bool_type?
+        private def bool_type?
           return false unless @types.size == 2
 
           has_true = @types.any? { |t| t.is_a?(ClassInstance) && t.name == "TrueClass" }
@@ -154,19 +223,28 @@ module TypeGuessr
           has_true && has_false
         end
 
-        def optional_type?
+        private def nullable_bool_type?
+          return false unless @types.size == 3
+
+          has_true = @types.any? { |t| t.is_a?(ClassInstance) && t.name == "TrueClass" }
+          has_false = @types.any? { |t| t.is_a?(ClassInstance) && t.name == "FalseClass" }
+          has_nil = @types.any? { |t| nil_type?(t) }
+          has_true && has_false && has_nil
+        end
+
+        private def optional_type?
           @types.size == 2 && @types.any? { |t| nil_type?(t) }
         end
 
-        def nil_type?(type)
+        private def nil_type?(type)
           type.is_a?(ClassInstance) && type.name == "NilClass"
         end
 
-        def non_nil_type
+        private def non_nil_type
           @types.find { |t| !nil_type?(t) }
         end
 
-        def normalize(types, cutoff)
+        private def normalize(types, cutoff)
           # Flatten nested unions
           flattened = flatten_unions(types)
 
@@ -180,20 +258,20 @@ module TypeGuessr
           apply_cutoff(filtered, cutoff)
         end
 
-        def flatten_unions(types)
+        private def flatten_unions(types)
           types.flat_map do |type|
             type.is_a?(Union) ? type.types : type
           end
         end
 
-        def simplify_if_unknown_present(types)
+        private def simplify_if_unknown_present(types)
           return types if types.size <= 1
 
-          has_unknown = types.any? { |t| t.is_a?(Unknown) }
+          has_unknown = types.any?(Unknown)
           has_unknown ? [Unknown.instance] : types
         end
 
-        def apply_cutoff(types, cutoff)
+        private def apply_cutoff(types, cutoff)
           types.take(cutoff)
         end
       end
@@ -219,6 +297,10 @@ module TypeGuessr
           "Array[#{@element_type}]"
         end
 
+        def inspect
+          "#<ArrayType:#{@element_type}>"
+        end
+
         def substitute(substitutions)
           new_element = @element_type.substitute(substitutions)
           return self if new_element.equal?(@element_type)
@@ -230,11 +312,66 @@ module TypeGuessr
           "Array"
         end
 
-        def type_variable_substitutions
+        def type_parameter_bindings
           { Elem: @element_type }
         end
       end
 
+      # TupleType - array with per-position element types
+      # Preserves positional type information for mixed-type array literals
+      # Falls back to ArrayType when element count exceeds MAX_ELEMENTS
+      class TupleType < Type
+        attr_reader :element_types
+
+        MAX_ELEMENTS = 8
+
+        def self.new(element_types)
+          return ArrayType.new(Union.new(element_types)) if element_types.size > MAX_ELEMENTS
+
+          super
+        end
+
+        def initialize(element_types)
+          super()
+          @element_types = element_types
+        end
+
+        def eql?(other)
+          super && @element_types == other.element_types
+        end
+
+        def hash
+          [self.class, @element_types].hash
+        end
+
+        def to_s
+          "[#{@element_types.join(", ")}]"
+        end
+
+        def inspect
+          "#<TupleType:#{self}>"
+        end
+
+        def substitute(substitutions)
+          new_types = @element_types.map { |t| t.substitute(substitutions) }
+          return self if new_types.zip(@element_types).all? { |n, o| n.equal?(o) }
+
+          TupleType.new(new_types)
+        end
+
+        def rbs_class_name
+          "Array"
+        end
+
+        def type_parameter_bindings
+          return { Elem: Unknown.instance } if @element_types.empty?
+
+          unique = @element_types.uniq
+          elem = unique.size == 1 ? unique.first : Union.new(unique)
+          { Elem: elem }
+        end
+      end
+
       # HashType - hash with key and value types
       class HashType < Type
         attr_reader :key_type, :value_type
@@ -257,6 +394,10 @@ module TypeGuessr
           "Hash[#{@key_type}, #{@value_type}]"
         end
 
+        def inspect
+          "#<HashType:#{@key_type},#{@value_type}>"
+        end
+
         def substitute(substitutions)
           new_key = @key_type.substitute(substitutions)
           new_value = @value_type.substitute(substitutions)
@@ -269,7 +410,7 @@ module TypeGuessr
           "Hash"
         end
 
-        def type_variable_substitutions
+        def type_parameter_bindings
           { K: @key_type, V: @value_type }
         end
       end
@@ -295,6 +436,10 @@ module TypeGuessr
           "Range[#{@element_type}]"
         end
 
+        def inspect
+          "#<RangeType:#{@element_type}>"
+        end
+
         def substitute(substitutions)
           new_element = @element_type.substitute(substitutions)
           return self if new_element.equal?(@element_type)
@@ -306,7 +451,7 @@ module TypeGuessr
           "Range"
         end
 
-        def type_variable_substitutions
+        def type_parameter_bindings
           { Elem: @element_type }
         end
       end
@@ -315,9 +460,13 @@ module TypeGuessr
       class HashShape < Type
         attr_reader :fields
 
-        def self.new(fields, max_fields: RubyLsp::TypeGuessr::Config.hash_shape_max_fields)
-          # Widen to generic Hash when too many fields
-          return ClassInstance.new("Hash") if fields.size > max_fields
+        def self.new(fields, max_fields: 15)
+          # Widen to generic HashType when too many fields
+          if fields.size > max_fields
+            value_types = fields.values.uniq
+            value_type = value_types.size == 1 ? value_types.first : Union.new(value_types)
+            return HashType.new(ClassInstance.for("Symbol"), value_type)
+          end
 
           super(fields)
         end
@@ -342,7 +491,11 @@ module TypeGuessr
           "{ #{fields_str} }"
         end
 
-        def merge_field(key, value_type, max_fields: RubyLsp::TypeGuessr::Config.hash_shape_max_fields)
+        def inspect
+          "#<HashShape:#{self}>"
+        end
+
+        def merge_field(key, value_type, max_fields: 15)
           new_fields = @fields.merge(key => value_type)
           HashShape.new(new_fields, max_fields: max_fields)
         end
@@ -358,8 +511,8 @@ module TypeGuessr
           "Hash"
         end
 
-        def type_variable_substitutions
-          key_type = ClassInstance.new("Symbol")
+        def type_parameter_bindings
+          key_type = ClassInstance.for("Symbol")
           value_types = @fields.values.uniq
           value_type = if value_types.empty?
                          Unknown.instance
@@ -393,6 +546,10 @@ module TypeGuessr
           @name.to_s
         end
 
+        def inspect
+          "#<TypeVariable:#{@name}>"
+        end
+
         def substitute(substitutions)
           substitutions[@name] || self
         end
@@ -420,6 +577,67 @@ module TypeGuessr
           "..."
         end
       end
+
+      # ParamSignature - structural component of MethodSignature (not a Type)
+      # Represents a single parameter with its name, kind, and inferred type
+      ParamSignature = Data.define(:name, :kind, :type) do
+        def to_s
+          type_str = type.to_s
+          case kind
+          when :required         then "#{type_str} #{name}"
+          when :optional         then "?#{type_str} #{name}"
+          when :rest             then "*#{type_str} #{name}"
+          when :keyword_required then "#{name}: #{type_str}"
+          when :keyword_optional then "#{name}: ?#{type_str}"
+          when :keyword_rest     then "**#{type_str} #{name}"
+          when :block            then "&#{type_str} #{name}"
+          when :forwarding       then "..."
+          end
+        end
+      end
+
+      # MethodSignature - first-class type for Proc/Lambda/Method signatures
+      # Follows the same pattern as ArrayType: holds inner types and delegates substitute
+      class MethodSignature < Type
+        attr_reader :params, :return_type
+
+        def initialize(params, return_type)
+          super()
+          @params = params
+          @return_type = return_type
+        end
+
+        def eql?(other)
+          super && @params == other.params && @return_type == other.return_type
+        end
+
+        def hash
+          [self.class, @params, @return_type].hash
+        end
+
+        def to_s
+          params_str = @params.join(", ")
+          "(#{params_str}) -> #{@return_type}"
+        end
+
+        def inspect
+          "#<MethodSignature:#{self}>"
+        end
+
+        def substitute(substitutions)
+          new_params = @params.map do |p|
+            ParamSignature.new(name: p.name, kind: p.kind, type: p.type.substitute(substitutions))
+          end
+          new_return_type = @return_type.substitute(substitutions)
+          return self if new_params == @params && new_return_type.equal?(@return_type)
+
+          MethodSignature.new(new_params, new_return_type)
+        end
+
+        def rbs_class_name
+          "Proc"
+        end
+      end
     end
   end
 end

data/lib/type_guessr/core.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Configuration
+require_relative "core/config"
+
+# Core type system
+require_relative "core/types"
+
+# Node infrastructure
+require_relative "core/node_key_generator"
+require_relative "core/node_context_helper"
+require_relative "core/ir"
+require_relative "core/index"
+
+# Registries
+require_relative "core/registry"
+
+# Converters
+require_relative "core/converter"
+
+# Inference
+require_relative "core/inference"
+
+# Utilities
+require_relative "core/signature_builder"
+require_relative "core/type_simplifier"
+require_relative "core/type_serializer"
+require_relative "core/cache"
+require_relative "core/logger"

data/lib/type_guessr/mcp/file_watcher.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module TypeGuessr
+  module MCP
+    # Watches a project directory for .rb file changes using mtime polling.
+    # Detects modified, added, and deleted files and invokes a callback.
+    #
+    # Usage:
+    #   watcher = FileWatcher.new(project_path: "/path/to/project", interval: 2) do |modified, added, removed|
+    #     modified.each { |f| reindex(f) }
+    #     removed.each { |f| remove(f) }
+    #   end
+    #   watcher.start
+    class FileWatcher
+      # @param project_path [String] Root directory to watch
+      # @param interval [Numeric] Polling interval in seconds (default: 2)
+      # @param on_change [Proc] Callback receiving (modified, added, removed) arrays
+      def initialize(project_path:, on_change:, interval: 2)
+        @project_path = project_path
+        @interval = interval
+        @on_change = on_change
+        @thread = nil
+        @running = false
+      end
+
+      def start
+        @running = true
+        @snapshot = take_snapshot
+        @thread = Thread.new { poll_loop }
+        @thread.abort_on_exception = true
+      end
+
+      def stop
+        @running = false
+        @thread&.join(5)
+        @thread = nil
+      end
+
+      def running?
+        @running && @thread&.alive?
+      end
+
+      private def poll_loop
+        while @running
+          sleep(@interval)
+          check_changes
+        end
+      end
+
+      private def check_changes
+        current = take_snapshot
+        previous = @snapshot
+
+        modified = []
+        added = []
+        removed = []
+
+        current.each do |path, mtime|
+          if previous.key?(path)
+            modified << path if mtime > previous[path]
+          else
+            added << path
+          end
+        end
+
+        previous.each_key do |path|
+          removed << path unless current.key?(path)
+        end
+
+        @snapshot = current
+
+        return if modified.empty? && added.empty? && removed.empty?
+
+        @on_change.call(modified, added, removed)
+      end
+
+      private def take_snapshot
+        pattern = File.join(@project_path, "**", "*.rb")
+        Dir.glob(pattern).each_with_object({}) do |path, hash|
+          hash[path] = File.mtime(path)
+        rescue Errno::ENOENT
+          # File deleted between glob and mtime - skip
+        end
+      end
+    end
+  end
+end