solargraph 0.59.0 → 0.59.2

data/lib/solargraph/source/cursor.rb

@@ -115,8 +115,17 @@ module Solargraph
       def recipient
         @recipient ||= begin
           node = recipient_node
-          # @sg-ignore Need to add nil check here
-          node ? Cursor.new(source, Range.from_node(node).ending) : nil
+          if node.nil?
+            nil
+          else
+            rng = Range.from_node(node)
+            if rng
+              Cursor.new(source, rng.ending)
+            else
+              pos = Position.new(position.line, [position.column - 1, 0].max)
+              Cursor.new(source, pos)
+            end
+          end
         end
       end
       alias receiver recipient

data/lib/solargraph/source/source_chainer.rb

@@ -32,10 +32,10 @@ module Solargraph
       # @return [Source::Chain]
       def chain
         # Special handling for files that end with an integer and a period
-        if phrase =~ /^[0-9]+\.$/
-          return Chain.new([Chain::Literal.new('Integer', Integer(phrase[0..-2])),
-                            Chain::UNDEFINED_CALL])
-        end
+        # if phrase =~ /^[0-9]+\.$/
+        #   return Chain.new([Chain::Literal.new('Integer', Integer(phrase[0..-2])),
+        #                     Chain::UNDEFINED_CALL])
+        # end
         if phrase.start_with?(':') && !phrase.start_with?('::')
           return Chain.new([Chain::Literal.new('Symbol',
                                                # @sg-ignore Need to add nil check here

data/lib/solargraph/source_map/clip.rb

@@ -54,8 +54,13 @@ module Solargraph
       # @return [Array<Pin::Method>]
       def signify
         return [] unless cursor.argument?
+        return [] if cursor.recipient_node.nil?
         chain = Parser.chain(cursor.recipient_node, cursor.filename)
-        chain.define(api_map, context_pin, locals).select { |pin| pin.is_a?(Pin::Method) }
+        name_pin = context_pin
+        if name_pin.nil?
+          name_pin = Pin::ProxyType.anonymous(ComplexType.try_parse('::Object'))
+        end
+        chain.define(api_map, name_pin, locals).select { |pin| pin.is_a?(Pin::Method) }
       end
 
       # @return [ComplexType]

data/lib/solargraph/type_checker.rb

@@ -283,7 +283,7 @@ module Solargraph
 
     # @return [Array<Pin::BaseVariable>]
     def all_variables
-      source_map.pins_by_class(Pin::BaseVariable) + source_map.locals.select { |pin| pin.is_a?(Pin::LocalVariable) }
+      source_map.pins_by_class(Pin::BaseVariable) + source_map.locals.grep(Pin::LocalVariable)
     end
 
     # @return [Array<Problem>]
@@ -773,9 +773,9 @@ module Solargraph
         return [] if parameters.any?(&:rest?)
         opt = optional_param_count(parameters)
         return [] if unchecked.length <= req + opt
-        if req + add_params + 1 == unchecked.length && any_splatted_call?(unchecked.map(&:node)) && (parameters.map(&:decl) & %i[
-          kwarg kwoptarg kwrestarg
-        ]).any?
+        if req + add_params + 1 == unchecked.length && any_splatted_call?(unchecked.map(&:node)) && parameters.map(&:decl).intersect?(%i[
+                                                                                                                                        kwarg kwoptarg kwrestarg
+                                                                                                                                      ])
           return []
         end
         return [] if arguments.length - req == parameters.select { |p| %i[optarg kwoptarg].include?(p.decl) }.length

data/lib/solargraph/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Solargraph
-  VERSION = ENV.fetch('SOLARGRAPH_FORCE_VERSION', '0.59.0')
+  VERSION = ENV.fetch('SOLARGRAPH_FORCE_VERSION', '0.59.2')
 end

data/lib/solargraph/yard_map/cache.rb

@@ -1,25 +1,25 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class YardMap
-    class Cache
-      def initialize
-        # @type [Hash{String => Array<Solargraph::Pin::Base>}]
-        @path_pins = {}
-      end
-
-      # @param path [String]
-      # @param pins [Array<Solargraph::Pin::Base>]
-      # @return [Array<Solargraph::Pin::Base>]
-      def set_path_pins path, pins
-        @path_pins[path] = pins
-      end
-
-      # @param path [String]
-      # @return [Array<Solargraph::Pin::Base>]
-      def get_path_pins path
-        @path_pins[path]
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  class YardMap
+    class Cache
+      def initialize
+        # @type [Hash{String => Array<Solargraph::Pin::Base>}]
+        @path_pins = {}
+      end
+
+      # @param path [String]
+      # @param pins [Array<Solargraph::Pin::Base>]
+      # @return [Array<Solargraph::Pin::Base>]
+      def set_path_pins path, pins
+        @path_pins[path] = pins
+      end
+
+      # @param path [String]
+      # @return [Array<Solargraph::Pin::Base>]
+      def get_path_pins path
+        @path_pins[path]
+      end
+    end
+  end
+end

data/lib/solargraph/yard_map/mapper/to_constant.rb

@@ -1,28 +1,28 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class YardMap
-    class Mapper
-      module ToConstant
-        extend YardMap::Helpers
-
-        # @param code_object [YARD::CodeObjects::Base]
-        # @param closure [Pin::Closure, nil]
-        # @param spec [Gem::Specification, nil]
-        # @return [Pin::Constant]
-        def self.make code_object, closure = nil, spec = nil
-          closure ||= create_closure_namespace_for(code_object, spec)
-
-          Pin::Constant.new(
-            location: object_location(code_object, spec),
-            closure: closure,
-            name: code_object.name.to_s,
-            comments: code_object.docstring ? code_object.docstring.all.to_s : '',
-            visibility: code_object.visibility,
-            source: :yardoc
-          )
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  class YardMap
+    class Mapper
+      module ToConstant
+        extend YardMap::Helpers
+
+        # @param code_object [YARD::CodeObjects::Base]
+        # @param closure [Pin::Closure, nil]
+        # @param spec [Gem::Specification, nil]
+        # @return [Pin::Constant]
+        def self.make code_object, closure = nil, spec = nil
+          closure ||= create_closure_namespace_for(code_object, spec)
+
+          Pin::Constant.new(
+            location: object_location(code_object, spec),
+            closure: closure,
+            name: code_object.name.to_s,
+            comments: code_object.docstring ? code_object.docstring.all.to_s : '',
+            visibility: code_object.visibility,
+            source: :yardoc
+          )
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/yard_map/mapper/to_method.rb

@@ -32,7 +32,7 @@ module Solargraph
           # @sg-ignore Need to add nil check here
           final_visibility ||= VISIBILITY_OVERRIDE[[closure.path, final_scope]]
           # @sg-ignore Need to add nil check here
-          if closure.path == 'Kernel' && Kernel.private_instance_methods(false).include?(name.to_sym)
+          if closure.path == 'Kernel' && Kernel.private_method_defined?(name.to_sym, false)
             final_visibility ||= :private
           end
           final_visibility ||= visibility

data/lib/solargraph.rb

@@ -113,13 +113,13 @@ module Solargraph
   # @yieldreturn [generic<T>]
   # @sg-ignore dynamic call, but both functions behave the same
   # @return [generic<T>]
-  def self.with_clean_env &block
+  def self.with_clean_env(&)
     meth = if Bundler.respond_to?(:with_original_env)
              :with_original_env
            else
              :with_clean_env
            end
-    Bundler.send meth, &block
+    Bundler.send(meth, &)
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solargraph
 version: !ruby/object:Gem::Version
-  version: 0.59.0
+  version: 0.59.2
 platform: ruby
 authors:
 - Fred Snyder
@@ -804,7 +804,6 @@ files:
 - rbs/fills/rubygems/0/errors.rbs
 - rbs/fills/rubygems/0/spec_fetcher.rbs
 - rbs/fills/rubygems/0/specification.rbs
-- rbs/fills/tuple/tuple.rbs
 - rbs/shims/ast/0/node.rbs
 - rbs/shims/ast/2.4/.rbs_meta.yaml
 - rbs/shims/ast/2.4/ast.rbs

data/rbs/fills/tuple/tuple.rbs

@@ -1,177 +0,0 @@
-# <-- liberally borrowed from
-#     https://github.com/ruby/rbs/blob/master/core/array.rbs, which
-#     was generated from
-#     https://github.com/ruby/ruby/blob/master/array.c
-#     -->
-module Solargraph
-  module Fills
-    class Tuple[unchecked out A,
-                unchecked out B = A,
-                unchecked out C = A | B,
-                unchecked out D = A | B | C,
-                unchecked out E = A | B | C | D,
-                unchecked out F = A | B | C | D | E,
-                unchecked out G = A | B | C | D | E | F,
-                unchecked out H = A | B | C | D | E | F | G,
-                unchecked out I = A | B | C | D | E | F | G | H,
-                unchecked out J = A | B | C | D | E | F | G | H | I] < Array[A | B | C | D | E | F | G | H | I | J]
-      # <!--
-      #   rdoc-file=array.c
-      #   - self[index] -> object or nil
-      # -->
-      # Returns elements from `self`; does not modify `self`.
-      #
-      # In brief:
-      #
-      #     a = [:foo, 'bar', 2]
-      #
-      #     # Single argument index: returns one element.
-      #     a[0]     # => :foo          # Zero-based index.
-      #
-      # When a single integer argument `index` is given, returns the element at offset
-      # `index`:
-      #
-      #     a = [:foo, 'bar', 2]
-      #     a[0] # => :foo
-      #     a[2] # => 2
-      #     a # => [:foo, "bar", 2]
-      def []: (0 index) -> A
-            | (1 index) -> B
-            | (2 index) -> C
-            | (3 index) -> D
-            | (4 index) -> E
-            | (5 index) -> F
-            | (6 index) -> G
-            | (7 index) -> H
-            | (8 index) -> I
-            | (9 index) -> J
-            | (int index) -> nil
-
-      # <!--
-      #   rdoc-file=array.c
-      #   - at(index) -> object or nil
-      # -->
-      # Returns the element of `self` specified by the given `index` or `nil` if there
-      # is no such element; `index` must be an [integer-convertible
-      # object](rdoc-ref:implicit_conversion.rdoc@Integer-Convertible+Objects).
-      #
-      # For non-negative `index`, returns the element of `self` at offset `index`:
-      #
-      #     a = [:foo, 'bar', 2]
-      #     a.at(0)   # => :foo
-      #     a.at(2)   # => 2
-      #     a.at(2.0) # => 2
-      #
-      # Related: Array#[]; see also [Methods for
-      # Fetching](rdoc-ref:Array@Methods+for+Fetching).
-      #
-      def at: (0 index) -> A
-            | (1 index) -> B
-            | (2 index) -> C
-            | (3 index) -> D
-            | (4 index) -> E
-            | (5 index) -> F
-            | (6 index) -> G
-            | (7 index) -> H
-            | (8 index) -> I
-            | (9 index) -> J
-            | (int index) -> nil
-
-      # <!--
-      #   rdoc-file=array.c
-      #   - fetch(index) -> element
-      #   - fetch(index, default_value) -> element or default_value
-      #   - fetch(index) {|index| ... } -> element or block_return_value
-      # -->
-      # Returns the element of `self` at offset `index` if `index` is in range;
-      # `index` must be an [integer-convertible
-      # object](rdoc-ref:implicit_conversion.rdoc@Integer-Convertible+Objects).
-      #
-      # With the single argument `index` and no block, returns the element at offset
-      # `index`:
-      #
-      #     a = [:foo, 'bar', 2]
-      #     a.fetch(1)   # => "bar"
-      #     a.fetch(1.1) # => "bar"
-      #
-      # With arguments `index` and `default_value` (which may be any object) and no
-      # block, returns `default_value` if `index` is out-of-range:
-      #
-      #     a = [:foo, 'bar', 2]
-      #     a.fetch(1, nil)  # => "bar"
-      #     a.fetch(3, :foo) # => :foo
-      #
-      # With argument `index` and a block, returns the element at offset `index` if
-      # index is in range (and the block is not called); otherwise calls the block
-      # with index and returns its return value:
-      #
-      #     a = [:foo, 'bar', 2]
-      #     a.fetch(1) {|index| raise 'Cannot happen' } # => "bar"
-      #     a.fetch(50) {|index| "Value for #{index}" } # => "Value for 50"
-      #
-      # Related: see [Methods for Fetching](rdoc-ref:Array@Methods+for+Fetching).
-      #
-      def fetch: (0 index) -> A
-               | (1 index) -> B
-               | (2 index) -> C
-               | (3 index) -> D
-               | (4 index) -> E
-               | (5 index) -> F
-               | (6 index) -> G
-               | (7 index) -> H
-               | (8 index) -> I
-               | (9 index) -> J
-               | (int index) -> void
-               | [T] (0 index, T default) -> (A | T)
-               | [T] (1 index, T default) -> (B | T)
-               | [T] (2 index, T default) -> (C | T)
-               | [T] (3 index, T default) -> (D | T)
-               | [T] (4 index, T default) -> (E | T)
-               | [T] (5 index, T default) -> (F | T)
-               | [T] (6 index, T default) -> (G | T)
-               | [T] (7 index, T default) -> (H | T)
-               | [T] (8 index, T default) -> (I | T)
-               | [T] (9 index, T default) -> (J | T)
-               | [T] (int index, T default) -> (A | B | C | D | E | F | G | H | I | J | T)
-               | [T] (0 index) { (int index) -> T } -> (A | T)
-               | [T] (1 index) { (int index) -> T } -> (B | T)
-               | [T] (2 index) { (int index) -> T } -> (C | T)
-               | [T] (3 index) { (int index) -> T } -> (D | T)
-               | [T] (4 index) { (int index) -> T } -> (E | T)
-               | [T] (5 index) { (int index) -> T } -> (F | T)
-               | [T] (6 index) { (int index) -> T } -> (G | T)
-               | [T] (7 index) { (int index) -> T } -> (H | T)
-               | [T] (8 index) { (int index) -> T } -> (I | T)
-               | [T] (9 index) { (int index) -> T } -> (J | T)
-               | [T] (int index) { (int index) -> T } -> (A | B | C | D | E | F | G | H | I | J | T)
-
-      # <!--
-      #   rdoc-file=array.rb
-      #   - first -> object or nil
-      #   - first(count) -> new_array
-      # -->
-      # Returns elements from `self`, or `nil`; does not modify `self`.
-      #
-      # With no argument given, returns the first element (if available):
-      #
-      #     a = [:foo, 'bar', 2]
-      #     a.first # => :foo
-      #     a # => [:foo, "bar", 2]
-      #
-      # If `self` is empty, returns `nil`.
-      #
-      #     [].first # => nil
-      #
-      # With a non-negative integer argument `count` given, returns the first `count`
-      # elements (as available) in a new array:
-      #
-      #     a.first(0)  # => []
-      #     a.first(2)  # => [:foo, "bar"]
-      #     a.first(50) # => [:foo, "bar", 2]
-      #
-      # Related: see [Methods for Querying](rdoc-ref:Array@Methods+for+Querying).
-      #
-      def first: %a{implicitly-returns-nil} () -> A
-    end
-  end
-end