type-guessr 0.0.1 → 0.0.3

data/lib/ruby_lsp/type_guessr/hover.rb

@@ -6,34 +6,8 @@ module RubyLsp
     class Hover
       # Core layer shortcuts
       Types = ::TypeGuessr::Core::Types
-      private_constant :Types
-
-      # Define all node types that should trigger hover content
-      HOVER_NODE_TYPES = %i[
-        local_variable_read
-        local_variable_write
-        local_variable_target
-        instance_variable_read
-        instance_variable_write
-        instance_variable_target
-        class_variable_read
-        class_variable_write
-        class_variable_target
-        global_variable_read
-        global_variable_write
-        global_variable_target
-        required_parameter
-        optional_parameter
-        rest_parameter
-        required_keyword_parameter
-        optional_keyword_parameter
-        keyword_rest_parameter
-        block_parameter
-        forwarding_parameter
-        call
-        def
-        self
-      ].freeze
+      NodeContextHelper = ::TypeGuessr::Core::NodeContextHelper
+      private_constant :Types, :NodeContextHelper
 
       def initialize(runtime_adapter, response_builder, node_context, dispatcher, global_state)
         @runtime_adapter = runtime_adapter
@@ -45,18 +19,16 @@ module RubyLsp
       end
 
       # Dynamically define handler methods for each node type
-      HOVER_NODE_TYPES.each do |node_type|
+      Constants::HOVER_NODE_MAPPING.each_key do |node_type|
         define_method(:"on_#{node_type}_node_enter") do |node|
           add_hover_content(node)
         end
       end
 
-      private
-
-      def register_listeners(dispatcher)
+      private def register_listeners(dispatcher)
         dispatcher.register(
           self,
-          *HOVER_NODE_TYPES.map { |type| :"on_#{type}_node_enter" }
+          *Constants::HOVER_NODE_MAPPING.keys.map { |type| :"on_#{type}_node_enter" }
         )
       end
 
@@ -64,12 +36,12 @@ module RubyLsp
       IR = ::TypeGuessr::Core::IR
       private_constant :IR
 
-      def add_hover_content(node)
+      private def add_hover_content(node)
         # Generate node_key from scope and Prism node
         # DefNode is indexed with parent scope (not including the method itself)
         exclude_method = node.is_a?(Prism::DefNode)
-        scope_id = generate_scope_id(exclude_method: exclude_method)
-        node_hash = generate_node_hash(node)
+        scope_id = NodeContextHelper.generate_scope_id(@node_context, exclude_method: exclude_method)
+        node_hash = NodeContextHelper.generate_node_hash(node, @node_context)
         return unless node_hash
 
         node_key = "#{scope_id}:#{node_hash}"
@@ -105,21 +77,19 @@ module RubyLsp
         warn "[TypeGuessr] Error in add_hover_content: #{e.message}\n#{e.backtrace.first(5).join("\n")}"
       end
 
-      def add_def_node_hover(def_node)
-        # Build method signature: (params) -> return_type
-        params_str = format_params(def_node.params)
-        return_result = @runtime_adapter.infer_type(def_node)
-        return_type_str = return_result.type.to_s
-
-        signature = "(#{params_str}) -> #{return_type_str}"
-        content = "**Guessed Signature:** `#{signature}`"
+      private def add_def_node_hover(def_node)
+        method_sig = @runtime_adapter.build_method_signature(def_node)
+        content = "**Guessed Signature:** `#{method_sig}`"
 
-        content += build_debug_info(return_result) if debug_enabled?
+        if debug_enabled?
+          return_result = @runtime_adapter.infer_type(def_node)
+          content += build_debug_info(return_result)
+        end
 
         @response_builder.push(content, category: :documentation)
       end
 
-      def add_call_node_hover(call_node)
+      private def add_call_node_hover(call_node)
         # Special case: Handle .new calls to show constructor signature
         # Support both ClassName.new (ConstantNode) and self.new (SelfNode) in singleton methods
         if call_node.method == :new &&
