ruby-lsp 0.17.8 → 0.17.10

data/lib/ruby_lsp/requests/hover.rb

@@ -36,10 +36,10 @@ module RubyLsp
           global_state: GlobalState,
           position: T::Hash[Symbol, T.untyped],
           dispatcher: Prism::Dispatcher,
-          typechecker_enabled: T::Boolean,
+          sorbet_level: Document::SorbetLevel,
         ).void
       end
-      def initialize(document, global_state, position, dispatcher, typechecker_enabled)
+      def initialize(document, global_state, position, dispatcher, sorbet_level)
         super()
         node_context = document.locate_node(position, node_types: Listeners::Hover::ALLOWED_TARGETS)
         target = node_context.node
@@ -65,7 +65,7 @@ module RubyLsp
         @target = T.let(target, T.nilable(Prism::Node))
         uri = document.uri
         @response_builder = T.let(ResponseBuilders::Hover.new, ResponseBuilders::Hover)
-        Listeners::Hover.new(@response_builder, global_state, uri, node_context, dispatcher, typechecker_enabled)
+        Listeners::Hover.new(@response_builder, global_state, uri, node_context, dispatcher, sorbet_level)
         Addon.addons.each do |addon|
           addon.create_hover_listener(@response_builder, node_context, dispatcher)
         end

data/lib/ruby_lsp/requests/on_type_formatting.rb

@@ -32,8 +32,9 @@ module RubyLsp
 
       END_REGEXES = T.let(
         [
-          /\b(if|unless|for|while|class|module|until|def|case)\b.*/,
-          /.*\s\bdo\b/,
+          /\b(if|unless|for|while|until)\b($|\s|\()/,
+          /\b(class|module|def|case)\b($|\s)/,
+          /.*\s\bdo\b($|\s)/,
         ],
         T::Array[Regexp],
       )

data/lib/ruby_lsp/requests/signature_help.rb

@@ -46,10 +46,10 @@ module RubyLsp
           position: T::Hash[Symbol, T.untyped],
           context: T.nilable(T::Hash[Symbol, T.untyped]),
           dispatcher: Prism::Dispatcher,
-          typechecker_enabled: T::Boolean,
+          sorbet_level: Document::SorbetLevel,
         ).void
       end
-      def initialize(document, global_state, position, context, dispatcher, typechecker_enabled) # rubocop:disable Metrics/ParameterLists
+      def initialize(document, global_state, position, context, dispatcher, sorbet_level) # rubocop:disable Metrics/ParameterLists
         super()
         node_context = document.locate_node(
           { line: position[:line], character: position[:character] },
@@ -61,7 +61,7 @@ module RubyLsp
         @target = T.let(target, T.nilable(Prism::Node))
         @dispatcher = dispatcher
         @response_builder = T.let(ResponseBuilders::SignatureHelp.new, ResponseBuilders::SignatureHelp)
-        Listeners::SignatureHelp.new(@response_builder, global_state, node_context, dispatcher, typechecker_enabled)
+        Listeners::SignatureHelp.new(@response_builder, global_state, node_context, dispatcher, sorbet_level)
       end
 
       sig { override.returns(T.nilable(Interface::SignatureHelp)) }

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

@@ -130,13 +130,17 @@ module RubyLsp
             title: String,
             entries: T.any(T::Array[RubyIndexer::Entry], RubyIndexer::Entry),
             max_entries: T.nilable(Integer),
+            extra_links: T.nilable(String),
           ).returns(String)
         end
-        def markdown_from_index_entries(title, entries, max_entries = nil)
+        def markdown_from_index_entries(title, entries, max_entries = nil, extra_links: nil)
           categorized_markdown = categorized_markdown_from_index_entries(title, entries, max_entries)
 
+          markdown = +(categorized_markdown[:title] || "")
+          markdown << "\n\n#{extra_links}" if extra_links
+
           <<~MARKDOWN.chomp
-            #{categorized_markdown[:title]}
+            #{markdown}
 
             #{categorized_markdown[:links]}
 
@@ -204,6 +208,11 @@ module RubyLsp
             Constant::SymbolKind::FIELD
           end
         end
+
+        sig { params(sorbet_level: Document::SorbetLevel).returns(T::Boolean) }
+        def sorbet_level_true_or_higher?(sorbet_level)
+          sorbet_level == Document::SorbetLevel::True || sorbet_level == Document::SorbetLevel::Strict
+        end
       end
     end
   end

data/lib/ruby_lsp/server.rb

@@ -477,15 +477,17 @@ module RubyLsp
             @global_state,
             params[:position],
             dispatcher,
-            typechecker_enabled?(document),
+            sorbet_level(document),
           ).perform,
         ),
       )
     end
 
-    sig { params(document: Document).returns(T::Boolean) }
-    def typechecker_enabled?(document)
-      @global_state.has_type_checker && document.sorbet_sigil_is_true_or_higher
+    sig { params(document: Document).returns(Document::SorbetLevel) }
+    def sorbet_level(document)
+      return Document::SorbetLevel::Ignore unless @global_state.has_type_checker
+
+      document.sorbet_level
     end
 
     sig { params(message: T::Hash[Symbol, T.untyped]).void }
@@ -594,7 +596,7 @@ module RubyLsp
             document,
             @global_state,
             params,
-            typechecker_enabled?(document),
+            sorbet_level(document),
             dispatcher,
           ).perform,
         ),
@@ -624,7 +626,7 @@ module RubyLsp
             params[:position],
             params[:context],
             dispatcher,
-            typechecker_enabled?(document),
+            sorbet_level(document),
           ).perform,
         ),
       )
@@ -644,7 +646,7 @@ module RubyLsp
             @global_state,
             params[:position],
             dispatcher,
