solargraph 0.39.0 → 0.39.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 71e5d6fa6baec1130d64df74ed6fcf49c6c41df2f1386cb5cd2760a7605a9e48
-  data.tar.gz: 91d9d6c695a63a0defab2c31967b2828907c800a94eb220c9210db9b672f2f27
+  metadata.gz: b287c1f54a79a771b343e16110cc0640a948abd0a6a5d7f187cd43e7bbea8b45
+  data.tar.gz: 9b425158e5ee4f420c0ea84397d7d171f1893f2e49aed6ebbb3c7f920618679d
 SHA512:
-  metadata.gz: 2b37f7a917d8c865063f14c62e185e919cb88f221219fdc611ef003aa0a17af99bdd762fd4d4fc36105f37c36b0bdd4017500abe17b3aa1506423df8b16ee55a
-  data.tar.gz: 60110bec4c847690cecdfa0d73d0495d09340a56ddf650dfbfc737e1f8b62682e1cce3de568edec7e52f4d4ff052e4c4746a2ec907c20320b6b133de610b6f3a
+  metadata.gz: b7c6214462ba598bfd184367c39d05264f82a5b0f94503ffe55ab321b8a8e7c8ef9da470780a7608b47c2360b8dc647d05a0546ff4ecddc6005ff2b015371629
+  data.tar.gz: 6810ce41c48475b6875b1337f56f3cd4553abba55e51a0c42158678a6545a4255e0c2ae96b51961fe4c23bee95afb3c8a78322db93a36ac85506a433ee73aaf8

data/lib/solargraph/parser/legacy/class_methods.rb

@@ -78,6 +78,10 @@ module Solargraph
           NodeChainer.chain *args
         end
 
+        def chain_string *args
+          NodeChainer.load_string *args
+        end
+
         def process_node *args
           Solargraph::Parser::NodeProcessor.process *args
         end

data/lib/solargraph/parser/legacy/node_chainer.rb

@@ -73,8 +73,11 @@ module Solargraph
             end
           elsif n.type == :self
             result.push Chain::Head.new('self')
-          elsif [:super, :zsuper].include?(n.type)
-            result.push Chain::Head.new('super')
+          elsif n.type == :zsuper
+            result.push Chain::ZSuper.new('super', @in_block || block_passed?(n))
+          elsif n.type == :super
+            args = n.children.map { |c| NodeChainer.chain(c) }
+            result.push Chain::Call.new('super', args, @in_block || block_passed?(n))
           elsif n.type == :const
             const = unpack_name(n)
             result.push Chain::Constant.new(const)

data/lib/solargraph/parser/legacy/node_methods.rb

@@ -126,7 +126,7 @@ module Solargraph
             result.push node
             node.children[0].children[2..-1].each { |child| result.concat call_nodes_from(child) }
             node.children[1..-1].each { |child| result.concat call_nodes_from(child) }
-          elsif node.type == :send
+          elsif [:send, :super, :zsuper].include?(node.type)
             result.push node
             node.children[2..-1].each { |child| result.concat call_nodes_from(child) }
           else
@@ -210,8 +210,12 @@ module Solargraph
                 result.concat get_return_nodes_only(node.children[2])
               elsif node.type == :case
                 node.children[1..-1].each do |cc|
-                  result.concat reduce_to_value_nodes(cc.children[1..-2])
-                  result.concat reduce_to_value_nodes([cc.children.last])
+                  if cc.nil?
+                    result.push NIL_NODE
+                  else
+                    result.concat reduce_to_value_nodes(cc.children[1..-2]) unless cc.children.length < 1
+                    result.concat reduce_to_value_nodes([cc.children.last])
+                  end
                 end
               else
                 result.push node

data/lib/solargraph/parser/rubyvm/class_methods.rb

@@ -8,7 +8,7 @@ module Solargraph
         # @param filename [String]
         # @return [Array(Parser::AST::Node, Array<Parser::Source::Comment>)]
         def parse_with_comments code, filename = nil
-          node = RubyVM::AbstractSyntaxTree.parse(code)
+          node = RubyVM::AbstractSyntaxTree.parse(code).children[2]
           comments = CommentRipper.new(code).parse
           [node, comments]
         rescue ::SyntaxError => e
@@ -20,7 +20,7 @@ module Solargraph
         # @param line [Integer]
         # @return [Parser::AST::Node]
         def parse code, filename = nil, line = 0
