solargraph 0.47.2 → 0.54.0

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

@@ -7,97 +7,100 @@ module Solargraph
         # @return [String]
         attr_reader :word
 
-        # @return [Array<Chain>]
+        # @return [::Array<Chain>]
         attr_reader :arguments
 
+        # @return [Chain, nil]
+        attr_reader :block
+
         # @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
+        # @param arguments [::Array<Chain>]
+        # @param block [Chain, nil]
+        def initialize word, arguments = [], block = nil
           @word = word
           @arguments = arguments
-          @with_block = with_block
+          @block = block
+          fix_block_pass
         end
 
         def with_block?
-          @with_block
+          !!@block
         end
 
         # @param api_map [ApiMap]
         # @param name_pin [Pin::Base]
-        # @param locals [Array<Pin::Base>]
+        # @param locals [::Array<Pin::LocalVariable>]
         def resolve api_map, name_pin, locals
           return super_pins(api_map, name_pin) if word == 'super'
+          return yield_pins(api_map, name_pin) if word == 'yield'
           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)
+          # @param [ComplexType::UniqueType]
+          pins = name_pin.binder.each_unique_type.flat_map do |context|
+            api_map.get_method_stack(context.namespace == '' ? '' : context.tag, word, scope: context.scope)
+          end
           return [] if pins.empty?
           inferred_pins(pins, api_map, name_pin.context, locals)
         end
 
         private
 
-        # @param pins [Array<Pin::Base>]
+        # @param pins [::Enumerable<Pin::Method>]
         # @param api_map [ApiMap]
         # @param context [ComplexType]
-        # @param locals [Pin::LocalVariable]
-        # @return [Array<Pin::Base>]
+        # @param locals [::Array<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 unless p.is_a?(Pin::Method)
+            overloads = p.signatures
             # 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?
+            # start with overloads that require blocks; if we are
+            # passing a block, we want to find a signature that will
+            # use it.  If we didn't pass a block, the logic below will
+            # reject it regardless
+
+            sorted_overloads = overloads.sort { |ol| ol.block? ? -1 : 1 }
+            new_signature_pin = nil
+            sorted_overloads.each do |ol|
+              next unless arity_matches?(arguments, ol)
               match = true
+
+              atypes = []
               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?('*')
+                  match = ol.parameters.any?(&:restarg?)
                   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)
+                atype = atypes[idx] ||= arg.infer(api_map, Pin::ProxyType.anonymous(context), locals)
                 # @todo Weak type comparison
-                unless atype.tag == other.tag || api_map.super_and_sub?(other.tag, atype.tag)
+                # unless atype.tag == param.return_type.tag || api_map.super_and_sub?(param.return_type.tag, atype.tag)
+                unless param.return_type.undefined? || atype.name == param.return_type.name || api_map.super_and_sub?(param.return_type.name, atype.name) || param.return_type.generic?
                   match = false
                   break
                 end
               end
               if match
-                type = extra_return_type(ol, context)
-                break if type
-                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?)
+                if ol.block && with_block?
+                  block_atypes = ol.block.parameters.map(&:return_type)
+                  blocktype = block_call_type(api_map, context, block_atypes, locals)
+                end
+                new_signature_pin = ol.resolve_generics_from_context_until_complete(ol.generics, atypes, nil, nil, blocktype)
+                new_return_type = new_signature_pin.return_type
+                type = with_params(new_return_type.self_to(context.to_s), context).qualify(api_map, context.namespace) if new_return_type.defined?
                 type ||= ComplexType::UNDEFINED
               end
               break if type.defined?
             end
+            p = p.with_single_signature(new_signature_pin) unless new_signature_pin.nil?
             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?
+            if !p.macros.empty?
               result = process_macro(p, api_map, context, locals)
               next result unless result.return_type.undefined?
             elsif !p.directives.empty?
@@ -107,19 +110,29 @@ module Solargraph
             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)
+            if pin.path == 'Class#new' && context.tag != 'Class'
+              pin.proxy(ComplexType.try_parse(context.namespace))
+            else
+              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
         end
 
-        # @param pin [Pin::Method]
+        # @param pin [Pin::Base]
         # @param api_map [ApiMap]
         # @param context [ComplexType]
-        # @param locals [Pin::Base]
+        # @param locals [Enumerable<Pin::Base>]
         # @return [Pin::Base]
         def process_macro pin, api_map, context, locals
           pin.macros.each do |macro|
