solargraph 0.54.5 → 0.55.4

data/lib/solargraph/pin/method.rb

@@ -10,6 +10,8 @@ module Solargraph
       # @return [::Symbol] :public, :private, or :protected
       attr_reader :visibility
 
+      attr_writer :signatures
+
       # @return [Parser::AST::Node]
       attr_reader :node
 
@@ -116,13 +118,16 @@ module Solargraph
               name: name,
               decl: decl,
               presence: location ? location.range : nil,
-              return_type: ComplexType.try_parse(*p.types)
+              return_type: ComplexType.try_parse(*p.types),
+              source: source
             )
           end
           yield_return_type = ComplexType.try_parse(*yieldreturn_tags.flat_map(&:types))
-          block = Signature.new(generics: generics, parameters: yield_parameters, return_type: yield_return_type)
+          block = Signature.new(generics: generics, parameters: yield_parameters, return_type: yield_return_type, source: source)
         end
-        Signature.new(generics: generics, parameters: parameters, return_type: return_type, block: block)
+        signature = Signature.new(generics: generics, parameters: parameters, return_type: return_type, block: block, closure: self, source: source)
+        block.closure = signature if block
+        signature
       end
 
       # @return [::Array<Signature>]
@@ -163,12 +168,12 @@ module Solargraph
         end
       end
 
-      def desc
+      def inner_desc
         # ensure the signatures line up when logged
         if signatures.length > 1
-          "\n#{to_rbs}\n"
+          path + " \n#{to_rbs}\n"
         else
-          to_rbs
+          super
         end
       end
 
@@ -196,13 +201,14 @@ module Solargraph
         name.end_with?('?') ? ComplexType::BOOLEAN : ComplexType::UNDEFINED
       end
 
+      # @sg-ignore
       def documentation
         if @documentation.nil?
-          @documentation ||= super || ''
+          method_docs ||= super || ''
           param_tags = docstring.tags(:param)
           unless param_tags.nil? or param_tags.empty?
-            @documentation += "\n\n" unless @documentation.empty?
-            @documentation += "Params:\n"
+            method_docs += "\n\n" unless method_docs.empty?
+            method_docs += "Params:\n"
             lines = []
             param_tags.each do |p|
               l = "* #{p.name}"
@@ -210,12 +216,12 @@ module Solargraph
               l += " #{p.text}"
               lines.push l
             end
-            @documentation += lines.join("\n")
+            method_docs += lines.join("\n")
           end
           yieldparam_tags = docstring.tags(:yieldparam)
           unless yieldparam_tags.nil? or yieldparam_tags.empty?
-            @documentation += "\n\n" unless @documentation.empty?
-            @documentation += "Block Params:\n"
+            method_docs += "\n\n" unless method_docs.empty?
+            method_docs += "Block Params:\n"
             lines = []
             yieldparam_tags.each do |p|
               l = "* #{p.name}"
@@ -223,12 +229,12 @@ module Solargraph
               l += " #{p.text}"
               lines.push l
             end
-            @documentation += lines.join("\n")
+            method_docs += lines.join("\n")
           end
           yieldreturn_tags = docstring.tags(:yieldreturn)
           unless yieldreturn_tags.empty?
-            @documentation += "\n\n" unless @documentation.empty?
-            @documentation += "Block Returns:\n"
+            method_docs += "\n\n" unless method_docs.empty?
+            method_docs += "Block Returns:\n"
             lines = []
             yieldreturn_tags.each do |r|
               l = "*"
@@ -236,12 +242,12 @@ module Solargraph
               l += " #{r.text}"
               lines.push l
             end
-            @documentation += lines.join("\n")
+            method_docs += lines.join("\n")
           end
           return_tags = docstring.tags(:return)
           unless return_tags.empty?
-            @documentation += "\n\n" unless @documentation.empty?
-            @documentation += "Returns:\n"
+            method_docs += "\n\n" unless method_docs.empty?
+            method_docs += "Returns:\n"
             lines = []
             return_tags.each do |r|
               l = "*"
@@ -249,10 +255,11 @@ module Solargraph
               l += " #{r.text}"
               lines.push l
             end
-            @documentation += lines.join("\n")
+            method_docs += lines.join("\n")
           end
-          @documentation += "\n\n" unless @documentation.empty?
-          @documentation += "Visibility: #{visibility}"
+          method_docs += "\n\n" unless method_docs.empty?
+          method_docs += "Visibility: #{visibility}"
+          @documentation = method_docs
           concat_example_tags
         end
         @documentation.to_s
@@ -302,10 +309,12 @@ module Solargraph
                 name: name,
                 decl: decl,
                 presence: location ? location.range : nil,
-                return_type: param_type_from_name(tag, src.first)
+                return_type: param_type_from_name(tag, src.first),
+                source: :overloads
               )
             end,