@@ -128,6 +98,15 @@ module RubyLsp
           return
         end
 
+        # Handle implicit self calls (receiver is nil)
+        unless call_node.receiver
+          def_node = lookup_def_node_for_implicit_self(call_node)
+          if def_node
+            add_def_node_hover(def_node)
+            return
+          end
+        end
+
         # Get receiver type to look up method signature
         if call_node.receiver
           # For ConstantNode receiver (e.g., File.exist?, RBS::Environment.from_loader),
@@ -142,34 +121,55 @@ module RubyLsp
           class_name = extract_class_name(receiver_type)
 
           if class_name
-            # Look up signature via SignatureProvider
-            # Use class method lookup for SingletonType (e.g., RBS::Environment.from_loader)
-            signatures = if receiver_type.is_a?(Types::SingletonType)
-                           @runtime_adapter.signature_provider.get_class_method_signatures(
-                             class_name, call_node.method.to_s
-                           )
-                         else
-                           @runtime_adapter.signature_provider.get_method_signatures(
-                             class_name, call_node.method.to_s
-                           )
-                         end
-
-            if signatures.any?
-              # Format the signature(s)
-              sig_strs = signatures.map { |sig| sig.method_type.to_s }
-              content = "**Guessed Signature:** `#{sig_strs.first}`"
-
-              if debug_enabled?
-                content += "\n\n**[TypeGuessr Debug]**"
-                content += "\n\n**Receiver:** `#{receiver_type}`"
-                if sig_strs.size > 1
-                  content += "\n\n**Overloads:**\n"
-                  sig_strs.each { |s| content += "- `#{s}`\n" }
+            method_name_str = call_node.method.to_s
+            skip_stdlib_rbs = if receiver_type.is_a?(Types::SingletonType)
+                                @runtime_adapter.skip_stdlib_rbs_class_method?(class_name, method_name_str)
+                              else
+                                @runtime_adapter.skip_stdlib_rbs_method?(class_name, method_name_str)
+                              end
+
+            # Methods marked skip_stdlib_rbs skip DefNode + RBS → go straight to fallback (resolver)
+            unless skip_stdlib_rbs
+              # Try to find DefNode first (for project methods)
+              unless receiver_type.is_a?(Types::SingletonType)
+                def_node = @runtime_adapter.lookup_method(class_name, method_name_str)
+                if def_node
+                  add_def_node_hover(def_node)
+                  return
                 end
               end
 
-              @response_builder.push(content, category: :documentation)
-              return
+              # Fall back to RBS signature lookup (for stdlib/gems)
+              rbs_result = if receiver_type.is_a?(Types::SingletonType)
+                             @runtime_adapter.get_rbs_class_method_signatures(
+                               class_name, method_name_str
+                             )
+                           else
+                             @runtime_adapter.get_rbs_method_signatures(
+                               class_name, method_name_str
+                             )
+                           end
+
+              signatures = rbs_result[:signatures]
+              owner = rbs_result[:owner]
+
+              if signatures.any?
+                sig_strs = signatures.map { |sig| sig.method_type.to_s }
+                content = "**Guessed Signature:** `#{sig_strs.first}`"
+
+                if debug_enabled?
+                  content += "\n\n**[TypeGuessr Debug]**"
+                  content += "\n\n**Receiver:** `#{receiver_type}`"
+                  content += "\n\n**Defined in:** `#{owner}`" if owner != class_name
+                  if sig_strs.size > 1
+                    content += "\n\n**Overloads:**\n"
+                    sig_strs.each { |s| content += "- `#{s}`\n" }
+                  end
+                end
+
+                @response_builder.push(content, category: :documentation)
+                return
+              end
             end
           end
         end
@@ -187,7 +187,7 @@ module RubyLsp
       end
 
       # Build parameter signature for a method call using RubyIndexer
-      def build_call_signature_params(call_node)
+      private def build_call_signature_params(call_node)
         method_entry = lookup_method_entry_for_call(call_node)
 
         if method_entry&.signatures&.any?