+            # @todo 'Wrong argument type for
+            #   Solargraph::Source::Chain::Call#inner_process_macro:
+            #   macro expected YARD::Tags::MacroDirective, received
+            #   generic<Elem>' is because we lose 'rooted' information
+            #   in the 'Chain::Array' class internally, leaving
+            #   ::Array#each shadowed when it shouldn't be.
             result = inner_process_macro(pin, macro, api_map, context, locals)
             return result unless result.return_type.undefined?
           end
@@ -129,7 +142,7 @@ module Solargraph
         # @param pin [Pin::Method]
         # @param api_map [ApiMap]
         # @param context [ComplexType]
-        # @param locals [Pin::Base]
+        # @param locals [Enumerable<Pin::Base>]
         # @return [Pin::ProxyType]
         def process_directive pin, api_map, context, locals
           pin.directives.each do |dir|
@@ -141,11 +154,11 @@ module Solargraph
           Pin::ProxyType.anonymous ComplexType::UNDEFINED
         end
 
-        # @param pin [Pin]
+        # @param pin [Pin::Base]
         # @param macro [YARD::Tags::MacroDirective]
         # @param api_map [ApiMap]
         # @param context [ComplexType]
-        # @param locals [Array<Pin::Base>]
+        # @param locals [Enumerable<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)) }
@@ -169,35 +182,86 @@ module Solargraph
 
         # @param docstring [YARD::Docstring]
         # @param context [ComplexType]
-        # @return [ComplexType]
+        # @return [ComplexType, nil]
         def extra_return_type docstring, context
-          if docstring.has_tag?(:return_single_parameter) #&& context.subtypes.one?
+          if docstring.has_tag?('return_single_parameter') #&& context.subtypes.one?
             return context.subtypes.first || ComplexType::UNDEFINED
-          elsif docstring.has_tag?(:return_value_parameter) && context.value_types.one?
+          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>]
+        # @param arguments [::Array<Chain>]
+        # @param signature [Pin::Signature]
         # @return [Boolean]
-        def arguments_match arguments, parameters
+        def arity_matches? arguments, signature
+          parameters = signature.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?('*'))
+          parcount -= 1 if !parameters.empty? && parameters.last.block?
+          return false if signature.block? && !with_block?
+          return false if argcount < parcount && !(argcount == parcount - 1 && parameters.last.restarg?)
           true
         end
 
         # @param api_map [ApiMap]
         # @param name_pin [Pin::Base]
-        # @return [Array<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 = api_map.get_method_stack(name_pin.namespace, name_pin.name, scope: name_pin.context.scope)
           pins.reject{|p| p.path == name_pin.path}
         end
+
+        # @param api_map [ApiMap]
+        # @param name_pin [Pin::Base]
+        # @return [::Array<Pin::Base>]
+        def yield_pins api_map, name_pin
+          method_pin = api_map.get_method_stack(name_pin.namespace, name_pin.name, scope: name_pin.context.scope).first
+          return [] if method_pin.nil?
+
+          method_pin.signatures.map(&:block).compact
+        end
+
+        # @param type [ComplexType]
+        # @param context [ComplexType]
+        # @return [ComplexType]
+        def with_params type, context
+          return type unless type.to_s.include?('$')
+          ComplexType.try_parse(type.to_s.gsub('$', context.value_types.map(&:tag).join(', ')).gsub('<>', ''))
+        end
+
+        # @return [void]
+        def fix_block_pass
+          argument = @arguments.last&.links&.first
+          @block = @arguments.pop if argument.is_a?(BlockSymbol) || argument.is_a?(BlockVariable)
+        end
+
+        # @param api_map [ApiMap]
+        # @param context [ComplexType]
+        # @param block_parameter_types [::Array<ComplexType>]
+        # @param locals [::Array<Pin::LocalVariable>]
+        # @return [ComplexType, nil]
+        def block_call_type(api_map, context, block_parameter_types, locals)
+          return nil unless with_block?
+
+          # @todo Handle BlockVariable
+          if block.links.map(&:class) == [BlockSymbol]
+            # Ruby's shorthand for sending the passed in method name
+            # to the first yield parameter with no arguments
+            block_symbol_name = block.links.first.word
+            block_symbol_call_path = "#{block_parameter_types.first}##{block_symbol_name}"
+            callee = api_map.get_path_pins(block_symbol_call_path).first
+            return_type = callee&.return_type
+            # @todo: Figure out why we get unresolved generics at
+            #   this point and need to assume method return types
+            #   based on the generic type
+            return_type ||= api_map.get_path_pins("#{context.subtypes.first}##{block.links.first.word}").first&.return_type
+            return_type || ComplexType::UNDEFINED
+          else
+            block.infer(api_map, Pin::ProxyType.anonymous(context), locals)
+          end
+        end
       end
     end
   end

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

