solargraph 0.32.1 → 0.32.2

data/lib/solargraph/source/chain.rb

@@ -1,120 +1,120 @@
-# 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'
-
-      # Chain#infer uses the inference stack to avoid recursing into itself.
-      # See Chain#active_signature for more information.
-      @@inference_stack = []
-
-      UNDEFINED_CALL = Chain::Call.new('<undefined>')
-      UNDEFINED_CONSTANT = Chain::Constant.new('<undefined>')
-
-      # @return [Array<Source::Chain::Link>]
-      attr_reader :links
-
-      # @param links [Array<Chain::Link>]
-      def initialize links
-        @links = links
-        @links.push UNDEFINED_CALL if @links.empty?
-      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
-        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
-          locals = []
-          type = infer_first_defined(pins, api_map)
-          return [] if type.undefined?
-          working_pin = Pin::ProxyType.anonymous(type)
-        end
-        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
-        return ComplexType::UNDEFINED if undefined? || @@inference_stack.include?(active_signature(name_pin))
-        @@inference_stack.push active_signature(name_pin)
-        type = ComplexType::UNDEFINED
-        pins = define(api_map, name_pin, locals)
-        pins.each do |pin|
-          type = pin.typify(api_map)
-          break unless type.undefined?
-        end
-        type = pins.first.probe(api_map) unless type.defined? || pins.empty?
-        @@inference_stack.pop
-        type
-      end
-
-      # @return [Boolean]
-      def literal?
-        links.last.is_a?(Chain::Literal)
-      end
-
-      # @return [Boolean]
-      def undefined?
-        links.any?(&:undefined?)
-      end
-
-      # @return [Boolean]
-      def constant?
-        links.last.is_a?(Chain::Constant)
-      end
-
-      private
-
-      # Get a signature for this chain that includes the current context
-      # where it's being analyzed. Chain#infer uses this value to detect
-      # recursive inference into the same chain, e.g., when two variables
-      # reference each other in their assignments.
-      #
-      # @param pin [Pin::Base] The named pin context
-      # @return [String]
-      def active_signature(pin)
-        "#{pin.path}|#{links.map(&:word).join('.')}"
-      end
-
-      # @param pins [Array<Pin::Base>]
-      # @param api_map [ApiMap]
-      # @return [ComplexType]
-      def infer_first_defined pins, api_map
-        type = ComplexType::UNDEFINED
-        pins.each do |pin|
-          # type = pin.infer(api_map)
-          type = pin.typify(api_map)
-          break unless type.undefined?
-        end
-        type = pins.first.probe(api_map) unless type.defined? || pins.empty?
-        type
-      end
-    end
-  end
-end
+# 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'
+
+      # Chain#infer uses the inference stack to avoid recursing into itself.
+      # See Chain#active_signature for more information.
+      @@inference_stack = []
+
+      UNDEFINED_CALL = Chain::Call.new('<undefined>')
+      UNDEFINED_CONSTANT = Chain::Constant.new('<undefined>')
+
+      # @return [Array<Source::Chain::Link>]
+      attr_reader :links
+
+      # @param links [Array<Chain::Link>]
+      def initialize links
+        @links = links
+        @links.push UNDEFINED_CALL if @links.empty?
+      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
+        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
+          locals = []
+          type = infer_first_defined(pins, api_map)
+          return [] if type.undefined?
+          working_pin = Pin::ProxyType.anonymous(type)
+        end
+        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
+        return ComplexType::UNDEFINED if undefined? || @@inference_stack.include?(active_signature(name_pin))
+        @@inference_stack.push active_signature(name_pin)
+        type = ComplexType::UNDEFINED
+        pins = define(api_map, name_pin, locals)
+        pins.each do |pin|
+          type = pin.typify(api_map)
+          break unless type.undefined?
+        end
+        type = pins.first.probe(api_map) unless type.defined? || pins.empty?
+        @@inference_stack.pop
+        type
+      end
+
+      # @return [Boolean]
+      def literal?
+        links.last.is_a?(Chain::Literal)
+      end
+
+      # @return [Boolean]
+      def undefined?
+        links.any?(&:undefined?)
+      end
+
+      # @return [Boolean]
+      def constant?
+        links.last.is_a?(Chain::Constant)
+      end
+
+      private
+
+      # Get a signature for this chain that includes the current context
+      # where it's being analyzed. Chain#infer uses this value to detect
+      # recursive inference into the same chain, e.g., when two variables
+      # reference each other in their assignments.
+      #
+      # @param pin [Pin::Base] The named pin context
+      # @return [String]
+      def active_signature(pin)
+        "#{pin.path}|#{links.map(&:word).join('.')}"
+      end
+
+      # @param pins [Array<Pin::Base>]
+      # @param api_map [ApiMap]
+      # @return [ComplexType]
+      def infer_first_defined pins, api_map
+        type = ComplexType::UNDEFINED
+        pins.each do |pin|
+          # type = pin.infer(api_map)
+          type = pin.typify(api_map)
+          break unless type.undefined?
+        end
+        type = pins.first.probe(api_map) unless type.defined? || pins.empty?
+        type
+      end
+    end
+  end
+end

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