@@ -200,7 +200,7 @@ module RubyLsp
       end
 
       # Look up method entry from RubyIndexer based on call node
-      def lookup_method_entry_for_call(call_node)
+      private def lookup_method_entry_for_call(call_node)
         return nil unless @global_state&.index
         return nil unless call_node.receiver
 
@@ -215,7 +215,7 @@ module RubyLsp
       end
 
       # Format parameters from RubyIndexer method entry with inferred argument types
-      def format_params_from_entry(method_entry, args)
+      private def format_params_from_entry(method_entry, args)
         params = method_entry.signatures.first.parameters
         return "" if params.nil? || params.empty?
 
@@ -230,7 +230,7 @@ module RubyLsp
       end
 
       # Format a single parameter based on its type
-      def format_single_param(param, arg_type)
+      private def format_single_param(param, arg_type)
         param_name = param.name.to_s
 
         case param
@@ -254,7 +254,7 @@ module RubyLsp
       end
 
       # Format arguments when no method entry is available
-      def format_params_from_args(args)
+      private def format_params_from_args(args)
         args.each_with_index.map do |arg, i|
           arg_type = @runtime_adapter.infer_type(arg).type.to_s
           "#{arg_type} arg#{i + 1}"
@@ -262,12 +262,12 @@ module RubyLsp
       end
 
       # Look up class method entry from RubyIndexer
-      def lookup_class_method_entry(class_name, method_name)
+      private def lookup_class_method_entry(class_name, method_name)
         return nil unless @global_state&.index
 
         # Query singleton class for the method
         # Ruby LSP uses unqualified name for singleton class (e.g., "RBS::Environment::<Class:Environment>")
-        unqualified_name = class_name.split("::").last
+        unqualified_name = ::TypeGuessr::Core::IR.extract_last_name(class_name)
         singleton_name = "#{class_name}::<Class:#{unqualified_name}>"
         entries = @global_state.index.resolve_method(method_name, singleton_name)
         return nil if entries.nil? || entries.empty?
@@ -278,7 +278,7 @@ module RubyLsp
       end
 
       # Look up instance method entry from RubyIndexer
-      def lookup_instance_method_entry(class_name, method_name)
+      private def lookup_instance_method_entry(class_name, method_name)
         return nil unless @global_state&.index
 
         entries = @global_state.index.resolve_method(method_name, class_name)
@@ -289,13 +289,29 @@ module RubyLsp
         nil
       end
 
-      def extract_class_name(type)
+      # Look up DefNode for implicit self calls (receiver is nil)
+      # Searches in current class scope and falls back to top-level
+      private def lookup_def_node_for_implicit_self(call_node)
+        method_name = call_node.method.to_s
+
+        # Get current class scope from node_context
+        class_name = @node_context.nesting.map { |n| n.is_a?(String) ? n : n.name.to_s }.join("::")
+
+        # Try current class scope first
+        def_node = @runtime_adapter.lookup_method(class_name, method_name) if class_name && !class_name.empty?
+        return def_node if def_node
+
+        # Fall back to top-level (empty class name)
+        @runtime_adapter.lookup_method("", method_name)
+      end
+
+      private def extract_class_name(type)
         case type
         when Types::ClassInstance
           type.name
         when Types::SingletonType
           type.name
-        when Types::ArrayType
+        when Types::ArrayType, Types::TupleType
           "Array"
         when Types::HashType, Types::HashShape
           "Hash"
@@ -303,99 +319,51 @@ module RubyLsp
       end
 
       # Handle .new calls to show constructor signature
