ruby-lsp 0.3.8 → 0.4.0

data/lib/ruby_lsp/requests/path_completion.rb

@@ -0,0 +1,88 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    # ![Path completion demo](../../misc/path_completion.gif)
+    #
+    # The [completion](https://microsoft.github.io/language-server-protocol/specification#textDocument_completion)
+    # request looks up Ruby files in the $LOAD_PATH to suggest path completion inside `require` statements.
+    #
+    # # Example
+    #
+    # ```ruby
+    # require "ruby_lsp/requests" # --> completion: suggests `base_request`, `code_actions`, ...
+    # ```
+    class PathCompletion < BaseRequest
+      extend T::Sig
+
+      sig { params(document: Document, position: Document::PositionShape).void }
+      def initialize(document, position)
+        super(document)
+
+        @tree = T.let(Support::PrefixTree.new(collect_load_path_files), Support::PrefixTree)
+
+        char_position = document.create_scanner.find_char_position(position)
+        @target = T.let(find(char_position), T.nilable(SyntaxTree::TStringContent))
+      end
+
+      sig { override.returns(T.all(T::Array[LanguageServer::Protocol::Interface::CompletionItem], Object)) }
+      def run
+        # no @target means the we are not inside a `require` call
+        return [] unless @target
+
+        text = @target.value
+        @tree.search(text).sort.map! do |path|
+          build_completion(path, path.delete_prefix(text))
+        end
+      end
+
+      private
+
+      sig { returns(T::Array[String]) }
+      def collect_load_path_files
+        $LOAD_PATH.flat_map do |p|
+          Dir.glob("**/*.rb", base: p)
+        end.map! do |result|
+          result.delete_suffix!(".rb")
+        end
+      end
+
+      sig { params(position: Integer).returns(T.nilable(SyntaxTree::TStringContent)) }
+      def find(position)
+        matched, parent = locate(
+          T.must(@document.tree),
+          position,
+          node_types: [SyntaxTree::Command, SyntaxTree::CommandCall, SyntaxTree::CallNode],
+        )
+
+        return unless matched && parent
+
+        case matched
+        when SyntaxTree::Command, SyntaxTree::CallNode, SyntaxTree::CommandCall
+          return unless matched.message.value == "require"
+
+          args = matched.arguments
+          args = args.arguments if args.is_a?(SyntaxTree::ArgParen)
+
+          path_node = args.parts.first.parts.first
+          return unless path_node
+          return unless (path_node.location.start_char..path_node.location.end_char).cover?(position)
+
+          path_node
+        end
+      end
+
+      sig do
+        params(label: String, insert_text: String).returns(LanguageServer::Protocol::Interface::CompletionItem)
+      end
+      def build_completion(label, insert_text)
+        LanguageServer::Protocol::Interface::CompletionItem.new(
+          label: label,
+          insert_text: insert_text,
+          kind: LanguageServer::Protocol::Constant::CompletionItemKind::REFERENCE,
+        )
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests/semantic_highlighting.rb

@@ -20,7 +20,7 @@ module RubyLsp
     # ```
     class SemanticHighlighting < BaseRequest
       extend T::Sig
