solargraph 0.52.0 → 0.53.4

data/lib/solargraph/parser/{legacy → parser_gem}/node_processors/defs_node.rb

@@ -2,10 +2,10 @@
 
 module Solargraph
   module Parser
-    module Legacy
+    module ParserGem
       module NodeProcessors
         class DefsNode < DefNode
-          include Legacy::NodeMethods
+          include ParserGem::NodeMethods
 
           def process
             s_visi = region.visibility

data/lib/solargraph/parser/{legacy → parser_gem}/node_processors/gvasgn_node.rb

@@ -2,7 +2,7 @@
 
 module Solargraph
   module Parser
-    module Legacy
+    module ParserGem
       module NodeProcessors
         class GvasgnNode < Parser::NodeProcessor::Base
           def process

data/lib/solargraph/parser/{legacy → parser_gem}/node_processors/ivasgn_node.rb

@@ -2,10 +2,10 @@
 
 module Solargraph
   module Parser
-    module Legacy
+    module ParserGem
       module NodeProcessors
         class IvasgnNode < Parser::NodeProcessor::Base
-          include Legacy::NodeMethods
+          include ParserGem::NodeMethods
 
           def process
             loc = get_node_location(node)

data/lib/solargraph/parser/{legacy → parser_gem}/node_processors/lvasgn_node.rb

@@ -2,10 +2,10 @@
 
 module Solargraph
   module Parser
-    module Legacy
+    module ParserGem
       module NodeProcessors
         class LvasgnNode < Parser::NodeProcessor::Base
-          include Legacy::NodeMethods
+          include ParserGem::NodeMethods
 
           def process
             here = get_node_start_position(node)

data/lib/solargraph/parser/{legacy → parser_gem}/node_processors/namespace_node.rb

@@ -2,10 +2,10 @@
 
 module Solargraph
   module Parser
-    module Legacy
+    module ParserGem
       module NodeProcessors
         class NamespaceNode < Parser::NodeProcessor::Base
-          include Legacy::NodeMethods
+          include ParserGem::NodeMethods
 
           def process
             sc = nil

data/lib/solargraph/parser/{legacy → parser_gem}/node_processors/orasgn_node.rb

@@ -2,7 +2,7 @@
 
 module Solargraph
   module Parser
-    module Legacy
+    module ParserGem
       module NodeProcessors
         class OrasgnNode < Parser::NodeProcessor::Base
           def process

data/lib/solargraph/parser/{legacy → parser_gem}/node_processors/resbody_node.rb

@@ -2,13 +2,13 @@
 
 module Solargraph
   module Parser
-    module Legacy
+    module ParserGem
       module NodeProcessors
         class ResbodyNode < Parser::NodeProcessor::Base
-          include Legacy::NodeMethods
+          include ParserGem::NodeMethods
 
           def process
-            if node.children[1]
+            if node.children[1] # Exception local variable name
               here = get_node_start_position(node.children[1])
               presence = Range.new(here, region.closure.location.range.ending)
               loc = get_node_location(node.children[1])

data/lib/solargraph/parser/{legacy → parser_gem}/node_processors/sclass_node.rb

@@ -2,7 +2,7 @@
 
 module Solargraph
   module Parser
-    module Legacy
+    module ParserGem
       module NodeProcessors
         class SclassNode < Parser::NodeProcessor::Base
           def process

data/lib/solargraph/parser/{legacy → parser_gem}/node_processors/send_node.rb

@@ -2,10 +2,10 @@
 
 module Solargraph
   module Parser
-    module Legacy
+    module ParserGem
       module NodeProcessors
         class SendNode < Parser::NodeProcessor::Base
-          include Legacy::NodeMethods
+          include ParserGem::NodeMethods
 
           def process
             if node.children[0].nil?

data/lib/solargraph/parser/{rubyvm → parser_gem}/node_processors/sym_node.rb

@@ -2,7 +2,7 @@
 
 module Solargraph
   module Parser