-            return_type: ComplexType.try_parse(*tag.docstring.tags(:return).flat_map(&:types))
+            return_type: ComplexType.try_parse(*tag.docstring.tags(:return).flat_map(&:types)),
+            source: :overloads,
           )
         end
         @overloads
@@ -315,7 +324,7 @@ module Solargraph
         @anon_splat
       end
 
-      # @param [ApiMap]
+      # @param api_map [ApiMap]
       # @return [self]
       def resolve_ref_tag api_map
         return self if @resolved_ref_tag
@@ -342,8 +351,6 @@ module Solargraph
 
       attr_writer :block
 
-      attr_writer :signatures
-
       attr_writer :signature_help
 
       attr_writer :documentation
@@ -521,7 +528,7 @@ module Solargraph
 
       protected
 
-      attr_writer :signatures
+      attr_writer :return_type
     end
   end
 end

data/lib/solargraph/pin/namespace.rb

@@ -11,44 +11,52 @@ module Solargraph
       # @return [::Symbol] :class or :module
       attr_reader :type
 
+      # does not assert like super, as a namespace without a closure
+      # may be the root level namespace, or it may not yet be
+      # qualified
+      attr_reader :closure
+
       # @param type [::Symbol] :class or :module
       # @param visibility [::Symbol] :public or :private
       # @param gates [::Array<String>]
-      def initialize type: :class, visibility: :public, gates: [''], **splat
+      # @param name [String]
+      def initialize type: :class, visibility: :public, gates: [''], name: '', **splat
         # super(location, namespace, name, comments)
-        super(**splat)
+        super(**splat, name: name)
         @type = type
         @visibility = visibility
         if name.start_with?('::')
-          @name = name[2..-1]
+          # @type [String]
+          name = name[2..-1] || ''
           @closure = Solargraph::Pin::ROOT_PIN
         end
         @open_gates = gates
-        if @name.include?('::')
+        if name.include?('::')
           # In this case, a chained namespace was opened (e.g., Foo::Bar)
           # but Foo does not exist.
-          parts = @name.split('::')
-          @name = parts.pop
+          parts = name.split('::')
+          name = parts.pop
           closure_name = if [Solargraph::Pin::ROOT_PIN, nil].include?(closure)
             ''
           else
             closure.full_context.namespace + '::'
           end
           closure_name += parts.join('::')
-          @closure = Pin::Namespace.new(name: closure_name, gates: [parts.join('::')])
+          @closure = Pin::Namespace.new(name: closure_name, gates: [parts.join('::')], source: :namespace)
           @context = nil
         end
+        @name = name
       end
 
       def to_rbs
         "#{@type.to_s} #{return_type.all_params.first.to_rbs}#{rbs_generics}".strip
       end
 
-      def desc
+      def inner_desc
         if name.nil? || name.empty?
           '(top-level)'
         else
-          return_type.rooted_tags
+          super
         end
       end
 

data/lib/solargraph/pin/parameter.rb

@@ -9,14 +9,16 @@ module Solargraph
       # @return [String]
       attr_reader :asgn_code
 
+      # allow this to be set to the method after the method itself has
+      # been created
+      attr_writer :closure
+
       # @param decl [::Symbol] :arg, :optarg, :kwarg, :kwoptarg, :restarg, :kwrestarg, :block, :blockarg
       # @param asgn_code [String, nil]
-      # @param return_type [ComplexType, nil]
-      def initialize decl: :arg, asgn_code: nil, return_type: nil, **splat
+      def initialize decl: :arg, asgn_code: nil, **splat
         super(**splat)
         @asgn_code = asgn_code
         @decl = decl
-        @return_type = return_type
       end
 
       def keyword?
@@ -115,6 +117,15 @@ module Solargraph
         closure.is_a?(Pin::Block) ? typify_block_param(api_map) : typify_method_param(api_map)
       end
 
+      # @param atype [ComplexType]
+      # @param api_map [ApiMap]
+      def compatible_arg?(atype, api_map)
+        # make sure we get types from up the method
+        # inheritance chain if we don't have them on this pin
+        ptype = typify api_map
+        ptype.undefined? || ptype.can_assign?(api_map, atype) || ptype.generic?
+      end
+
       def documentation
         tag = param_tag
         return '' if tag.nil? || tag.text.nil?
@@ -141,8 +152,9 @@ module Solargraph
       # @param api_map [ApiMap]
       # @return [ComplexType]
       def typify_block_param api_map
-        if closure.is_a?(Pin::Block) && closure.receiver
-          return closure.typify_parameters(api_map)[index]
+        block_pin = closure
+        if block_pin.is_a?(Pin::Block) && block_pin.receiver
+          return block_pin.typify_parameters(api_map)[index]
         end
         ComplexType::UNDEFINED
       end

data/lib/solargraph/pin/proxy_type.rb

@@ -4,24 +4,30 @@ module Solargraph
   module Pin
     class ProxyType < Base
       # @param return_type [ComplexType]