-      include SyntaxTree::WithEnvironment
+      include SyntaxTree::WithScope
 
       TOKEN_TYPES = T.let(
         {
@@ -78,11 +78,28 @@ module RubyLsp
         T::Array[String],
       )
 
-      class SemanticToken < T::Struct
-        const :location, SyntaxTree::Location
-        const :length, Integer
-        const :type, Integer
-        const :modifier, T::Array[Integer]
+      class SemanticToken
+        extend T::Sig
+
+        sig { returns(SyntaxTree::Location) }
+        attr_reader :location
+
+        sig { returns(Integer) }
+        attr_reader :length
+
+        sig { returns(Integer) }
+        attr_reader :type
+
+        sig { returns(T::Array[Integer]) }
+        attr_reader :modifier
+
+        sig { params(location: SyntaxTree::Location, length: Integer, type: Integer, modifier: T::Array[Integer]).void }
+        def initialize(location:, length:, type:, modifier:)
+          @location = location
+          @length = length
+          @type = type
+          @modifier = modifier
+        end
       end
 
       sig do
@@ -126,8 +143,10 @@ module RubyLsp
         visit(node.receiver)
 
         message = node.message
-        unless message == :call || special_method?(message.value)
-          add_token(message.location, :method)
+        if message != :call && !special_method?(message.value)
+          type = Support::Sorbet.annotation?(node) ? :type : :method
+
+          add_token(message.location, type)
         end
 
         visit(node.arguments)
@@ -137,7 +156,9 @@ module RubyLsp
       def visit_command(node)
         return super unless visible?(node, @range)
 
-        add_token(node.message.location, :method) unless special_method?(node.message.value)
+        unless special_method?(node.message.value)
+          add_token(node.message.location, :method)
+        end
         visit(node.arguments)
       end
 
@@ -243,7 +264,10 @@ module RubyLsp
       def visit_vcall(node)
         return super unless visible?(node, @range)
 
-        add_token(node.value.location, :method) unless special_method?(node.value.value)
+        return if special_method?(node.value.value)
+
+        type = Support::Sorbet.annotation?(node) ? :type : :method
+        add_token(node.value.location, type)
       end
 
       sig { override.params(node: SyntaxTree::ClassDeclaration).void }
@@ -305,7 +329,7 @@ module RubyLsp
 
       sig { params(value: SyntaxTree::Ident).returns(Symbol) }
       def type_for_local(value)
-        local = current_environment.find_local(value.value)
+        local = current_scope.find_local(value.value)
 
         if local.nil? || local.type == :variable
           :variable

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

@@ -0,0 +1,46 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    module Support
+      class Annotation
+        extend T::Sig
+        sig do
+          params(
+            arity: T.any(Integer, T::Range[Integer]),
+            receiver: T::Boolean,
+          ).void
+        end
+        def initialize(arity:, receiver: false)
+          @arity = arity
+          @receiver = receiver
+        end
+
+        sig { returns(T.any(Integer, T::Range[Integer])) }
+        attr_reader :arity
+
+        sig { returns(T::Boolean) }
+        attr_reader :receiver
+
+        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
+        end
+
+        sig { params(receiver: T.nilable(String)).returns(T::Boolean) }
+        def supports_receiver?(receiver)
+          return receiver.nil? || receiver.empty? if @receiver == false
+
+          receiver == "T"
+        end
+      end
+    end
+  end
+end

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

@@ -10,9 +10,20 @@ module RubyLsp
         READ = LanguageServer::Protocol::Constant::DocumentHighlightKind::READ
         WRITE = LanguageServer::Protocol::Constant::DocumentHighlightKind::WRITE
 
-        class HighlightMatch < T::Struct
-          const :type, Integer
-          const :node, SyntaxTree::Node
+        class HighlightMatch
+          extend T::Sig
+
+          sig { returns(Integer) }
+          attr_reader :type
+
+          sig { returns(SyntaxTree::Node) }
+          attr_reader :node
+
+          sig { params(type: Integer, node: SyntaxTree::Node).void }
+          def initialize(type:, node:)
+            @type = type
+            @node = node
+          end
         end
 
         sig { params(node: SyntaxTree::Node).void }

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

@@ -0,0 +1,80 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    module Support
+      class PrefixTree
+        extend T::Sig
+
+        sig { params(items: T::Array[String]).void }
+        def initialize(items)
+          @root = T.let(Node.new(""), Node)
+
+          items.each do |item|
+            insert(item)
+          end
+        end
+
+        sig { params(prefix: String).returns(T::Array[String]) }
+        def search(prefix)
+          node = T.let(@root, Node)
+
+          prefix.each_char do |char|
+            snode = node.children[char]
+            return [] unless snode
+
+            node = snode
+          end
+
+          node.collect
+        end
+
+        private
+
+        sig { params(item: String).void }
+        def insert(item)
+          node = T.let(@root, Node)
+
+          item.each_char do |char|
+            node = node.children[char] ||= Node.new(node.value + char)
+          end
+
+          node.leaf = true
+        end
+
+        class Node
+          extend T::Sig
+
+          sig { returns(T::Hash[String, Node]) }
+          attr_reader :children
+
+          sig { returns(String) }
+          attr_reader :value
+
+          sig { returns(T::Boolean) }
+          attr_accessor :leaf
+
+          sig { params(value: String).void }
+          def initialize(value)
+            @children = T.let({}, T::Hash[String, Node])
+            @value = T.let(value, String)
+            @leaf = T.let(false, T::Boolean)
+          end
+
+          sig { returns(T::Array[String]) }
+          def collect
+            result = T.let([], T::Array[String])
+            result << value if leaf
+
+            children.each_value do |node|
+              result.concat(node.collect)
+            end
+
+            result
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -9,52 +9,35 @@ module RubyLsp
 
         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,
+            convention: Constant::DiagnosticSeverity::INFORMATION,
+            info: Constant::DiagnosticSeverity::INFORMATION,
+            refactor: Constant::DiagnosticSeverity::INFORMATION,
+            warning: Constant::DiagnosticSeverity::WARNING,
+            error: Constant::DiagnosticSeverity::ERROR,
+            fatal: Constant::DiagnosticSeverity::ERROR,
           }.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 = 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) }