-          RubyVM::AbstractSyntaxTree.parse(code)
+          RubyVM::AbstractSyntaxTree.parse(code).children[2]
         rescue ::SyntaxError => e
           raise Parser::SyntaxError, e.message
         end
@@ -83,6 +83,10 @@ module Solargraph
           NodeChainer.chain *args
         end
 
+        def chain_string *args
+          NodeChainer.load_string *args
+        end
+
         def process_node *args
           Solargraph::Parser::NodeProcessor.process *args
         end

data/lib/solargraph/parser/rubyvm/node_chainer.rb

@@ -69,8 +69,10 @@ module Solargraph
             result.push Chain::Call.new(n.children[0].to_s, node_to_argchains(n.children[1]), @in_block || block_passed?(n))
           elsif n.type == :SELF
             result.push Chain::Head.new('self')
-          elsif [:SUPER, :ZSUPER].include?(n.type)
-            result.push Chain::Head.new('super')
+          elsif n.type == :ZSUPER
+            result.push Chain::ZSuper.new('super', @in_block || block_passed?(n))
+          elsif n.type == :SUPER
+            result.push Chain::Call.new('super', node_to_argchains(n.children.last), @in_block || block_passed?(n))
           elsif [:COLON2, :COLON3, :CONST].include?(n.type)
             const = unpack_name(n)
             result.push Chain::Constant.new(const)

data/lib/solargraph/source/chain.rb

@@ -20,6 +20,7 @@ module Solargraph
       autoload :Head,             'solargraph/source/chain/head'
       autoload :Or,               'solargraph/source/chain/or'
       autoload :BlockVariable,    'solargraph/source/chain/block_variable'
+      autoload :ZSuper,           'solargraph/source/chain/z_super'
 
       @@inference_stack = []
       @@inference_depth = 0

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

@@ -28,6 +28,7 @@ module Solargraph
         # @param name_pin [Pin::Base]
         # @param locals [Array<Pin::Base>]
         def resolve api_map, name_pin, locals
+          return super_pins(api_map, name_pin) if word == 'super'
           found = if head?
             locals.select { |p| p.name == word }
           else
@@ -188,6 +189,14 @@ module Solargraph
           return false if argcount < parcount && !(argcount == parcount - 1 && parameters.last.first.start_with?('*'))
           true
         end
+
+        # @param api_map [ApiMap]
+        # @param name_pin [Pin::Base]
+        # @return [Array<Pin::Base>]
+        def super_pins api_map, name_pin
+          pins = api_map.get_method_stack(name_pin.namespace, name_pin.name, scope: name_pin.scope)
+          pins.reject{|p| p.path == name_pin.path}
+        end
       end
     end
   end

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

@@ -10,19 +10,25 @@ module Solargraph
       class Head < Link
         def resolve api_map, name_pin, locals
           return [Pin::ProxyType.anonymous(name_pin.binder)] if word == 'self'
-          return super_pins(api_map, name_pin) if word == 'super'
+          # return super_pins(api_map, name_pin) if word == 'super'
           []
         end
 
+        # @todo This is temporary. Chain heads need to handle arguments to
+        #   `super`.
+        # def arguments
+        #   []
+        # end
+
         private
 
