ruby-lsp 0.22.1 → 0.23.10

data/lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb

@@ -16,15 +16,15 @@ module RubyIndexer
         index: Index,
         dispatcher: Prism::Dispatcher,
         parse_result: Prism::ParseResult,
-        file_path: String,
+        uri: URI::Generic,
         collect_comments: T::Boolean,
       ).void
     end
-    def initialize(index, dispatcher, parse_result, file_path, collect_comments: false)
+    def initialize(index, dispatcher, parse_result, uri, collect_comments: false)
       @index = index
-      @file_path = file_path
+      @uri = uri
       @enhancements = T.let(Enhancement.all(self), T::Array[Enhancement])
-      @visibility_stack = T.let([Entry::Visibility::PUBLIC], T::Array[Entry::Visibility])
+      @visibility_stack = T.let([VisibilityScope.public_scope], T::Array[VisibilityScope])
       @comments_by_line = T.let(
         parse_result.comments.to_h do |c|
           [c.location.start_line, c]
@@ -64,7 +64,6 @@ module RubyIndexer
         :on_constant_path_or_write_node_enter,
         :on_constant_path_operator_write_node_enter,
         :on_constant_path_and_write_node_enter,
-        :on_constant_or_write_node_enter,
         :on_constant_write_node_enter,
         :on_constant_or_write_node_enter,
         :on_constant_and_write_node_enter,
@@ -80,6 +79,11 @@ module RubyIndexer
         :on_instance_variable_or_write_node_enter,
         :on_instance_variable_target_node_enter,
         :on_alias_method_node_enter,
+        :on_class_variable_and_write_node_enter,
+        :on_class_variable_operator_write_node_enter,
+        :on_class_variable_or_write_node_enter,
+        :on_class_variable_target_node_enter,
+        :on_class_variable_write_node_enter,
       )
     end
 
@@ -87,7 +91,7 @@ module RubyIndexer
     def on_class_node_enter(node)
       constant_path = node.constant_path
       superclass = node.superclass
-      nesting = actual_nesting(constant_path.slice)
+      nesting = Index.actual_nesting(@stack, constant_path.slice)
 
       parent_class = case superclass
       when Prism::ConstantReadNode, Prism::ConstantPathNode
@@ -133,14 +137,14 @@ module RubyIndexer
 
     sig { params(node: Prism::SingletonClassNode).void }
     def on_singleton_class_node_enter(node)
-      @visibility_stack.push(Entry::Visibility::PUBLIC)
+      @visibility_stack.push(VisibilityScope.public_scope)
 
       current_owner = @owner_stack.last
 
       if current_owner
         expression = node.expression
-        name = (expression.is_a?(Prism::SelfNode) ? "<Class:#{@stack.last}>" : "<Class:#{expression.slice}>")
-        real_nesting = actual_nesting(name)
+        name = (expression.is_a?(Prism::SelfNode) ? "<Class:#{last_name_in_stack}>" : "<Class:#{expression.slice}>")
+        real_nesting = Index.actual_nesting(@stack, name)
 
         existing_entries = T.cast(@index[real_nesting.join("::")], T.nilable(T::Array[Entry::SingletonClass]))
 
