type-guessr 0.0.1

data/lib/type_guessr/core/inference/result.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../types"
+
+module TypeGuessr
+  module Core
+    module Inference
+      # Represents the result of type inference with reasoning
+      # Contains the inferred type and why it was inferred
+      class Result
+        attr_reader :type, :reason, :source
+
+        # @param type [Types::Type] The inferred type
+        # @param reason [String] Why this type was inferred
+        # @param source [Symbol] Source of the type (:gem, :project, :stdlib, :literal, :unknown)
+        def initialize(type, reason, source = :unknown)
+          @type = type
+          @reason = reason
+          @source = source
+        end
+
+        def ==(other)
+          other.is_a?(Result) &&
+            type == other.type &&
+            reason == other.reason &&
+            source == other.source
+        end
+
+        alias eql? ==
+
+        def hash
+          [type, reason, source].hash
+        end
+
+        def to_s
+          "#{type} (#{reason})"
+        end
+      end
+    end
+  end
+end

data/lib/type_guessr/core/ir/nodes.rb

@@ -0,0 +1,599 @@
+# frozen_string_literal: true
+
+module TypeGuessr
+  module Core
+    module IR
+      # Location information for IR nodes
+      # @param line [Integer] Line number (1-indexed)
+      # @param col_range [Range] Column range
+      Loc = Data.define(:line, :col_range)
+
+      # Pretty print helper for IR nodes (Prism-style tree output)
+      module TreeInspect
+        BRANCH = "├── "
+        LAST_BRANCH = "└── "
+        PIPE = "│   "
+        SPACE = "    "
+
+        def tree_inspect(indent: "", last: true, root: false)
+          lines = if root
+                    ["@ #{self.class.name.split("::").last} (location: #{format_loc})"]
+                  else
+                    prefix = last ? LAST_BRANCH : BRANCH
+                    indent += (last ? SPACE : PIPE)
+                    ["#{indent.delete_suffix(last ? SPACE : PIPE)}#{prefix}@ #{self.class.name.split("::").last} (location: #{format_loc})"]
+                  end
+          lines.concat(tree_inspect_fields(indent))
+          lines.join("\n")
+        end
+
+        private
+
+        def format_loc
+          loc ? "(#{loc.line},#{loc.col_range.begin})-(#{loc.line},#{loc.col_range.end})" : "∅"
+        end
+
+        def tree_field(name, value, indent, last: false)
+          prefix = last ? LAST_BRANCH : BRANCH
+          case value
+          when nil
+            "#{indent}#{prefix}#{name}: ∅"
+          when Array
+            if value.empty?
+              "#{indent}#{prefix}#{name}: (length: 0)"
+            else
+              lines = ["#{indent}#{prefix}#{name}: (length: #{value.size})"]
+              value.each_with_index do |item, idx|
+                is_last = idx == value.size - 1
+                item_indent = indent + (last ? SPACE : PIPE)
+                if item.is_a?(TreeInspect)
+                  lines << item.tree_inspect(indent: item_indent, last: is_last)
+                else
+                  item_prefix = is_last ? LAST_BRANCH : BRANCH
+                  lines << "#{item_indent}#{item_prefix}#{item.inspect}"
+                end
+              end
+              lines.join("\n")
+            end
+          when Symbol, String, Integer, TrueClass, FalseClass
+            "#{indent}#{prefix}#{name}: #{value.inspect}"
+          else
+            if value.is_a?(TreeInspect)
+              lines = ["#{indent}#{prefix}#{name}:"]
+              child_indent = indent + (last ? SPACE : PIPE)
+              lines << value.tree_inspect(indent: child_indent, last: true)
+              lines.join("\n")
+            else
+              "#{indent}#{prefix}#{name}: #{value.inspect}"
+            end
+          end
+        end
+
+        def tree_inspect_fields(_indent)
+          []
+        end
+      end
+
+      # Base class for all IR nodes
+      # IR represents a reverse dependency graph where each node points to nodes it depends on
+      class Node
+        attr_reader :loc
+
+        def initialize(loc:)
+          @loc = loc
+        end
+
+        # Returns all nodes that this node directly depends on
+        # @return [Array<Node>]
+        def dependencies
+          []
+        end
+
+        # Generate a unique hash for this node (type + identifier + line)
+        # @return [String]
+        def node_hash
+          raise NotImplementedError, "#{self.class} must implement node_hash"
+        end
+
+        # Generate a unique key for this node (scope_id + node_hash)
+        # @param scope_id [String] The scope identifier (e.g., "User#save")
+        # @return [String]
+        def node_key(scope_id)
+          "#{scope_id}:#{node_hash}"
+        end
+      end
+
+      # Literal value node
+      # @param type [TypeGuessr::Core::Types::Type] The type of the literal
+      # @param literal_value [Object, nil] The actual literal value (for Symbol, Integer, String)
+      # @param values [Array<Node>, nil] Internal value nodes for compound literals (Hash/Array)
+      # @param loc [Loc] Location information
+      #
+      # Examples: "hello" → String, 123 → Integer, [] → Array, {} → Hash
+      # For compound literals, values contains the internal expression nodes
+      # For simple literals, literal_value stores the actual value (e.g., :a for symbols)
+      LiteralNode = Data.define(:type, :literal_value, :values, :loc) do
+        include TreeInspect
+
+        def dependencies
+          values || []
+        end
+
+        def node_hash
+          type_name = type.is_a?(Class) ? type.name.split("::").last : type.class.name.split("::").last
+          "lit:#{type_name}:#{loc&.line}"
+        end
+
+        def node_key(scope_id)
+          "#{scope_id}:#{node_hash}"
+        end
+
+        def tree_inspect_fields(indent)
+          type_str = type.respond_to?(:name) ? type.name : type.class.name.split("::").last
+          [
+            tree_field(:type, type_str, indent),
+            tree_field(:literal_value, literal_value, indent),
+            tree_field(:values, values, indent, last: true),
+          ]
+        end
+      end
+
+      # Local variable write node (assignment)
+      # @param name [Symbol] Variable name
+      # @param value [Node] The node of the assigned value
+      # @param called_methods [Array<Symbol>] Methods called on this variable (for method-based inference)
+      # @param loc [Loc] Location information
+      #
+      # Note: called_methods is a shared array object that can be mutated during parsing
+      LocalWriteNode = Data.define(:name, :value, :called_methods, :loc) do
+        include TreeInspect
+
+        def dependencies
+          value ? [value] : []
+        end
+
+        def node_hash
+          "local_write:#{name}:#{loc&.line}"
+        end
+
+        def node_key(scope_id)
+          "#{scope_id}:#{node_hash}"
+        end
+
+        def tree_inspect_fields(indent)
+          [
+            tree_field(:name, name, indent),
+            tree_field(:value, value, indent),
+            tree_field(:called_methods, called_methods, indent, last: true),
+          ]
+        end
+      end
+
+      # Local variable read node (reference)
+      # @param name [Symbol] Variable name
+      # @param write_node [LocalWriteNode, nil] The LocalWriteNode this read references
+      # @param called_methods [Array<Symbol>] Methods called on this variable (for method-based inference)
+      # @param loc [Loc] Location information
+      #
+      # Note: called_methods is shared with LocalWriteNode for method-based inference propagation
+      LocalReadNode = Data.define(:name, :write_node, :called_methods, :loc) do
+        include TreeInspect
+
+        def dependencies
+          write_node ? [write_node] : []
+        end
+
+        def node_hash
+          "local_read:#{name}:#{loc&.line}"
+        end
+
+        def node_key(scope_id)
+          "#{scope_id}:#{node_hash}"
+        end
+
+        def tree_inspect_fields(indent)
+          [
+            tree_field(:name, name, indent),
+            tree_field(:write_node, write_node, indent),
+            tree_field(:called_methods, called_methods, indent, last: true),
+          ]
+        end
+      end
+
+      # Instance variable write node (@name = value)
+      # @param name [Symbol] Variable name (e.g., :@recipe)
+      # @param class_name [String, nil] Enclosing class name for deferred resolution
+      # @param value [Node] The node of the assigned value
+      # @param called_methods [Array<Symbol>] Methods called on this variable (for method-based inference)
+      # @param loc [Loc] Location information
+      InstanceVariableWriteNode = Data.define(:name, :class_name, :value, :called_methods, :loc) do
+        include TreeInspect
+
+        def dependencies
+          value ? [value] : []
+        end
+
+        def node_hash
+          "ivar_write:#{name}:#{loc&.line}"
+        end
+
+        def node_key(scope_id)
+          "#{scope_id}:#{node_hash}"
+        end
+
+        def tree_inspect_fields(indent)
+          [
+            tree_field(:name, name, indent),
+            tree_field(:class_name, class_name, indent),
+            tree_field(:value, value, indent),
+            tree_field(:called_methods, called_methods, indent, last: true),
+          ]
+        end
+      end
+
+      # Instance variable read node (@name)
+      # @param name [Symbol] Variable name (e.g., :@recipe)
+      # @param class_name [String, nil] Enclosing class name for deferred resolution
+      # @param write_node [InstanceVariableWriteNode, nil] The write node this read references
+      # @param called_methods [Array<Symbol>] Methods called on this variable (for method-based inference)
+      # @param loc [Loc] Location information
+      #
+      # Note: write_node may be nil at conversion time if assignment appears later.
+      # Resolver performs deferred lookup using class_name.
+      InstanceVariableReadNode = Data.define(:name, :class_name, :write_node, :called_methods, :loc) do
+        include TreeInspect
+
+        def dependencies
+          write_node ? [write_node] : []
+        end
+
+        def node_hash
+          "ivar_read:#{name}:#{loc&.line}"
+        end
+
+        def node_key(scope_id)
+          "#{scope_id}:#{node_hash}"
+        end
+
+        def tree_inspect_fields(indent)
+          [
+            tree_field(:name, name, indent),
+            tree_field(:class_name, class_name, indent),
+            tree_field(:write_node, write_node, indent),
+            tree_field(:called_methods, called_methods, indent, last: true),
+          ]
+        end
+      end
+
+      # Class variable write node (@@name = value)
+      # @param name [Symbol] Variable name (e.g., :@@count)
+      # @param class_name [String, nil] Enclosing class name for deferred resolution
+      # @param value [Node] The node of the assigned value
+      # @param called_methods [Array<Symbol>] Methods called on this variable (for method-based inference)
+      # @param loc [Loc] Location information
+      ClassVariableWriteNode = Data.define(:name, :class_name, :value, :called_methods, :loc) do
+        include TreeInspect
+
+        def dependencies
+          value ? [value] : []
+        end
+
+        def node_hash
+          "cvar_write:#{name}:#{loc&.line}"
+        end
+
+        def node_key(scope_id)
+          "#{scope_id}:#{node_hash}"
+        end
+
+        def tree_inspect_fields(indent)
+          [
+            tree_field(:name, name, indent),
+            tree_field(:class_name, class_name, indent),
+            tree_field(:value, value, indent),
+            tree_field(:called_methods, called_methods, indent, last: true),
+          ]
+        end
+      end
+
+      # Class variable read node (@@name)
+      # @param name [Symbol] Variable name (e.g., :@@count)
+      # @param class_name [String, nil] Enclosing class name for deferred resolution
+      # @param write_node [ClassVariableWriteNode, nil] The write node this read references
+      # @param called_methods [Array<Symbol>] Methods called on this variable (for method-based inference)
+      # @param loc [Loc] Location information
+      ClassVariableReadNode = Data.define(:name, :class_name, :write_node, :called_methods, :loc) do
+        include TreeInspect
+
+        def dependencies
+          write_node ? [write_node] : []
+        end
+
+        def node_hash
+          "cvar_read:#{name}:#{loc&.line}"
+        end
+
+        def node_key(scope_id)
+          "#{scope_id}:#{node_hash}"
+        end
+
+        def tree_inspect_fields(indent)
+          [
+            tree_field(:name, name, indent),
+            tree_field(:class_name, class_name, indent),
+            tree_field(:write_node, write_node, indent),
+            tree_field(:called_methods, called_methods, indent, last: true),
+          ]
+        end
+      end
+
+      # Method parameter node
+      # @param name [Symbol] Parameter name
+      # @param kind [Symbol] Parameter kind (:required, :optional, :rest, :keyword_required,
+      #                      :keyword_optional, :keyword_rest, :block, :forwarding)
+      # @param default_value [Node, nil] Default value node (nil if no default)
+      # @param called_methods [Array<Symbol>] Methods called on this parameter (for method-based inference)
+      # @param loc [Loc] Location information
+      #
+      # Note: called_methods is a shared array object that can be mutated during parsing
+      ParamNode = Data.define(:name, :kind, :default_value, :called_methods, :loc) do
+        include TreeInspect
+
+        def dependencies
+          default_value ? [default_value] : []
+        end
+
+        def node_hash
+          "param:#{name}:#{loc&.line}"
+        end
+
+        def node_key(scope_id)
+          "#{scope_id}:#{node_hash}"
+        end
+
+        def tree_inspect_fields(indent)
+          [
+            tree_field(:name, name, indent),
+            tree_field(:kind, kind, indent),
+            tree_field(:default_value, default_value, indent),
+            tree_field(:called_methods, called_methods, indent, last: true),
+          ]
+        end
+      end
+
+      # Constant reference node
+      # @param name [String] Constant name (e.g., "DEFAULT_NAME", "User::ADMIN")
+      # @param dependency [Node] The node where this constant is defined
+      # @param loc [Loc] Location information
+      ConstantNode = Data.define(:name, :dependency, :loc) do
+        include TreeInspect
+
+        def dependencies
+          dependency ? [dependency] : []
+        end
+
+        def node_hash
+          "const:#{name}:#{loc&.line}"
+        end
+
+        def node_key(scope_id)
+          "#{scope_id}:#{node_hash}"
+        end
+
+        def tree_inspect_fields(indent)
+          [
+            tree_field(:name, name, indent),
+            tree_field(:dependency, dependency, indent, last: true),
+          ]
+        end
+      end
+
+      # Method call node
+      # @param method [Symbol] Method name
+      # @param receiver [Node, nil] Receiver node (nil for implicit self)
+      # @param args [Array<Node>] Argument nodes
+      # @param block_params [Array<BlockParamSlot>] Block parameter slots
+      # @param block_body [Node, nil] Block body return node (for inferring block return type)
+      # @param has_block [Boolean] Whether a block was provided (even if empty)
+      # @param loc [Loc] Location information
+      CallNode = Data.define(:method, :receiver, :args, :block_params, :block_body, :has_block, :loc) do
+        include TreeInspect
+
+        def dependencies
+          deps = []
+          deps << receiver if receiver
+          deps.concat(args)
+          deps << block_body if block_body
+          deps
+        end
+
+        def node_hash
+          "call:#{method}:#{loc&.line}"
+        end
+
+        def node_key(scope_id)
+          "#{scope_id}:#{node_hash}"
+        end
+
+        def tree_inspect_fields(indent)
+          [
+            tree_field(:method, method, indent),
+            tree_field(:receiver, receiver, indent),
+            tree_field(:args, args, indent),
+            tree_field(:block_params, block_params, indent),
+            tree_field(:block_body, block_body, indent),
+            tree_field(:has_block, has_block, indent, last: true),
+          ]
+        end
+      end
+
+      # Block parameter slot
+      # Represents a parameter slot in a block (e.g., |user| in users.each { |user| ... })
+      # @param index [Integer] Parameter index (0-based)
+      # @param call_node [CallNode] The call node this slot belongs to
+      # @param loc [Loc] Location information for the parameter itself
+      BlockParamSlot = Data.define(:index, :call_node, :loc) do
+        include TreeInspect
+
+        def dependencies
+          [call_node]
+        end
+
+        def node_hash
+          "bparam:#{index}:#{loc&.line}"
+        end
+
+        def node_key(scope_id)
+          "#{scope_id}:#{node_hash}"
+        end
+
+        def tree_inspect_fields(indent)
+          [
+            tree_field(:index, index, indent),
+            tree_field(:call_node, "(CallNode ref)", indent, last: true),
+          ]
+        end
+      end
+
+      # Branch merge node
+      # Represents the convergence point of multiple branches (if/else, case/when, etc.)
+      # The type is the union of all branch types
+      # @param branches [Array<Node>] Final nodes from each branch
+      # @param loc [Loc] Location information
+      MergeNode = Data.define(:branches, :loc) do
+        include TreeInspect
+
+        def dependencies
+          branches
+        end
+
+        def node_hash
+          "merge:#{loc&.line}"
+        end
+
+        def node_key(scope_id)
+          "#{scope_id}:#{node_hash}"
+        end
+
+        def tree_inspect_fields(indent)
+          [tree_field(:branches, branches, indent, last: true)]
+        end
+      end
+
+      # Method definition node
+      # @param name [Symbol] Method name
+      # @param class_name [String, nil] Enclosing class name
+      # @param params [Array<ParamNode>] Parameter nodes
+      # @param return_node [Node] Node representing the return value
+      # @param body_nodes [Array<Node>] All nodes in the method body
+      # @param loc [Loc] Location information
+      # @param singleton [Boolean] true if this is a singleton method (def self.method_name)
+      DefNode = Data.define(:name, :class_name, :params, :return_node, :body_nodes, :loc, :singleton) do
+        include TreeInspect
+
+        def dependencies
+          deps = params.dup
+          deps << return_node if return_node
+          deps.concat(body_nodes || [])
+          deps
+        end
+
+        def node_hash
+          "def:#{name}:#{loc&.line}"
+        end
+
+        def node_key(scope_id)
+          "#{scope_id}:#{node_hash}"
+        end
+
+        def tree_inspect_fields(indent)
+          [
+            tree_field(:name, name, indent),
+            tree_field(:class_name, class_name, indent),
+            tree_field(:params, params, indent),
+            tree_field(:return_node, return_node, indent),
+            tree_field(:body_nodes, body_nodes, indent),
+            tree_field(:singleton, singleton, indent, last: true),
+          ]
+        end
+      end
+
+      # Class/Module node - container for methods and other definitions
+      # @param name [String] Class or module name
+      # @param methods [Array<DefNode>] Method definitions in this class/module
+      # @param loc [Loc] Location information
+      ClassModuleNode = Data.define(:name, :methods, :loc) do
+        include TreeInspect
+
+        def dependencies
+          methods
+        end
+
+        def node_hash
+          "class:#{name}:#{loc&.line}"
+        end
+
+        def node_key(scope_id)
+          "#{scope_id}:#{node_hash}"
+        end
+
+        def tree_inspect_fields(indent)
+          [
+            tree_field(:name, name, indent),
+            tree_field(:methods, methods, indent, last: true),
+          ]
+        end
+      end
+
+      # Self reference node
+      # @param class_name [String] Name of the enclosing class/module
+      # @param singleton [Boolean] Whether this self is in a singleton method context
+      # @param loc [Loc] Location information
+      SelfNode = Data.define(:class_name, :singleton, :loc) do
+        include TreeInspect
+
+        def dependencies
+          []
+        end
+
+        def node_hash
+          "self:#{class_name}:#{loc&.line}"
+        end
+
+        def node_key(scope_id)
+          "#{scope_id}:#{node_hash}"
+        end
+
+        def tree_inspect_fields(indent)
+          [
+            tree_field(:class_name, class_name, indent),
+            tree_field(:singleton, singleton, indent, last: true),
+          ]
+        end
+      end
+
+      # Explicit return statement node
+      # @param value [Node, nil] Return value node (nil for bare `return`)
+      # @param loc [Loc] Location information
+      ReturnNode = Data.define(:value, :loc) do
+        include TreeInspect
+
+        def dependencies
+          value ? [value] : []
+        end
+
+        def node_hash
+          "return:#{loc&.line}"
+        end
+
+        def node_key(scope_id)
+          "#{scope_id}:#{node_hash}"
+        end
+
+        def tree_inspect_fields(indent)
+          [tree_field(:value, value, indent, last: true)]
+        end
+      end
+    end
+  end
+end

data/lib/type_guessr/core/logger.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../../ruby_lsp/type_guessr/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 = {})
+        return unless debug_enabled?
+
+        output = "[TypeGuessr:DEBUG] #{msg}"
+        output += " #{context.inspect}" unless context.empty?
+        warn output
+      end
+
+      # 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?
+
+        warn "[TypeGuessr:ERROR] #{msg}"
+        return unless exception
+
+        warn "  #{exception.class}: #{exception.message}"
+        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?
+      end
+    end
+  end
+end