solargraph 0.59.0 → 0.59.2

data/lib/solargraph/parser/parser_gem/node_processors/casgn_node.rb

@@ -1,36 +1,36 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module ParserGem
-      module NodeProcessors
-        class CasgnNode < Parser::NodeProcessor::Base
-          include ParserGem::NodeMethods
-
-          def process
-            pins.push Solargraph::Pin::Constant.new(
-              location: get_node_location(node),
-              closure: region.closure,
-              name: const_name,
-              comments: comments_for(node),
-              assignment: node.children[2],
-              source: :parser
-            )
-            process_children
-          end
-
-          private
-
-          # @return [String]
-          def const_name
-            if node.children[0]
-              Parser::NodeMethods.unpack_name(node.children[0]) + "::#{node.children[1]}"
-            else
-              node.children[1].to_s
-            end
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class CasgnNode < Parser::NodeProcessor::Base
+          include ParserGem::NodeMethods
+
+          def process
+            pins.push Solargraph::Pin::Constant.new(
+              location: get_node_location(node),
+              closure: region.closure,
+              name: const_name,
+              comments: comments_for(node),
+              assignment: node.children[2],
+              source: :parser
+            )
+            process_children
+          end
+
+          private
+
+          # @return [String]
+          def const_name
+            if node.children[0]
+              Parser::NodeMethods.unpack_name(node.children[0]) + "::#{node.children[1]}"
+            else
+              node.children[1].to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/parser_gem/node_processors/cvasgn_node.rb

@@ -1,24 +1,24 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module ParserGem
-      module NodeProcessors
-        class CvasgnNode < Parser::NodeProcessor::Base
-          def process
-            loc = get_node_location(node)
-            pins.push Solargraph::Pin::ClassVariable.new(
-              location: loc,
-              closure: region.closure,
-              name: node.children[0].to_s,
-              comments: comments_for(node),
-              assignment: node.children[1],
-              source: :parser
-            )
-            process_children
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class CvasgnNode < Parser::NodeProcessor::Base
+          def process
+            loc = get_node_location(node)
+            pins.push Solargraph::Pin::ClassVariable.new(
+              location: loc,
+              closure: region.closure,
+              name: node.children[0].to_s,
+              comments: comments_for(node),
+              assignment: node.children[1],
+              source: :parser
+            )
+            process_children
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/parser_gem/node_processors/gvasgn_node.rb

@@ -1,24 +1,24 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module ParserGem
-      module NodeProcessors
-        class GvasgnNode < Parser::NodeProcessor::Base
-          def process
-            loc = get_node_location(node)
-            pins.push Solargraph::Pin::GlobalVariable.new(
-              location: loc,
-              closure: region.closure,
-              name: node.children[0].to_s,
-              comments: comments_for(node),
-              assignment: node.children[1],
-              source: :parser
-            )
-            process_children
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class GvasgnNode < Parser::NodeProcessor::Base
+          def process
+            loc = get_node_location(node)
+            pins.push Solargraph::Pin::GlobalVariable.new(
+              location: loc,
+              closure: region.closure,
+              name: node.children[0].to_s,
+              comments: comments_for(node),
+              assignment: node.children[1],
+              source: :parser
+            )
+            process_children
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/parser_gem/node_processors/namespace_node.rb

@@ -1,40 +1,40 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module ParserGem
-      module NodeProcessors
-        class NamespaceNode < Parser::NodeProcessor::Base
-          include ParserGem::NodeMethods
-
-          def process
-            superclass_name = nil
-            superclass_name = unpack_name(node.children[1]) if node.type == :class && node.children[1]&.type == :const
-
-            loc = get_node_location(node)
-            nspin = Solargraph::Pin::Namespace.new(
-              type: node.type,
-              location: loc,
-              closure: region.closure,
-              name: unpack_name(node.children[0]),
-              comments: comments_for(node),
-              visibility: :public,
-              gates: region.closure.gates.freeze,
-              source: :parser
-            )
-            pins.push nspin
-            unless superclass_name.nil?
-              pins.push Pin::Reference::Superclass.new(
-                location: loc,
-                closure: pins.last,
-                name: superclass_name,
-                source: :parser
-              )
-            end
-            process_children region.update(closure: nspin, visibility: :public)
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class NamespaceNode < Parser::NodeProcessor::Base
+          include ParserGem::NodeMethods
+
+          def process
+            superclass_name = nil
+            superclass_name = unpack_name(node.children[1]) if node.type == :class && node.children[1]&.type == :const
+
+            loc = get_node_location(node)
+            nspin = Solargraph::Pin::Namespace.new(
+              type: node.type,
+              location: loc,
+              closure: region.closure,
+              name: unpack_name(node.children[0]),
+              comments: comments_for(node),
+              visibility: :public,
+              gates: region.closure.gates.freeze,
+              source: :parser
+            )
+            pins.push nspin
+            unless superclass_name.nil?
+              pins.push Pin::Reference::Superclass.new(
+                location: loc,
+                closure: pins.last,
+                name: superclass_name,
+                source: :parser
+              )
+            end
+            process_children region.update(closure: nspin, visibility: :public)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/parser/parser_gem/node_processors/sym_node.rb

