type-guessr 0.0.1

data/lib/type_guessr/core/types.rb

@@ -0,0 +1,425 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module TypeGuessr
+  module Core
+    module Types
+      # Base class for all type representations
+      class Type
+        def ==(other)
+          eql?(other)
+        end
+
+        def eql?(other)
+          self.class == other.class
+        end
+
+        def hash
+          self.class.hash
+        end
+
+        # Substitute type variables with concrete types
+        # @param substitutions [Hash{Symbol => Type}] type variable substitutions
+        # @return [Type] the type with substitutions applied (self if no change)
+        def substitute(_substitutions)
+          self
+        end
+
+        # Get the RBS class name for this type
+        # Used for looking up method signatures in RBSProvider
+        # @return [String, nil] class name or nil if not applicable
+        def rbs_class_name
+          nil
+        end
+
+        # 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
+          {}
+        end
+      end
+
+      # Unknown type - no information available
+      class Unknown < Type
+        include Singleton
+
+        def to_s
+          "untyped"
+        end
+      end
+
+      # ClassInstance - instance of a class
+      class ClassInstance < Type
+        attr_reader :name
+
+        def initialize(name)
+          super()
+          @name = name
+        end
+
+        def eql?(other)
+          super && @name == other.name
+        end
+
+        def hash
+          [self.class, @name].hash
+        end
+
+        def to_s
+          case @name
+          when "NilClass" then "nil"
+          when "TrueClass" then "true"
+          when "FalseClass" then "false"
+          else @name
+          end
+        end
+
+        def rbs_class_name
+          @name
+        end
+      end
+
+      # SingletonType - represents the class object itself (singleton class)
+      class SingletonType < Type
+        attr_reader :name
+
+        def initialize(name)
+          super()
+          @name = name
+        end
+
+        def eql?(other)
+          super && @name == other.name
+        end
+
+        def hash
+          [self.class, @name].hash
+        end
+
+        def to_s
+          "singleton(#{@name})"
+        end
+
+        def rbs_class_name
+          @name
+        end
+      end
+
+      # Union - union of multiple types
+      class Union < Type
+        attr_reader :types
+
+        def initialize(types, cutoff: RubyLsp::TypeGuessr::Config.union_cutoff)
+          super()
+          @types = normalize(types, cutoff)
+        end
+
+        def eql?(other)
+          return false unless super
+
+          # Compare as sets since order doesn't matter
+          @types.to_set == other.types.to_set
+        end
+
+        def hash
+          [self.class, @types.to_set].hash
+        end
+
+        def to_s
+          if bool_type?
+            "bool"
+          elsif optional_type?
+            "?#{non_nil_type}"
+          else
+            @types.map(&:to_s).sort.join(" | ")
+          end
+        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) }
+
+          Union.new(new_types)
+        end
+
+        private
+
+        def bool_type?
+          return false unless @types.size == 2
+
+          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_true && has_false
+        end
+
+        def optional_type?
+          @types.size == 2 && @types.any? { |t| nil_type?(t) }
+        end
+
+        def nil_type?(type)
+          type.is_a?(ClassInstance) && type.name == "NilClass"
+        end
+
+        def non_nil_type
+          @types.find { |t| !nil_type?(t) }
+        end
+
+        def normalize(types, cutoff)
+          # Flatten nested unions
+          flattened = flatten_unions(types)
+
+          # Deduplicate
+          deduplicated = flattened.uniq
+
+          # Simplify to Unknown if Unknown is present (T | untyped = untyped)
+          filtered = simplify_if_unknown_present(deduplicated)
+
+          # Apply cutoff
+          apply_cutoff(filtered, cutoff)
+        end
+
+        def flatten_unions(types)
+          types.flat_map do |type|
+            type.is_a?(Union) ? type.types : type
+          end
+        end
+
+        def simplify_if_unknown_present(types)
+          return types if types.size <= 1
+
+          has_unknown = types.any? { |t| t.is_a?(Unknown) }
+          has_unknown ? [Unknown.instance] : types
+        end
+
+        def apply_cutoff(types, cutoff)
+          types.take(cutoff)
+        end
+      end
+
+      # ArrayType - array with element type
+      class ArrayType < Type
+        attr_reader :element_type
+
+        def initialize(element_type = Unknown.instance)
+          super()
+          @element_type = element_type
+        end
+
+        def eql?(other)
+          super && @element_type == other.element_type
+        end
+
+        def hash
+          [self.class, @element_type].hash
+        end
+
+        def to_s
+          "Array[#{@element_type}]"
+        end
+
+        def substitute(substitutions)
+          new_element = @element_type.substitute(substitutions)
+          return self if new_element.equal?(@element_type)
+
+          ArrayType.new(new_element)
+        end
+
+        def rbs_class_name
+          "Array"
+        end
+
+        def type_variable_substitutions
+          { Elem: @element_type }
+        end
+      end
+
+      # HashType - hash with key and value types
+      class HashType < Type
+        attr_reader :key_type, :value_type
+
+        def initialize(key_type = Unknown.instance, value_type = Unknown.instance)
+          super()
+          @key_type = key_type
+          @value_type = value_type
+        end
+
+        def eql?(other)
+          super && @key_type == other.key_type && @value_type == other.value_type
+        end
+
+        def hash
+          [self.class, @key_type, @value_type].hash
+        end
+
+        def to_s
+          "Hash[#{@key_type}, #{@value_type}]"
+        end
+
+        def substitute(substitutions)
+          new_key = @key_type.substitute(substitutions)
+          new_value = @value_type.substitute(substitutions)
+          return self if new_key.equal?(@key_type) && new_value.equal?(@value_type)
+
+          HashType.new(new_key, new_value)
+        end
+
+        def rbs_class_name
+          "Hash"
+        end
+
+        def type_variable_substitutions
+          { K: @key_type, V: @value_type }
+        end
+      end
+
+      # RangeType - range with element type
+      class RangeType < Type
+        attr_reader :element_type
+
+        def initialize(element_type = Unknown.instance)
+          super()
+          @element_type = element_type
+        end
+
+        def eql?(other)
+          super && @element_type == other.element_type
+        end
+
+        def hash
+          [self.class, @element_type].hash
+        end
+
+        def to_s
+          "Range[#{@element_type}]"
+        end
+
+        def substitute(substitutions)
+          new_element = @element_type.substitute(substitutions)
+          return self if new_element.equal?(@element_type)
+
+          RangeType.new(new_element)
+        end
+
+        def rbs_class_name
+          "Range"
+        end
+
+        def type_variable_substitutions
+          { Elem: @element_type }
+        end
+      end
+
+      # HashShape - hash with known field types (Symbol/String keys only)
+      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
+
+          super(fields)
+        end
+
+        def initialize(fields)
+          super()
+          @fields = fields
+        end
+
+        def eql?(other)
+          super && @fields == other.fields
+        end
+
+        def hash
+          [self.class, @fields].hash
+        end
+
+        def to_s
+          return "{ }" if @fields.empty?
+
+          fields_str = @fields.map { |k, v| "#{k}: #{v}" }.join(", ")
+          "{ #{fields_str} }"
+        end
+
+        def merge_field(key, value_type, max_fields: RubyLsp::TypeGuessr::Config.hash_shape_max_fields)
+          new_fields = @fields.merge(key => value_type)
+          HashShape.new(new_fields, max_fields: max_fields)
+        end
+
+        def substitute(substitutions)
+          new_fields = @fields.transform_values { |v| v.substitute(substitutions) }
+          return self if new_fields.all? { |k, v| v.equal?(@fields[k]) }
+
+          HashShape.new(new_fields)
+        end
+
+        def rbs_class_name
+          "Hash"
+        end
+
+        def type_variable_substitutions
+          key_type = ClassInstance.new("Symbol")
+          value_types = @fields.values.uniq
+          value_type = if value_types.empty?
+                         Unknown.instance
+                       elsif value_types.size == 1
+                         value_types.first
+                       else
+                         Union.new(value_types)
+                       end
+          { K: key_type, V: value_type }
+        end
+      end
+
+      # TypeVariable - represents a type variable from RBS (e.g., Elem, K, V, U)
+      class TypeVariable < Type
+        attr_reader :name
+
+        def initialize(name)
+          super()
+          @name = name
+        end
+
+        def eql?(other)
+          super && @name == other.name
+        end
+
+        def hash
+          [self.class, @name].hash
+        end
+
+        def to_s
+          @name.to_s
+        end
+
+        def substitute(substitutions)
+          substitutions[@name] || self
+        end
+      end
+
+      # SelfType - represents the 'self' type from RBS
+      # Gets substituted with the receiver type at resolution time
+      class SelfType < Type
+        include Singleton
+
+        def to_s
+          "self"
+        end
+
+        def substitute(substitutions)
+          substitutions[:self] || self
+        end
+      end
+
+      # ForwardingArgs - represents the forwarding parameter (...)
+      class ForwardingArgs < Type
+        include Singleton
+
+        def to_s
+          "..."
+        end
+      end
+    end
+  end
+end