@@ -19,8 +19,14 @@ module Solargraph
           end
           parts = base.split('::')
           gates.each do |gate|
+            # @todo 'Wrong argument type for
+            #   Solargraph::Source::Chain::Constant#deep_constant_type:
+            #   gate expected String, received generic<Elem>' is because
+            #   we lose 'rooted' information in the 'Chain::Array' class
+            #   internally, leaving ::Array#each shadowed when it
+            #   shouldn't be.
             type = deep_constant_type(gate, api_map)
-            # Use deep inference to resolve root 
+            # 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)
@@ -35,6 +41,8 @@ module Solargraph
 
         private
 
+        # @param pin [Pin::Base]
+        # @return [::Array<String>]
         def crawl_gates pin
           clos = pin
           until clos.nil?
@@ -48,6 +56,9 @@ module Solargraph
           ['']
         end
 
+        # @param pins [::Array<Pin::Base>]
+        # @param api_map [ApiMap]
+        # @return [ComplexType]
         def first_pin_type(pins, api_map)
           type = ComplexType::UNDEFINED
           pins.each do |pin|
@@ -59,6 +70,9 @@ module Solargraph
           type
         end
 
+        # @param gate [String]
+        # @param api_map [ApiMap]
+        # @return [ComplexType]
         def deep_constant_type(gate, api_map)
           type = ComplexType::ROOT
           return type if gate == ''

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      class If < Link
+        def word
+          '<if>'
+        end
+
+        # @param links [::Array<Link>]
+        def initialize links
+          @links = links
+        end
+
+        def resolve api_map, name_pin, locals
+          types = @links.map { |link| link.infer(api_map, name_pin, locals) }
+          [Solargraph::Pin::ProxyType.anonymous(Solargraph::ComplexType.try_parse(types.map(&:tag).uniq.join(', ')))]
+        end
+      end
+    end
+  end
+end

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

@@ -7,8 +7,10 @@ module Solargraph
         # @return [String]
         attr_reader :word
 
+        # @return [Pin::Base]
         attr_accessor :last_context
 
+        # @param word [String]
         def initialize word = '<undefined>'
           @word = word
         end
@@ -23,12 +25,16 @@ module Solargraph
 
         # @param api_map [ApiMap]
         # @param name_pin [Pin::Base]
-        # @param locals [Array<Pin::Base>]
-        # @return [Array<Pin::Base>]
+        # @param locals [::Enumerable<Pin::Base>]
+        # @return [::Array<Pin::Base>]
         def resolve api_map, name_pin, locals
           []
         end
 
+        def inspect
+          "#{self.class} #{word}"
+        end
+
         def head?
           @head ||= false
         end

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

@@ -8,7 +8,7 @@ module Solargraph
           '<or>'
         end
 
-        # @param type [String]
+        # @param links [::Array<Link>]
         def initialize links
           @links = links
         end

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

@@ -7,11 +7,11 @@ module Solargraph
         # @return [String]
         attr_reader :word
 
-        # @return [Array<Chain>]
+        # @return [::Array<Chain>]
         attr_reader :arguments
 
         # @param word [String]
-        # @param arguments [Array<Chain>]
+        # @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
@@ -20,7 +20,7 @@ module Solargraph
 
         # @param api_map [ApiMap]
         # @param name_pin [Pin::Base]
-        # @param locals [Array<Pin::Base>]
+        # @param locals [::Array<Pin::Base>]
         def resolve api_map, name_pin, locals
           return super_pins(api_map, name_pin)
         end

data/lib/solargraph/source/chain.rb

@@ -19,23 +19,30 @@ module Solargraph
       autoload :GlobalVariable,   'solargraph/source/chain/global_variable'
       autoload :Literal,          'solargraph/source/chain/literal'
       autoload :Head,             'solargraph/source/chain/head'
