ruby-lsp 0.0.4 → 0.1.0

data/lib/ruby_lsp/requests/folding_ranges.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
@@ -13,7 +13,9 @@ module RubyLsp
     # end # <-- folding range end
     # ```
     class FoldingRanges < BaseRequest
-      SIMPLE_FOLDABLES = [
+      extend T::Sig
+
+      SIMPLE_FOLDABLES = T.let([
         SyntaxTree::ArrayLiteral,
         SyntaxTree::BraceBlock,
         SyntaxTree::Case,
@@ -30,24 +32,37 @@ module RubyLsp
         SyntaxTree::Unless,
         SyntaxTree::Until,
         SyntaxTree::While,
-      ].freeze
+      ].freeze, T::Array[T.class_of(SyntaxTree::Node)])
 
-      NODES_WITH_STATEMENTS = [
+      NODES_WITH_STATEMENTS = T.let([
         SyntaxTree::Else,
         SyntaxTree::Elsif,
         SyntaxTree::Ensure,
         SyntaxTree::In,
         SyntaxTree::Rescue,
         SyntaxTree::When,
-      ].freeze
+      ].freeze, T::Array[T.class_of(SyntaxTree::Node)])
+
+      StatementNode = T.type_alias do
+        T.any(
+          SyntaxTree::Else,
+          SyntaxTree::Elsif,
+          SyntaxTree::Ensure,
+          SyntaxTree::In,
+          SyntaxTree::Rescue,
+          SyntaxTree::When,
+        )
+      end
 
+      sig { params(document: Document).void }
       def initialize(document)
         super
 
-        @ranges = []
-        @partial_range = nil
+        @ranges = T.let([], T::Array[LanguageServer::Protocol::Interface::FoldingRange])
+        @partial_range = T.let(nil, T.nilable(PartialRange))
       end
 
+      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::FoldingRange], Object)) }
       def run
         visit(@document.tree)
         emit_partial_range
@@ -56,14 +71,15 @@ module RubyLsp
 
       private
 
+      sig { params(node: T.nilable(SyntaxTree::Node)).void }
       def visit(node)
         return unless handle_partial_range(node)
 
         case node
         when *SIMPLE_FOLDABLES
-          add_node_range(node)
+          add_node_range(T.must(node))
         when *NODES_WITH_STATEMENTS
-          add_statements_range(node, node.statements)
+          add_statements_range(T.must(node), T.cast(node, StatementNode).statements)
         when SyntaxTree::Begin
           add_statements_range(node, node.bodystmt.statements)
         when SyntaxTree::Call, SyntaxTree::CommandCall
@@ -80,27 +96,38 @@ module RubyLsp
       end
 
       class PartialRange
-        attr_reader :kind, :end_line
+        extend T::Sig
 
+        sig { returns(String) }
+        attr_reader :kind
+
+        sig { returns(Integer) }
+        attr_reader :end_line
+
+        sig { params(node: SyntaxTree::Node, kind: String).returns(PartialRange) }
         def self.from(node, kind)
           new(node.location.start_line - 1, node.location.end_line - 1, kind)
         end
 
+        sig { params(start_line: Integer, end_line: Integer, kind: String).void }
         def initialize(start_line, end_line, kind)
           @start_line = start_line
           @end_line = end_line
           @kind = kind
         end
 
+        sig { params(node: SyntaxTree::Node).returns(PartialRange) }
         def extend_to(node)
           @end_line = node.location.end_line - 1
           self
         end
 
+        sig { params(node: SyntaxTree::Node).returns(T::Boolean) }
         def new_section?(node)
           node.is_a?(SyntaxTree::Comment) && @end_line + 1 != node.location.start_line - 1
         end
 