-            typechecker_enabled?(document),
+            sorbet_level(document),
           ).perform,
         ),
       )
@@ -763,8 +765,6 @@ module RubyLsp
       # stuck indexing files
       Thread.new do
         begin
-          RubyIndexer::RBSIndexer.new(@global_state.index).index_ruby_core
-
           @global_state.index.index_all do |percentage|
             progress("indexing-progress", percentage)
             true

data/lib/ruby_lsp/store.rb

@@ -38,13 +38,18 @@ module RubyLsp
       document = @state[uri.to_s]
       return document unless document.nil?
 
-      path = T.must(uri.to_standardized_path)
+      # For unsaved files (`untitled:Untitled-1` uris), there's no path to read from. If we don't have the untitled file
+      # already present in the store, then we have to raise non existing document error
+      path = uri.to_standardized_path
+      raise NonExistingDocumentError, uri.to_s unless path
+
       ext = File.extname(path)
       language_id = if ext == ".erb" || ext == ".rhtml"
         Document::LanguageId::ERB
       else
         Document::LanguageId::Ruby
       end
+
       set(uri: uri, source: File.binread(path), version: 0, language_id: language_id)
       T.must(@state[uri.to_s])
     rescue Errno::ENOENT

data/lib/ruby_lsp/test_helper.rb

@@ -21,7 +21,7 @@ module RubyLsp
       &block)
       server = RubyLsp::Server.new(test_mode: true)
       server.global_state.stubs(:has_type_checker).returns(false) if stub_no_typechecker
-      server.global_state.apply_options({})
+      server.global_state.apply_options({ initializationOptions: { experimentalFeaturesEnabled: true } })
       language_id = uri.to_s.end_with?(".erb") ? "erb" : "ruby"
 
       if source

data/lib/ruby_lsp/type_inferrer.rb

@@ -7,12 +7,16 @@ module RubyLsp
   class TypeInferrer
     extend T::Sig
 
-    sig { params(index: RubyIndexer::Index).void }
-    def initialize(index)
+    sig { params(experimental_features: T::Boolean).returns(T::Boolean) }
+    attr_writer :experimental_features
+
+    sig { params(index: RubyIndexer::Index, experimental_features: T::Boolean).void }
+    def initialize(index, experimental_features = true)
       @index = index
+      @experimental_features = experimental_features
     end
 
-    sig { params(node_context: NodeContext).returns(T.nilable(String)) }
+    sig { params(node_context: NodeContext).returns(T.nilable(Type)) }
     def infer_receiver_type(node_context)
       node = node_context.node
 
@@ -28,7 +32,7 @@ module RubyLsp
 
     private
 
-    sig { params(node: Prism::CallNode, node_context: NodeContext).returns(T.nilable(String)) }
+    sig { params(node: Prism::CallNode, node_context: NodeContext).returns(T.nilable(Type)) }
     def infer_receiver_for_call_node(node, node_context)
       receiver = node.receiver
 
@@ -47,23 +51,40 @@ module RubyLsp
         return unless name
 
         *parts, last = name.split("::")
-        return "#{last}::<Class:#{last}>" if parts.empty?
+        return Type.new("#{last}::<Class:#{last}>") if parts.empty?
+
+        Type.new("#{parts.join("::")}::#{last}::<Class:#{last}>")
+      else
+        return unless @experimental_features
+
+        raw_receiver = node.receiver&.slice
 
-        "#{parts.join("::")}::#{last}::<Class:#{last}>"
+        if raw_receiver
+          guessed_name = raw_receiver
+            .delete_prefix("@")
+            .delete_prefix("@@")
+            .split("_")
+            .map(&:capitalize)
+            .join
+
+          entries = @index.resolve(guessed_name, node_context.nesting) || @index.first_unqualified_const(guessed_name)
+          name = entries&.first&.name
+          GuessedType.new(name) if name
+        end
       end
     end
 
-    sig { params(node_context: NodeContext).returns(String) }
+    sig { params(node_context: NodeContext).returns(Type) }
     def self_receiver_handling(node_context)
       nesting = node_context.nesting
       # If we're at the top level, then the invocation is happening on `<main>`, which is a special singleton that
       # inherits from Object
-      return "Object" if nesting.empty?
-      return node_context.fully_qualified_name if node_context.surrounding_method
+      return Type.new("Object") if nesting.empty?
+      return Type.new(node_context.fully_qualified_name) if node_context.surrounding_method
 
       # If we're not inside a method, then we're inside the body of a class or module, which is a singleton
       # context
-      "#{nesting.join("::")}::<Class:#{nesting.last}>"
+      Type.new("#{nesting.join("::")}::<Class:#{nesting.last}>")
     end
 
     sig do
@@ -80,5 +101,22 @@ module RubyLsp
            Prism::ConstantPathNode::MissingNodesInConstantPathError
       nil
     end
+
+    # A known type
+    class Type
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      def initialize(name)
+        @name = name
+      end
+    end
+
+    # A type that was guessed based on the receiver raw name
+    class GuessedType < Type
+    end
   end
 end

data/lib/ruby_lsp/utils.rb

@@ -25,6 +25,7 @@ module RubyLsp
     end,
     String,
   )
+  GUESSED_TYPES_URL = "https://github.com/Shopify/ruby-lsp/blob/main/DESIGN_AND_ROADMAP.md#guessed-types"
 
   # A notification to be sent to the client
   class Message

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-lsp
 version: !ruby/object:Gem::Version
-  version: 0.17.8
+  version: 0.17.10
 platform: ruby
 authors:
 - Shopify
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-07-18 00:00:00.000000000 Z
+date: 2024-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: language_server-protocol
@@ -204,7 +204,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.15
+rubygems_version: 3.5.16
 signing_key:
 specification_version: 4
 summary: An opinionated language server for Ruby