-        # @param api_map [ApiMap]
-        # @param name_pin [Pin::Base]
-        # @return [Array<Pin::Base>]
-        def super_pins api_map, name_pin
-          pins = api_map.get_method_stack(name_pin.namespace, name_pin.name, scope: name_pin.scope)
-          pins.reject{|p| p.path == name_pin.path}
-        end
+        # # @param api_map [ApiMap]
+        # # @param name_pin [Pin::Base]
+        # # @return [Array<Pin::Base>]
+        # def super_pins api_map, name_pin
+        #   pins = api_map.get_method_stack(name_pin.namespace, name_pin.name, scope: name_pin.scope)
+        #   pins.reject{|p| p.path == name_pin.path}
+        # end
       end
     end
   end

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

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class ZSuper < Call
+        # @return [String]
+        attr_reader :word
+
+        # @return [Array<Chain>]
+        attr_reader :arguments
+
+        # @param word [String]
+        # @param arguments [Array<Chain>]
+        # @param with_block [Boolean] True if the chain is inside a block
+        # @param head [Boolean] True if the call is the start of its chain
+        def initialize word, with_block = false
+          super(word, [], with_block)
+        end
+
+        def with_block?
+          @with_block
+        end
+
+        # @param api_map [ApiMap]
+        # @param name_pin [Pin::Base]
+        # @param locals [Array<Pin::Base>]
+        def resolve api_map, name_pin, locals
+          return super_pins(api_map, name_pin)
+        end
+
+        private
+
+        # @param pins [Array<Pin::Base>]
+        # @param api_map [ApiMap]
+        # @param context [ComplexType]
+        # @param locals [Pin::LocalVariable]
+        # @return [Array<Pin::Base>]
+        def inferred_pins pins, api_map, context, locals
+          result = pins.map do |p|
+            overloads = p.docstring.tags(:overload)
+            # next p if overloads.empty?
+            type = ComplexType::UNDEFINED
+            # @param [YARD::Tags::OverloadTag]
+            overloads.each do |ol|
+              next unless arguments_match(arguments, ol.parameters)
+              next if ol.parameters.last && ol.parameters.last.first.start_with?('&') && ol.parameters.last.last.nil? && !with_block?
+              match = true
+              arguments.each_with_index do |arg, idx|
+                achain = arguments[idx]
+                next if achain.nil?
+                param = ol.parameters[idx]
+                if param.nil?
+                  match = false unless ol.parameters.last && ol.parameters.last.first.start_with?('*')
+                  break
+                end
+                par = ol.tags(:param).select { |pp| pp.name == param.first }.first
+                next if par.nil? || par.types.nil? || par.types.empty?
+                atype = achain.infer(api_map, Pin::ProxyType.anonymous(context), locals)
+                other = ComplexType.try_parse(*par.types)
+                # @todo Weak type comparison
+                unless atype.tag == other.tag || api_map.super_and_sub?(other.tag, atype.tag)
+                  match = false
+                  break
+                end
+              end
+              if match
+                type = extra_return_type(ol, context)
+                type = ComplexType.try_parse(*ol.tag(:return).types).self_to(context.to_s).qualify(api_map, context.namespace) if ol.has_tag?(:return) && ol.tag(:return).types && !ol.tag(:return).types.empty? && (type.nil? || type.undefined?)
+                type ||= ComplexType::UNDEFINED
+              end
+              break if type.defined?
+            end
+            next p.proxy(type) if type.defined?
+            type = extra_return_type(p.docstring, context)
+            if type
+              next Solargraph::Pin::Method.new(
+                location: p.location,
+                closure: p.closure,
+                name: p.name,
+                comments: "@return [#{context.subtypes.first.to_s}]",
+                scope: p.scope,
+                visibility: p.visibility,
+                parameters: p.parameters,
+                node: p.node
+              )
+            end
+            if p.is_a?(Pin::Method) && !p.macros.empty?
+              result = process_macro(p, api_map, context, locals)
+              next result unless result.return_type.undefined?
+            elsif !p.directives.empty?
+              result = process_directive(p, api_map, context, locals)
+              next result unless result.return_type.undefined?
+            end
+            p
+          end
+          result.map do |pin|
+            next pin if pin.return_type.undefined?
+            selfy = pin.return_type.self_to(context.tag)
+            selfy == pin.return_type ? pin : pin.proxy(selfy)
+          end
+        end
+
+        # @param pin [Pin::Method]
+        # @param api_map [ApiMap]
+        # @param context [ComplexType]
+        # @param locals [Pin::Base]
+        # @return [Pin::Base]
+        def process_macro pin, api_map, context, locals
+          pin.macros.each do |macro|
+            result = inner_process_macro(pin, macro, api_map, context, locals)
+            return result unless result.return_type.undefined?
+          end
+          Pin::ProxyType.anonymous(ComplexType::UNDEFINED)
+        end
+
+        # @param pin [Pin::Method]
+        # @param api_map [ApiMap]
+        # @param context [ComplexType]
+        # @param locals [Pin::Base]
+        # @return [Pin::ProxyType]
+        def process_directive pin, api_map, context, locals
+          pin.directives.each do |dir|
+            macro = api_map.named_macro(dir.tag.name)
+            next if macro.nil?
+            result = inner_process_macro(pin, macro, api_map, context, locals)
+            return result unless result.return_type.undefined?
+          end
+          Pin::ProxyType.anonymous ComplexType::UNDEFINED
+        end
+
+        # @param pin [Pin]
+        # @param macro [YARD::Tags::MacroDirective]
+        # @param api_map [ApiMap]
+        # @param context [ComplexType]
+        # @param locals [Array<Pin::Base>]
+        # @return [Pin::ProxyType]
+        def inner_process_macro pin, macro, api_map, context, locals
+          vals = arguments.map{ |c| Pin::ProxyType.anonymous(c.infer(api_map, pin, locals)) }
+          txt = macro.tag.text.clone
+          if txt.empty? && macro.tag.name
+            named = api_map.named_macro(macro.tag.name)
+            txt = named.tag.text.clone if named
+          end
+          i = 1
+          vals.each do |v|
+            txt.gsub!(/\$#{i}/, v.context.namespace)
+            i += 1
+          end
+          docstring = Solargraph::Source.parse_docstring(txt).to_docstring
+          tag = docstring.tag(:return)
+          unless tag.nil? || tag.types.nil?
+            return Pin::ProxyType.anonymous(ComplexType.try_parse(*tag.types))
+          end
+          Pin::ProxyType.anonymous(ComplexType::UNDEFINED)
+        end
+
+        # @param docstring [YARD::Docstring]
+        # @param context [ComplexType]
+        # @return [ComplexType]
+        def extra_return_type docstring, context
+          if docstring.has_tag?(:return_single_parameter) && context.subtypes.one?
+            return context.subtypes.first
+          elsif docstring.has_tag?(:return_value_parameter) && context.value_types.one?
+            return context.value_types.first
+          end
+          nil
+        end
+
+        # @param arguments [Array<Chain>]
+        # @param parameters [Array<String>]
+        # @return [Boolean]
+        def arguments_match arguments, parameters
+          argcount = arguments.length
+          # argcount -= 1 if !arguments.empty? && arguments.last.links.first.word.start_with?('&')
+          parcount = parameters.length
+          parcount -= 1 if !parameters.empty? && parameters.last.first.start_with?('&')
+          return false if argcount < parcount && !(argcount == parcount - 1 && parameters.last.first.start_with?('*'))
+          true
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/type_checker.rb

@@ -248,7 +248,11 @@ module Solargraph
         if pins.first.is_a?(Pin::BaseMethod)
           # @type [Pin::BaseMethod]
           pin = pins.first
-          ap = arity_problems_for(pin, base.links.last.arguments, location)
+          if base.links.last.is_a?(Solargraph::Source::Chain::ZSuper)
+            ap = arity_problems_for(pin, fake_args_for(block_pin), location)
+          else
+            ap = arity_problems_for(pin, base.links.last.arguments, location)
+          end
           unless ap.empty?
             result.concat ap
             break
@@ -470,5 +474,25 @@ module Solargraph
       pin.docstring.has_tag?(:abstract) ||
         (pin.closure && pin.closure.docstring.has_tag?(:abstract))
     end
+
+    def fake_args_for(pin)
+      args = []
+      with_opts = false
+      with_block = false
+      pin.parameters.each do |pin|
+        if [:kwarg, :kwoptarg, :kwrestarg].include?(pin.decl)
+          with_opts = true
+        elsif pin.decl == :block
+          with_block = true
+        elsif pin.decl == :restarg
+          args.push Solargraph::Source::Chain.new([Solargraph::Source::Chain::Variable.new(pin.name)], nil, true)
+        else
+          args.push Solargraph::Source::Chain.new([Solargraph::Source::Chain::Variable.new(pin.name)])
+        end
+      end
+      args.push Solargraph::Parser.chain_string('{}') if with_opts
+      args.push Solargraph::Parser.chain_string('&') if with_block
+      args
+    end
   end
 end

data/lib/solargraph/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Solargraph
-  VERSION = '0.39.0'
+  VERSION = '0.39.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solargraph
 version: !ruby/object:Gem::Version
-  version: 0.39.0
+  version: 0.39.1
 platform: ruby
 authors:
 - Fred Snyder
@@ -513,6 +513,7 @@ files:
 - lib/solargraph/source/chain/literal.rb
 - lib/solargraph/source/chain/or.rb
 - lib/solargraph/source/chain/variable.rb
+- lib/solargraph/source/chain/z_super.rb
 - lib/solargraph/source/change.rb
 - lib/solargraph/source/cursor.rb
 - lib/solargraph/source/encoding_fixes.rb