-    module Rubyvm
+    module ParserGem
       module NodeProcessors
         class SymNode < Parser::NodeProcessor::Base
           def process

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'solargraph/parser/node_processor'
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        autoload :BeginNode,     'solargraph/parser/parser_gem/node_processors/begin_node'
+        autoload :DefNode,       'solargraph/parser/parser_gem/node_processors/def_node'
+        autoload :DefsNode,      'solargraph/parser/parser_gem/node_processors/defs_node'
+        autoload :SendNode,      'solargraph/parser/parser_gem/node_processors/send_node'
+        autoload :NamespaceNode, 'solargraph/parser/parser_gem/node_processors/namespace_node'
+        autoload :SclassNode,    'solargraph/parser/parser_gem/node_processors/sclass_node'
+        autoload :IvasgnNode,    'solargraph/parser/parser_gem/node_processors/ivasgn_node'
+        autoload :CvasgnNode,    'solargraph/parser/parser_gem/node_processors/cvasgn_node'
+        autoload :LvasgnNode,    'solargraph/parser/parser_gem/node_processors/lvasgn_node'
+        autoload :GvasgnNode,    'solargraph/parser/parser_gem/node_processors/gvasgn_node'
+        autoload :CasgnNode,     'solargraph/parser/parser_gem/node_processors/casgn_node'
+        autoload :AliasNode,     'solargraph/parser/parser_gem/node_processors/alias_node'
+        autoload :ArgsNode,      'solargraph/parser/parser_gem/node_processors/args_node'
+        autoload :BlockNode,     'solargraph/parser/parser_gem/node_processors/block_node'
+        autoload :OrasgnNode,    'solargraph/parser/parser_gem/node_processors/orasgn_node'
+        autoload :SymNode,       'solargraph/parser/parser_gem/node_processors/sym_node'
+        autoload :ResbodyNode,   'solargraph/parser/parser_gem/node_processors/resbody_node'
+      end
+    end
+
+    module NodeProcessor
+      register :source,       ParserGem::NodeProcessors::BeginNode
+      register :begin,        ParserGem::NodeProcessors::BeginNode
+      register :kwbegin,      ParserGem::NodeProcessors::BeginNode
+      register :rescue,       ParserGem::NodeProcessors::BeginNode
+      register :resbody,      ParserGem::NodeProcessors::ResbodyNode
+      register :def,          ParserGem::NodeProcessors::DefNode
+      register :defs,         ParserGem::NodeProcessors::DefsNode
+      register :send,         ParserGem::NodeProcessors::SendNode
+      register :class,        ParserGem::NodeProcessors::NamespaceNode
+      register :module,       ParserGem::NodeProcessors::NamespaceNode
+      register :sclass,       ParserGem::NodeProcessors::SclassNode
+      register :ivasgn,       ParserGem::NodeProcessors::IvasgnNode
+      register :cvasgn,       ParserGem::NodeProcessors::CvasgnNode
+      register :lvasgn,       ParserGem::NodeProcessors::LvasgnNode
+      register :gvasgn,       ParserGem::NodeProcessors::GvasgnNode
+      register :casgn,        ParserGem::NodeProcessors::CasgnNode
+      register :alias,        ParserGem::NodeProcessors::AliasNode
+      register :args,         ParserGem::NodeProcessors::ArgsNode
+      register :forward_args, ParserGem::NodeProcessors::ArgsNode
+      register :block,        ParserGem::NodeProcessors::BlockNode
+      register :or_asgn,      ParserGem::NodeProcessors::OrasgnNode
+      register :sym,          ParserGem::NodeProcessors::SymNode
+    end
+  end
+end

data/lib/solargraph/parser/parser_gem.rb

@@ -0,0 +1,12 @@
+module Solargraph
+  module Parser
+    module ParserGem
+      autoload :FlawedBuilder, 'solargraph/parser/parser_gem/flawed_builder'
+      autoload :ClassMethods, 'solargraph/parser/parser_gem/class_methods'
+      autoload :NodeMethods, 'solargraph/parser/parser_gem/node_methods'
+      autoload :NodeChainer, 'solargraph/parser/parser_gem/node_chainer'
+    end
+  end
+end
+
+require 'solargraph/parser/parser_gem/node_processors'

data/lib/solargraph/parser/snippet.rb

@@ -1,7 +1,9 @@
 module Solargraph
   module Parser
     class Snippet
+      # @return [Range]
       attr_reader :range
+      # @return [String]
       attr_reader :text
 
       def initialize range, text

data/lib/solargraph/parser.rb

@@ -1,8 +1,7 @@
 module Solargraph
   module Parser
     autoload :CommentRipper, 'solargraph/parser/comment_ripper'
-    autoload :Legacy, 'solargraph/parser/legacy'
-    autoload :Rubyvm, 'solargraph/parser/rubyvm'
+    autoload :ParserGem, 'solargraph/parser/parser_gem'
     autoload :Region, 'solargraph/parser/region'
     autoload :NodeProcessor, 'solargraph/parser/node_processor'
     autoload :Snippet, 'solargraph/parser/snippet'
@@ -10,19 +9,17 @@ module Solargraph
     class SyntaxError < StandardError
     end
 
-    # True if the parser can use RubyVM.
-    #
     def self.rubyvm?
