Migrate document to use YARP

lib/ruby_lsp/document.rb

@@ -9,8 +9,8 @@ class Document
  RangeShape = T.type_alias { { start: PositionShape, end: PositionShape } }
  EditShape = T.type_alias { { range: RangeShape, text: String } }
 
- sig { returns(T.nilable(SyntaxTree::Node)) }
- attr_reader :tree
+ sig { returns(YARP::ParseResult) }
+ attr_reader :parse_result
 
  sig { returns(String) }
  attr_reader :source
@@ -30,9 +30,12 @@ def initialize(source:, version:, uri:, encoding: Constant::PositionEncodingKind
  @uri = T.let(uri, URI::Generic)
  @unparsed_edits = T.let([], T::Array[EditShape])
  @syntax_error = T.let(false, T::Boolean)
- @tree = T.let(SyntaxTree.parse(@source), T.nilable(SyntaxTree::Node))
- rescue SyntaxTree::Parser::ParseError
- @syntax_error = true
+ @parse_result = T.let(YARP.parse(@source), YARP::ParseResult)
+ end
+
+ sig { returns(YARP::Node) }
+ def tree
+ @parse_result.value
  end
 
  sig { params(other: Document).returns(T::Boolean) }
@@ -89,20 +92,12 @@ def parse
  return if @unparsed_edits.empty?
 
  @unparsed_edits.clear
- @tree = SyntaxTree.parse(@source)
- @syntax_error = false
- rescue SyntaxTree::Parser::ParseError
- @syntax_error = true
+ @parse_result = YARP.parse(@source)
  end
 
  sig { returns(T::Boolean) }
  def syntax_error?
- @syntax_error
- end
-
- sig { returns(T::Boolean) }
- def parsed?
- !@tree.nil?
+ @parse_result.failure?
  end
 
  sig { returns(Scanner) }
@@ -113,27 +108,25 @@ def create_scanner
  sig do
  params(
  position: PositionShape,
- node_types: T::Array[T.class_of(SyntaxTree::Node)],
- ).returns([T.nilable(SyntaxTree::Node), T.nilable(SyntaxTree::Node), T::Array[String]])
+ node_types: T::Array[T.class_of(YARP::Node)],
+ ).returns([T.nilable(YARP::Node), T.nilable(YARP::Node), T::Array[String]])
  end
  def locate_node(position, node_types: [])
- return [nil, nil, []] unless parsed?
-
- locate(T.must(@tree), create_scanner.find_char_position(position), node_types: node_types)
+ locate(@parse_result.value, create_scanner.find_char_position(position), node_types: node_types)
  end
 
  sig do
  params(
- node: SyntaxTree::Node,
+ node: YARP::Node,
  char_position: Integer,
- node_types: T::Array[T.class_of(SyntaxTree::Node)],
- ).returns([T.nilable(SyntaxTree::Node), T.nilable(SyntaxTree::Node), T::Array[String]])
+ node_types: T::Array[T.class_of(YARP::Node)],
+ ).returns([T.nilable(YARP::Node), T.nilable(YARP::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)])
+ queue = T.let(node.child_nodes.compact, T::Array[T.nilable(YARP::Node)])
  closest = node
- parent = T.let(nil, T.nilable(SyntaxTree::Node))
- nesting = T.let([], T::Array[T.any(SyntaxTree::ClassDeclaration, SyntaxTree::ModuleDeclaration)])
+ parent = T.let(nil, T.nilable(YARP::Node))
+ nesting = T.let([], T::Array[T.any(YARP::ClassNode, YARP::ModuleNode)])
 
  until queue.empty?
  candidate = queue.shift
@@ -144,24 +137,24 @@ def locate(node, char_position, node_types: [])
  # 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)
+T.unsafe(queue).unshift(*candidate.child_nodes)
 
  # Skip if the current node doesn't cover the desired position
  loc = candidate.location
- next unless (loc.start_char...loc.end_char).cover?(char_position)
+ next unless (loc.start_offset...loc.end_offset).cover?(char_position)
 
  # If the node's start character is already past the position, then we should've found the closest node
  # already
- break if char_position < loc.start_char
+ break if char_position < loc.start_offset
 
  # 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
+ nesting.pop if previous_level && loc.start_offset > previous_level.location.end_offset
 
  # 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)
+ if candidate.is_a?(YARP::ClassNode) || candidate.is_a?(YARP::ModuleNode)
  nesting << candidate
  end
 
@@ -170,13 +163,13 @@ def locate(node, char_position, node_types: [])
 
  # If the current node is narrower than or equal to the previous closest node, then it is more precise
  closest_loc = closest.location
- if loc.end_char - loc.start_char <= closest_loc.end_char - closest_loc.start_char
+ if loc.end_offset - loc.start_offset <= closest_loc.end_offset - closest_loc.start_offset
  parent = closest
  closest = candidate
  end
  end
 
- [closest, parent, nesting.map { |n| n.constant.constant.value }]
+ [closest, parent, nesting.map { |n| n.constant_path.location.slice }]
  end
 
  class Scanner

sorbet/rbi/shims/yarp.rbi

