Migrate semantic highlighting to YARP (#1000)

Co-authored-by: Alexandre Terrasa <[email protected]>

lib/ruby_lsp/event_emitter.rb

@@ -88,24 +88,6 @@ def visit_call_node(node)
       @listeners[:after_call]&.each { |l| T.unsafe(l).after_call(node) }
     end
 
-    sig { override.params(node: YARP::ConstantPathWriteNode).void }
-    def visit_constant_path_write_node(node)
-      @listeners[:on_constant_path_write]&.each { |l| T.unsafe(l).on_constant_path_write(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::ConstantPathNode).void }
-    def visit_constant_path_node(node)
-      @listeners[:on_constant_path]&.each { |l| T.unsafe(l).on_constant_path(node) }
-      super
-    end
-
-    sig { override.params(node: YARP::ConstantWriteNode).void }
-    def visit_constant_write_node(node)
-      @listeners[:on_constant_write]&.each { |l| T.unsafe(l).on_constant_write(node) }
-      super
-    end
-
     sig { override.params(node: YARP::InstanceVariableWriteNode).void }
     def visit_instance_variable_write_node(node)
       @listeners[:on_instance_variable_write]&.each { |l| T.unsafe(l).on_instance_variable_write(node) }
@@ -125,15 +107,16 @@ def visit_def_node(node)
       @listeners[:after_def]&.each { |l| T.unsafe(l).after_def(node) }
     end
 
-    sig { override.params(node: SyntaxTree::VarField).void }
-    def visit_var_field(node)
-      @listeners[:on_var_field]&.each { |l| T.unsafe(l).on_var_field(node) }
+    sig { override.params(node: YARP::BlockNode).void }
+    def visit_block_node(node)
+      @listeners[:on_block]&.each { |l| T.unsafe(l).on_block(node) }
       super
+      @listeners[:after_block]&.each { |l| T.unsafe(l).after_block(node) }
     end
 
-    sig { override.params(node: SyntaxTree::Comment).void }
-    def visit_comment(node)
-      @listeners[:on_comment]&.each { |l| T.unsafe(l).on_comment(node) }
+    sig { override.params(node: YARP::SelfNode).void }
+    def visit_self_node(node)
+      @listeners[:on_self]&.each { |l| T.unsafe(l).on_self(node) }
       super
     end
 
@@ -143,52 +126,131 @@ def visit_rescue_node(node)
       super
     end
 
-    sig { override.params(node: SyntaxTree::Kw).void }
-    def visit_kw(node)
-      @listeners[:on_kw]&.each { |l| T.unsafe(l).on_kw(node) }
+    sig { override.params(node: YARP::BlockParameterNode).void }
+    def visit_block_parameter_node(node)
+      @listeners[:on_block_parameter]&.each { |l| T.unsafe(l).on_block_parameter(node) }
       super
     end
 
-    sig { override.params(node: SyntaxTree::Params).void }
-    def visit_params(node)
-      @listeners[:on_params]&.each { |l| T.unsafe(l).on_params(node) }
+    sig { override.params(node: YARP::KeywordParameterNode).void }
+    def visit_keyword_parameter_node(node)
+      @listeners[:on_keyword_parameter]&.each { |l| T.unsafe(l).on_keyword_parameter(node) }
       super
     end
 
-    sig { override.params(node: SyntaxTree::Field).void }
-    def visit_field(node)
-      @listeners[:on_field]&.each { |l| T.unsafe(l).on_field(node) }
+    sig { override.params(node: YARP::KeywordRestParameterNode).void }
+    def visit_keyword_rest_parameter_node(node)
+      @listeners[:on_keyword_rest_parameter]&.each { |l| T.unsafe(l).on_keyword_rest_parameter(node) }
       super
     end
 
-    sig { override.params(node: SyntaxTree::VarRef).void }
-    def visit_var_ref(node)
-      @listeners[:on_var_ref]&.each { |l| T.unsafe(l).on_var_ref(node) }
+    sig { override.params(node: YARP::OptionalParameterNode).void }
+    def visit_optional_parameter_node(node)
+      @listeners[:on_optional_parameter]&.each { |l| T.unsafe(l).on_optional_parameter(node) }
       super
     end
 
-    sig { override.params(node: SyntaxTree::BlockVar).void }
-    def visit_block_var(node)
-      @listeners[:on_block_var]&.each { |l| T.unsafe(l).on_block_var(node) }
+    sig { override.params(node: YARP::RequiredParameterNode).void }
+    def visit_required_parameter_node(node)
+      @listeners[:on_required_parameter]&.each { |l| T.unsafe(l).on_required_parameter(node) }
       super
     end
 
-    sig { override.params(node: SyntaxTree::LambdaVar).void }
-    def visit_lambda_var(node)
-      @listeners[:on_lambda_var]&.each { |l| T.unsafe(l).on_lambda_var(node) }
+    sig { override.params(node: YARP::RestParameterNode).void }
+    def visit_rest_parameter_node(node)
+      @listeners[:on_rest_parameter]&.each { |l| T.unsafe(l).on_rest_parameter(node) }
       super
     end
 
-    sig { override.params(node: SyntaxTree::Binary).void }
-    def visit_binary(node)
-      super
-      @listeners[:after_binary]&.each { |l| T.unsafe(l).after_binary(node) }
-    end
-
     sig { override.params(node: YARP::ConstantReadNode).void }
     def visit_constant_read_node(node)
       @listeners[:on_constant_read]&.each { |l| T.unsafe(l).on_constant_read(node) }
       super
     end
+
+    sig { override.params(node: YARP::ConstantPathNode).void }
+    def visit_constant_path_node(node)
+      @listeners[:on_constant_path]&.each { |l| T.unsafe(l).on_constant_path(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::ConstantPathWriteNode).void }
+    def visit_constant_path_write_node(node)
+      @listeners[:on_constant_path_write]&.each { |l| T.unsafe(l).on_constant_path_write(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::ConstantWriteNode).void }
+    def visit_constant_write_node(node)
+      @listeners[:on_constant_write]&.each { |l| T.unsafe(l).on_constant_write(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::ConstantAndWriteNode).void }
+    def visit_constant_and_write_node(node)
+      @listeners[:on_constant_and_write]&.each { |l| T.unsafe(l).on_constant_and_write(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::ConstantOperatorWriteNode).void }
+    def visit_constant_operator_write_node(node)
+      @listeners[:on_constant_operator_write]&.each { |l| T.unsafe(l).on_constant_operator_write(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::ConstantOrWriteNode).void }
+    def visit_constant_or_write_node(node)
+      @listeners[:on_constant_or_write]&.each { |l| T.unsafe(l).on_constant_or_write(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::ConstantTargetNode).void }
+    def visit_constant_target_node(node)
+      @listeners[:on_constant_target]&.each { |l| T.unsafe(l).on_constant_target(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::LocalVariableWriteNode).void }
+    def visit_local_variable_write_node(node)
+      @listeners[:on_local_variable_write]&.each { |l| T.unsafe(l).on_local_variable_write(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::LocalVariableReadNode).void }
+    def visit_local_variable_read_node(node)
+      @listeners[:on_local_variable_read]&.each { |l| T.unsafe(l).on_local_variable_read(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::LocalVariableAndWriteNode).void }
+    def visit_local_variable_and_write_node(node)
+      @listeners[:on_local_variable_and_write]&.each { |l| T.unsafe(l).on_local_variable_and_write(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::LocalVariableOperatorWriteNode).void }
+    def visit_local_variable_operator_write_node(node)
+      @listeners[:on_local_variable_operator_write]&.each { |l| T.unsafe(l).on_local_variable_operator_write(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::LocalVariableOrWriteNode).void }
+    def visit_local_variable_or_write_node(node)
+      @listeners[:on_local_variable_or_write]&.each { |l| T.unsafe(l).on_local_variable_or_write(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::LocalVariableTargetNode).void }
+    def visit_local_variable_target_node(node)
+      @listeners[:on_local_variable_target]&.each { |l| T.unsafe(l).on_local_variable_target(node) }
+      super
+    end
+
+    sig { override.params(node: YARP::LambdaNode).void }
+    def visit_lambda_node(node)
+      @listeners[:on_lambda]&.each { |l| T.unsafe(l).on_lambda(node) }
+      super
+      @listeners[:after_lambda]&.each { |l| T.unsafe(l).after_lambda(node) }
+    end
   end
 end

lib/ruby_lsp/internal.rb

@@ -14,6 +14,7 @@
 require "ruby_indexer/ruby_indexer"
 require "core_ext/uri"
 require "ruby_lsp/utils"
+require "ruby_lsp/parameter_scope"
 require "ruby_lsp/server"
 require "ruby_lsp/executor"
 require "ruby_lsp/event_emitter"

lib/ruby_lsp/parameter_scope.rb

@@ -0,0 +1,33 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  class ParameterScope
+    extend T::Sig
+
+    sig { returns(T.nilable(ParameterScope)) }
+    attr_reader :parent
+
+    sig { params(parent: T.nilable(ParameterScope)).void }
+    def initialize(parent = nil)
+      @parent = parent
+      @parameters = T.let(Set.new, T::Set[Symbol])
+    end
+
+    sig { params(name: T.any(String, Symbol)).void }
+    def <<(name)
+      @parameters << name.to_sym
+    end
+
+    sig { params(name: T.any(Symbol, String)).returns(Symbol) }
+    def type_for(name)
+      parameter?(name) ? :parameter : :variable
+    end
+
+    sig { params(name: T.any(Symbol, String)).returns(T::Boolean) }
+    def parameter?(name)
+      sym = name.to_sym
+      @parameters.include?(sym) || (!@parent.nil? && @parent.parameter?(sym))
+    end
+  end
+end