+      autoload :If,               'solargraph/source/chain/if'
       autoload :Or,               'solargraph/source/chain/or'
       autoload :BlockVariable,    'solargraph/source/chain/block_variable'
+      autoload :BlockSymbol,      'solargraph/source/chain/block_symbol'
       autoload :ZSuper,           'solargraph/source/chain/z_super'
       autoload :Hash,             'solargraph/source/chain/hash'
+      autoload :Array,            'solargraph/source/chain/array'
 
       @@inference_stack = []
       @@inference_depth = 0
+      @@inference_invalidation_key = nil
+      @@inference_cache = {}
 
       UNDEFINED_CALL = Chain::Call.new('<undefined>')
       UNDEFINED_CONSTANT = Chain::Constant.new('<undefined>')
 
-      # @return [Array<Source::Chain::Link>]
+      # @return [::Array<Source::Chain::Link>]
       attr_reader :links
 
       attr_reader :node
 
-      # @param links [Array<Chain::Link>]
+      # @param node [Parser::AST::Node, nil]
+      # @param links [::Array<Chain::Link>]
+      # @param splat [Boolean]
       def initialize links, node = nil, splat = false
         @links = links.clone
         @links.push UNDEFINED_CALL if @links.empty?
@@ -56,28 +63,51 @@ module Solargraph
 
       # @param api_map [ApiMap]
       # @param name_pin [Pin::Base]
-      # @param locals [Array<Pin::Base>]
-      # @return [Array<Pin::Base>]
+      # @param locals [::Enumerable<Pin::LocalVariable>]
+      #
+      # @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)
-          type = infer_first_defined(pins, working_pin, api_map)
+          type = infer_first_defined(pins, working_pin, api_map, locals)
           return [] if type.undefined?
           working_pin = Pin::ProxyType.anonymous(type)
         end
-        links.last.last_context = working_pin
+        links.last.last_context = name_pin
         links.last.resolve(api_map, working_pin, locals)
       end
 
       # @param api_map [ApiMap]
       # @param name_pin [Pin::Base]
-      # @param locals [Array<Pin::Base>]
+      # @param locals [::Enumerable<Pin::LocalVariable>]
       # @return [ComplexType]
+      # @sg-ignore
       def infer api_map, name_pin, locals
+        out = nil
+        cached = @@inference_cache[[node, node.location, links.map(&:word), name_pin&.return_type, locals]] unless node.nil?
+        return cached if cached && @@inference_invalidation_key == api_map.hash
+        out = infer_uncached api_map, name_pin, locals
+        if @@inference_invalidation_key != api_map.hash
+          @@inference_cache = {}
+          @@inference_invalidation_key = api_map.hash
+        end
+        @@inference_cache[[node, node.location, links.map(&:word), name_pin&.return_type, locals]] = out unless node.nil?
+        out
+      end
+
+      # @param api_map [ApiMap]
+      # @param name_pin [Pin::Base]
+      # @param locals [::Enumerable<Pin::LocalVariable>]
+      # @return [ComplexType]
+      def infer_uncached api_map, name_pin, locals
+        from_here = base.infer(api_map, name_pin, locals) unless links.length == 1
+        if from_here
+          name_pin = name_pin.proxy(from_here)
+        end
         pins = define(api_map, name_pin, locals)
-        type = infer_first_defined(pins, links.last.last_context, api_map)
+        type = infer_first_defined(pins, links.last.last_context, api_map, locals)
         maybe_nil(type)
       end
 
@@ -109,29 +139,46 @@ module Solargraph
 
       private
 
-      # @param pins [Array<Pin::Base>]
+      # @param pins [::Array<Pin::Base>]
+      # @param context [Pin::Base]
       # @param api_map [ApiMap]
+      # @param locals [::Enumerable<Pin::LocalVariable>]
       # @return [ComplexType]
-      def infer_first_defined pins, context, api_map
+      def infer_first_defined pins, context, api_map, locals
         possibles = []
+        # @todo this param tag shouldn't be needed to probe the type
+        # @todo ...but given it is needed, typecheck should complain that it is needed
+        # @param pin [Pin::Base]
         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
           if type.defined?
-            possibles.push type
-            break if pin.is_a?(Pin::Method)
+            if type.generic?
+              # @todo even at strong, no typechecking complaint
+              #   happens when a [Pin::Base,nil] is passed into a method
+              #   that accepts only [Pin::Namespace] as an argument
+              type = type.resolve_generics(pin.closure, context.return_type)
+            end
+            if type.defined?
+              possibles.push type
+              break if pin.is_a?(Pin::Method)
+            end
           end
         end
         if possibles.empty?
           # Limit method inference recursion
           return ComplexType::UNDEFINED if @@inference_depth >= 10 && pins.first.is_a?(Pin::Method)
