solargraph 0.47.2 → 0.53.3

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,10 +19,13 @@ 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
@@ -30,12 +33,14 @@ module Solargraph
       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 +61,33 @@ 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]
       def infer 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 +119,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 +170,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

data/lib/solargraph/source.rb

@@ -8,7 +8,6 @@ module Solargraph
   class Source
     autoload :Updater,       'solargraph/source/updater'
     autoload :Change,        'solargraph/source/change'
-    autoload :Mapper,        'solargraph/source/mapper'
     autoload :EncodingFixes, 'solargraph/source/encoding_fixes'
     autoload :Cursor,        'solargraph/source/cursor'
     autoload :Chain,         'solargraph/source/chain'
@@ -33,7 +32,7 @@ module Solargraph
     attr_reader :version
 
     # @param code [String]
-    # @param filename [String]
+    # @param filename [String, nil]
     # @param version [Integer]
     def initialize code, filename = nil, version = 0
       @code = normalize(code)
@@ -213,6 +212,7 @@ module Solargraph
       end
     end
 
+    # @return [::Array<Range>]
     def string_ranges
       @string_ranges ||= Parser.string_ranges(node)
     end
@@ -250,7 +250,7 @@ module Solargraph
     end
 
     # @param node [Parser::AST::Node]
-    # @return [String]
+    # @return [String, nil]
     def comments_for node
       rng = Range.from_node(node)
       stringified_comments[rng.start.line] ||= begin
@@ -301,7 +301,7 @@ module Solargraph
 
     # Get a hash of comments grouped by the line numbers of the associated code.
     #
-    # @return [Hash{Integer => Array<Parser::Source::Comment>}]
+    # @return [Hash{Integer => String}]
     def associated_comments
       @associated_comments ||= begin
         result = {}
@@ -323,6 +323,8 @@ module Solargraph
 
     private
 
+    # @param line [Integer]
+    # @return [Integer]
     def first_not_empty_from line
       cursor = line
       cursor += 1 while cursor < code_lines.length && code_lines[cursor].strip.empty?
@@ -332,7 +334,7 @@ module Solargraph
 
     # @param top [Parser::AST::Node]
     # @param result [Array<Range>]
-    # @param parent [Symbol]
+    # @param parent [Symbol, nil]
     # @return [void]
     def inner_folding_ranges top, result = [], parent = nil
       return unless Parser.is_ast_node?(top)
@@ -411,7 +413,7 @@ module Solargraph
       result
     end
 
-    # @param n [Parser::AST::Node]
+    # @param n [Parser::AST::Node, nil]
     # @return [Array<Parser::AST::Node>]
     def string_nodes_in n
       result = []
@@ -425,30 +427,23 @@ module Solargraph
       result
     end
 
-    # @param node [Parser::AST::Node]
+    # @param node [Parser::AST::Node, nil]
     # @param position [Position]
     # @param stack [Array<Parser::AST::Node>]
     # @return [void]
     def inner_tree_at node, position, stack
       return if node.nil?
       here = Range.from_node(node)
-      if here.contain?(position) || colonized(here, position, node)
+      if here.contain?(position)
         stack.unshift node
         node.children.each do |c|
           next unless Parser.is_ast_node?(c)
-          next if !Parser.rubyvm? && c.loc.expression.nil?
+          next if c.loc.expression.nil?
           inner_tree_at(c, position, stack)
         end
       end
     end
 
-    def colonized range, position, node
-      node.type == :COLON2 &&
-        range.ending.line == position.line &&
-        range.ending.character == position.character - 2 &&
-        code[Position.to_offset(code, Position.new(position.line, position.character - 2)), 2] == '::'
-    end
-
     protected
 
     # @return [String]
@@ -464,7 +459,7 @@ module Solargraph
       @code = val
     end
 
-    # @return [Parser::AST::Node]
+    # @return [Parser::AST::Node, nil]
     attr_writer :node
 
     # @return [Array<Range>]
@@ -476,7 +471,7 @@ module Solargraph
     # @return [Boolean]
     attr_writer :parsed
 
-    # @return [Array<Parser::Source::Comment>]
+    # @return [Hash{Integer => String}
     attr_writer :comments
 
     # @return [Boolean]
@@ -503,7 +498,7 @@ module Solargraph
       end
 
       # @param code [String]
-      # @param filename [String]
+      # @param filename [String, nil]
       # @param version [Integer]
       # @return [Solargraph::Source]
       def load_string code, filename = nil, version = 0
@@ -516,6 +511,10 @@ module Solargraph
         # HACK: Pass a dummy code object to the parser for plugins that
         # expect it not to be nil
         YARD::Docstring.parser.parse(comments, YARD::CodeObjects::Base.new(:root, 'stub'))
+      rescue StandardError => e
+        Solargraph.logger.info "YARD failed to parse docstring: [#{e.class}] #{e.message}"
+        Solargraph.logger.debug "Unparsed comment: #{comments}"
+        YARD::Docstring.parser
       end
     end
   end

data/lib/solargraph/source_map/clip.rb

@@ -13,14 +13,20 @@ module Solargraph
         @cursor = cursor
       end
 