+        sig { returns(Interface::CodeAction) }
         def to_lsp_code_action
-          LanguageServer::Protocol::Interface::CodeAction.new(
+          Interface::CodeAction.new(
             title: "Autocorrect #{@offense.cop_name}",
-            kind: LanguageServer::Protocol::Constant::CodeActionKind::QUICK_FIX,
-            edit: LanguageServer::Protocol::Interface::WorkspaceEdit.new(
+            kind: Constant::CodeActionKind::QUICK_FIX,
+            edit: Interface::WorkspaceEdit.new(
               document_changes: [
-                LanguageServer::Protocol::Interface::TextDocumentEdit.new(
-                  text_document: LanguageServer::Protocol::Interface::OptionalVersionedTextDocumentIdentifier.new(
+                Interface::TextDocumentEdit.new(
+                  text_document: Interface::OptionalVersionedTextDocumentIdentifier.new(
                     uri: @uri,
                     version: nil,
                   ),
-                  edits: @replacements,
+                  edits: @offense.correctable? ? offense_replacements : [],
                 ),
               ],
             ),
@@ -62,45 +45,47 @@ module RubyLsp
           )
         end
 
-        sig { returns(LanguageServer::Protocol::Interface::Diagnostic) }
+        sig { returns(Interface::Diagnostic) }
         def to_lsp_diagnostic
           if @offense.correctable?
             severity = RUBOCOP_TO_LSP_SEVERITY[@offense.severity.name]
             message = @offense.message
           else
-            severity = LanguageServer::Protocol::Constant::DiagnosticSeverity::WARNING
+            severity = Constant::DiagnosticSeverity::WARNING
             message = "#{@offense.message}\n\nThis offense is not auto-correctable.\n"
           end
-          LanguageServer::Protocol::Interface::Diagnostic.new(
+
+          Interface::Diagnostic.new(
             message: message,
             source: "RuboCop",
             code: @offense.cop_name,
             severity: severity,
-            range: LanguageServer::Protocol::Interface::Range.new(
-              start: LanguageServer::Protocol::Interface::Position.new(
+            range: Interface::Range.new(
+              start: Interface::Position.new(
                 line: @offense.line - 1,
                 character: @offense.column,
               ),
-              end: LanguageServer::Protocol::Interface::Position.new(
+              end: Interface::Position.new(
                 line: @offense.last_line - 1,
                 character: @offense.last_column,
               ),
             ),
+            data: {
+              correctable: @offense.correctable?,
+              code_action: to_lsp_code_action,
+            },
           )
         end
 
         private
 
-        sig { returns(T::Array[LanguageServer::Protocol::Interface::TextEdit]) }
+        sig { returns(T::Array[Interface::TextEdit]) }
         def offense_replacements
           @offense.corrector.as_replacements.map do |range, replacement|
-            LanguageServer::Protocol::Interface::TextEdit.new(
-              range: LanguageServer::Protocol::Interface::Range.new(
-                start: LanguageServer::Protocol::Interface::Position.new(line: range.line - 1, character: range.column),
-                end: LanguageServer::Protocol::Interface::Position.new(
-                  line: range.last_line - 1,
-                  character: range.last_column,
-                ),
+            Interface::TextEdit.new(
+              range: Interface::Range.new(
+                start: Interface::Position.new(line: range.line - 1, character: range.column),
+                end: Interface::Position.new(line: range.last_line - 1, character: range.last_column),
               ),
               new_text: replacement,
             )

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

@@ -21,7 +21,7 @@ module RubyLsp
           @runner = T.let(RuboCopRunner.new("-a"), RuboCopRunner)
         end
 
-        sig { params(uri: String, document: Document).returns(T.nilable(String)) }
+        sig { params(uri: String, document: Document).returns(String) }
         def run(uri, document)
           filename = CGI.unescape(URI.parse(uri).path)
 

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

@@ -16,6 +16,22 @@ end
 module RubyLsp
   module Requests
     module Support
+      class InternalRuboCopError < StandardError
+        extend T::Sig
+
+        MESSAGE = <<~EOS
+          An internal error occurred for the %s cop.
+          Updating to a newer version of RuboCop may solve this.
+          For more details, run RuboCop on the command line.
+        EOS
+
+        sig { params(rubocop_error: RuboCop::ErrorWithAnalyzedFileLocation).void }
+        def initialize(rubocop_error)
+          message = format(MESSAGE, rubocop_error.cop.name)
+          super(message)
+        end
+      end
+
       # :nodoc:
       class RuboCopRunner < RuboCop::Runner
         extend T::Sig
@@ -31,10 +47,18 @@ module RubyLsp
             "--force-exclusion",
             "--format",
             "RuboCop::Formatter::BaseFormatter", # Suppress any output by using the base formatter
-          ].freeze,
+          ],
           T::Array[String],
         )
 
+        begin
+          RuboCop::Options.new.parse(["--raise-cop-error"])
+          DEFAULT_ARGS << "--raise-cop-error"
+        rescue OptionParser::InvalidOption
+          # older versions of RuboCop don't support this flag
+        end
+        DEFAULT_ARGS.freeze
+
         sig { params(args: String).void }
         def initialize(*args)
           @options = T.let({}, T::Hash[Symbol, T.untyped])
@@ -63,6 +87,8 @@ module RubyLsp
           raise Formatting::Error, error.message
         rescue RuboCop::ValidationError => error
           raise ConfigurationError, error.message
+        rescue RuboCop::ErrorWithAnalyzedFileLocation => error
+          raise InternalRuboCopError, error
         end
 
         sig { returns(String) }

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

@@ -0,0 +1,120 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyLsp
+  module Requests
+    module Support
+      class Sorbet
+        class << self
+          extend T::Sig
+
+          ANNOTATIONS = T.let(
+            {
+              "abstract!" => Annotation.new(arity: 0),
+              "absurd" => Annotation.new(arity: 1, receiver: true),
+              "all" => Annotation.new(arity: (2..), receiver: true),
+              "any" => Annotation.new(arity: (2..), receiver: true),
+              "assert_type!" => Annotation.new(arity: 2, receiver: true),
+              "attached_class" => Annotation.new(arity: 0, receiver: true),
+              "bind" => Annotation.new(arity: 2, receiver: true),
+              "cast" => Annotation.new(arity: 2, receiver: true),
+              "class_of" => Annotation.new(arity: 1, receiver: true),
+              "enums" => Annotation.new(arity: 0),
+              "interface!" => Annotation.new(arity: 0),
+              "let" => Annotation.new(arity: 2, receiver: true),
+              "mixes_in_class_methods" => Annotation.new(arity: 1),
+              "must" => Annotation.new(arity: 1, receiver: true),
+              "must_because" => Annotation.new(arity: 1, receiver: true),
+              "nilable" => Annotation.new(arity: 1, receiver: true),
+              "noreturn" => Annotation.new(arity: 0, receiver: true),
+              "requires_ancestor" => Annotation.new(arity: 0),
+              "reveal_type" => Annotation.new(arity: 1, receiver: true),
+              "sealed!" => Annotation.new(arity: 0),
+              "self_type" => Annotation.new(arity: 0, receiver: true),
+              "sig" => Annotation.new(arity: 0),
+              "type_member" => Annotation.new(arity: (0..1)),
+              "type_template" => Annotation.new(arity: 0),
+              "unsafe" => Annotation.new(arity: 1),
+              "untyped" => Annotation.new(arity: 0, receiver: true),
+            },
+            T::Hash[String, Annotation],
+          )
+
+          sig do
+            params(
+              node: T.any(SyntaxTree::CallNode, SyntaxTree::VCall),
+            ).returns(T::Boolean)
+          end
+          def annotation?(node)
+            annotation = annotation(node)
+
+            return false if annotation.nil?
+
+            return false unless annotation.supports_receiver?(receiver_name(node))
+
+            annotation.supports_arity?(node.arity)
+          end
+
+          private
+
+          sig { params(node: T.any(SyntaxTree::CallNode, SyntaxTree::VCall)).returns(T.nilable(Annotation)) }
+          def annotation(node)
+            case node
+            when SyntaxTree::VCall
+              ANNOTATIONS[node.value.value]
+            when SyntaxTree::CallNode
+              ANNOTATIONS[node.message.value]
+            else
+              T.absurd(node)
+            end
+          end
+
+          sig do
+            params(receiver: T.any(SyntaxTree::CallNode, SyntaxTree::VCall)).returns(T.nilable(String))
+          end
+          def receiver_name(receiver)
+            case receiver
+            when SyntaxTree::CallNode
+              node_name(receiver.receiver)
+            when SyntaxTree::VCall
+              nil
+            else
+              T.absurd(receiver)
+            end
+          end
+
+          sig do
+            params(node: T.nilable(T.any(
+              SyntaxTree::VarRef,
+              SyntaxTree::CallNode,
+              SyntaxTree::VCall,
+              SyntaxTree::Ident,
+              SyntaxTree::Backtick,
+              SyntaxTree::Const,
+              SyntaxTree::Op,
+              Symbol,
+            ))).returns(T.nilable(String))
+          end
+          def node_name(node)
+            case node
+            when NilClass
+              nil
+            when SyntaxTree::VarRef
+              node.value.value
+            when SyntaxTree::CallNode
+              node_name(node.receiver)
+            when SyntaxTree::VCall
+              node_name(node.value)
+            when SyntaxTree::Ident, SyntaxTree::Backtick, SyntaxTree::Const, SyntaxTree::Op
+              node.value
+            when Symbol
+              node.to_s
+            else
+              T.absurd(node)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_lsp/requests.rb

@@ -16,6 +16,7 @@ module RubyLsp
   # - {RubyLsp::Requests::CodeActions}
   # - {RubyLsp::Requests::DocumentHighlight}
   # - {RubyLsp::Requests::InlayHints}
+  # - {RubyLsp::Requests::PathCompletion}
 
   module Requests
     autoload :BaseRequest, "ruby_lsp/requests/base_request"
@@ -31,15 +32,18 @@ module RubyLsp
     autoload :CodeActions, "ruby_lsp/requests/code_actions"
     autoload :DocumentHighlight, "ruby_lsp/requests/document_highlight"
     autoload :InlayHints, "ruby_lsp/requests/inlay_hints"
+    autoload :PathCompletion, "ruby_lsp/requests/path_completion"
 
     # :nodoc:
     module Support
       autoload :RuboCopDiagnostic, "ruby_lsp/requests/support/rubocop_diagnostic"
       autoload :SelectionRange, "ruby_lsp/requests/support/selection_range"
       autoload :SemanticTokenEncoder, "ruby_lsp/requests/support/semantic_token_encoder"
-      autoload :SyntaxErrorDiagnostic, "ruby_lsp/requests/support/syntax_error_diagnostic"
+      autoload :Annotation, "ruby_lsp/requests/support/annotation"
+      autoload :Sorbet, "ruby_lsp/requests/support/sorbet"
       autoload :HighlightTarget, "ruby_lsp/requests/support/highlight_target"
       autoload :RailsDocumentClient, "ruby_lsp/requests/support/rails_document_client"
+      autoload :PrefixTree, "ruby_lsp/requests/support/prefix_tree"
     end
   end
 end