ruby-lsp 0.10.1 → 0.11.1

data/lib/ruby_lsp/requests/selection_ranges.rb

@@ -25,41 +25,37 @@ module RubyLsp
 
       NODES_THAT_CAN_BE_PARENTS = T.let(
         [
-          SyntaxTree::Assign,
-          SyntaxTree::ArrayLiteral,
-          SyntaxTree::Begin,
-          SyntaxTree::BlockNode,
-          SyntaxTree::CallNode,
-          SyntaxTree::Case,
-          SyntaxTree::ClassDeclaration,
-          SyntaxTree::Command,
-          SyntaxTree::DefNode,
-          SyntaxTree::Elsif,
-          SyntaxTree::Else,
-          SyntaxTree::EmbDoc,
-          SyntaxTree::Ensure,
-          SyntaxTree::For,
-          SyntaxTree::HashLiteral,
-          SyntaxTree::Heredoc,
-          SyntaxTree::HeredocBeg,
-          SyntaxTree::HshPtn,
-          SyntaxTree::IfNode,
-          SyntaxTree::In,
-          SyntaxTree::Lambda,
-          SyntaxTree::MethodAddBlock,
-          SyntaxTree::ModuleDeclaration,
-          SyntaxTree::Params,
-          SyntaxTree::Rescue,
-          SyntaxTree::RescueEx,
-          SyntaxTree::StringConcat,
-          SyntaxTree::StringLiteral,
-          SyntaxTree::UnlessNode,
-          SyntaxTree::UntilNode,
-          SyntaxTree::VCall,
-          SyntaxTree::When,
-          SyntaxTree::WhileNode,
+          YARP::ArgumentsNode,
+          YARP::ArrayNode,
+          YARP::AssocNode,
+          YARP::BeginNode,
+          YARP::BlockNode,
+          YARP::CallNode,
+          YARP::CaseNode,
+          YARP::ClassNode,
+          YARP::DefNode,
+          YARP::ElseNode,
+          YARP::EnsureNode,
+          YARP::ForNode,
+          YARP::HashNode,
+          YARP::HashPatternNode,
+          YARP::IfNode,
+          YARP::InNode,
+          YARP::InterpolatedStringNode,
+          YARP::KeywordHashNode,
+          YARP::LambdaNode,
+          YARP::LocalVariableWriteNode,
+          YARP::ModuleNode,
+          YARP::ParametersNode,
+          YARP::RescueNode,
+          YARP::StringConcatNode,
+          YARP::StringNode,
+          YARP::UnlessNode,
+          YARP::UntilNode,
+          YARP::WhenNode,
+          YARP::WhileNode,
         ].freeze,
-        T::Array[T.class_of(SyntaxTree::Node)],
+        T::Array[T.class_of(YARP::Node)],
       )
 
       sig { params(document: Document).void }
@@ -72,19 +68,23 @@ module RubyLsp
 
       sig { override.returns(T.all(T::Array[Support::SelectionRange], Object)) }
       def run
-        visit(@document.tree) if @document.parsed?
+        visit(@document.tree)
         @ranges.reverse!
       end
 
       private
 
-      sig { override.params(node: T.nilable(SyntaxTree::Node)).void }
+      sig { override.params(node: T.nilable(YARP::Node)).void }
       def visit(node)
         return if node.nil?
 
-        range = create_selection_range(node.location, @stack.last)
-
+        range = if node.is_a?(YARP::InterpolatedStringNode)
+          create_heredoc_selection_range(node, @stack.last)
+        else
+          create_selection_range(node.location, @stack.last)
+        end
         @ranges << range
+
         return if node.child_nodes.empty?
 
         @stack << range if NODES_THAT_CAN_BE_PARENTS.include?(node.class)