@@ -1,20 +1,20 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Parser
-    module ParserGem
-      module NodeProcessors
-        class SymNode < Parser::NodeProcessor::Base
-          # @return [void]
-          def process
-            pins.push Solargraph::Pin::Symbol.new(
-              get_node_location(node),
-              ":#{node.children[0]}",
-              source: :parser
-            )
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class SymNode < Parser::NodeProcessor::Base
+          # @return [void]
+          def process
+            pins.push Solargraph::Pin::Symbol.new(
+              get_node_location(node),
+              ":#{node.children[0]}",
+              source: :parser
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/pin/base.rb

@@ -293,7 +293,7 @@ module Solargraph
       # @param attr [::Symbol]
       # @return [void]
       # @todo strong typechecking should complain when there are no block-related tags
-      def assert_same_array_content other, attr, &block
+      def assert_same_array_content(other, attr, &)
         arr1 = send(attr)
         raise "Expected #{attr} on #{self} to be an Enumerable, got #{arr1.class}" unless arr1.is_a?(::Enumerable)
         # @type arr1 [::Enumerable]
@@ -302,9 +302,9 @@ module Solargraph
         # @type arr2 [::Enumerable]
 
         # @type [undefined]
-        values1 = arr1.map(&block)
+        values1 = arr1.map(&)
         # @type [undefined]
-        values2 = arr2.map(&block)
+        values2 = arr2.map(&)
         # @sg-ignore
         return arr1 if values1 == values2
         Solargraph.assert_or_log(:"combine_with_#{attr}",

data/lib/solargraph/pin/method.rb

@@ -508,6 +508,7 @@ module Solargraph
         # @todo Stubbing this method while we debug an infinite loop bug in Ruby 3.x
         return same_type_arity_signatures
 
+        # rubocop:disable Lint/UnreachableCode
         # This is an O(n^2) operation, so bail out if n is not small
         return same_type_arity_signatures if same_type_arity_signatures.length > 10
 
@@ -534,6 +535,7 @@ module Solargraph
             end
           end
         end
+        # rubocop:enable Lint/UnreachableCode
       end
 
       # @param name [String]

data/lib/solargraph/pin/parameter.rb

@@ -31,7 +31,9 @@ module Solargraph
       end
 
       def combine_with other, attrs = {}
-        # Parameters can be combined with local variables
+        # Parameters can only be combined with local variables in the same closure
+        return self unless other.closure == closure
+
         new_attrs = if other.is_a?(Parameter)
                       {
                         decl: assert_same(other, :decl),

data/lib/solargraph/pin/reference/require.rb

@@ -1,14 +1,14 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class Reference
-      class Require < Reference
-        def initialize location, name, **splat
-          # super(location, '', name)
-          super(location: location, name: name, closure: Pin::ROOT_PIN, **splat)
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Reference
+      class Require < Reference
+        def initialize location, name, **splat
+          # super(location, '', name)
+          super(location: location, name: name, closure: Pin::ROOT_PIN, **splat)
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/pin/search.rb

@@ -41,11 +41,11 @@ module Solargraph
           match = [fuzzy_string_match(pin.path, @query), fuzzy_string_match(pin.name, @query)].max
           Result.new(match, pin) if match > 0.7
         end
-          .compact
-          # @param a [self]
-          # @param b [self]
-          # @sg-ignore https://github.com/castwide/solargraph/pull/1050
-          .sort { |a, b| b.match <=> a.match }
+             .compact
+             # @param a [self]
+             # @param b [self]
+             # @sg-ignore https://github.com/castwide/solargraph/pull/1050
+             .sort { |a, b| b.match <=> a.match }
              .map(&:pin)
       end
 

data/lib/solargraph/pin/singleton.rb

@@ -1,11 +1,11 @@
-# frozen_string_literal: true
-
-module Solargraph
-  module Pin
-    class Singleton < Closure
-      def initialize name: '', location: nil, closure: nil, **splat
-        super
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Singleton < Closure
+      def initialize name: '', location: nil, closure: nil, **splat
+        super
+      end
+    end
+  end
+end

data/lib/solargraph/rbs_map/conversions.rb

@@ -481,7 +481,7 @@ module Solargraph
         visibility = VISIBILITY_OVERRIDE[override_key]
         simple_override_key = [closure.path, scope]
         visibility ||= VISIBILITY_OVERRIDE[simple_override_key]
-        if closure.path == 'Kernel' && Kernel.private_instance_methods(false).include?(decl.name)
+        if closure.path == 'Kernel' && Kernel.private_method_defined?(decl.name, false)
           visibility ||= :private
         end
         if decl.kind == :singleton_instance
@@ -552,16 +552,19 @@ module Solargraph
       # @param pin [Pin::Method]
       # @return [void]
       def method_def_to_sigs decl, pin
+        # rubocop:disable Style/SafeNavigationChainLength
+        implicit_nil = decl.overloads.first&.annotations&.map(&:string)&.include?('implicitly-returns-nil') || false
+        # rubocop:enable Style/SafeNavigationChainLength
         # @param overload [RBS::AST::Members::MethodDefinition::Overload]
         decl.overloads.map do |overload|
           # @sg-ignore Wrong argument type for Solargraph::RbsMap::Conversions#location_decl_to_pin_location:
           #   location expected RBS::Location, nil, received RBS::Location<:type, :type_params>, RBS::AST::Members::Attribute::loc, nil
           type_location = location_decl_to_pin_location(overload.method_type.location)
           generics = type_parameter_names(overload.method_type)
-          signature_parameters, signature_return_type = parts_of_function(overload.method_type, pin)
+          signature_parameters, signature_return_type = parts_of_function(overload.method_type, pin, implicit_nil)
           rbs_block = overload.method_type.block
           block = if rbs_block
-                    block_parameters, block_return_type = parts_of_function(rbs_block, pin)
+                    block_parameters, block_return_type = parts_of_function(rbs_block, pin, implicit_nil)
                     Pin::Signature.new(generics: generics, parameters: block_parameters,
                                        return_type: block_return_type, source: :rbs,
                                        type_location: type_location, closure: pin)
@@ -588,14 +591,15 @@ module Solargraph
 
       # @param type [RBS::MethodType, RBS::Types::Block]
       # @param pin [Pin::Method]
+      # @param implicit_nil [Boolean]
       # @return [Array(Array<Pin::Parameter>, ComplexType)]
-      def parts_of_function type, pin
+      def parts_of_function type, pin, implicit_nil
         type_location = pin.type_location
         if defined?(RBS::Types::UntypedFunction) && type.type.is_a?(RBS::Types::UntypedFunction)
           return [
             [Solargraph::Pin::Parameter.new(decl: :restarg, name: 'arg', closure: pin, source: :rbs,
                                             type_location: type_location)],
-            method_type_to_type(type)
+            method_type_to_type(type, implicit_nil)
           ]
         end
 
@@ -659,7 +663,7 @@ module Solargraph
                                                          source: :rbs, type_location: type_location)
         end
 
-        return_type = method_type_to_type(type)
+        return_type = method_type_to_type(type, implicit_nil)
         [parameters, return_type]
       end
 
@@ -842,9 +846,12 @@ module Solargraph
       end
 
       # @param type [RBS::MethodType, RBS::Types::Block]
+      # @param implicit_nil [Boolean]
       # @return [ComplexType, ComplexType::UniqueType]
-      def method_type_to_type type
-        other_type_to_type type.type.return_type
+      def method_type_to_type type, implicit_nil
+        tag = other_type_to_type type.type.return_type
+        return ComplexType.parse("#{tag}, nil") if tag && implicit_nil
+        tag
       end
 
       # @param type [RBS::Types::Bases::Base,Object] RBS type object.

data/lib/solargraph/shell.rb

@@ -188,7 +188,7 @@ module Solargraph
         names.each do |name|
           if name == 'core'
             # @sg-ignore cache_core and core? are dynamically defined
-            PinCache.cache_core(out: $stdout) if !PinCache.core? || options[:rebuild]
+            PinCache.cache_core(out: $stdout) # if !PinCache.core? || options[:rebuild]
             next
           end
 

data/lib/solargraph/source/chain/array.rb

@@ -19,18 +19,7 @@ module Solargraph
         # @param name_pin [Pin::Base]
         # @param locals [::Array<Pin::Parameter, Pin::LocalVariable>]
         def resolve api_map, name_pin, locals
-          child_types = @children.map do |child|
-            child.infer(api_map, name_pin, locals).simplify_literals
-          end
-          type = if child_types.empty? || child_types.any?(&:undefined?)
-                   ComplexType::UniqueType.new('Array', rooted: true)
-                 elsif child_types.uniq.length == 1 && child_types.first.defined?
-                   ComplexType::UniqueType.new('Array', [], child_types.uniq, rooted: true, parameters_type: :list)
-                 elsif child_types.empty?
-                   ComplexType::UniqueType.new('Array', rooted: true, parameters_type: :list)
-                 else
-                   ComplexType::UniqueType.new('Array', [], child_types, rooted: true, parameters_type: :fixed)
-                 end
+          type = ComplexType::UniqueType.new('Array', rooted: true)
           [Pin::ProxyType.anonymous(type, source: :chain)]
         end
       end

data/lib/solargraph/source/chain/block_symbol.rb

@@ -1,13 +1,13 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class Source
-    class Chain
-      class BlockSymbol < Link
-        def resolve api_map, name_pin, locals
-          [Pin::ProxyType.anonymous(ComplexType.try_parse('::Proc'), source: :chain)]
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class BlockSymbol < Link
+        def resolve api_map, name_pin, locals
+          [Pin::ProxyType.anonymous(ComplexType.try_parse('::Proc'), source: :chain)]
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain/block_variable.rb

@@ -1,13 +1,13 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class Source
-    class Chain
-      class BlockVariable < Link
-        def resolve api_map, name_pin, locals
-          [Pin::ProxyType.anonymous(ComplexType.try_parse('::Proc'), source: :chain)]
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class BlockVariable < Link
+        def resolve api_map, name_pin, locals
+          [Pin::ProxyType.anonymous(ComplexType.try_parse('::Proc'), source: :chain)]
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain/head.rb

@@ -1,19 +1,19 @@
-# frozen_string_literal: true
-
-module Solargraph
-  class Source
-    class Chain
-      # Chain::Head is a link for ambiguous words, e.g.; `String` can refer to
-      # either a class (`String`) or a function (`Kernel#String`).
-      #
-      # @note Chain::Head is only intended to handle `self` and `super`.
-      class Head < Link
-        def resolve api_map, name_pin, locals
-          return [Pin::ProxyType.anonymous(name_pin.binder, source: :chain)] if word == 'self'
-          # return super_pins(api_map, name_pin) if word == 'super'
-          []
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      # Chain::Head is a link for ambiguous words, e.g.; `String` can refer to
+      # either a class (`String`) or a function (`Kernel#String`).
+      #
+      # @note Chain::Head is only intended to handle `self` and `super`.
+      class Head < Link
+        def resolve api_map, name_pin, locals
+          return [Pin::ProxyType.anonymous(name_pin.binder, source: :chain)] if word == 'self'
+          # return super_pins(api_map, name_pin) if word == 'super'
+          []
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain/literal.rb

@@ -13,21 +13,25 @@ module Solargraph
         def initialize type, node
           super("<#{type}>")
 
-          if node.is_a?(::Parser::AST::Node)
-            # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
-            if node.type == :true
-              @value = true
-            # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
-            elsif node.type == :false
-              @value = false
-            # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
-            elsif %i[int sym].include?(node.type)
-              # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
-              @value = node.children.first
-            end
-          end
+          # @todo We might be able to do some light inference from literals and
+          #   tuples as long as literal values are intransitive.
+
+          # if node.is_a?(::Parser::AST::Node)
+          #   # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
+          #   if node.type == :true
+          #     @value = true
+          #   # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
+          #   elsif node.type == :false
+          #     @value = false
+          #   # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
+          #   elsif %i[int sym].include?(node.type)
+          #     # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
+          #     @value = node.children.first
+          #   end
+          # end
           @type = type
-          @literal_type = ComplexType.try_parse(@value.inspect)
+          # @literal_type = ComplexType.try_parse(@value.inspect)
+          @literal_type = ComplexType::UNDEFINED
           @complex_type = ComplexType.try_parse(type)
         end