solargraph 0.39.7

data/lib/solargraph/source/chain.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+# HACK: Fix autoload issue
+require 'solargraph/source/chain/link'
+
+module Solargraph
+  class Source
+    # A chain of constants, variables, and method calls for inferring types of
+    # values.
+    #
+    class Chain
+      autoload :Link,             'solargraph/source/chain/link'
+      autoload :Call,             'solargraph/source/chain/call'
+      autoload :Variable,         'solargraph/source/chain/variable'
+      autoload :ClassVariable,    'solargraph/source/chain/class_variable'
+      autoload :Constant,         'solargraph/source/chain/constant'
+      autoload :InstanceVariable, 'solargraph/source/chain/instance_variable'
+      autoload :GlobalVariable,   'solargraph/source/chain/global_variable'
+      autoload :Literal,          'solargraph/source/chain/literal'
+      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
+
+      UNDEFINED_CALL = Chain::Call.new('<undefined>')
+      UNDEFINED_CONSTANT = Chain::Constant.new('<undefined>')
+
+      # @return [Array<Source::Chain::Link>]
+      attr_reader :links
+
+      attr_reader :node
+
+      # @param links [Array<Chain::Link>]
+      def initialize links, node = nil, splat = false
+        @links = links.clone
+        @links.push UNDEFINED_CALL if @links.empty?
+        head = true
+        @links.map! do |link|
+          result = (head ? link.clone_head : link.clone_body)
+          head = false
+          result
+        end
+        @node = node
+        @splat = splat
+      end
+
+      # @return [Chain]
+      def base
+        @base ||= Chain.new(links[0..-2])
+      end
+
+      # @param api_map [ApiMap]
+      # @param name_pin [Pin::Base]
+      # @param locals [Array<Pin::Base>]
+      # @return [Array<Pin::Base>]
+      def define api_map, name_pin, locals
+        rebind_block name_pin, api_map, locals
+        return [] if undefined?
+        working_pin = name_pin
+        links[0..-2].each do |link|
+          pins = link.resolve(api_map, working_pin, locals)
+          # Locals are only used when resolving the first link
+          # @todo There's a problem here. Call links need to resolve arguments
+          #   that might refer to local variables.
+          # locals = []
+          type = infer_first_defined(pins, working_pin, api_map)
+          return [] if type.undefined?
+          working_pin = Pin::ProxyType.anonymous(type)
+        end
+        links.last.last_context = working_pin
+        links.last.resolve(api_map, working_pin, locals)
+      end
+
+      # @param api_map [ApiMap]
+      # @param name_pin [Pin::Base]
+      # @param locals [Array<Pin::Base>]
+      # @return [ComplexType]
+      def infer api_map, name_pin, locals
+        rebind_block name_pin, api_map, locals
+        pins = define(api_map, name_pin, locals)
+        infer_first_defined(pins, links.last.last_context, api_map)
+      end
+
+      # @return [Boolean]
+      def literal?
+        links.last.is_a?(Chain::Literal)
+      end
+
+      def undefined?
+        links.any?(&:undefined?)
+      end
+
+      def defined?
+        !undefined?
+      end
+
+      # @return [Boolean]
+      def constant?
+        links.last.is_a?(Chain::Constant)
+      end
+
+      def splat?
+        @splat
+      end
+
+      private
+
+      # @param pins [Array<Pin::Base>]
+      # @param api_map [ApiMap]
+      # @return [ComplexType]
+      def infer_first_defined pins, context, api_map
+        type = ComplexType::UNDEFINED
+        pins.each do |pin|
+          # Avoid infinite recursion
+          next if @@inference_stack.include?(pin.identity)
+          @@inference_stack.push pin.identity
+          type = pin.typify(api_map)
+          @@inference_stack.pop
+          break if type.defined?
+        end
+        if type.undefined?
+          # Limit method inference recursion
+          return type if @@inference_depth >= 10 && pins.first.is_a?(Pin::BaseMethod)
+          @@inference_depth += 1
+          pins.each do |pin|
+            # Avoid infinite recursion
+            next if @@inference_stack.include?(pin.identity)
+            @@inference_stack.push pin.identity
+            type = pin.probe(api_map)
+            @@inference_stack.pop
+            break if type.defined?
+          end
+          @@inference_depth -= 1
+        end
+        return type if context.nil? || context.return_type.undefined?
+        type.self_to(context.return_type.namespace)
+      end
+
+      def skippable_block_receivers api_map
+        @@skippable_block_receivers ||= (
+          api_map.get_methods('Array', deep: false).map(&:name) +
+          api_map.get_methods('Enumerable', deep: false).map(&:name) +
+          api_map.get_methods('Hash', deep: false).map(&:name) +
+          ['new']
+        ).to_set
+      end
+
+      def rebind_block pin, api_map, locals
+        return unless pin.is_a?(Pin::Block) && pin.receiver && !pin.rebound?
+        # This first rebind just sets the block pin's rebound state
+        pin.rebind ComplexType::UNDEFINED
+        chain = Parser.chain(pin.receiver, pin.location.filename)
+        return if skippable_block_receivers(api_map).include?(chain.links.last.word)
+        if ['instance_eval', 'instance_exec', 'class_eval', 'class_exec', 'module_eval', 'module_exec'].include?(chain.links.last.word)
+          type = chain.base.infer(api_map, pin, locals)
+          pin.rebind type
+        else
+          receiver_pin = chain.define(api_map, pin, locals).first
+          return if receiver_pin.nil? || receiver_pin.docstring.nil?
+          ys = receiver_pin.docstring.tag(:yieldself)
+          unless ys.nil? || ys.types.nil? || ys.types.empty?
+            ysct = ComplexType.try_parse(*ys.types).qualify(api_map, receiver_pin.context.namespace)
+            pin.rebind ysct
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +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'))]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class Call < Link
+        # @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, arguments = [], with_block = false
+          @word = word
+          @arguments = arguments
+          @with_block = 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) if word == 'super'
+          found = if head?
+            locals.select { |p| p.name == word }
+          else
+            []
+          end
+          return inferred_pins(found, api_map, name_pin.context, locals) unless found.empty?
+          pins = api_map.get_method_stack(name_pin.binder.namespace, word, scope: name_pin.binder.scope)
+          return [] if pins.empty?
+          inferred_pins(pins, api_map, name_pin.context, locals)
+        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
+
+        # @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
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class ClassVariable < Link
+        def resolve api_map, name_pin, locals
+          api_map.get_class_variable_pins(name_pin.context.namespace).select{|p| p.name == word}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class Constant < Link
+        def initialize word
+          @word = word
+        end
+
+        def resolve api_map, name_pin, locals
+          return [Pin::ROOT_PIN] if word.empty?
+          if word.start_with?('::')
+            base = word[2..-1]
+            gates = ['']
+          else
+            base = word
+            gates = crawl_gates(name_pin)
+          end
+          parts = base.split('::')
+          gates.each do |gate|
+            type = deep_constant_type(gate, api_map)
+            # Use deep inference to resolve root 
+            parts[0..-2].each do |sym|
+              pins = api_map.get_constants('', type.namespace).select{ |pin| pin.name == sym }
+              type = first_pin_type(pins, api_map)
+              break if type.undefined?
+            end
+            next if type.undefined?
+            result = api_map.get_constants('', type.namespace).select { |pin| pin.name == parts.last }
+            return result unless result.empty?
+          end
+          []
+        end
+
+        private
+
+        def crawl_gates pin
+          clos = pin
+          until clos.nil?
+            if clos.is_a?(Pin::Namespace)
+              gates = clos.gates
+              gates.push('') if gates.empty?
+              return gates
+            end
+            clos = clos.closure
+          end
+          ['']
+        end
+
+        def first_pin_type(pins, api_map)
+          type = ComplexType::UNDEFINED
+          pins.each do |pin|
+            type = pin.typify(api_map)
+            break if type.defined?
+            type = pin.probe(api_map)
+            break if type.defined?
+          end
+          type
+        end
+
+        def deep_constant_type(gate, api_map)
+          type = ComplexType::ROOT
+          return type if gate == ''
+          gate.split('::').each do |word|
+            pins = api_map.get_constants('', type.namespace).select { |pin| pin.name == word }
+            type = first_pin_type(pins, api_map)
+            break if type.undefined?
+          end
+          type
+        end
+      end
+    end
+  end
+end