+        sig { returns(LanguageServer::Protocol::Interface::FoldingRange) }
         def to_range
           LanguageServer::Protocol::Interface::FoldingRange.new(
             start_line: @start_line,
@@ -110,6 +137,7 @@ module RubyLsp
         end
       end
 
+      sig { params(node: T.nilable(SyntaxTree::Node)).returns(T::Boolean) }
       def handle_partial_range(node)
         kind = partial_range_kind(node)
 
@@ -118,18 +146,20 @@ module RubyLsp
           return true
         end
 
+        target_node = T.must(node)
         @partial_range = if @partial_range.nil?
-          PartialRange.from(node, kind)
-        elsif @partial_range.kind != kind || @partial_range.new_section?(node)
+          PartialRange.from(target_node, kind)
+        elsif @partial_range.kind != kind || @partial_range.new_section?(target_node)
           emit_partial_range
-          PartialRange.from(node, kind)
+          PartialRange.from(target_node, kind)
         else
-          @partial_range.extend_to(node)
+          @partial_range.extend_to(target_node)
         end
 
         false
       end
 
+      sig { params(node: T.nilable(SyntaxTree::Node)).returns(T.nilable(String)) }
       def partial_range_kind(node)
         case node
         when SyntaxTree::Comment
@@ -141,6 +171,7 @@ module RubyLsp
         end
       end
 
+      sig { void }
       def emit_partial_range
         return if @partial_range.nil?
 
@@ -148,6 +179,7 @@ module RubyLsp
         @partial_range = nil
       end
 
+      sig { params(node: T.any(SyntaxTree::Call, SyntaxTree::CommandCall)).void }
       def add_call_range(node)
         receiver = T.let(node.receiver, SyntaxTree::Node)
         loop do
@@ -168,6 +200,7 @@ module RubyLsp
         visit(node.arguments)
       end
 
+      sig { params(node: T.any(SyntaxTree::Def, SyntaxTree::Defs)).void }
       def add_def_range(node)
         params_location = node.params.location
 
@@ -180,10 +213,12 @@ module RubyLsp
         visit(node.bodystmt.statements)
       end
 
+      sig { params(node: SyntaxTree::Node, statements: SyntaxTree::Statements).void }
       def add_statements_range(node, statements)
         add_lines_range(node.location.start_line, statements.location.end_line) unless statements.empty?
       end
 
+      sig { params(node: SyntaxTree::StringConcat).void }
       def add_string_concat(node)
         left = T.let(node.left, SyntaxTree::Node)
         left = left.left while left.is_a?(SyntaxTree::StringConcat)
@@ -191,14 +226,13 @@ module RubyLsp
         add_lines_range(left.location.start_line, node.right.location.end_line)
       end
 
+      sig { params(node: SyntaxTree::Node).void }
       def add_node_range(node)
-        add_location_range(node.location)
-      end
-
-      def add_location_range(location)
+        location = node.location
         add_lines_range(location.start_line, location.end_line)
       end
 
+      sig { params(start_line: Integer, end_line: Integer).void }
       def add_lines_range(start_line, end_line)
         return if start_line >= end_line
 

data/lib/ruby_lsp/requests/formatting.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
@@ -15,13 +15,17 @@ module RubyLsp
     # end
     # ```
     class Formatting < RuboCopRequest
-      RUBOCOP_FLAGS = (COMMON_RUBOCOP_FLAGS + ["--autocorrect"]).freeze
+      extend T::Sig
 
+      RUBOCOP_FLAGS = T.let((COMMON_RUBOCOP_FLAGS + ["--auto-correct"]).freeze, T::Array[String])
+
+      sig { params(uri: String, document: Document).void }
       def initialize(uri, document)
         super
-        @formatted_text = nil
+        @formatted_text = T.let(nil, T.nilable(String))
       end
 
+      sig { override.returns(T.nilable(T.all(T::Array[LanguageServer::Protocol::Interface::TextEdit], Object))) }
       def run
         super
 
@@ -44,6 +48,7 @@ module RubyLsp
 
       private
 
+      sig { returns(T::Array[String]) }
       def rubocop_flags
         RUBOCOP_FLAGS
       end

data/lib/ruby_lsp/requests/rubocop_request.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "rubocop"
@@ -8,23 +8,31 @@ module RubyLsp
   module Requests
     # :nodoc:
     class RuboCopRequest < RuboCop::Runner
-      COMMON_RUBOCOP_FLAGS = [
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      COMMON_RUBOCOP_FLAGS = T.let([
         "--stderr", # Print any output to stderr so that our stdout does not get polluted
         "--format",
         "RuboCop::Formatter::BaseFormatter", # Suppress any output by using the base formatter
-      ].freeze
+      ].freeze, T::Array[String])
 
-      attr_reader :file, :text
+      sig { returns(String) }
+      attr_reader :file
 
-      def self.run(uri, document)
-        new(uri, document).run
-      end
+      sig { returns(String) }
+      attr_reader :text
 
+      sig { params(uri: String, document: Document).void }
       def initialize(uri, document)
-        @file = CGI.unescape(URI.parse(uri).path)
+        @file = T.let(CGI.unescape(URI.parse(uri).path), String)
         @document = document
-        @text = document.source
+        @text = T.let(document.source, String)
         @uri = uri
+        @options = T.let({}, T::Hash[Symbol, T.untyped])
+        @diagnostics = T.let([], T::Array[Support::RuboCopDiagnostic])
 
         super(
           ::RuboCop::Options.new.parse(rubocop_flags).first,
@@ -32,6 +40,7 @@ module RubyLsp
         )
       end
 
+      sig { overridable.returns(Object) }
       def run
         # We communicate with Rubocop via stdin
         @options[:stdin] = text
@@ -42,6 +51,7 @@ module RubyLsp
 
       private
 
+      sig { returns(T::Array[String]) }
       def rubocop_flags
         COMMON_RUBOCOP_FLAGS
       end

data/lib/ruby_lsp/requests/selection_ranges.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
@@ -17,7 +17,9 @@ module RubyLsp
     # end
     # ```
     class SelectionRanges < BaseRequest
-      NODES_THAT_CAN_BE_PARENTS = [
+      extend T::Sig
+
+      NODES_THAT_CAN_BE_PARENTS = T.let([
         SyntaxTree::Assign,
         SyntaxTree::ArrayLiteral,
         SyntaxTree::Begin,
@@ -54,15 +56,17 @@ module RubyLsp
         SyntaxTree::VCall,
         SyntaxTree::When,
         SyntaxTree::While,
-      ].freeze
+      ].freeze, T::Array[T.class_of(SyntaxTree::Node)])
 
+      sig { params(document: Document).void }
       def initialize(document)
         super(document)
 
-        @ranges = []
-        @stack = []
+        @ranges = T.let([], T::Array[Support::SelectionRange])
+        @stack = T.let([], T::Array[Support::SelectionRange])
       end
 
+      sig { override.returns(T.all(T::Array[Support::SelectionRange], Object)) }
       def run
         visit(@document.tree)
         @ranges.reverse!
@@ -70,6 +74,7 @@ module RubyLsp
 
       private
 
+      sig { params(node: T.nilable(SyntaxTree::Node)).void }
       def visit(node)
         return if node.nil?
 
@@ -83,6 +88,12 @@ module RubyLsp
         @stack.pop if NODES_THAT_CAN_BE_PARENTS.include?(node.class)
       end
 
+      sig do
+        params(
+          location: SyntaxTree::Location,
+          parent: T.nilable(Support::SelectionRange)
+        ).returns(Support::SelectionRange)
+      end
       def create_selection_range(location, parent = nil)
         RubyLsp::Requests::Support::SelectionRange.new(
           range: LanguageServer::Protocol::Interface::Range.new(

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
@@ -17,12 +17,15 @@ module RubyLsp
     # end
     # ```
     class SemanticHighlighting < BaseRequest
-      TOKEN_TYPES = [
+      extend T::Sig
+
+      TOKEN_TYPES = T.let([
         :variable,
         :method,
-      ].freeze
+        :namespace,
+      ].freeze, T::Array[Symbol])
 
-      TOKEN_MODIFIERS = {
+      TOKEN_MODIFIERS = T.let({
         declaration: 0,
         definition: 1,
         readonly: 2,
@@ -33,18 +36,32 @@ module RubyLsp
         modification: 7,
         documentation: 8,
         default_library: 9,
-      }.freeze
+      }.freeze, T::Hash[Symbol, Integer])
 
-      SemanticToken = Struct.new(:location, :length, :type, :modifier)
+      class SemanticToken < T::Struct
+        const :location, SyntaxTree::Location
+        const :length, Integer
+        const :type, Integer
+        const :modifier, T::Array[Integer]
+      end
 
+      sig { params(document: Document, encoder: T.nilable(Support::SemanticTokenEncoder)).void }
       def initialize(document, encoder: nil)
         super(document)
 
         @encoder = encoder
-        @tokens = []
-        @tree = document.tree
+        @tokens = T.let([], T::Array[SemanticToken])
+        @tree = T.let(document.tree, SyntaxTree::Node)
       end
 
+      sig do
+        override.returns(
+          T.any(
+            LanguageServer::Protocol::Interface::SemanticTokens,
+            T.all(T::Array[SemanticToken], Object),
+          )
+        )
+      end
       def run
         visit(@tree)
         return @tokens unless @encoder
@@ -52,60 +69,118 @@ module RubyLsp
         @encoder.encode(@tokens)
       end
 
-      def visit_m_assign(node)
-        node.target.parts.each do |var_ref|
-          add_token(var_ref.value.location, :variable)
-        end
-      end
-
-      def visit_var_field(node)
-        case node.value
-        when SyntaxTree::Ident
-          add_token(node.value.location, :variable)
-        end
-      end
-
-      def visit_var_ref(node)
-        case node.value
-        when SyntaxTree::Ident
-          add_token(node.value.location, :variable)
-        end
-      end
-
+      sig { params(node: SyntaxTree::ARefField).void }
       def visit_a_ref_field(node)
         add_token(node.collection.value.location, :variable)
       end
 
+      sig { params(node: SyntaxTree::Call).void }
       def visit_call(node)
         visit(node.receiver)
         add_token(node.message.location, :method)
         visit(node.arguments)
       end
 
+      sig { params(node: SyntaxTree::Command).void }
       def visit_command(node)
         add_token(node.message.location, :method)
         visit(node.arguments)
       end
 
+      sig { params(node: SyntaxTree::CommandCall).void }
       def visit_command_call(node)
         visit(node.receiver)
         add_token(node.message.location, :method)
         visit(node.arguments)
       end
 
+      sig { params(node: SyntaxTree::Const).void }
+      def visit_const(node)
+        add_token(node.location, :namespace)
+      end
+
+      sig { params(node: SyntaxTree::Def).void }
+      def visit_def(node)
+        add_token(node.name.location, :method, [:declaration])
+        visit(node.params)
+        visit(node.bodystmt)
+      end
+
+      sig { params(node: SyntaxTree::DefEndless).void }
+      def visit_def_endless(node)
+        add_token(node.name.location, :method, [:declaration])
+        visit(node.paren)
+        visit(node.operator)
+        visit(node.statement)
+      end
+
+      sig { params(node: SyntaxTree::Defs).void }
+      def visit_defs(node)
+        visit(node.target)
+        visit(node.operator)
+        add_token(node.name.location, :method, [:declaration])
+        visit(node.params)
+        visit(node.bodystmt)
+      end
+
+      sig { params(node: SyntaxTree::FCall).void }
       def visit_fcall(node)
         add_token(node.value.location, :method)
         visit(node.arguments)
       end
 
+      sig { params(node: SyntaxTree::Kw).void }
+      def visit_kw(node)
+        case node.value
+        when "self"
+          add_token(node.location, :variable, [:default_library])
+        end
+      end
+
+      sig { params(node: SyntaxTree::MAssign).void }
+      def visit_m_assign(node)
+        node.target.parts.each do |var_ref|
+          add_token(var_ref.value.location, :variable)
+        end
+      end
+
+      sig { params(node: SyntaxTree::VarField).void }
+      def visit_var_field(node)
+        case node.value
+        when SyntaxTree::Ident
+          add_token(node.value.location, :variable)
+        else
+          visit(node.value)
+        end
+      end
+
+      sig { params(node: SyntaxTree::VarRef).void }
+      def visit_var_ref(node)
+        case node.value
+        when SyntaxTree::Ident
+          add_token(node.value.location, :variable)
+        else
+          visit(node.value)
+        end
+      end
+
+      sig { params(node: SyntaxTree::VCall).void }
       def visit_vcall(node)
         add_token(node.value.location, :method)
       end
 
+      sig { params(location: SyntaxTree::Location, type: Symbol, modifiers: T::Array[Symbol]).void }
       def add_token(location, type, modifiers = [])
         length = location.end_char - location.start_char
         modifiers_indices = modifiers.filter_map { |modifier| TOKEN_MODIFIERS[modifier] }
-        @tokens.push(SemanticToken.new(location, length, TOKEN_TYPES.index(type), modifiers_indices))
+        @tokens.push(
+          SemanticToken.new(
+            location: location,
+            length: length,
+            type: T.must(TOKEN_TYPES.index(type)),
+            modifier: modifiers_indices
+          )
+        )
       end
     end
   end

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

@@ -1,35 +1,45 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
   module Requests
     module Support
       class RuboCopDiagnostic
-        RUBOCOP_TO_LSP_SEVERITY = {
+        extend T::Sig
+
+        RUBOCOP_TO_LSP_SEVERITY = T.let({
           convention: LanguageServer::Protocol::Constant::DiagnosticSeverity::INFORMATION,
           info: LanguageServer::Protocol::Constant::DiagnosticSeverity::INFORMATION,
           refactor: LanguageServer::Protocol::Constant::DiagnosticSeverity::INFORMATION,
           warning: LanguageServer::Protocol::Constant::DiagnosticSeverity::WARNING,
           error: LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR,
           fatal: LanguageServer::Protocol::Constant::DiagnosticSeverity::ERROR,
-        }.freeze
+        }.freeze, T::Hash[Symbol, Integer])
 
+        sig { returns(T::Array[LanguageServer::Protocol::Interface::TextEdit]) }
         attr_reader :replacements
 
+        sig { params(offense: RuboCop::Cop::Offense, uri: String).void }
         def initialize(offense, uri)
           @offense = offense
           @uri = uri
-          @replacements = offense.correctable? ? offense_replacements : []
+          @replacements = T.let(
+            offense.correctable? ? offense_replacements : [],
+            T::Array[LanguageServer::Protocol::Interface::TextEdit]
+          )
         end
 
+        sig { returns(T::Boolean) }
         def correctable?
           @offense.correctable?
         end
 
+        sig { params(range: T::Range[Integer]).returns(T::Boolean) }
         def in_range?(range)
           range.cover?(@offense.line - 1)
         end
 
+        sig { returns(LanguageServer::Protocol::Interface::CodeAction) }
         def to_lsp_code_action
           LanguageServer::Protocol::Interface::CodeAction.new(
             title: "Autocorrect #{@offense.cop_name}",
@@ -49,6 +59,7 @@ module RubyLsp
           )
         end
 
+        sig { returns(LanguageServer::Protocol::Interface::Diagnostic) }
         def to_lsp_diagnostic
           LanguageServer::Protocol::Interface::Diagnostic.new(
             message: @offense.message,
@@ -70,6 +81,7 @@ module RubyLsp
 
         private
 
+        sig { returns(T::Array[LanguageServer::Protocol::Interface::TextEdit]) }
         def offense_replacements
           @offense.corrector.as_replacements.map do |range, replacement|
             LanguageServer::Protocol::Interface::TextEdit.new(

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

@@ -1,10 +1,13 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
   module Requests
     module Support
       class SelectionRange < LanguageServer::Protocol::Interface::SelectionRange
+        extend T::Sig
+
+        sig { params(position: Document::PositionShape).returns(T::Boolean) }
         def cover?(position)
           line_range = (range.start.line..range.end.line)
           character_range = (range.start.character..range.end.character)

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

@@ -1,15 +1,23 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module RubyLsp
   module Requests
     module Support
       class SemanticTokenEncoder
+        extend T::Sig
+
+        sig { void }
         def initialize
-          @current_row = 0
-          @current_column = 0
+          @current_row = T.let(0, Integer)
+          @current_column = T.let(0, Integer)
         end
 
+        sig do
+          params(
+            tokens: T::Array[SemanticHighlighting::SemanticToken]
+          ).returns(LanguageServer::Protocol::Interface::SemanticTokens)
+        end
         def encode(tokens)
           delta = tokens
             .sort_by do |token|
@@ -31,6 +39,7 @@ module RubyLsp
 
         # For more information on how each number is calculated, read:
         # https://microsoft.github.io/language-server-protocol/specifications/specification-current/#textDocument_semanticTokens
+        sig { params(token: SemanticHighlighting::SemanticToken).returns(T::Array[Integer]) }
         def compute_delta(token)
           row = token.location.start_line - 1
           column = token.location.start_column
@@ -49,6 +58,7 @@ module RubyLsp
         # For example, [:default_library] will be encoded as
         # 0b1000000000, as :default_library is the 10th bit according
         # to the token modifiers index map.
+        sig { params(modifiers: T::Array[Integer]).returns(Integer) }
         def encode_modifiers(modifiers)
           modifiers.inject(0) do |encoded_modifiers, modifier|
             encoded_modifiers | (1 << modifier)