solargraph 0.47.2 → 0.53.3

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class ArgsNode < Parser::NodeProcessor::Base
+          def process
+            if node.type == :forward_args
+              forward
+            else
+              node.children.each do |u|
+                loc = get_node_location(u)
+                locals.push Solargraph::Pin::Parameter.new(
+                  location: loc,
+                  closure: region.closure,
+                  comments: comments_for(node),
+                  name: u.children[0].to_s,
+                  assignment: u.children[1],
+                  asgn_code: u.children[1] ? region.code_for(u.children[1]) : nil,
+                  presence: region.closure.location.range,
+                  decl: get_decl(u)
+                )
+                region.closure.parameters.push locals.last
+              end
+            end
+            process_children
+          end
+
+          private
+
+          # @return [void]
+          def forward
+            loc = get_node_location(node)
+            locals.push Solargraph::Pin::Parameter.new(
+              location: loc,
+              closure: region.closure,
+              presence: region.closure.location.range,
+              decl: get_decl(node)
+            )
+            region.closure.parameters.push locals.last
+          end
+
+          # @param node [AST::Node]
+          # @return [Symbol]
+          def get_decl node
+            node.type
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -2,10 +2,10 @@
 
 module Solargraph
   module Parser
-    module Legacy
+    module ParserGem
       module NodeProcessors
         class BlockNode < Parser::NodeProcessor::Base
-          include Legacy::NodeMethods
+          include ParserGem::NodeMethods
 
           def process
             location = get_node_location(node)