+
           @@inference_depth += 1
+          # @param pin [Pin::Base]
           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
@@ -143,17 +190,20 @@ module Solargraph
           @@inference_depth -= 1
         end
         return ComplexType::UNDEFINED if possibles.empty?
+
         type = if possibles.length > 1
           sorted = possibles.map { |t| t.rooted? ? "::#{t}" : t.to_s }.sort { |a, _| a == 'nil' ? 1 : 0 }
           ComplexType.parse(*sorted)
         else
-          possibles.first
+          ComplexType.parse(possibles.map(&:to_s).join(', '))
         end
         return type if context.nil? || context.return_type.undefined?
-        type.self_to(context.return_type.namespace)
+
+        type.self_to(context.return_type.tag)
       end
 
       # @param type [ComplexType]
+      # @return [ComplexType]
       def maybe_nil type
         return type if type.undefined? || type.void? || type.nullable?
         return type unless nullable?

data/lib/solargraph/source/change.rb

@@ -69,6 +69,9 @@ module Solargraph
 
       private
 
+      # @param text [String]
+      # @param insert [String]
+      # @return [String]
       def commit text, insert
         start_offset = Position.to_offset(text, range.start)
         end_offset = Position.to_offset(text, range.ending)

data/lib/solargraph/source/cursor.rb

@@ -115,6 +115,7 @@ module Solargraph
       end
       alias receiver recipient
 
+      # @return [AST::Node]
       def node
         @node ||= source.node_at(position.line, position.column)
       end
@@ -135,6 +136,7 @@ module Solargraph
         end
       end
 
+      # @return [Parser::AST::Node, nil]
       def recipient_node
         @recipient_node ||= Solargraph::Parser::NodeMethods.find_recipient_node(self)
       end

data/lib/solargraph/source/source_chainer.rb

@@ -14,10 +14,10 @@ module Solargraph
 
       class << self
         # @param source [Source]
-        # @param position [Position]
+        # @param position [Position, Array(Integer, Integer)]
         # @return [Source::Chain]
         def chain source, position
-          new(source, position).chain
+          new(source, Solargraph::Position.normalize(position)).chain
         end
       end
 
@@ -41,12 +41,12 @@ module Solargraph
           parent = nil
           if !source.repaired? && source.parsed? && source.synchronized?
             tree = source.tree_at(position.line, position.column)
-            # node, parent = source.tree_at(position.line, position.column)[0..2]
-            tree.shift while tree.length > 1 && tree.first.type == :SCOPE
             node, parent = tree[0..2]
           elsif source.parsed? && source.repaired? && end_of_phrase == '.'
             node, parent = source.tree_at(fixed_position.line, fixed_position.column)[0..2]
             node = Parser.parse(fixed_phrase) if node.nil?
+          elsif source.repaired?
+            node = Parser.parse(fixed_phrase)
           else
             node, parent = source.tree_at(fixed_position.line, fixed_position.column)[0..2] unless source.error_ranges.any?{|r| r.nil? || r.include?(fixed_position)}
             # Exception for positions that chain literal nodes in unsynchronized sources
@@ -58,7 +58,7 @@ module Solargraph
         end
         return Chain.new([Chain::UNDEFINED_CALL]) if node.nil? || (node.type == :sym && !phrase.start_with?(':'))
         # chain = NodeChainer.chain(node, source.filename, parent && parent.type == :block)
-        chain = Parser.chain(node, source.filename, parent && [:ITER, :block].include?(parent.type))
+        chain = Parser.chain(node, source.filename, parent)
         if source.repaired? || !source.parsed? || !source.synchronized?
           if end_of_phrase.strip == '.'
             chain.links.push Chain::UNDEFINED_CALL
@@ -126,10 +126,13 @@ module Solargraph
         Position.line_char_to_offset(@source.code, line, column)
       end
 
+      # @return [Integer]
       def signature_data
         @signature_data ||= get_signature_data_at(offset)
       end
 
+      # @param index [Integer]
+      # @return [Integer]
       def get_signature_data_at index
         brackets = 0
         squares = 0