-      def initialize return_type: ComplexType::UNDEFINED, **splat
+      def initialize return_type: ComplexType::UNDEFINED, binder: nil, **splat
         super(**splat)
         @return_type = return_type
+        @binder = binder if binder
       end
 
       def context
         @return_type
       end
 
-      # @param return_type [ComplexType]
+      # @param context [ComplexType, ComplexType::UniqueType] Used as context for this pin
+      # @param closure [Pin::Namespace, nil] Used as the closure for this pin
+      # @param binder [ComplexType, ComplexType::UniqueType, nil]
       # @return [ProxyType]
-      def self.anonymous return_type
-        parts = return_type.namespace.split('::')
-        namespace = parts[0..-2].join('::').to_s
+      def self.anonymous context, closure: nil, binder: nil, **kwargs
+        unless closure
+          parts = context.namespace.split('::')
+          namespace = parts[0..-2].join('::').to_s
+          closure = Solargraph::Pin::Namespace.new(name: namespace, source: :proxy_type)
+        end
         # name = parts.last.to_s
         # ProxyType.new(nil, namespace, name, return_type)
         ProxyType.new(
-          closure: Solargraph::Pin::Namespace.new(name: namespace), return_type: return_type
+          closure: closure, return_type: context, binder: binder || context, **kwargs
         )
       end
     end

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

@@ -10,18 +10,22 @@ module Solargraph
         # @return [::Array<Symbol>]
         attr_reader :delete
 
-        def initialize location, name, tags, delete = []
-          super(location: location, name: name)
+        def closure
+          nil
+        end
+
+        def initialize location, name, tags, delete = [], **splat
+          super(location: location, name: name, **splat)
           @tags = tags
           @delete = delete
         end
 
-        def self.method_return name, *tags, delete: []
-          new(nil, name, [YARD::Tags::Tag.new('return', nil, tags)], delete)
+        def self.method_return name, *tags, delete: [], **splat
+          new(nil, name, [YARD::Tags::Tag.new('return', nil, tags)], delete, **splat)
         end
 
-        def self.from_comment name, comment
-          new(nil, name, Solargraph::Source.parse_docstring(comment).to_docstring.tags)
+        def self.from_comment name, comment, **splat
+          new(nil, name, Solargraph::Source.parse_docstring(comment).to_docstring.tags, **splat)
         end
       end
     end

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

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

data/lib/solargraph/pin/signature.rb

@@ -1,6 +1,10 @@
 module Solargraph
   module Pin
     class Signature < Callable
+      # allow signature to be created before method pin, then set this
+      # to the method pin
+      attr_writer :closure
+
       def initialize **splat
         super(**splat)
       end

data/lib/solargraph/pin/singleton.rb

@@ -3,7 +3,7 @@
 module Solargraph
   module Pin
     class Singleton < Closure
-      def initialize name: '', location: nil, closure: nil
+      def initialize name: '', location: nil, closure: nil, **splat
         super
       end
     end

data/lib/solargraph/pin/symbol.rb

@@ -5,8 +5,9 @@ module Solargraph
     class Symbol < Base
       # @param location [Solargraph::Location]
       # @param name [String]
-      def initialize location, name
-        super(location: location, name: name)
+      def initialize(location, name, **kwargs)
+        # @sg-ignore "Unrecognized keyword argument kwargs to Solargraph::Pin::Base#initialize"
+        super(location: location, name: name, **kwargs)
         # @name = name
         # @location = location
       end

data/lib/solargraph/pin/until.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Until < Base
+      include Breakable
+
+      # @param receiver [Parser::AST::Node, nil]
+      # @param node [Parser::AST::Node, nil]
+      # @param context [ComplexType, nil]
+      # @param args [::Array<Parameter>]
+      def initialize node: nil, **splat
+        super(**splat)
+        @node = node
+      end
+    end
+  end
+end

data/lib/solargraph/pin/while.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class While < Base
+      include Breakable
+
+      # @param receiver [Parser::AST::Node, nil]
+      # @param node [Parser::AST::Node, nil]
+      # @param context [ComplexType, nil]
+      # @param args [::Array<Parameter>]
+      def initialize node: nil, **splat
+        super(**splat)
+        @node = node
+      end
+    end
+  end
+end

data/lib/solargraph/pin.rb

@@ -34,8 +34,11 @@ module Solargraph
     autoload :Singleton,        'solargraph/pin/singleton'
     autoload :KeywordParam,     'solargraph/pin/keyword_param'
     autoload :Search,           'solargraph/pin/search'
+    autoload :Breakable,        'solargraph/pin/breakable'
+    autoload :Until,            'solargraph/pin/until'
+    autoload :While,            'solargraph/pin/while'
     autoload :Callable,         'solargraph/pin/callable'
 
-    ROOT_PIN = Pin::Namespace.new(type: :class, name: '', closure: nil)
+    ROOT_PIN = Pin::Namespace.new(type: :class, name: '', closure: nil, source: :pin_rb)
   end
 end