-      # !!defined?(RubyVM::AbstractSyntaxTree)
       false
     end
 
-    selected = rubyvm? ? Rubyvm : Legacy
-    # include selected
-    # @!parse
-    #   extend Solargraph::Parser::Legacy::ClassMethods
-    extend selected::ClassMethods
+    # @deprecated
+    Legacy = ParserGem
 
-    NodeMethods = (rubyvm? ? Rubyvm::NodeMethods : Legacy::NodeMethods)
+    ClassMethods = ParserGem::ClassMethods
+
+    extend ParserGem::ClassMethods
+
+    NodeMethods = ParserGem::NodeMethods
   end
 end

data/lib/solargraph/pin/base.rb

@@ -25,7 +25,6 @@ module Solargraph
       attr_accessor :source
 
       # @param location [Solargraph::Location, nil]
-      # @param kind [Integer]
       # @param closure [Solargraph::Pin::Closure, nil]
       # @param name [String]
       # @param comments [String]
@@ -41,6 +40,43 @@ module Solargraph
         @comments ||= ''
       end
 
+      # @param generics_to_resolve [Enumerable<String>]
+      # @param return_type_context [ComplexType, nil]
+      # @param context [ComplexType]
+      # @param resolved_generic_values [Hash{String => ComplexType}]
+      # @return [self]
+      def resolve_generics_from_context(generics_to_resolve, return_type_context = nil, resolved_generic_values: {})
+        proxy return_type.resolve_generics_from_context(generics_to_resolve,
+                                                        return_type_context,
+                                                        resolved_generic_values: resolved_generic_values)
+      end
+
+      # @yieldparam [ComplexType]
+      # @yieldreturn [ComplexType]
+      # @return [self]
+      def transform_types(&transform)
+        proxy return_type.transform(&transform)
+      end
+
+      # Determine the concrete type for each of the generic type
+      # parameters used in this method based on the parameters passed
+      # into the its class and return a new method pin.
+      #
+      # @param definitions [Pin::Namespace] The module/class which uses generic types
+      # @param context_type [ComplexType] The receiver type
+      # @return [self]
+      def resolve_generics definitions, context_type
+        transformed = transform_types { |t| t.resolve_generics(definitions, context_type) if t }
+        transformed.erase_generics(definitions.generics)
+      end
+
+      # @param generics_to_erase [Enumerable<String>]
+      # @return [self]
+      def erase_generics(generics_to_erase)
+        return self if generics_to_erase.empty?
+        transform_types { |t| t.erase_generics(generics_to_erase) }
+      end
+
       # @return [String, nil]
       def filename
         return nil if location.nil?
@@ -58,7 +94,7 @@ module Solargraph
       end
 
       def to_s
-        name.to_s
+        to_rbs
       end
 
       # @return [Boolean]
@@ -103,13 +139,13 @@ module Solargraph
         @docstring ||= Solargraph::Source.parse_docstring('').to_docstring
       end
 
-      # @return [Array<YARD::Tags::Directive>]
+      # @return [::Array<YARD::Tags::Directive>]
       def directives
         parse_comments unless defined?(@directives)
         @directives
       end
 
-      # @return [Array<YARD::Tags::MacroDirective>]
+      # @return [::Array<YARD::Tags::MacroDirective>]
       def macros
         @macros ||= collect_macros
       end
@@ -216,12 +252,31 @@ module Solargraph
         result
       end
 
+      # @return [String]
       def identity
         @identity ||= "#{closure.path}|#{name}"
       end
 
+      # @return [String, nil]
+      def to_rbs
+        return_type.to_rbs
+      end
+
+      # @return [String, nil]
+      def desc
+        if path
+          if to_rbs
+            path + ' ' + to_rbs
+          else
+            path
+          end
+        else
+          to_rbs
+        end
+      end
+
       def inspect
-        "#<#{self.class} `#{self.path}` at #{self.location.inspect}>"
+        "#<#{self.class} `#{self.desc}` at #{self.location.inspect}>"
       end
 
       protected
@@ -266,8 +321,8 @@ module Solargraph
         true
       end
 
-      # @param dir1 [Array<YARD::Tags::Directive>]
-      # @param dir2 [Array<YARD::Tags::Directive>]
+      # @param dir1 [::Array<YARD::Tags::Directive>]
+      # @param dir2 [::Array<YARD::Tags::Directive>]
       # @return [Boolean]
       def compare_directives dir1, dir2
         return false if dir1.length != dir2.length
@@ -288,7 +343,7 @@ module Solargraph
           tag1.types == tag2.types
       end
 
