solargraph 0.39.0 → 0.40.0

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
@@ -56,7 +57,6 @@ module Solargraph
       # @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|
@@ -78,7 +78,6 @@ module Solargraph
       # @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
@@ -111,18 +110,21 @@ module Solargraph
       # @param api_map [ApiMap]
       # @return [ComplexType]
       def infer_first_defined pins, context, api_map
-        type = ComplexType::UNDEFINED
+        possibles = []
         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?
+          if type.defined?
+            possibles.push type
+            break if pin.is_a?(Pin::Method)
+          end
         end
-        if type.undefined?
+        if possibles.empty?
           # Limit method inference recursion
-          return type if @@inference_depth >= 10 && pins.first.is_a?(Pin::BaseMethod)
+          return ComplexType::UNDEFINED if @@inference_depth >= 10 && pins.first.is_a?(Pin::Method)
           @@inference_depth += 1
           pins.each do |pin|
             # Avoid infinite recursion
@@ -130,41 +132,22 @@ module Solargraph
             @@inference_stack.push pin.identity
             type = pin.probe(api_map)
             @@inference_stack.pop
-            break if type.defined?
+            if type.defined?
+              possibles.push type
+              break if pin.is_a?(Pin::Method)
+            end
           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
+        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
-          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
+          possibles.first
         end
+        return type if context.nil? || context.return_type.undefined?
+        type.self_to(context.return_type.namespace)
       end
     end
   end

data/lib/solargraph/source/source_chainer.rb

@@ -17,7 +17,6 @@ module Solargraph
         # @param position [Position]
         # @return [Source::Chain]
         def chain source, position
-          # raise "Not a source" unless source.is_a?(Source)
           new(source, position).chain
         end
       end
@@ -32,6 +31,8 @@ module Solargraph
 
       # @return [Source::Chain]
       def chain
+        # Special handling for files that end with an integer and a period
+        return Chain.new([Chain::Literal.new('Integer'), Chain::UNDEFINED_CALL]) if phrase =~ /^[0-9]+\.$/
         return Chain.new([Chain::Literal.new('Symbol')]) if phrase.start_with?(':') && !phrase.start_with?('::')
         begin
           return Chain.new([]) if phrase.end_with?('..')

data/lib/solargraph/source.rb