-      def add_new_call_hover(call_node)
-        # Resolve constant to get class name (handles aliases)
-        receiver_result = @runtime_adapter.infer_type(call_node.receiver)
-        class_name = case receiver_result.type
-                     when Types::SingletonType then receiver_result.type.name
-                     else call_node.receiver.name
-                     end
-
-        # Look up initialize method signature
-        init_info = lookup_initialize_signature(class_name)
-
-        content = if init_info
-                    case init_info[:source]
-                    when :project
-                      params_str = format_params(init_info[:params])
-                      "**Guessed Signature:** `(#{params_str}) -> #{class_name}`"
-                    when :rbs
-                      sig_str = init_info[:signature].method_type.to_s
-                      sig_str = sig_str.sub(/-> .+$/, "-> #{class_name}")
-                      "**Guessed Signature:** `#{sig_str}`"
-                    end
-                  else
-                    "**Guessed Signature:** `() -> #{class_name}`"
+      private def add_new_call_hover(call_node)
+        class_name = resolve_receiver_class_name(call_node.receiver)
+        result = @runtime_adapter.build_constructor_signature(class_name)
+
+        content = case result[:source]
+                  when :project, :default
+                    "**Guessed Signature:** `#{result[:signature]}`"
+                  when :rbs
+                    sig_str = result[:rbs_signature].method_type.to_s
+                    sig_str = sig_str.sub(/-> .+$/, "-> #{class_name}")
+                    "**Guessed Signature:** `#{sig_str}`"
                   end
 
-        content += build_debug_info_for_new(init_info, class_name) if debug_enabled?
+        content += build_debug_info_for_new(result[:source], class_name) if debug_enabled?
 
         @response_builder.push(content, category: :documentation)
       end
 
-      # Look up initialize method signature for a class
-      def lookup_initialize_signature(class_name)
-        # 1. Try project methods first
-        def_node = @runtime_adapter.lookup_method(class_name, "initialize")
-        return { params: def_node.params, source: :project } if def_node
-
-        # 2. Fall back to RBS signatures
-        signatures = @runtime_adapter.signature_provider.get_method_signatures(
-          class_name, "initialize"
-        )
-        return { signature: signatures.first, source: :rbs } if signatures.any?
+      # Resolve receiver to class name (handles aliases via type inference)
+      # Uses CodeIndexAdapter to resolve short constant names to fully qualified names
+      private def resolve_receiver_class_name(receiver)
+        receiver_result = @runtime_adapter.infer_type(receiver)
+        short_name = case receiver_result.type
+                     when Types::SingletonType then receiver_result.type.name
+                     else receiver.name
+                     end
 
-        nil
+        # Use CodeIndexAdapter to resolve full qualified name with nesting context
+        nesting = @node_context.nesting.map { |n| n.is_a?(String) ? n : n.name.to_s }
+        @runtime_adapter.resolve_constant_name(short_name, nesting) || short_name
       end
 
       # Build debug info for .new calls
-      def build_debug_info_for_new(init_info, class_name)
+      private def build_debug_info_for_new(source, class_name)
         info = "\n\n**[TypeGuessr Debug]**"
         info += "\n\n**Class:** `#{class_name}`"
-        info += "\n\n**Source:** #{init_info&.[](:source) || :inferred}"
+        info += "\n\n**Source:** #{source}"
         info
       end
 
-      def format_params(params)
-        return "" if params.nil? || params.empty?
-
-        params.map do |param|
-          param_type = infer_param_type(param)
-          type_str = param_type.to_s
-
-          case param.kind
-          when :required
-            "#{type_str} #{param.name}"
-          when :optional
-            "?#{type_str} #{param.name}"
-          when :rest
-            "*#{type_str} #{param.name}"
-          when :keyword_required
-            "#{param.name}: #{type_str}"
-          when :keyword_optional
-            "#{param.name}: ?#{type_str}"
-          when :keyword_rest
-            "**#{type_str} #{param.name}"
-          when :block
-            "&#{type_str} #{param.name}"
-          when :forwarding
-            "..."
-          else
-            "#{type_str} #{param.name}"
-          end
-        end.join(", ")
-      end
-
-      def infer_param_type(param)
-        result = @runtime_adapter.infer_type(param)
-        result.type
+      private def debug_enabled?
+        ::TypeGuessr::Core::Config.debug?
       end
 