@@ -154,7 +158,7 @@ module RubyIndexer
         else
           entry = Entry::SingletonClass.new(
             real_nesting,
-            @file_path,
+            @uri,
             Location.from_prism_location(node.location, @code_units_cache),
             Location.from_prism_location(expression.location, @code_units_cache),
             collect_comments(node),
@@ -275,15 +279,14 @@ module RubyIndexer
       when :include, :prepend, :extend
         handle_module_operation(node, message)
       when :public
-        @visibility_stack.push(Entry::Visibility::PUBLIC)
+        @visibility_stack.push(VisibilityScope.public_scope)
       when :protected
-        @visibility_stack.push(Entry::Visibility::PROTECTED)
+        @visibility_stack.push(VisibilityScope.new(visibility: Entry::Visibility::PROTECTED))
       when :private
-        @visibility_stack.push(Entry::Visibility::PRIVATE)
+        @visibility_stack.push(VisibilityScope.new(visibility: Entry::Visibility::PRIVATE))
       when :module_function
         handle_module_function(node)
       when :private_class_method
-        @visibility_stack.push(Entry::Visibility::PRIVATE)
         handle_private_class_method(node)
       end
 
@@ -291,7 +294,7 @@ module RubyIndexer
         enhancement.on_call_node_enter(node)
       rescue StandardError => e
         @indexing_errors << <<~MSG
-          Indexing error in #{@file_path} with '#{enhancement.class.name}' on call node enter enhancement: #{e.message}
+          Indexing error in #{@uri} with '#{enhancement.class.name}' on call node enter enhancement: #{e.message}
         MSG
       end
     end
@@ -312,49 +315,67 @@ module RubyIndexer
         enhancement.on_call_node_leave(node)
       rescue StandardError => e
         @indexing_errors << <<~MSG
-          Indexing error in #{@file_path} with '#{enhancement.class.name}' on call node leave enhancement: #{e.message}
+          Indexing error in #{@uri} with '#{enhancement.class.name}' on call node leave enhancement: #{e.message}
         MSG
       end
     end
 
     sig { params(node: Prism::DefNode).void }
     def on_def_node_enter(node)
+      owner = @owner_stack.last
+      return unless owner
+
       @inside_def = true
       method_name = node.name.to_s
       comments = collect_comments(node)
+      scope = current_visibility_scope
 
       case node.receiver
       when nil
+        location = Location.from_prism_location(node.location, @code_units_cache)
+        name_location = Location.from_prism_location(node.name_loc, @code_units_cache)
+        signatures = [Entry::Signature.new(list_params(node.parameters))]
+
         @index.add(Entry::Method.new(
           method_name,
-          @file_path,
-          Location.from_prism_location(node.location, @code_units_cache),
-          Location.from_prism_location(node.name_loc, @code_units_cache),
+          @uri,
+          location,
+          name_location,
           comments,
-          [Entry::Signature.new(list_params(node.parameters))],
-          current_visibility,
-          @owner_stack.last,
+          signatures,
+          scope.visibility,
+          owner,
         ))
-      when Prism::SelfNode
-        owner = @owner_stack.last
 
-        if owner
+        if scope.module_func
           singleton = @index.existing_or_new_singleton_class(owner.name)
 
           @index.add(Entry::Method.new(
             method_name,
-            @file_path,
-            Location.from_prism_location(node.location, @code_units_cache),
-            Location.from_prism_location(node.name_loc, @code_units_cache),
+            @uri,
+            location,
+            name_location,
             comments,
-            [Entry::Signature.new(list_params(node.parameters))],
-            current_visibility,
+            signatures,
+            Entry::Visibility::PUBLIC,
             singleton,
           ))
-
-          @owner_stack << singleton
-          @stack << "<Class:#{@stack.last}>"
         end
+      when Prism::SelfNode
+        singleton = @index.existing_or_new_singleton_class(owner.name)
+
+        @index.add(Entry::Method.new(
+          method_name,
+          @uri,
+          Location.from_prism_location(node.location, @code_units_cache),
+          Location.from_prism_location(node.name_loc, @code_units_cache),
+          comments,
+          [Entry::Signature.new(list_params(node.parameters))],
+          scope.visibility,
+          singleton,
+        ))
+
+        @owner_stack << singleton
       end
     end
 
@@ -364,7 +385,6 @@ module RubyIndexer
 
       if node.receiver.is_a?(Prism::SelfNode)
         @owner_stack.pop
-        @stack.pop
       end
     end
 
@@ -427,13 +447,38 @@ module RubyIndexer
           method_name,
           node.old_name.slice,
           @owner_stack.last,
-          @file_path,
+          @uri,
           Location.from_prism_location(node.new_name.location, @code_units_cache),
           comments,
         ),
       )
     end
 