@@ -94,11 +94,36 @@ module RubyLsp
 
       sig do
         params(
-          location: SyntaxTree::Location,
+          node: YARP::InterpolatedStringNode,
+          parent: T.nilable(Support::SelectionRange),
+        ).returns(Support::SelectionRange)
+      end
+      def create_heredoc_selection_range(node, parent)
+        opening_loc = node.opening_loc || node.location
+        closing_loc = node.closing_loc || node.location
+
+        RubyLsp::Requests::Support::SelectionRange.new(
+          range: Interface::Range.new(
+            start: Interface::Position.new(
+              line: opening_loc.start_line - 1,
+              character: opening_loc.start_column,
+            ),
+            end: Interface::Position.new(
+              line: closing_loc.end_line - 1,
+              character: closing_loc.end_column,
+            ),
+          ),
+          parent: parent,
+        )
+      end
+
+      sig do
+        params(
+          location: YARP::Location,
           parent: T.nilable(Support::SelectionRange),
         ).returns(Support::SelectionRange)
       end
-      def create_selection_range(location, parent = nil)
+      def create_selection_range(location, parent)
         RubyLsp::Requests::Support::SelectionRange.new(
           range: Interface::Range.new(
             start: Interface::Position.new(

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -83,7 +83,7 @@ module RubyLsp
       class SemanticToken
         extend T::Sig
 
-        sig { returns(SyntaxTree::Location) }
+        sig { returns(YARP::Location) }
         attr_reader :location
 
         sig { returns(Integer) }
@@ -95,7 +95,7 @@ module RubyLsp
         sig { returns(T::Array[Integer]) }
         attr_reader :modifier
 
-        sig { params(location: SyntaxTree::Location, length: Integer, type: Integer, modifier: T::Array[Integer]).void }
+        sig { params(location: YARP::Location, length: Integer, type: Integer, modifier: T::Array[Integer]).void }
         def initialize(location:, length:, type:, modifier:)
           @location = location
           @length = length
@@ -120,56 +120,60 @@ module RubyLsp
         @_response = T.let([], ResponseType)
         @range = range
         @special_methods = T.let(nil, T.nilable(T::Array[String]))
+        @current_scope = T.let(ParameterScope.new, ParameterScope)
 
         emitter.register(
           self,
-          :after_binary,
-          :on_block_var,
           :on_call,
           :on_class,
-          :on_command,
-          :on_command_call,
-          :on_const,
           :on_def,
-          :on_field,
-          :on_kw,
-          :on_lambda_var,
+          :after_def,
+          :on_block,
+          :after_block,
+          :on_self,
           :on_module,
-          :on_params,
-          :on_var_field,
-          :on_var_ref,
-          :on_vcall,
+          :on_local_variable_write,
+          :on_local_variable_read,
+          :on_block_parameter,
+          :on_keyword_parameter,
+          :on_keyword_rest_parameter,
+          :on_optional_parameter,
+          :on_required_parameter,
+          :on_rest_parameter,
+          :on_constant_read,
+          :on_constant_write,
+          :on_constant_and_write,
+          :on_constant_operator_write,
+          :on_constant_or_write,
+          :on_constant_target,
+          :on_local_variable_and_write,
+          :on_local_variable_operator_write,
+          :on_local_variable_or_write,
+          :on_local_variable_target,
+          :on_block_local_variable,
         )
       end
 
-      sig { params(node: SyntaxTree::CallNode).void }
+      sig { params(node: YARP::CallNode).void }
       def on_call(node)
         return unless visible?(node, @range)
 
         message = node.message
-        if !message.is_a?(Symbol) && !special_method?(message.value)
-          type = Support::Sorbet.annotation?(node) ? :type : :method
-          add_token(message.location, type)
-        end
-      end
-
-      sig { params(node: SyntaxTree::Command).void }
-      def on_command(node)
-        return unless visible?(node, @range)
+        return unless message
 
-        add_token(node.message.location, :method) unless special_method?(node.message.value)
-      end
+        # We can't push a semantic token for [] and []= because the argument inside the brackets is a part of
+        # the message_loc
+        return if message.start_with?("[") && (message.end_with?("]") || message.end_with?("]="))
 
-      sig { params(node: SyntaxTree::CommandCall).void }
-      def on_command_call(node)
-        return unless visible?(node, @range)
+        return process_regexp_locals(node) if message == "=~"
+        return if special_method?(message)
 
-        message = node.message
-        add_token(message.location, :method) unless message.is_a?(Symbol)
+        type = Support::Sorbet.annotation?(node) ? :type : :method
+        add_token(T.must(node.message_loc), type)
       end
 
-      sig { params(node: SyntaxTree::Const).void }
-      def on_const(node)
+      sig { params(node: YARP::ConstantReadNode).void }
+      def on_constant_read(node)
         return unless visible?(node, @range)
         # When finding a module or class definition, we will have already pushed a token related to this constant. We
         # need to look at the previous two tokens and if they match this locatione exactly, avoid pushing another token
@@ -179,153 +183,199 @@ module RubyLsp
         add_token(node.location, :namespace)
       end
 
-      sig { params(node: SyntaxTree::DefNode).void }
-      def on_def(node)
+      sig { params(node: YARP::ConstantWriteNode).void }
+      def on_constant_write(node)
         return unless visible?(node, @range)
 
-        add_token(node.name.location, :method, [:declaration])
+        add_token(node.name_loc, :namespace)
       end
 
-      sig { params(node: SyntaxTree::Kw).void }
-      def on_kw(node)
+      sig { params(node: YARP::ConstantAndWriteNode).void }
+      def on_constant_and_write(node)
         return unless visible?(node, @range)
 
-        case node.value
-        when "self"
-          add_token(node.location, :variable, [:default_library])
-        end
+        add_token(node.name_loc, :namespace)
       end
 
-      sig { params(node: SyntaxTree::Params).void }
-      def on_params(node)
+      sig { params(node: YARP::ConstantOperatorWriteNode).void }
+      def on_constant_operator_write(node)
         return unless visible?(node, @range)
 
-        node.keywords.each do |keyword, *|
-          location = keyword.location
-          add_token(location_without_colon(location), :parameter)
-        end
+        add_token(node.name_loc, :namespace)
+      end
 
-        node.requireds.each do |required|
-          add_token(required.location, :parameter)
-        end
+      sig { params(node: YARP::ConstantOrWriteNode).void }
+      def on_constant_or_write(node)
+        return unless visible?(node, @range)
 
-        rest = node.keyword_rest
-        if rest && !rest.is_a?(SyntaxTree::ArgsForward) && !rest.is_a?(Symbol)
-          name = rest.name
-          add_token(name.location, :parameter) if name
-        end
+        add_token(node.name_loc, :namespace)
+      end
+
+      sig { params(node: YARP::ConstantTargetNode).void }
+      def on_constant_target(node)
+        return unless visible?(node, @range)
+
+        add_token(node.location, :namespace)
       end
 
-      sig { params(node: SyntaxTree::Field).void }
-      def on_field(node)
+      sig { params(node: YARP::DefNode).void }
+      def on_def(node)
+        @current_scope = ParameterScope.new(@current_scope)
         return unless visible?(node, @range)
 
-        add_token(node.name.location, :method)
+        add_token(node.name_loc, :method, [:declaration])
+      end
+
+      sig { params(node: YARP::DefNode).void }
+      def after_def(node)
+        @current_scope = T.must(@current_scope.parent)
+      end
+
+      sig { params(node: YARP::BlockNode).void }
+      def on_block(node)
+        @current_scope = ParameterScope.new(@current_scope)
       end
 
-      sig { params(node: SyntaxTree::VarField).void }
-      def on_var_field(node)
+      sig { params(node: YARP::BlockNode).void }
+      def after_block(node)
+        @current_scope = T.must(@current_scope.parent)
+      end
+
+      sig { params(node: YARP::BlockLocalVariableNode).void }
+      def on_block_local_variable(node)
+        add_token(node.location, :variable)
+      end
+
+      sig { params(node: YARP::BlockParameterNode).void }
+      def on_block_parameter(node)
+        name = node.name
+        @current_scope << name.to_sym if name
+      end
+
+      sig { params(node: YARP::KeywordParameterNode).void }
+      def on_keyword_parameter(node)
+        name = node.name
+        @current_scope << name.to_s.delete_suffix(":").to_sym if name
+
         return unless visible?(node, @range)
 
-        value = node.value
+        location = node.name_loc
+        add_token(location.copy(length: location.length - 1), :parameter)
+      end
 
-        case value
-        when SyntaxTree::Ident
-          type = type_for_local(value)
-          add_token(value.location, type)
+      sig { params(node: YARP::KeywordRestParameterNode).void }
+      def on_keyword_rest_parameter(node)
+        name = node.name
+
+        if name
+          @current_scope << name.to_sym
+
+          add_token(T.must(node.name_loc), :parameter) if visible?(node, @range)
         end
       end
 
-      sig { params(node: SyntaxTree::VarRef).void }
-      def on_var_ref(node)
+      sig { params(node: YARP::OptionalParameterNode).void }
+      def on_optional_parameter(node)
+        @current_scope << node.name
+        return unless visible?(node, @range)
+
+        add_token(node.name_loc, :parameter)
+      end
+
+      sig { params(node: YARP::RequiredParameterNode).void }
+      def on_required_parameter(node)
+        @current_scope << node.name
         return unless visible?(node, @range)
 
-        value = node.value
+        add_token(node.location, :parameter)
+      end
+
+      sig { params(node: YARP::RestParameterNode).void }
+      def on_rest_parameter(node)
+        name = node.name
 
-        case value
-        when SyntaxTree::Ident
-          type = type_for_local(value)
-          add_token(value.location, type)
+        if name
+          @current_scope << name.to_sym
+
+          add_token(T.must(node.name_loc), :parameter) if visible?(node, @range)
         end
       end
 
-      # All block locals are variables. E.g.: [].each do |x; block_local|
-      sig { params(node: SyntaxTree::BlockVar).void }
-      def on_block_var(node)
-        node.locals.each { |local| add_token(local.location, :variable) }
+      sig { params(node: YARP::SelfNode).void }
+      def on_self(node)
+        return unless visible?(node, @range)
+
+        add_token(node.location, :variable, [:default_library])
       end
 
-      # All lambda locals are variables. E.g.: ->(x; lambda_local) {}
-      sig { params(node: SyntaxTree::LambdaVar).void }
-      def on_lambda_var(node)
-        node.locals.each { |local| add_token(local.location, :variable) }
+      sig { params(node: YARP::LocalVariableWriteNode).void }
+      def on_local_variable_write(node)
+        return unless visible?(node, @range)
+
+        add_token(node.name_loc, @current_scope.type_for(node.name))
       end
 
-      sig { params(node: SyntaxTree::VCall).void }
-      def on_vcall(node)
+      sig { params(node: YARP::LocalVariableReadNode).void }
+      def on_local_variable_read(node)
         return unless visible?(node, @range)
 
-        # A VCall may exist as a local in the current_scope. This happens when used named capture groups in a regexp
-        ident = node.value
-        value = ident.value
-        local = @emitter.current_scope.find_local(value)
-        return if local.nil? && special_method?(value)
-
-        type = if local
-          :variable
-        elsif Support::Sorbet.annotation?(node)
-          :type
-        else
-          :method
+        # Numbered parameters
+        if /_\d+/.match?(node.name)
+          add_token(node.location, :parameter)
+          return
         end
 
-        add_token(node.value.location, type)
+        add_token(node.location, @current_scope.type_for(node.name))
       end
 
-      sig { params(node: SyntaxTree::Binary).void }
-      def after_binary(node)
-        # You can only capture local variables with regexp by using the =~ operator
-        return unless node.operator == :=~
+      sig { params(node: YARP::LocalVariableAndWriteNode).void }
+      def on_local_variable_and_write(node)
+        return unless visible?(node, @range)
 
-        left = node.left
-        # The regexp needs to be on the left hand side of the =~ for local variable capture
-        return unless left.is_a?(SyntaxTree::RegexpLiteral)
+        add_token(node.name_loc, @current_scope.type_for(node.name))
+      end
 
-        parts = left.parts
-        return unless parts.one?
+      sig { params(node: YARP::LocalVariableOperatorWriteNode).void }
+      def on_local_variable_operator_write(node)
+        return unless visible?(node, @range)
 
-        content = parts.first
-        return unless content.is_a?(SyntaxTree::TStringContent)
+        add_token(node.name_loc, @current_scope.type_for(node.name))
+      end
 
-        # For each capture name we find in the regexp, look for a local in the current_scope
-        Regexp.new(content.value, Regexp::FIXEDENCODING).names.each do |name|
-          local = @emitter.current_scope.find_local(name)
-          next unless local
+      sig { params(node: YARP::LocalVariableOrWriteNode).void }
+      def on_local_variable_or_write(node)
+        return unless visible?(node, @range)
 
-          local.definitions.each { |definition| add_token(definition, :variable) }
-        end
+        add_token(node.name_loc, @current_scope.type_for(node.name))
+      end
+
+      sig { params(node: YARP::LocalVariableTargetNode).void }
+      def on_local_variable_target(node)
+        return unless visible?(node, @range)
+
+        add_token(node.location, @current_scope.type_for(node.name))
       end
 
-      sig { params(node: SyntaxTree::ClassDeclaration).void }
+      sig { params(node: YARP::ClassNode).void }
       def on_class(node)
         return unless visible?(node, @range)
 
-        add_token(node.constant.location, :class, [:declaration])
+        add_token(node.constant_path.location, :class, [:declaration])
 
         superclass = node.superclass
         add_token(superclass.location, :class) if superclass
       end
 
-      sig { params(node: SyntaxTree::ModuleDeclaration).void }
+      sig { params(node: YARP::ModuleNode).void }
       def on_module(node)
         return unless visible?(node, @range)
 
-        add_token(node.constant.location, :namespace, [:declaration])
+        add_token(node.constant_path.location, :namespace, [:declaration])
       end
 
-      sig { params(location: SyntaxTree::Location, type: Symbol, modifiers: T::Array[Symbol]).void }
+      sig { params(location: YARP::Location, type: Symbol, modifiers: T::Array[Symbol]).void }
       def add_token(location, type, modifiers = [])
-        length = location.end_char - location.start_char
+        length = location.end_offset - location.start_offset
         modifiers_indices = modifiers.filter_map { |modifier| TOKEN_MODIFIERS[modifier] }
         @_response.push(
           SemanticToken.new(
@@ -339,38 +389,30 @@ module RubyLsp
 
       private
 
-      # Exclude the ":" symbol at the end of a location
-      # We use it on keyword parameters to be consistent
-      # with the rest of the parameters
-      sig { params(location: T.untyped).returns(SyntaxTree::Location) }
-      def location_without_colon(location)
-        SyntaxTree::Location.new(
-          start_line: location.start_line,
-          start_column: location.start_column,
-          start_char: location.start_char,
-          end_char: location.end_char - 1,
-          end_column: location.end_column - 1,
-          end_line: location.end_line,
-        )
-      end
-
-      # Textmate provides highlighting for a subset
-      # of these special Ruby-specific methods.
-      # We want to utilize that highlighting, so we
-      # avoid making a semantic token for it.
+      # Textmate provides highlighting for a subset of these special Ruby-specific methods.  We want to utilize that
+      # highlighting, so we avoid making a semantic token for it.
       sig { params(method_name: String).returns(T::Boolean) }
       def special_method?(method_name)
         SPECIAL_RUBY_METHODS.include?(method_name)
       end
 
-      sig { params(value: SyntaxTree::Ident).returns(Symbol) }
-      def type_for_local(value)
-        local = @emitter.current_scope.find_local(value.value)
+      sig { params(node: YARP::CallNode).void }
+      def process_regexp_locals(node)
+        receiver = node.receiver
+
+        # The regexp needs to be the receiver of =~ for local variable capture
+        return unless receiver.is_a?(YARP::RegularExpressionNode)
+
+        content = receiver.content
+        loc = receiver.content_loc
+
+        # For each capture name we find in the regexp, look for a local in the current_scope
+        Regexp.new(content, Regexp::FIXEDENCODING).names.each do |name|
+          # The +3 is to compensate for the "(?<" part of the capture name
+          capture_name_offset = T.must(content.index("(?<#{name}>")) + 3
+          local_var_loc = loc.copy(start_offset: loc.start_offset + capture_name_offset, length: name.length)
 
-        if local.nil? || local.type == :variable
-          :variable
-        else
-          :parameter
+          add_token(local_var_loc, @current_scope.type_for(name))
         end
       end
     end

data/lib/ruby_lsp/requests/show_syntax_tree.rb

@@ -29,7 +29,6 @@ module RubyLsp
 
       sig { override.returns(String) }
       def run
-        return "Document contains syntax error" if @document.syntax_error?
         return ast_for_range if @range
 
         output_string = +""
@@ -47,7 +46,7 @@ module RubyLsp
         start_char = scanner.find_char_position(range[:start])
         end_char = scanner.find_char_position(range[:end])
 
-        queue = T.cast(@document.tree, SyntaxTree::Program).statements.body.dup
+        queue = @document.tree.statements.body.dup
         found_nodes = []
 
         until queue.empty?
@@ -58,10 +57,10 @@ module RubyLsp
 
           # If the node is fully covered by the selection, then we found one of the nodes to be displayed and don't want
           # to continue descending into its children
-          if (start_char..end_char).cover?(loc.start_char..loc.end_char)
+          if (start_char..end_char).cover?(loc.start_offset..loc.end_offset)
             found_nodes << node
           else
-            queue.unshift(*node.child_nodes)
+            T.unsafe(queue).unshift(*node.child_nodes)
           end
         end
 

data/lib/ruby_lsp/requests/support/annotation.rb

@@ -17,28 +17,29 @@ module RubyLsp
           @receiver = receiver
         end
 
-        sig { returns(T.any(Integer, T::Range[Integer])) }
-        attr_reader :arity
+        sig { params(node: YARP::CallNode).returns(T::Boolean) }
+        def match?(node)
+          receiver_matches?(node) && arity_matches?(node)
+        end
 
-        sig { returns(T::Boolean) }
-        attr_reader :receiver
+        private
 
-        sig { params(arity: T.any(T::Range[Integer], Integer)).returns(T::Boolean) }
-        def supports_arity?(arity)
-          if @arity.is_a?(Integer)
-            @arity == arity
-          elsif @arity.is_a?(Range)
-            @arity.cover?(arity)
-          else
-            T.absurd(@arity)
-          end
+        sig { params(node: YARP::CallNode).returns(T::Boolean) }
+        def receiver_matches?(node)
+          node_receiver = node.receiver
+          (node_receiver && @receiver && node_receiver.location.slice == "T") || (!node_receiver && !@receiver)
         end
 
-        sig { params(receiver: T.nilable(String)).returns(T::Boolean) }
-        def supports_receiver?(receiver)
-          return receiver.nil? || receiver.empty? if @receiver == false
+        sig { params(node: YARP::CallNode).returns(T::Boolean) }
+        def arity_matches?(node)
+          node_arity = node.arguments&.arguments&.size || 0
 
-          receiver == "T"
+          case @arity
+          when Integer
+            node_arity == @arity
+          when Range
+            @arity.cover?(node_arity)
+          end
         end
       end
     end