-      # @return [Array<Pin::Base>]
+      # @return [Array<Pin::Base>] Relevant pins for infering the type of the Cursor's position
       def define
         return [] if cursor.comment? || cursor.chain.literal?
         result = cursor.chain.define(api_map, block, locals)
+        result.concat file_global_methods
         result.concat((source_map.pins + source_map.locals).select{ |p| p.name == cursor.word && p.location.range.contain?(cursor.position) }) if result.empty?
         result
       end
 
+      # @return [Array<Pin::Base>]
+      def types
+        infer.namespaces.map { |namespace| api_map.get_path_pins(namespace) }.flatten
+      end
+
       # @return [Completion]
       def complete
         return package_completions([]) if !source_map.source.parsed? || cursor.string?
@@ -43,19 +49,25 @@ module Solargraph
       # @return [ComplexType]
       def infer
         result = cursor.chain.infer(api_map, block, locals)
+        if result.tag == 'Class'
+          # HACK: Exception to return BasicObject from Class#new
+          dfn = cursor.chain.define(api_map, block, locals).first
+          return ComplexType.try_parse('BasicObject') if dfn && dfn.path == 'Class#new'
+        end
         return result unless result.tag == 'self'
-        ComplexType.try_parse(cursor.chain.base.infer(api_map, block, locals).namespace)
+        ComplexType.try_parse(cursor.chain.base.infer(api_map, block, locals).tag)
       end
 
       # Get an array of all the locals that are visible from the cursors's
       # position. Locals can be local variables, method parameters, or block
       # parameters. The array starts with the nearest local pin.
       #
-      # @return [Array<Solargraph::Pin::Base>]
+      # @return [::Array<Solargraph::Pin::Base>]
       def locals
         @locals ||= source_map.locals_at(location)
       end
 
+      # @return [::Array<String>]
       def gates
         block.gates
       end
@@ -88,11 +100,12 @@ module Solargraph
         @source_map ||= api_map.source_map(cursor.filename)
       end
 
+      # @return [Location]
       def location
         Location.new(source_map.filename, Solargraph::Range.new(cursor.position, cursor.position))
       end
 
-      # @return [Solargraph::Pin::Base]
+      # @return [Solargraph::Pin::Closure]
       def block
         @block ||= source_map.locate_block_pin(cursor.node_position.line, cursor.node_position.character)
       end
@@ -104,22 +117,7 @@ module Solargraph
         @context_pin ||= source_map.locate_named_path_pin(cursor.node_position.line, cursor.node_position.character)
       end
 
-      # @return [Array<Pin::Base>]
-      def yielded_self_pins
-        return [] unless block.is_a?(Pin::Block) && block.receiver
-        chain = Parser.chain(block.receiver, source_map.source.filename)
-        receiver_pin = chain.define(api_map, context_pin, locals).first
-        return [] if receiver_pin.nil?
-        result = []
-        ys = receiver_pin.docstring.tag(:yieldpublic)
-        unless ys.nil? || ys.types.empty?
-          ysct = ComplexType.try_parse(*ys.types).qualify(api_map, receiver_pin.context.namespace)
-          result.concat api_map.get_complex_type_methods(ysct, '', false)
-        end
-        result
-      end
-
-      # @return [Array<Pin::KeywordParam]
+      # @return [Array<Pin::KeywordParam>]
       def complete_keyword_parameters
         return [] unless cursor.argument? && cursor.chain.links.one? && cursor.word =~ /^[a-z0-9_]*:?$/
         pins = signify
@@ -143,7 +141,7 @@ module Solargraph
         result
       end
 
-      # @param result [Array<Pin::Base>]
+      # @param result [Enumerable<Pin::Base>]
       # @return [Completion]
       def package_completions result
         frag_start = cursor.start_of_word.to_s.downcase
@@ -154,6 +152,7 @@ module Solargraph
         Completion.new(filtered, cursor.range)
       end
 
+      # @return [Completion]
       def tag_complete
         result = []
         match = source_map.code[0..cursor.offset-1].match(/[\[<, ]([a-z0-9_:]*)\z/i)
@@ -172,6 +171,7 @@ module Solargraph
         package_completions(result)
       end
 
+      # @return [Completion]
       def code_complete
         result = []
         result.concat complete_keyword_parameters
@@ -209,16 +209,23 @@ module Solargraph
               return package_completions(api_map.get_global_variable_pins)
             end
             result.concat locals
+            result.concat file_global_methods unless block.binder.namespace.empty?
             result.concat api_map.get_constants(context_pin.context.namespace, *gates)
             result.concat api_map.get_methods(block.binder.namespace, scope: block.binder.scope, visibility: [:public, :private, :protected])
             result.concat api_map.get_methods('Kernel')
-            # result.concat ApiMap.keywords
             result.concat api_map.keyword_pins.to_a
-            result.concat yielded_self_pins
           end
         end
         package_completions(result)
       end
+
+      # @return [Array<Pin::Base>]
+      def file_global_methods
+        return [] if cursor.word.empty?
+        source_map.pins.select do |pin|
+          pin.is_a?(Pin::Method) && pin.namespace == '' && pin.name.start_with?(cursor.word)
+        end
+      end
     end
   end
 end