-      def debug_enabled?
-        Config.debug?
-      end
-
-      def build_debug_info(result, ir_node = nil)
+      private def build_debug_info(result, ir_node = nil)
         info = "\n\n**[TypeGuessr Debug]**"
         info += "\n\n**Reason:** #{result.reason}"
         info += "\n\n**Source:** #{result.source}"
@@ -406,7 +374,7 @@ module RubyLsp
         info
       end
 
-      def extract_called_methods(ir_node)
+      private def extract_called_methods(ir_node)
         case ir_node
         when IR::LocalWriteNode, IR::LocalReadNode,
              IR::InstanceVariableWriteNode, IR::InstanceVariableReadNode,
@@ -421,108 +389,8 @@ module RubyLsp
         end
       end
 
-      # Generate scope_id from node_context
-      # Format: "ClassName#method_name" or "ClassName" or "#method_name" or ""
-      # @param exclude_method [Boolean] Whether to exclude method from scope (for DefNode)
-      def generate_scope_id(exclude_method: false)
-        class_path = @node_context.nesting.map do |n|
-          n.is_a?(String) ? n : n.name.to_s
-        end.join("::")
-
-        method_name = exclude_method ? nil : @node_context.surrounding_method
-
-        if method_name
-          "#{class_path}##{method_name}"
-        else
-          class_path
-        end
-      end
-
-      # Generate node_hash from Prism node to match IR node_hash format
-      def generate_node_hash(node)
-        line = node.location.start_line
-        case node
-        when Prism::LocalVariableWriteNode, Prism::LocalVariableTargetNode
-          "local_write:#{node.name}:#{line}"
-        when Prism::LocalVariableReadNode
-          "local_read:#{node.name}:#{line}"
-        when Prism::InstanceVariableWriteNode, Prism::InstanceVariableTargetNode
-          "ivar_write:#{node.name}:#{line}"
-        when Prism::InstanceVariableReadNode
-          "ivar_read:#{node.name}:#{line}"
-        when Prism::ClassVariableWriteNode, Prism::ClassVariableTargetNode
-          "cvar_write:#{node.name}:#{line}"
-        when Prism::ClassVariableReadNode
-          "cvar_read:#{node.name}:#{line}"
-        when Prism::GlobalVariableWriteNode, Prism::GlobalVariableTargetNode
-          "global_write:#{node.name}:#{line}"
-        when Prism::GlobalVariableReadNode
-          "global_read:#{node.name}:#{line}"
-        when Prism::RequiredParameterNode, Prism::OptionalParameterNode, Prism::RestParameterNode,
-             Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode,
-             Prism::KeywordRestParameterNode, Prism::BlockParameterNode
-          # Check if this is a block parameter (parent is BlockParametersNode)
-          if block_parameter?(node)
-            index = block_parameter_index(node)
-            "bparam:#{index}:#{line}"
-          else
-            "param:#{node.name}:#{line}"
-          end
-        when Prism::ForwardingParameterNode
-          "param:...:#{line}"
-        when Prism::CallNode
-          # Use message_loc for accurate line number
-          call_line = node.message_loc&.start_line || line
-          "call:#{node.name}:#{call_line}"
-        when Prism::DefNode
-          # Use name_loc for accurate line number
-          def_line = node.name_loc&.start_line || line
-          "def:#{node.name}:#{def_line}"
-        when Prism::SelfNode
-          class_path = @node_context.nesting.map do |n|
-            n.is_a?(String) ? n : n.name.to_s
-          end.join("::")
-          "self:#{class_path}:#{line}"
-        end
-      end
-
-      # Check if a parameter node is inside a block (not a method definition)
-      def block_parameter?(node)
-        call_node = @node_context.call_node
-        return false unless call_node&.block
-
-        # Check if this parameter is in the block's parameters
-        block_params = call_node.block.parameters&.parameters
-        return false unless block_params
-
-        all_params = collect_block_params(block_params)
-        all_params.include?(node)
-      end
-
-      # Get the index of a block parameter
-      def block_parameter_index(node)
-        call_node = @node_context.call_node
-        return 0 unless call_node&.block
-
-        block_params = call_node.block.parameters&.parameters
-        return 0 unless block_params
-
-        all_params = collect_block_params(block_params)
-        all_params.index(node) || 0
-      end
-
-      # Collect all positional parameters from a ParametersNode
-      def collect_block_params(params_node)
-        all_params = []
-        all_params.concat(params_node.requireds || [])
-        all_params.concat(params_node.optionals || [])
-        all_params << params_node.rest if params_node.rest
-        all_params.concat(params_node.posts || [])
-        all_params
-      end
-
       # Format type with definition link if available