+    sig { params(node: Prism::ClassVariableAndWriteNode).void }
+    def on_class_variable_and_write_node_enter(node)
+      handle_class_variable(node, node.name_loc)
+    end
+
+    sig { params(node: Prism::ClassVariableOperatorWriteNode).void }
+    def on_class_variable_operator_write_node_enter(node)
+      handle_class_variable(node, node.name_loc)
+    end
+
+    sig { params(node: Prism::ClassVariableOrWriteNode).void }
+    def on_class_variable_or_write_node_enter(node)
+      handle_class_variable(node, node.name_loc)
+    end
+
+    sig { params(node: Prism::ClassVariableTargetNode).void }
+    def on_class_variable_target_node_enter(node)
+      handle_class_variable(node, node.location)
+    end
+
+    sig { params(node: Prism::ClassVariableWriteNode).void }
+    def on_class_variable_write_node_enter(node)
+      handle_class_variable(node, node.name_loc)
+    end
+
     sig do
       params(
         name: String,
@@ -448,7 +493,7 @@ module RubyIndexer
 
       @index.add(Entry::Method.new(
         name,
-        @file_path,
+        @uri,
         location,
         location,
         comments,
@@ -471,8 +516,8 @@ module RubyIndexer
       name_loc = Location.from_prism_location(name_location, @code_units_cache)
 
       entry = Entry::Module.new(
-        actual_nesting(name),
-        @file_path,
+        Index.actual_nesting(@stack, name),
+        @uri,
         location,
         name_loc,
         comments,
@@ -491,10 +536,10 @@ module RubyIndexer
       ).void
     end
     def add_class(name_or_nesting, full_location, name_location, parent_class_name: nil, comments: nil)
-      nesting = name_or_nesting.is_a?(Array) ? name_or_nesting : actual_nesting(name_or_nesting)
+      nesting = name_or_nesting.is_a?(Array) ? name_or_nesting : Index.actual_nesting(@stack, name_or_nesting)
       entry = Entry::Class.new(
         nesting,
-        @file_path,
+        @uri,
         Location.from_prism_location(full_location, @code_units_cache),
         Location.from_prism_location(name_location, @code_units_cache),
         comments,
@@ -546,9 +591,45 @@ module RubyIndexer
 
       @index.add(Entry::GlobalVariable.new(
         name,
-        @file_path,
+        @uri,
+        Location.from_prism_location(loc, @code_units_cache),
+        comments,
+      ))
+    end
+
+    sig do
+      params(
+        node: T.any(
+          Prism::ClassVariableAndWriteNode,
+          Prism::ClassVariableOperatorWriteNode,
+          Prism::ClassVariableOrWriteNode,
+          Prism::ClassVariableTargetNode,
+          Prism::ClassVariableWriteNode,
+        ),
+        loc: Prism::Location,
+      ).void
+    end
+    def handle_class_variable(node, loc)
+      name = node.name.to_s
+      # Ignore incomplete class variable names, which aren't valid Ruby syntax.
+      # This could occur if the code is in an incomplete or temporary state.
+      return if name == "@@"
+
+      comments = collect_comments(node)
+
+      owner = @owner_stack.last
+
+      # set the class variable's owner to the attached context when defined within a singleton scope.
+      if owner.is_a?(Entry::SingletonClass)
+        owner = @owner_stack.reverse.find { |entry| !entry.name.include?("<Class:") }
+      end
+
+      @index.add(Entry::ClassVariable.new(
+        name,
+        @uri,
         Location.from_prism_location(loc, @code_units_cache),
         comments,
+        owner,
       ))
     end
 
@@ -578,7 +659,7 @@ module RubyIndexer
 
       @index.add(Entry::InstanceVariable.new(
         name,
-        @file_path,
+        @uri,
         Location.from_prism_location(loc, @code_units_cache),
         collect_comments(node),
         owner,
@@ -642,7 +723,7 @@ module RubyIndexer
           new_name_value,
           old_name_value,
           @owner_stack.last,
-          @file_path,
+          @uri,
           Location.from_prism_location(new_name.location, @code_units_cache),
           comments,
         ),
@@ -678,7 +759,7 @@ module RubyIndexer
             value.slice,
             @stack.dup,
             name,
-            @file_path,
+            @uri,
             Location.from_prism_location(node.location, @code_units_cache),
             comments,
           )
@@ -691,7 +772,7 @@ module RubyIndexer
             value.name.to_s,
             @stack.dup,
             name,
-            @file_path,
+            @uri,
             Location.from_prism_location(node.location, @code_units_cache),
             comments,
           )
@@ -702,14 +783,14 @@ module RubyIndexer
             value.target.slice,
             @stack.dup,
             name,
-            @file_path,
+            @uri,
             Location.from_prism_location(node.location, @code_units_cache),
             comments,
           )
         else
           Entry::Constant.new(
             name,
-            @file_path,
+            @uri,
             Location.from_prism_location(node.location, @code_units_cache),
             comments,
           )
@@ -768,6 +849,8 @@ module RubyIndexer
       return unless receiver.nil? || receiver.is_a?(Prism::SelfNode)
 
       comments = collect_comments(node)
+      scope = current_visibility_scope
+
       arguments.each do |argument|
         name, loc = case argument
         when Prism::SymbolNode
@@ -781,10 +864,10 @@ module RubyIndexer
         if reader
           @index.add(Entry::Accessor.new(
             name,
-            @file_path,
+            @uri,
             Location.from_prism_location(loc, @code_units_cache),
             comments,
-            current_visibility,
+            scope.visibility,
             @owner_stack.last,
           ))
         end
@@ -793,10 +876,10 @@ module RubyIndexer
 
         @index.add(Entry::Accessor.new(
           "#{name}=",
-          @file_path,
+          @uri,
           Location.from_prism_location(loc, @code_units_cache),
           comments,
-          current_visibility,
+          scope.visibility,
           @owner_stack.last,
         ))
       end
@@ -838,11 +921,20 @@ module RubyIndexer
 
     sig { params(node: Prism::CallNode).void }
     def handle_module_function(node)
+      # Invoking `module_function` in a class raises
+      owner = @owner_stack.last
+      return unless owner.is_a?(Entry::Module)
+
       arguments_node = node.arguments
-      return unless arguments_node
 
-      owner_name = @owner_stack.last&.name
-      return unless owner_name
+      # If `module_function` is invoked without arguments, all methods defined after it become singleton methods and the
+      # visibility for instance methods changes to private
+      unless arguments_node
+        @visibility_stack.push(VisibilityScope.module_function_scope)
+        return
+      end
+
+      owner_name = owner.name
 
       arguments_node.arguments.each do |argument|
         method_name = case argument
@@ -866,7 +958,7 @@ module RubyIndexer
           location = Location.from_prism_location(argument.location, @code_units_cache)
           @index.add(Entry::Method.new(
             method_name,
-            @file_path,
+            @uri,
             location,
             location,
             collect_comments(node)&.concat(entry.comments),
@@ -880,45 +972,48 @@ module RubyIndexer
 
     sig { params(node: Prism::CallNode).void }
     def handle_private_class_method(node)
-      node.arguments&.arguments&.each do |argument|
-        string_or_symbol_nodes = case argument
-        when Prism::StringNode, Prism::SymbolNode
-          [argument]
-        when Prism::ArrayNode
-          argument.elements
-        else
-          []
-        end
+      arguments = node.arguments&.arguments
+      return unless arguments
 
-        unless string_or_symbol_nodes.empty?
-          # pop the visibility off since there isn't a method definition following `private_class_method`
-          @visibility_stack.pop
-        end
+      # If we're passing a method definition directly to `private_class_method`, push a new private scope. That will be
+      # applied when the indexer finds the method definition and then popped on `call_node_leave`
+      if arguments.first.is_a?(Prism::DefNode)
+        @visibility_stack.push(VisibilityScope.new(visibility: Entry::Visibility::PRIVATE))
+        return
+      end
 
-        string_or_symbol_nodes.each do |string_or_symbol_node|
-          method_name = case string_or_symbol_node
-          when Prism::StringNode
-            string_or_symbol_node.content
-          when Prism::SymbolNode
-            string_or_symbol_node.value
-          end
-          next unless method_name
+      owner_name = @owner_stack.last&.name
+      return unless owner_name
+
+      # private_class_method accepts strings, symbols or arrays of strings and symbols as arguments. Here we build a
+      # single list of all of the method names that have to be made private
+      arrays, others = T.cast(
+        arguments.partition { |argument| argument.is_a?(Prism::ArrayNode) },
+        [T::Array[Prism::ArrayNode], T::Array[Prism::Node]],
+      )
+      arrays.each { |array| others.concat(array.elements) }
 
-          owner_name = @owner_stack.last&.name
-          next unless owner_name
+      names = others.filter_map do |argument|
+        case argument
+        when Prism::StringNode
+          argument.unescaped
+        when Prism::SymbolNode
+          argument.value
+        end
+      end
 
-          entries = @index.resolve_method(method_name, @index.existing_or_new_singleton_class(owner_name).name)
-          next unless entries
+      names.each do |name|
+        entries = @index.resolve_method(name, @index.existing_or_new_singleton_class(owner_name).name)
+        next unless entries
 
-          entries.each do |entry|
-            entry.visibility = Entry::Visibility::PRIVATE
-          end
+        entries.each do |entry|
+          entry.visibility = Entry::Visibility::PRIVATE
         end
       end
     end
 
-    sig { returns(Entry::Visibility) }
-    def current_visibility
+    sig { returns(VisibilityScope) }
+    def current_visibility_scope
       T.must(@visibility_stack.last)
     end
 
@@ -1009,26 +1104,22 @@ module RubyIndexer
       end
     end
 
-    sig { params(name: String).returns(T::Array[String]) }
-    def actual_nesting(name)
-      nesting = @stack + [name]
-      corrected_nesting = []
-
-      nesting.reverse_each do |name|
-        corrected_nesting.prepend(name.delete_prefix("::"))
-
-        break if name.start_with?("::")
-      end
-
-      corrected_nesting
-    end
-
     sig { params(short_name: String, entry: Entry::Namespace).void }
     def advance_namespace_stack(short_name, entry)
-      @visibility_stack.push(Entry::Visibility::PUBLIC)
+      @visibility_stack.push(VisibilityScope.public_scope)
       @owner_stack << entry
       @index.add(entry)
       @stack << short_name
     end
+
+    # Returns the last name in the stack not as we found it, but in terms of declared constants. For example, if the
+    # last entry in the stack is a compact namespace like `Foo::Bar`, then the last name is `Bar`
+    sig { returns(T.nilable(String)) }
+    def last_name_in_stack
+      name = @stack.last
+      return unless name
+
+      name.split("::").last
+    end
   end
 end