data/lib/type_guessr/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module TypeGuessr
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification
+name: type-guessr
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- riseshia
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby-lsp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+description: TypeGuessr provides heuristic type inference
+email:
+- ''
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/ruby_lsp/type_guessr/addon.rb
+- lib/ruby_lsp/type_guessr/config.rb
+- lib/ruby_lsp/type_guessr/debug_server.rb
+- lib/ruby_lsp/type_guessr/graph_builder.rb
+- lib/ruby_lsp/type_guessr/hover.rb
+- lib/ruby_lsp/type_guessr/runtime_adapter.rb
+- lib/ruby_lsp/type_guessr/type_inferrer.rb
+- lib/type-guessr.rb
+- lib/type_guessr/core/converter/prism_converter.rb
+- lib/type_guessr/core/converter/rbs_converter.rb
+- lib/type_guessr/core/index/location_index.rb
+- lib/type_guessr/core/inference/resolver.rb
+- lib/type_guessr/core/inference/result.rb
+- lib/type_guessr/core/ir/nodes.rb
+- lib/type_guessr/core/logger.rb
+- lib/type_guessr/core/rbs_provider.rb
+- lib/type_guessr/core/registry/method_registry.rb
+- lib/type_guessr/core/registry/variable_registry.rb
+- lib/type_guessr/core/signature_provider.rb
+- lib/type_guessr/core/type_simplifier.rb
+- lib/type_guessr/core/types.rb
+- lib/type_guessr/version.rb
+homepage: https://github.com/riseshia/type-guessr
+licenses: []
+metadata:
+  homepage_uri: https://github.com/riseshia/type-guessr
+  source_code_uri: https://github.com/riseshia/type-guessr
+  changelog_uri: https://github.com/riseshia/type-guessr/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: A heuristic type inference tool for Ruby
+test_files: []