Add class_method attribute to scopes and enhance method call handling

Author: kwerle

lib/db/schema.rb

@@ -19,6 +19,7 @@ def write(*args)
           t.string  :path
           t.string  :class_type, null: false
           t.text    :parameters      # JSON string of method parameters
+          t.boolean :class_method, default: false  # true for class methods (def self.method)
         end
 
         add_index :scopes, :name

lib/ruby_language_server/project_manager.rb

@@ -162,16 +162,26 @@ def possible_definitions(uri, position)
       name = word_at_location(uri, position)
       return {} if name.blank?
 
+      # Special case: "new" should find "initialize" (instance method, not class method)
       name = 'initialize' if name == 'new'
+
       context = context_at_location(uri, position)
 
-      # If context has more than one element and the receiver is not a constant (class),
-      # it's an instance method call (e.g., foo.bar, not Foo.bar)
-      # In that case, skip scope chain search and go straight to project definitions
-      if context && context.length > 1 && context.first && context.first[0] =~ /[a-z_@]/ # rubocop:disable Style/IfUnlessModifier
-        return project_definitions_for(name)
+      # If context has more than one element it's a method call on a receiver
+      if context.length > 1
+        receiver = context.first
+        # Determine if it's a class method call (Foo.method) or instance method call (foo.method)
+        if likely_class_name?(receiver)
+          # Class method call or MyClass.new (which finds initialize as instance method)
+          # initialize is weird because it's defined as an instance method but called on the class.
+          return project_definitions_for(name, name == 'initialize' ? false : true)
+        else
+          # Instance method call (e.g., foo.bar, @foo.bar, FOO.bar)
+          return project_definitions_for(name, false)
+        end
       end
 
+      # No receiver - search in scope chain first, then project-wide
       scope = scopes_at(uri, position).first
       results = scope_definitions_for(name, scope, uri)
       return results unless results.empty?
@@ -194,8 +204,14 @@ def scope_definitions_for(name, scope, uri)
       return_array.uniq
     end
 
-    def project_definitions_for(name)
+    def project_definitions_for(name, class_method_filter = nil)
       scopes = RubyLanguageServer::ScopeData::Scope.where(name:)
+
+      # Filter by class_method attribute if specified
+      unless class_method_filter.nil?
+        scopes = scopes.where(class_method: class_method_filter)
+      end
+
       variables = RubyLanguageServer::ScopeData::Variable.constant_variables.where(name:)
       (scopes + variables).reject { |scope| scope.code_file.nil? }.map do |scope|
         Location.hash(scope.code_file.uri, scope.top_line, 1)
@@ -204,6 +220,18 @@ def project_definitions_for(name)
 
     private
 
+    # Guess if a receiver name is likely a class name based on idiomatic Ruby conventions.
+    # This is a heuristic and not 100% accurate (e.g., FOO could be a constant holding an instance).
+    # Returns true for names like "Foo" or "FooBar" (starts with uppercase, has lowercase letters).
+    # Returns false for "FOO" (all uppercase constant) or "foo" (variable/method).
+    def likely_class_name?(name)
+      # Must start with uppercase letter
+      return false unless name[0] =~ /[A-Z]/
+
+      # Must contain at least one lowercase letter to distinguish from constants like FOO
+      name =~ /[a-z]/
+    end
+
     def code_file_for_uri(uri)
       CodeFile.find_by_uri(uri) || CodeFile.build(uri, nil)
     end

lib/ruby_language_server/scope_parser.rb

@@ -71,8 +71,11 @@ def visit_def_node(node)
       line = node.location.start_line
       end_line = node.location.end_line
       column = node.location.start_column
+      is_class_method = node.receiver.is_a?(Prism::SelfNode)
 
       scope = push_scope(ScopeData::Scope::TYPE_METHOD, name, line, column, end_line, false)
+      scope.class_method = is_class_method
+      scope.save!
 
       # Extract and store parameters
       if node.parameters

spec/lib/ruby_language_server/project_manager_spec.rb

@@ -194,6 +194,7 @@ def initialize
       CODE_FILE
 
       project_manager.update_document_content('new_uri', file_with_new)
+      project_manager.tags_for_uri('new_uri') # Force load of tags
 
       # Position on "new"
       position = OpenStruct.new(line: 6, character: 17)
@@ -303,7 +304,6 @@ def some_method(meaningful)       # line 17: parameter declaration
       end
 
       it 'finds only class method when called on class name' do
-        skip "Class method vs instance method distinction not yet implemented"
 
         # Position on "meaningful" method call on Foo (line 20, character 12)
         position = OpenStruct.new(line: 20, character: 12)