@@ -1,107 +1,107 @@
-module Solargraph
-  class Source
-    class Chain
-      class Call < Link
-        # @return [String]
-        attr_reader :word
-
-        # @return [Array<Chain>]
-        attr_reader :arguments
-
-        def initialize word, arguments = []
-          @word = word
-          @arguments = arguments
-        end
-
-        def resolve api_map, name_pin, locals
-          found = locals.select{|p| p.name == word}
-          return inferred_pins(found, api_map, name_pin.context, locals) unless found.empty?
-          pins = api_map.get_method_stack(name_pin.context.namespace, word, scope: name_pin.context.scope)
-          return [] if pins.empty?
-          pins.unshift virtual_new_pin(pins.first, name_pin.context) if external_constructor?(pins.first, name_pin.context)
-          inferred_pins(pins, api_map, name_pin.context, locals)
-        end
-
-        private
-
-        # Create a `new` pin to facilitate type inference. This is necessary for
-        # classes from YARD and classes in the namespace that do not have an
-        # `initialize` method.
-        #
-        # @param new_pin [Solargraph::Pin::Base]
-        # @param context [Solargraph::ComplexType]
-        # @return [Pin::Method]
-        def virtual_new_pin new_pin, context
-          Pin::ProxyType.anonymous(ComplexType.try_parse(context.namespace))
-        end
-
-        def inferred_pins pins, api_map, context, locals
-          result = pins.map do |p|
-            if CoreFills::METHODS_RETURNING_SELF.include?(p.path)
-              next Solargraph::Pin::Method.new(p.location, p.namespace, p.name, "@return [#{context.tag}]", p.scope, p.visibility, p.parameters, p.node)
-            end
-            if CoreFills::METHODS_RETURNING_SUBTYPES.include?(p.path) && !context.subtypes.empty?
-              next Solargraph::Pin::Method.new(p.location, p.namespace, p.name, "@return [#{context.subtypes.first.tag}]", p.scope, p.visibility, p.parameters, p.node)
-            end
-            if p.kind == 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
-            next p if p.kind == Pin::METHOD || p.kind == Pin::ATTRIBUTE || p.kind == Pin::NAMESPACE
-            # type = p.infer(api_map)
-            type = p.typify(api_map)
-            type = p.probe(api_map) if type.undefined?
-            next p if p.return_complex_type == type
-            p.proxy type
-          end
-          result
-        end
-
-        def external_constructor? pin, context
-          pin.path == 'Class#new' || (pin.name == 'new' && pin.scope == :class && pin.return_type != context)
-        end
-
-        # @param pin [Pin::Method]
-        # @param api_map [ApiMap]
-        # @param context [ComplexType]
-        # @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.new(nil, nil, nil, ComplexType::UNDEFINED)
-        end
-
-        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.new(nil, nil, nil, ComplexType::UNDEFINED)
-        end
-
-        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
-          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.new(nil, nil, nil, ComplexType::UNDEFINED)
-        end
-      end
-    end
-  end
-end
+module Solargraph
+  class Source
+    class Chain
+      class Call < Link
+        # @return [String]
+        attr_reader :word
+
+        # @return [Array<Chain>]
+        attr_reader :arguments
+
+        def initialize word, arguments = []
+          @word = word
+          @arguments = arguments
+        end
+
+        def resolve api_map, name_pin, locals
+          found = locals.select{|p| p.name == word}
+          return inferred_pins(found, api_map, name_pin.context, locals) unless found.empty?
+          pins = api_map.get_method_stack(name_pin.context.namespace, word, scope: name_pin.context.scope)
+          return [] if pins.empty?
+          pins.unshift virtual_new_pin(pins.first, name_pin.context) if external_constructor?(pins.first, name_pin.context)
+          inferred_pins(pins, api_map, name_pin.context, locals)
+        end
+
+        private
+
+        # Create a `new` pin to facilitate type inference. This is necessary for
+        # classes from YARD and classes in the namespace that do not have an
+        # `initialize` method.
+        #
+        # @param new_pin [Solargraph::Pin::Base]
+        # @param context [Solargraph::ComplexType]
+        # @return [Pin::Method]
+        def virtual_new_pin new_pin, context
+          Pin::ProxyType.anonymous(ComplexType.try_parse(context.namespace))
+        end
+
+        def inferred_pins pins, api_map, context, locals
+          result = pins.map do |p|
+            if CoreFills::METHODS_RETURNING_SELF.include?(p.path)
+              next Solargraph::Pin::Method.new(p.location, p.namespace, p.name, "@return [#{context.tag}]", p.scope, p.visibility, p.parameters, p.node)
+            end
+            if CoreFills::METHODS_RETURNING_SUBTYPES.include?(p.path) && !context.subtypes.empty?
+              next Solargraph::Pin::Method.new(p.location, p.namespace, p.name, "@return [#{context.subtypes.first.tag}]", p.scope, p.visibility, p.parameters, p.node)
+            end
+            if p.kind == 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
+            next p if p.kind == Pin::METHOD || p.kind == Pin::ATTRIBUTE || p.kind == Pin::NAMESPACE
+            # type = p.infer(api_map)
+            type = p.typify(api_map)
+            type = p.probe(api_map) if type.undefined?
+            next p if p.return_complex_type == type
+            p.proxy type
+          end
+          result
+        end
+
+        def external_constructor? pin, context
+          pin.path == 'Class#new' || (pin.name == 'new' && pin.scope == :class && pin.return_type != context)
+        end
+
+        # @param pin [Pin::Method]
+        # @param api_map [ApiMap]
+        # @param context [ComplexType]
+        # @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.new(nil, nil, nil, ComplexType::UNDEFINED)
+        end
+
+        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.new(nil, nil, nil, ComplexType::UNDEFINED)
+        end
+
+        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
+          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.new(nil, nil, nil, ComplexType::UNDEFINED)
+        end
+      end
+    end
+  end
+end