@@ -284,7 +284,7 @@ module Solargraph
 
     FOLDING_NODE_TYPES = if Parser.rubyvm?
       %i[
-        CLASS SCLASS MODULE DEFN DEFS IF WHILE UNLESS ITER STR
+        CLASS SCLASS MODULE DEFN DEFS IF WHILE UNLESS ITER STR HASH ARRAY LIST
       ].freeze
     else
       %i[
@@ -338,25 +338,29 @@ module Solargraph
 
     def first_not_empty_from line
       cursor = line
-      cursor += 1 while cursor < code.lines.length && code.lines[cursor].strip.empty?
-      cursor = line if cursor > code.lines.length
+      cursor += 1 while cursor < code_lines.length && code_lines[cursor].strip.empty?
+      cursor = line if cursor > code_lines.length - 1
       cursor
     end
 
     # @param top [Parser::AST::Node]
     # @param result [Array<Range>]
+    # @param parent [Symbol]
     # @return [void]
-    def inner_folding_ranges top, result = []
+    def inner_folding_ranges top, result = [], parent = nil
       # return unless top.is_a?(::Parser::AST::Node)
       return unless Parser.is_ast_node?(top)
       if FOLDING_NODE_TYPES.include?(top.type)
-        range = Range.from_node(top)
-        if result.empty? || range.start.line > result.last.start.line
-          result.push range unless range.ending.line - range.start.line < 2
+        # @todo Smelly exception for hash's first-level array in RubyVM
+        unless [:ARRAY, :LIST].include?(top.type) && parent == :HASH
+          range = Range.from_node(top)
+          if result.empty? || range.start.line > result.last.start.line
+            result.push range unless range.ending.line - range.start.line < 2
+          end
         end
       end
       top.children.each do |child|
-        inner_folding_ranges(child, result)
+        inner_folding_ranges(child, result, top.type)
       end
     end
 
@@ -468,8 +472,12 @@ module Solargraph
     # @return [Integer]
     attr_writer :version
 
+    # @param val [String]
     # @return [String]
-    attr_writer :code
+    def code=(val)
+      @code_lines= nil
+      @code = val
+    end
 
     # @return [Parser::AST::Node]
     attr_writer :node
@@ -492,6 +500,13 @@ module Solargraph
     # @return [Source::Updater]
     attr_accessor :last_updater
 
+    private
+
+    # @return [Array<String>]
+    def code_lines
+      @code_lines ||= code.lines
+    end
+
     class << self
       # @param filename [String]
       # @return [Solargraph::Source]

data/lib/solargraph/source_map/clip.rb

@@ -25,51 +25,12 @@ module Solargraph
       def complete
         return package_completions([]) if !source_map.source.parsed? || cursor.string?
         return package_completions(api_map.get_symbols) if cursor.chain.literal? && cursor.chain.links.last.word == '<Symbol>'
-        return Completion.new([], cursor.range) if cursor.chain.literal? || cursor.comment?
-        result = []
-        result.concat complete_keyword_parameters
-        if cursor.chain.constant? || cursor.start_of_constant?
-          full = cursor.chain.links.first.word
-          type = if cursor.chain.undefined?
-            cursor.chain.base.infer(api_map, context_pin, locals)
-          else
-            if full.include?('::') && cursor.chain.links.length == 1
-              ComplexType.try_parse(full.split('::')[0..-2].join('::'))
-            elsif cursor.chain.links.length > 1
-              ComplexType.try_parse(full)
-            else
-              ComplexType::UNDEFINED
-            end
-          end
-          if type.undefined?
-            if full.include?('::')
-              result.concat api_map.get_constants(full, *gates)
-            else
-              result.concat api_map.get_constants('', cursor.start_of_constant? ? '' : context_pin.full_context.namespace, *gates) #.select { |pin| pin.name.start_with?(full) }
-            end
-          else
-            result.concat api_map.get_constants(type.namespace, cursor.start_of_constant? ? '' : context_pin.full_context.namespace, *gates)
-          end
+        return Completion.new([], cursor.range) if cursor.chain.literal?
+        if cursor.comment?
+          tag_complete
         else
-          type = cursor.chain.base.infer(api_map, block, locals)
-          result.concat api_map.get_complex_type_methods(type, block.binder.namespace, cursor.chain.links.length == 1)
-          if cursor.chain.links.length == 1
-            if cursor.word.start_with?('@@')
-              return package_completions(api_map.get_class_variable_pins(context_pin.full_context.namespace))
-            elsif cursor.word.start_with?('@')
-              return package_completions(api_map.get_instance_variable_pins(block.binder.namespace, block.binder.scope))
-            elsif cursor.word.start_with?('$')
-              return package_completions(api_map.get_global_variable_pins)
-            end
-            result.concat locals
-            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 yielded_self_pins
-          end
+          code_complete
         end
-        package_completions(result)
       end
 
       # @return [Array<Pin::Base>]
@@ -111,6 +72,13 @@ module Solargraph
         end
       end
 
+      # @param phrase [String]
+      # @return [Array<Solargraph::Pin::Base>]
+      def translate phrase
+        chain = Parser.chain(Parser.parse(phrase))
+        chain.define(api_map, block, locals)
+      end
+
       private
 
       # @return [ApiMap]
@@ -181,10 +149,76 @@ module Solargraph
         frag_start = cursor.start_of_word.to_s.downcase
         filtered = result.uniq(&:name).select { |s|
           s.name.downcase.start_with?(frag_start) &&
-            (!s.is_a?(Pin::BaseMethod) || s.name.match(/^[a-z0-9_]+(\!|\?|=)?$/i))
+            (!s.is_a?(Pin::Method) || s.name.match(/^[a-z0-9_]+(\!|\?|=)?$/i))
         }
         Completion.new(filtered, cursor.range)
       end
+
+      def tag_complete
+        result = []
+        match = source_map.code[0..cursor.offset-1].match(/[\[<, ]([a-z0-9_:]*)\z/i)
+        if match
+          full = match[1]
+          if full.include?('::')
+            if full.end_with?('::')
+              result.concat api_map.get_constants(full[0..-3], *gates)
+            else
+              result.concat api_map.get_constants(full.split('::')[0..-2].join('::'), *gates)
+            end
+          else
+            result.concat api_map.get_constants('', full.end_with?('::') ? '' : context_pin.full_context.namespace, *gates) #.select { |pin| pin.name.start_with?(full) }
+          end
+        end
+        package_completions(result)
+      end
+
+      def code_complete
+        result = []
+        result.concat complete_keyword_parameters
+        if cursor.chain.constant? || cursor.start_of_constant?
+          full = cursor.chain.links.first.word
+          type = if cursor.chain.undefined?
+            cursor.chain.base.infer(api_map, context_pin, locals)
+          else
+            if full.include?('::') && cursor.chain.links.length == 1
+              ComplexType.try_parse(full.split('::')[0..-2].join('::'))
+            elsif cursor.chain.links.length > 1
+              ComplexType.try_parse(full)
+            else
+              ComplexType::UNDEFINED
+            end
+          end
+          if type.undefined?
+            if full.include?('::')
+              result.concat api_map.get_constants(full, *gates)
+            else
+              result.concat api_map.get_constants('', cursor.start_of_constant? ? '' : context_pin.full_context.namespace, *gates) #.select { |pin| pin.name.start_with?(full) }
+            end
+          else
+            result.concat api_map.get_constants(type.namespace, cursor.start_of_constant? ? '' : context_pin.full_context.namespace, *gates)
+          end
+        else
+          type = cursor.chain.base.infer(api_map, block, locals)
+          result.concat api_map.get_complex_type_methods(type, block.binder.namespace, cursor.chain.links.length == 1)
+          if cursor.chain.links.length == 1
+            if cursor.word.start_with?('@@')
+              return package_completions(api_map.get_class_variable_pins(context_pin.full_context.namespace))
+            elsif cursor.word.start_with?('@')
+              return package_completions(api_map.get_instance_variable_pins(block.binder.namespace, block.binder.scope))
+            elsif cursor.word.start_with?('$')
+              return package_completions(api_map.get_global_variable_pins)
+            end
+            result.concat locals
+            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
+            result.concat yielded_self_pins
+          end
+        end
+        package_completions(result)
+      end
     end
   end
 end

data/lib/solargraph/source_map/mapper.rb

@@ -68,7 +68,7 @@ module Solargraph
         # @param d [YARD::Tags::Directive]
         parse.directives.each do |d|
           line_num = find_directive_line_number(cmnt, d.tag.tag_name, last_line)
-          pos = Solargraph::Position.new(comment_position.line + line_num, comment_position.column)
+          pos = Solargraph::Position.new(comment_position.line + line_num - 1, comment_position.column)
           process_directive(source_position, pos, d)
           last_line = line_num + 1
           # @todo The below call assumes the topmost comment line. The above
@@ -79,7 +79,11 @@ module Solargraph
         end
       end
 
+      # @param comment [String]
+      # @return [Integer]
       def find_directive_line_number comment, tag, start
+        # Avoid overruning the index
+        return start unless start < comment.lines.length
         num = comment.lines[start..-1].find_index do |line|
           # Legacy method directives might be `@method` instead of `@!method`
           # @todo Legacy syntax should probably emit a warning
@@ -91,23 +95,24 @@ module Solargraph
       # @param source_position [Position]
       # @param comment_position [Position]
       # @param directive [YARD::Tags::Directive]
+      # @return [void]
       def process_directive source_position, comment_position, directive
         docstring = Solargraph::Source.parse_docstring(directive.tag.text).to_docstring
         location = Location.new(@filename, Range.new(comment_position, comment_position))
         case directive.tag.tag_name
         when 'method'
-          namespace = closure_at(source_position)
+          namespace = closure_at(source_position) || @pins.first
           if namespace.location.range.start.line < comment_position.line
             namespace = closure_at(comment_position)
           end
-          region = Parser::Region.new(source: @source, closure: namespace)
           begin
-            src_node = Parser.parse("def #{directive.tag.name};end", @filename, location.range.start.line)
-            gen_pin = Parser.process_node(src_node, region).first.last
+            src = Solargraph::Source.load_string("def #{directive.tag.name};end", @source.filename)
+            region = Parser::Region.new(source: src, closure: namespace)
+            gen_pin = Parser.process_node(src.node, region).first.last
             return if gen_pin.nil?
-            # Move the location to the end of the line so the it gets
-            # recognized as originating from a comment
-            shifted = Solargraph::Position.new(comment_position.line, @code.lines[comment_position.line].chomp.length)
+            # Move the location to the end of the line so it gets recognized
+            # as originating from a comment
+            shifted = Solargraph::Position.new(comment_position.line, @code.lines[comment_position.line].to_s.chomp.length)
             # @todo: Smelly instance variable access
             gen_pin.instance_variable_set(:@comments, docstring.all.to_s)
             gen_pin.instance_variable_set(:@location, Solargraph::Location.new(@filename, Range.new(shifted, shifted)))
@@ -121,35 +126,50 @@ module Solargraph
           namespace = closure_at(source_position)
           t = (directive.tag.types.nil? || directive.tag.types.empty?) ? nil : directive.tag.types.flatten.join('')
           if t.nil? || t.include?('r')
-            pins.push Solargraph::Pin::Attribute.new(
+            pins.push Solargraph::Pin::Method.new(
               location: location,
               closure: namespace,
               name: directive.tag.name,
               comments: docstring.all.to_s,
-              access: :reader,
               scope: namespace.is_a?(Pin::Singleton) ? :class : :instance,
               visibility: :public,
-              explicit: false
+              explicit: false,
+              attribute: true
             )
           end
           if t.nil? || t.include?('w')
-            pins.push Solargraph::Pin::Attribute.new(
+            pins.push Solargraph::Pin::Method.new(
               location: location,
               closure: namespace,
               name: "#{directive.tag.name}=",
               comments: docstring.all.to_s,
-              access: :writer,
               scope: namespace.is_a?(Pin::Singleton) ? :class : :instance,
-              visibility: :public
+              visibility: :public,
+              attribute: true
             )
+            pins.last.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last)
+            if pins.last.return_type.defined?
+              pins.last.docstring.add_tag YARD::Tags::Tag.new(:param, '', pins.last.return_type.to_s.split(', '), 'value')
+            end
           end
         when 'parse'
-          ns = closure_at(source_position)
-          region = Parser::Region.new(source: @source, closure: ns)
           begin
-            node = Parser.parse(directive.tag.text, @filename, comment_position.line)
+            ns = closure_at(source_position)
+            src = Solargraph::Source.load_string(directive.tag.text, @source.filename)
+            region = Parser::Region.new(source: src, closure: ns)
             # @todo These pins may need to be marked not explicit
-            Parser.process_node(node, region, @pins)
+            index = @pins.length
+            loff = if @code.lines[comment_position.line].strip.end_with?('@!parse')
+              comment_position.line + 1
+            else
+              comment_position.line
+            end
+            Parser.process_node(src.node, region, @pins)
+            @pins[index..-1].each do |p|
+              # @todo Smelly instance variable access
+              p.location.range.start.instance_variable_set(:@line, p.location.range.start.line + loff)
+              p.location.range.ending.instance_variable_set(:@line, p.location.range.ending.line + loff)
+            end
           rescue Parser::SyntaxError => e
             # @todo Handle parser errors in !parse directives
           end
@@ -183,10 +203,10 @@ module Solargraph
       # @return [void]
       def process_comment_directives
         return unless @code =~ MACRO_REGEXP
-        used = []
+        code_lines = @code.lines
         @source.associated_comments.each do |line, comments|
-          src_pos = line ? Position.new(line, @code.lines[line].to_s.chomp.index(/[^\s]/) || 0) : Position.new(@code.lines.length, 0)
-          com_pos = Position.new(line - 1, 0)
+          src_pos = line ? Position.new(line, code_lines[line].to_s.chomp.index(/[^\s]/) || 0) : Position.new(code_lines.length, 0)
+          com_pos = Position.new(line + 1 - comments.lines.length, 0)
           process_comment(src_pos, com_pos, comments)
         end
       end

data/lib/solargraph/source_map.rb

@@ -3,6 +3,7 @@
 require 'jaro_winkler'
 require 'yard'
 require 'yard-solargraph'
+require 'set'
 
 module Solargraph
   # An index of pins and other ApiMap-related data for a Source.
@@ -29,7 +30,20 @@ module Solargraph
       @source = source.dup
       @pins = pins
       @locals = locals
-      environ.merge Convention.for(source)
+      environ.merge Convention.for_local(self) unless filename.nil?
+      @pin_class_hash = pins.to_set.classify(&:class).transform_values(&:to_a)
+      @pin_select_cache = {}
+    end
+
+    def pins_by_class klass
+      @pin_select_cache[klass] ||= @pin_class_hash.select { |key, _| key <= klass }.values.flatten
+    end
+
+    def rebindable_method_names
+      @rebindable_method_names ||= pins_by_class(Pin::Method)
+        .select { |pin| pin.comments && pin.comments.include?('@yieldself') }
+        .map(&:name)
+        .to_set
     end
 
     # @return [String]
@@ -44,7 +58,7 @@ module Solargraph
 
     # @return [Array<Pin::Reference::Require>]
     def requires
-      @requires ||= pins.select{ |p| p.is_a?(Pin::Reference::Require) }
+      pins_by_class(Pin::Reference::Require)
     end
 
     # @return [Environ]
@@ -62,6 +76,7 @@ module Solargraph
     # @param query [String]
     # @return [Array<Pin::Base>]
     def query_symbols query
+      return document_symbols if query && query.empty?
       document_symbols.select{ |pin| fuzzy_string_match(pin.path, query) || fuzzy_string_match(pin.name, query) }
     end
 
@@ -153,6 +168,9 @@ module Solargraph
       position = Position.new(line, character)
       found = nil
       pins.each do |pin|
+        # @todo Attribute pins should not be treated like closures, but
+        #   there's probably a better way to handle it
+        next if pin.is_a?(Pin::Method) && pin.attribute?
         found = pin if (klasses.empty? || klasses.any? { |kls| pin.is_a?(kls) } ) && pin.location.range.contain?(position)
         break if pin.location.range.start.line > line
       end

data/lib/solargraph/type_checker/param_def.rb

@@ -20,7 +20,7 @@ module Solargraph
       class << self
         # Get an array of ParamDefs from a method pin.
         #
-        # @param pin [Solargraph::Pin::BaseMethod]
+        # @param pin [Solargraph::Pin::Method]
         # @return [Array<ParamDef>]
         def from pin
           result = []