-      # @return [Array<YARD::Tags::Handlers::Directive>]
+      # @return [::Array<YARD::Tags::Handlers::Directive>]
       def collect_macros
         return [] unless maybe_directives?
         parse = Solargraph::Source.parse_docstring(comments)

data/lib/solargraph/pin/base_variable.rb

@@ -39,7 +39,7 @@ module Solargraph
       def probe api_map
         return ComplexType::UNDEFINED if @assignment.nil?
         types = []
-        returns_from(@assignment).each do |node|
+        value_position_nodes_only(@assignment).each do |node|
           # Nil nodes may not have a location
           if node.nil? || node.type == :NIL || node.type == :nil
             types.push ComplexType::NIL
@@ -50,8 +50,8 @@ module Solargraph
             clip = api_map.clip_at(location.filename, pos)
             # Use the return node for inference. The clip might infer from the
             # first node in a method call instead of the entire call.
-            chain = Parser.chain(node, nil, clip.in_block?)
-            result = chain.infer(api_map, closure, clip.locals)
+            chain = Parser.chain(node, nil, nil)
+            result = chain.infer(api_map, closure, clip.locals).self_to(closure.context.tag)
             types.push result unless result.undefined?
           end
         end
@@ -71,6 +71,10 @@ module Solargraph
         true
       end
 
+      def desc
+        "#{to_rbs} = #{assignment&.type.inspect}"
+      end
+
       private
 
       # @return [ComplexType]

data/lib/solargraph/pin/block.rb

@@ -3,35 +3,40 @@
 module Solargraph
   module Pin
     class Block < Closure
-      # The signature of the method that receives this block.
-      #
       # @return [Parser::AST::Node]
       attr_reader :receiver
 
-      # @param args [Array<Parameter>]
-      def initialize receiver: nil, args: [], context: nil, **splat
+      # @return [Parser::AST::Node]
+      attr_reader :node
+
+      # @param receiver [Parser::AST::Node, nil]
+      # @param node [Parser::AST::Node, nil]
+      # @param context [ComplexType, nil]
+      # @param args [::Array<Parameter>]
+      def initialize receiver: nil, args: [], context: nil, node: nil, **splat
         super(**splat)
         @receiver = receiver
         @context = context
         @parameters = args
+        @node = node
       end
 
       # @param api_map [ApiMap]
       # @return [void]
       def rebind api_map
-        @binder ||= binder_or_nil(api_map)
+        @rebind ||= maybe_rebind(api_map)
       end
 
       def binder
-        @binder || closure.binder
+        @rebind&.defined? ? @rebind : closure.binder
       end
 
-      # @return [Array<Parameter>]
+      # @return [::Array<Parameter>]
       def parameters
         @parameters ||= []
       end
 
-      # @return [Array<String>]
+      # @return [::Array<String>]
       def parameter_names
         @parameter_names ||= parameters.map(&:name)
       end
@@ -39,39 +44,22 @@ module Solargraph
       private
 
       # @param api_map [ApiMap]
-      # @return [ComplexType, nil]
-      def binder_or_nil api_map
-        return nil unless receiver
-        word = receiver.children.find { |c| c.is_a?(::Symbol) }.to_s
-        return nil unless api_map.rebindable_method_names.include?(word)
+      # @return [ComplexType]
+      def maybe_rebind api_map
+        return ComplexType::UNDEFINED unless receiver
+
         chain = Parser.chain(receiver, location.filename)
         locals = api_map.source_map(location.filename).locals_at(location)
-        links_last_word = chain.links.last.word
-        if %w[instance_eval instance_exec class_eval class_exec module_eval module_exec].include?(links_last_word)
-          return chain.base.infer(api_map, self, locals)
-        end
-        if 'define_method' == links_last_word and chain.define(api_map, self, locals).first&.path == 'Module#define_method' # change class type to instance type
-          if chain.links.size > 1 # Class.define_method
-            ty = chain.base.infer(api_map, self, locals)
-            return Solargraph::ComplexType.parse(ty.namespace)
-          else # define_method without self
-            return Solargraph::ComplexType.parse(closure.binder.namespace)
-          end
-        end
-        # other case without early return, read block yieldreceiver tags
         receiver_pin = chain.define(api_map, self, locals).first
