Merge pull request #799 from Shopify/vs/add_nesting_to_locate

Keep track of nesting when locating nodes

Author: vinistock

lib/ruby_lsp/document.rb

@@ -114,10 +114,10 @@ def create_scanner
       params(
         position: PositionShape,
         node_types: T::Array[T.class_of(SyntaxTree::Node)],
-      ).returns([T.nilable(SyntaxTree::Node), T.nilable(SyntaxTree::Node)])
+      ).returns([T.nilable(SyntaxTree::Node), T.nilable(SyntaxTree::Node), T::Array[String]])
     end
     def locate_node(position, node_types: [])
-      return [nil, nil] unless parsed?
+      return [nil, nil, []] unless parsed?
 
       locate(T.must(@tree), create_scanner.find_char_position(position), node_types: node_types)
     end
@@ -127,21 +127,24 @@ def locate_node(position, node_types: [])
         node: SyntaxTree::Node,
         char_position: Integer,
         node_types: T::Array[T.class_of(SyntaxTree::Node)],
-      ).returns([T.nilable(SyntaxTree::Node), T.nilable(SyntaxTree::Node)])
+      ).returns([T.nilable(SyntaxTree::Node), T.nilable(SyntaxTree::Node), T::Array[String]])
     end
     def locate(node, char_position, node_types: [])
       queue = T.let(node.child_nodes.compact, T::Array[T.nilable(SyntaxTree::Node)])
       closest = node
       parent = T.let(nil, T.nilable(SyntaxTree::Node))
+      nesting = T.let([], T::Array[T.any(SyntaxTree::ClassDeclaration, SyntaxTree::ModuleDeclaration)])
 
       until queue.empty?
         candidate = queue.shift
 
         # Skip nil child nodes
         next if candidate.nil?
 
-        # Add the next child_nodes to the queue to be processed
-        queue.concat(candidate.child_nodes)
+        # Add the next child_nodes to the queue to be processed. The order here is important! We want to move in the
+        # same order as the visiting mechanism, which means searching the child nodes before moving on to the next
+        # sibling
+        queue.unshift(*candidate.child_nodes)
 
         # Skip if the current node doesn't cover the desired position
         loc = candidate.location
@@ -160,9 +163,20 @@ def locate(node, char_position, node_types: [])
           parent = closest
           closest = candidate
         end
+
+        # If the candidate starts after the end of the previous nesting level, then we've exited that nesting level and
+        # need to pop the stack
+        previous_level = nesting.last
+        nesting.pop if previous_level && candidate.start_char > previous_level.end_char
+
+        # Keep track of the nesting where we found the target. This is used to determine the fully qualified name of the
+        # target when it is a constant
+        if candidate.is_a?(SyntaxTree::ClassDeclaration) || candidate.is_a?(SyntaxTree::ModuleDeclaration)
+          nesting << candidate
+        end
       end
 
-      [closest, parent]
+      [closest, parent, nesting.map { |n| n.constant.constant.value }]
     end
 
     class Scanner

test/document_test.rb

@@ -456,7 +456,7 @@ class Post < ActiveRecord::Base
     # Locate the `Base` class
     found, parent = T.cast(
       document.locate_node({ line: 0, character: 27 }),
-      [SyntaxTree::Const, SyntaxTree::ConstPathRef],
+      [SyntaxTree::Const, SyntaxTree::ConstPathRef, T::Array[String]],
     )
     assert_instance_of(SyntaxTree::Const, found)
     assert_equal("Base", found.value)
@@ -466,13 +466,42 @@ class Post < ActiveRecord::Base
     assert_equal("ActiveRecord", T.cast(parent.parent, SyntaxTree::VarRef).value.value)
 
     # Locate the `where` invocation
-    found, parent = T.cast(document.locate_node({ line: 3, character: 4 }), [SyntaxTree::Ident, SyntaxTree::CallNode])
+    found, parent = T.cast(
+      document.locate_node({ line: 3, character: 4 }),
+      [SyntaxTree::Ident, SyntaxTree::CallNode, T::Array[String]],
+    )
     assert_instance_of(SyntaxTree::Ident, found)
     assert_equal("where", found.value)
 
     assert_instance_of(SyntaxTree::CallNode, parent)
   end
 
+  def test_locate_returns_nesting
+    document = RubyLsp::Document.new(source: <<~RUBY, version: 1, uri: "file:///foo/bar.rb")
+      module Foo
+        class Other
+          def do_it
+            Hello
+          end
+        end
+
+        class Bar
+          def baz
+            Qux
+          end
+        end
+      end
+    RUBY
+
+    found, _parent, nesting = document.locate_node({ line: 9, character: 6 })
+    assert_equal("Qux", T.cast(found, SyntaxTree::Const).value)
+    assert_equal(["Foo", "Bar"], nesting)
+
+    found, _parent, nesting = document.locate_node({ line: 3, character: 6 })
+    assert_equal("Hello", T.cast(found, SyntaxTree::Const).value)
+    assert_equal(["Foo", "Other"], nesting)
+  end
+
   def test_reparsing_without_new_edits_does_nothing
     document = RubyLsp::Document.new(source: +"", version: 1, uri: "file:///foo/bar.rb")
     document.push_edits(