-      def format_type_with_link(type)
+      private def format_type_with_link(type)
         formatted = type.to_s
 
         # Only link ClassInstance types
@@ -539,7 +407,7 @@ module RubyLsp
       end
 
       # Find entry for a type name in RubyIndexer
-      def find_type_entry(type_name)
+      private def find_type_entry(type_name)
         return nil unless @global_state&.index
 
         entries = @global_state.index.resolve(type_name, [])
@@ -550,7 +418,7 @@ module RubyLsp
       end
 
       # Build a location link from an entry
-      def build_location_link(entry)
+      private def build_location_link(entry)
         uri = entry.uri
         return nil if uri.nil?
 

data/lib/ruby_lsp/type_guessr/rails_server_addon.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+# This file is loaded in the Rails runner process (not the LSP server)
+# via RunnerClient.register_server_addon.
+# RubyLsp::Rails::ServerAddon is already defined when this file is required.
+
+module RubyLsp
+  module TypeGuessr
+    # ServerAddon that runs inside the Rails runner process.
+    # Queries ActiveRecord runtime for model metadata (columns, enums, associations, scopes).
+    class RailsServerAddon < ::RubyLsp::Rails::ServerAddon
+      def name
+        "TypeGuessr"
+      end
+
+      def execute(request, params)
+        case request
+        when "model_metadata"
+          handle_model_metadata(params)
+        end
+      end
+
+      private def handle_model_metadata(params)
+        class_name = params[:name]
+        klass = class_name.constantize
+
+        return send_error_response("#{class_name} is not an ActiveRecord model") unless active_record_model?(klass)
+
+        send_result({
+                      columns: extract_columns(klass),
+                      enums: extract_enums(klass),
+                      associations: extract_associations(klass),
+                      scopes: extract_scopes(klass)
+                    })
+      rescue NameError
+        send_error_response("#{class_name} is not a valid class")
+      rescue StandardError => e
+        send_error_response("#{e.class}: #{e.message}")
+      end
+
+      private def active_record_model?(klass)
+        klass < ::ActiveRecord::Base
+      rescue StandardError
+        false
+      end
+
+      private def extract_columns(klass)
+        klass.columns.map do |col|
+          [col.name, col.type.to_s, col.null]
+        end
+      end
+
+      private def extract_enums(klass)
+        return {} unless klass.respond_to?(:defined_enums)
+
+        klass.defined_enums
+      end
+
+      private def extract_associations(klass)
+        klass.reflect_on_all_associations.map do |assoc|
+          {
+            name: assoc.name.to_s,
+            macro: assoc.macro.to_s,
+            class_name: assoc.class_name
+          }
+        end
+      rescue StandardError
+        []
+      end
+
+      private def extract_scopes(klass)
+        enum_values = klass.respond_to?(:defined_enums) ? klass.defined_enums.values.flat_map(&:keys) : []
+        exclude = Set.new(enum_values + enum_values.map { |v| "not_#{v}" })
+
+        klass.singleton_methods(false)
+             .map(&:to_s)
+             .reject { |m| exclude.include?(m) || m.start_with?("find_by_", "create_", "build_") }
+      rescue StandardError
+        []
+      end
+    end
+  end
+end