@@ -21,6 +21,7 @@ module Solargraph
             pins.push Solargraph::Pin::Block.new(
               location: location,
               closure: parent,
+              node: node,
               receiver: node.children[0],
               comments: comments_for(node),
               scope: region.scope || region.closure.context.scope

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

@@ -2,22 +2,32 @@
 
 module Solargraph
   module Parser
-    module Legacy
+    module ParserGem
       module NodeProcessors
         class CasgnNode < Parser::NodeProcessor::Base
-          include Legacy::NodeMethods
+          include ParserGem::NodeMethods
 
           def process
-            here = get_node_start_position(node)
             pins.push Solargraph::Pin::Constant.new(
               location: get_node_location(node),
               closure: region.closure,
-              name: node.children[1].to_s,
+              name: const_name,
               comments: comments_for(node),
               assignment: node.children[2]
             )
             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

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

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

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

@@ -2,35 +2,22 @@
 
 module Solargraph
   module Parser
-    module Rubyvm
+    module ParserGem
       module NodeProcessors
         class DefNode < Parser::NodeProcessor::Base
           def process
+            name = node.children[0].to_s
+            scope = region.scope || (region.closure.is_a?(Pin::Singleton) ? :class : :instance)
             methpin = Solargraph::Pin::Method.new(
               location: get_node_location(node),
               closure: region.closure,
-              name: node.children[0].to_s,
+              name: name,
               comments: comments_for(node),
-              scope: region.scope || (region.closure.is_a?(Pin::Singleton) ? :class : :instance),
-              visibility: region.visibility,
+              scope: scope,
+              visibility: scope == :instance && name == 'initialize' ? :private : region.visibility,
               node: node
             )
-            if methpin.name == 'initialize' and methpin.scope == :instance
-              pins.push Solargraph::Pin::Method.new(
-                location: methpin.location,
-                closure: methpin.closure,
-                name: 'new',
-                comments: methpin.comments,
-                scope: :class,
-                parameters: methpin.parameters
-              )
-              # @todo Smelly instance variable access.
-              pins.last.instance_variable_set(:@return_type, ComplexType::SELF)
-              pins.push methpin
-              # @todo Smelly instance variable access.
-              methpin.instance_variable_set(:@visibility, :private)
-              methpin.instance_variable_set(:@return_type, ComplexType::VOID)
-            elsif region.visibility == :module_function
+            if region.visibility == :module_function
               pins.push Solargraph::Pin::Method.new(
                 location: methpin.location,
                 closure: methpin.closure,

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/parser_gem/node_processors/sclass_node.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Parser
+    module ParserGem
+      module NodeProcessors
+        class SclassNode < Parser::NodeProcessor::Base
+          def process
+            sclass = node.children[0]
+            if sclass.is_a?(AST::Node) && sclass.type == :self
+              closure = region.closure
+            elsif sclass.is_a?(AST::Node) && sclass.type == :casgn
+              names = [region.closure.namespace, region.closure.name]
+              if sclass.children[0].nil? && names.last != sclass.children[1].to_s
+                names << sclass.children[1].to_s
+              else
+                names.concat [NodeMethods.unpack_name(sclass.children[0]), sclass.children[1].to_s]
+              end
+              name = names.reject(&:empty?).join('::')
+              closure = Solargraph::Pin::Namespace.new(name: name, location: region.closure.location)
+            elsif sclass.is_a?(AST::Node) && sclass.type == :const
+              names = [region.closure.namespace, region.closure.name]
+              also = NodeMethods.unpack_name(sclass)
+              if also != region.closure.name
+                names << also
+              end
+              name = names.reject(&:empty?).join('::')
+              closure = Solargraph::Pin::Namespace.new(name: name, location: region.closure.location)
+            else
+              return
+            end
+            pins.push Solargraph::Pin::Singleton.new(
+              location: get_node_location(node),
+              closure: closure
+            )
+            process_children region.update(visibility: :public, scope: :class, closure: pins.last)
+          end
+        end
+      end
+    end
+  end
+end

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/{legacy → parser_gem}/node_processors/sym_node.rb

@@ -2,7 +2,7 @@
 
 module Solargraph
   module Parser
-    module Legacy
+    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/region.rb

@@ -23,7 +23,7 @@ module Solargraph
 
       # @param source [Source]
       # @param namespace [String]
-      # @param scope [Symbol]
+      # @param scope [Symbol, nil]
       # @param visibility [Symbol]
       def initialize source: Solargraph::Source.load_string(''), closure: nil,
                      scope: nil, visibility: :public, lvars: []

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,17 +9,17 @@ module Solargraph
     class SyntaxError < StandardError
     end
 
-    # True if the parser can use RubyVM.
-    #
     def self.rubyvm?
-      !!defined?(RubyVM::AbstractSyntaxTree)
-      # false
+      false
     end
 
-    selected = rubyvm? ? Rubyvm : Legacy
-    # include selected
-    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

@@ -21,9 +21,11 @@ module Solargraph
       # @return [String]
       attr_reader :path
 
-      # @param location [Solargraph::Location]
-      # @param kind [Integer]
-      # @param closure [Solargraph::Pin::Closure]
+      # @return [::Symbol]
+      attr_accessor :source
+
+      # @param location [Solargraph::Location, nil]
+      # @param closure [Solargraph::Pin::Closure, nil]
       # @param name [String]
       # @param comments [String]
       def initialize location: nil, closure: nil, name: '', comments: ''
@@ -38,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?
@@ -55,7 +94,7 @@ module Solargraph
       end
 
       def to_s
-        name.to_s
+        to_rbs
       end
 
       # @return [Boolean]
@@ -100,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
@@ -213,12 +252,31 @@ module Solargraph
         result
       end
 
+      # @return [String]
       def identity
-        @identity ||= "#{closure.context.namespace}|#{name}"
+        @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
@@ -263,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
@@ -285,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,13 +50,13 @@ 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
         return ComplexType::UNDEFINED if types.empty?
-        ComplexType.try_parse(*types.map(&:tag))
+        ComplexType.try_parse(*types.map(&:to_s))
       end
 
       def == other
@@ -71,6 +71,10 @@ module Solargraph
         true
       end
 
+      def desc
+        "#{to_rbs} = #{assignment&.type.inspect}"
+      end
+
       private
 
       # @return [ComplexType]