-        if receiver_pin && receiver_pin.docstring
-          ys = receiver_pin.docstring.tag(:yieldreceiver)
-          if ys && ys.types && !ys.types.empty?
-            target = if chain.links.first.is_a?(Source::Chain::Constant)
-              receiver_pin.full_context.namespace
-            else
-              full_context.namespace
-            end
-            return ComplexType.try_parse(*ys.types).qualify(api_map, receiver_pin.context.namespace).self_to(target)
-          end
-        end
-        nil
+        return ComplexType::UNDEFINED unless receiver_pin
+
+        types = receiver_pin.docstring.tag(:yieldreceiver)&.types
+        return ComplexType::UNDEFINED unless types&.any?
+
+        target = chain.base.infer(api_map, receiver_pin, locals)
+        target = full_context unless target.defined?
+
+        ComplexType.try_parse(*types).qualify(api_map, receiver_pin.context.namespace).self_to(target.to_s)
       end
     end
   end

data/lib/solargraph/pin/closure.rb

@@ -6,9 +6,12 @@ module Solargraph
       # @return [::Symbol] :class or :instance
       attr_reader :scope
 
-      def initialize scope: :class, **splat
+      # @param scope [::Symbol] :class or :instance
+      # @param generics [::Array<Pin::Parameter>, nil]
+      def initialize scope: :class, generics: nil, **splat
         super(**splat)
         @scope = scope
+        @generics = generics
       end
 
       def context
@@ -26,12 +29,24 @@ module Solargraph
         @binder || context
       end
 
-      # @return [Array<String>]
+      # @return [::Array<String>]
       def gates
         # @todo This check might not be necessary. There should always be a
         #   root pin
         closure ? closure.gates : ['']
       end
+
+      # @return [::Array<String>]
+      def generics
+        @generics ||= docstring.tags(:generic).map(&:name)
+      end
+
+      # @return [String]
+      def generics_as_rbs
+        return '' if generics.empty?
+
+        generics.join(', ') + ' '
+      end
     end
   end
 end

data/lib/solargraph/pin/common.rb

@@ -6,7 +6,7 @@ module Solargraph
       # @return [Location]
       attr_reader :location
 
-      # @return [Pin::Base, nil]
+      # @return [Pin::Closure, nil]
       attr_reader :closure
 
       # @return [String]
@@ -19,7 +19,7 @@ module Solargraph
         @return_type ||= ComplexType::UNDEFINED
       end
 
-      # @return [ComplexType]
+      # @return [ComplexType, Array<UniqueType>]
       def context
         # Get the static context from the nearest namespace
         @context ||= find_context
@@ -46,6 +46,10 @@ module Solargraph
         @path ||= name.empty? ? context.namespace : "#{context.namespace}::#{name}"
       end
 
+      protected
+
+      attr_writer :context
+
       private
 
       # @return [ComplexType]
@@ -56,7 +60,7 @@ module Solargraph
             return here.return_type
           elsif here.is_a?(Pin::Method)
             if here.scope == :instance
-              return ComplexType.try_parse(here.context.namespace)
+              return ComplexType.try_parse(here.context.tag)
             else
               return here.context
             end

data/lib/solargraph/pin/conversions.rb

@@ -5,7 +5,35 @@ require 'cgi'
 module Solargraph
   module Pin
     # @todo Move this stuff. It should be the responsibility of the language server.
+    # @todo abstract methods below should be verified to be overridden
+    #   by type checker when mixin included by non-abstract class
     module Conversions
+      # @!parse
+      #   include Documenting
+      #   include Common
+
+      # @return [Integer]
+      # @abstract
+      def completion_item_kind
+        raise NotImplementedError
+      end
+
+      # @abstract
+      # @return [Boolean]
+      def deprecated?
+        raise NotImplementedError
+      end
+
+      # @abstract
+      def probed?
+        raise NotImplementedError
+      end
+
+      # @abstract
+      def proxied?
+        raise NotImplementedError
+      end
+
       # @return [Hash]
       def completion_item
         @completion_item ||= {
@@ -34,12 +62,12 @@ module Solargraph
         end
       end
 
-      # @return [Array<Hash>]
+      # @return [::Array<Hash>]
       def signature_help
         []
       end
 
-      # @return [String]
+      # @return [String, nil]
       def detail
         # This property is not cached in an instance variable because it can
         # change when pins get proxied.
@@ -57,12 +85,14 @@ module Solargraph
         @link_documentation ||= generate_link
       end
 
+      # @return [String, nil]
       def text_documentation
         this_path = path || return_type.tag
         return nil if this_path == 'undefined'
         escape_brackets this_path
       end
 
+      # @return [void]
       def reset_conversions
         @completion_item = nil
         @resolve_completion_item = nil
@@ -73,7 +103,7 @@ module Solargraph
 
       private
 
-      # @return [String]
+      # @return [String, nil]
       def generate_link
         this_path = path || return_type.tag
         return nil if this_path == 'undefined'