@@ -0,0 +1,60 @@
+# typed: true
+
+module YARP
+ class << self
+ sig { params(source: String).returns(ParseResult) }
+ def parse(*source); end
+ end
+
+ class ParseResult
+ sig { returns(YARP::Node) }
+ def value; end
+
+ sig { returns(T::Boolean) }
+ def failure?; end
+
+ sig { returns(T::Boolean) }
+ def success?; end
+ end
+
+ class Node
+ sig { returns(T::Array[T.nilable(YARP::Node)]) }
+ def child_nodes; end
+
+ sig { returns(Location) }
+ def location; end
+ end
+
+ class Location
+ sig { returns(Integer) }
+ def start_offset; end
+
+ sig { returns(Integer) }
+ def end_offset; end
+
+ sig { returns(Integer) }
+ def start_line; end
+
+ sig { returns(Integer) }
+ def end_line; end
+
+ sig { returns(Integer) }
+ def start_column; end
+
+ sig { returns(Integer) }
+ def end_column; end
+
+ sig { returns(String) }
+ def slice; end
+ end
+
+ class ClassNode
+ sig { returns(ConstantPathNode) }
+ def constant_path; end
+ end
+
+ class ModuleNode
+ sig { returns(ConstantPathNode) }
+ def constant_path; end
+ end
+end

test/document_test.rb

@@ -320,20 +320,11 @@ def test_pushing_edits_to_document_with_unicode
  end
 
  def test_parsed_returns_true_when_parsed_successfully
+ # We are just ensuring that no error is raised
  document = RubyLsp::Document.new(source: +<<~RUBY, version: 1, uri: URI("file:///foo.rb"))
  # frozen_string_literal: true
  puts 'hello'
  RUBY
-
- assert_predicate(document, :parsed?)
- end
-
- def test_parsed_returns_false_when_parsing_fails
- document = RubyLsp::Document.new(source: +<<~RUBY, version: 1, uri: URI("file:///foo.rb"))
- class Foo
- RUBY
-
- refute_predicate(document, :parsed?)
  end
 
  def test_document_handle_4_byte_unicode_characters
@@ -351,7 +342,6 @@ class Foo
  )
 
  document.parse
- assert_predicate(document, :parsed?)
 
  assert_equal(<<~RUBY, document.source)
  class Foo
@@ -397,7 +387,6 @@ class Foo
  )
 
  document.parse
- assert_predicate(document, :parsed?)
 
  assert_equal(<<~RUBY, document.source)
  class Foo
@@ -447,33 +436,33 @@ class Post < ActiveRecord::Base
 
  # Locate the `ActiveRecord` module
  found, parent = document.locate_node({ line: 0, character: 19 })
- assert_instance_of(SyntaxTree::Const, found)
- assert_equal("ActiveRecord", T.cast(found, SyntaxTree::Const).value)
+ assert_instance_of(YARP::ConstantReadNode, found)
+ assert_equal("ActiveRecord", T.cast(found, YARP::ConstantReadNode).location.slice)
 
- assert_instance_of(SyntaxTree::VarRef, parent)
- assert_equal("ActiveRecord", T.cast(parent, SyntaxTree::VarRef).value.value)
+ assert_instance_of(YARP::ConstantPathNode, parent)
+ assert_equal("ActiveRecord", T.cast(parent, YARP::ConstantPathNode).child_nodes.first.location.slice)
 
  # Locate the `Base` class
  found, parent = T.cast(
  document.locate_node({ line: 0, character: 27 }),
- [SyntaxTree::Const, SyntaxTree::ConstPathRef, T::Array[String]],
+ [YARP::ConstantReadNode, YARP::ConstantPathNode, T::Array[String]],
  )
- assert_instance_of(SyntaxTree::Const, found)
- assert_equal("Base", found.value)
+ assert_instance_of(YARP::ConstantReadNode, found)
+ assert_equal("Base", found.location.slice)
 
- assert_instance_of(SyntaxTree::ConstPathRef, parent)
- assert_equal("Base", parent.constant.value)
- assert_equal("ActiveRecord", T.cast(parent.parent, SyntaxTree::VarRef).value.value)
+ assert_instance_of(YARP::ConstantPathNode, parent)
+ assert_equal("Base", parent.child_nodes[1].location.slice)
+ assert_equal("ActiveRecord", parent.child_nodes[0].location.slice)
 
  # Locate the `where` invocation
  found, parent = T.cast(
  document.locate_node({ line: 3, character: 4 }),
- [SyntaxTree::Ident, SyntaxTree::CallNode, T::Array[String]],
+ [YARP::CallNode, YARP::StatementsNode, T::Array[String]],
  )
- assert_instance_of(SyntaxTree::Ident, found)
- assert_equal("where", found.value)
+ assert_instance_of(YARP::CallNode, found)
+ assert_equal("where", found.message_loc.slice)
 
- assert_instance_of(SyntaxTree::CallNode, parent)
+ assert_instance_of(YARP::StatementsNode, parent)
  end
 
  def test_locate_returns_nesting
@@ -494,11 +483,11 @@ def baz
  RUBY
 
  found, _parent, nesting = document.locate_node({ line: 9, character: 6 })
- assert_equal("Qux", T.cast(found, SyntaxTree::Const).value)
+ assert_equal("Qux", T.cast(found, YARP::ConstantReadNode).location.slice)
  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("Hello", T.cast(found, YARP::ConstantReadNode).location.slice)
  assert_equal(["Foo", "Other"], nesting)
  end
 
@@ -513,8 +502,8 @@ def baz
  end
  RUBY
 
- found, _parent, nesting = document.locate_node({ line: 3, character: 6 }, node_types: [SyntaxTree::Const])
- assert_equal("Qux", T.cast(found, SyntaxTree::Const).value)
+ found, _parent, nesting = document.locate_node({ line: 3, character: 6 }, node_types: [YARP::ConstantReadNode])
+ assert_equal("Qux", T.cast(found, YARP::ConstantReadNode).location.slice)
  assert_equal(["Foo", "Bar"], nesting)
  end