solargraph 0.47.2 → 0.54.0

data/lib/solargraph/source/updater.rb

@@ -42,6 +42,7 @@ module Solargraph
         @output
       end
 
+      # @param text [String]
       # @return [String]
       def repair text
         changes.each do |ch|

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)
@@ -93,50 +92,6 @@ module Solargraph
       stack
     end
 
-    # Start synchronizing the source. This method updates the code without
-    # parsing a new AST. The resulting Source object will be marked not
-    # synchronized (#synchronized? == false).
-    #
-    # @param updater [Source::Updater]
-    # @return [Source]
-    def start_synchronize updater
-      raise 'Invalid synchronization' unless updater.filename == filename
-      real_code = updater.write(@code)
-      src = Source.allocate
-      src.filename = filename
-      src.code = real_code
-      src.version = updater.version
-      src.parsed = parsed?
-      src.repaired = updater.repair(@repaired)
-      src.synchronized = false
-      src.node = @node
-      src.comments = @comments
-      src.error_ranges = error_ranges
-      src.last_updater = updater
-      return src.finish_synchronize unless real_code.lines.length == @code.lines.length
-      src
-    end
-
-    # Finish synchronizing a source that was updated via #start_synchronize.
-    # This method returns self if the source is already synchronized. Otherwise
-    # it parses the AST and returns a new synchronized Source.
-    #
-    # @return [Source]
-    def finish_synchronize
-      return self if synchronized?
-      synced = Source.new(@code, filename)
-      if synced.parsed?
-        synced.version = version
-        return synced
-      end
-      synced = Source.new(@repaired, filename)
-      synced.error_ranges.concat (error_ranges + last_updater.changes.map(&:range))
-      synced.code = @code
-      synced.synchronized = true
-      synced.version = version
-      synced
-    end
-
     # Synchronize the Source with an update. This method applies changes to the
     # code, parses the new code's AST, and returns the resulting Source object.
     #
@@ -213,6 +168,7 @@ module Solargraph
       end
     end
 
+    # @return [::Array<Range>]
     def string_ranges
       @string_ranges ||= Parser.string_ranges(node)
     end
@@ -250,7 +206,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 +257,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 +279,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 +290,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 +369,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 +383,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 +415,7 @@ module Solargraph
       @code = val
     end
 
-    # @return [Parser::AST::Node]
+    # @return [Parser::AST::Node, nil]
     attr_writer :node
 
     # @return [Array<Range>]
@@ -476,7 +427,7 @@ module Solargraph
     # @return [Boolean]
     attr_writer :parsed
 
-    # @return [Array<Parser::Source::Comment>]
+    # @return [Hash{Integer => String}
     attr_writer :comments
 
     # @return [Boolean]
@@ -503,7 +454,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 +467,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

@@ -11,16 +11,23 @@ module Solargraph
       def initialize api_map, cursor
         @api_map = api_map
         @cursor = cursor
+        block.rebind(api_map) if block.is_a?(Pin::Block)
       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 +50,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 +101,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 +118,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 +142,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 +153,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 +172,7 @@ module Solargraph
         package_completions(result)
       end
 
+      # @return [Completion]
       def code_complete
         result = []
         result.concat complete_keyword_parameters
@@ -209,16 +210,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

data/lib/solargraph/source_map/mapper.rb

@@ -12,7 +12,7 @@ module Solargraph
 
       private_class_method :new
 
-      MACRO_REGEXP = /(@\!method|@\!attribute|@\!visibility|@\!domain|@\!macro|@\!parse|@\!override)/.freeze
+      DIRECTIVE_REGEXP = /(@\!method|@\!attribute|@\!visibility|@\!domain|@\!macro|@\!parse|@\!override)/.freeze
 
       # Generate the data.
       #
@@ -24,6 +24,8 @@ module Solargraph
         @code = source.code
         @comments = source.comments
         @pins, @locals = Parser.map(source)
+        @pins.each { |p| p.source = :code }
+        @locals.each { |l| l.source = :code }
         process_comment_directives
         [@pins, @locals]
       # rescue Exception => e
@@ -62,8 +64,12 @@ module Solargraph
         pins.select{|pin| pin.is_a?(Pin::Closure) and pin.location.range.contain?(position)}.last
       end
 
+      # @param source_position [Position]
+      # @param comment_position [Position]
+      # @param comment [String]
+      # @return [void]
       def process_comment source_position, comment_position, comment
-        return unless comment.encode('UTF-8', invalid: :replace, replace: '?') =~ MACRO_REGEXP
+        return unless comment.encode('UTF-8', invalid: :replace, replace: '?') =~ DIRECTIVE_REGEXP
         cmnt = remove_inline_comment_hashes(comment)
         parse = Solargraph::Source.parse_docstring(cmnt)
         last_line = 0
@@ -77,6 +83,8 @@ module Solargraph
       end
 
       # @param comment [String]
+      # @param tag [String]
+      # @param start [Integer]
       # @return [Integer]
       def find_directive_line_number comment, tag, start
         # Avoid overruning the index
@@ -105,7 +113,8 @@ module Solargraph
           begin
             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
+            method_gen_pins = Parser.process_node(src.node, region).first.select { |pin| pin.is_a?(Pin::Method) }
+            gen_pin = method_gen_pins.last
             return if gen_pin.nil?
             # Move the location to the end of the line so it gets recognized
             # as originating from a comment
@@ -135,7 +144,7 @@ module Solargraph
             )
           end
           if t.nil? || t.include?('w')
-            pins.push Solargraph::Pin::Method.new(
+            method_pin = Solargraph::Pin::Method.new(
               location: location,
               closure: namespace,
               name: "#{directive.tag.name}=",
@@ -144,7 +153,8 @@ module Solargraph
               visibility: :public,
               attribute: true
             )
-            pins.last.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last)
+            pins.push method_pin
+            method_pin.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
@@ -196,20 +206,26 @@ module Solargraph
           namespace.domains.concat directive.tag.types unless directive.tag.types.nil?
         when 'override'
           pins.push Pin::Reference::Override.new(location, directive.tag.name, docstring.tags)
+        when 'macro'
+          # @todo Handle macros
         end
       end
 
+      # @param line1 [Integer]
+      # @param line2 [Integer]
       def no_empty_lines?(line1, line2)
         @code.lines[line1..line2].none? { |line| line.strip.empty? }
       end
 
+      # @param comment [String]
+      # @return [String]
       def remove_inline_comment_hashes comment
         ctxt = ''
         num = nil
         started = false
         comment.lines.each { |l|
           # Trim the comment and minimum leading whitespace
-          p = l.encode('UTF-8', invalid: :replace, replace: '?').gsub(/^#/, '')
+          p = l.encode('UTF-8', invalid: :replace, replace: '?').gsub(/^#+/, '')
           if num.nil? && !p.strip.empty?
             num = p.index(/[^ ]/)
             started = true
@@ -224,7 +240,7 @@ module Solargraph
 
       # @return [void]
       def process_comment_directives
-        return unless @code.encode('UTF-8', invalid: :replace, replace: '?') =~ MACRO_REGEXP
+        return unless @code.encode('UTF-8', invalid: :replace, replace: '?') =~ DIRECTIVE_REGEXP
         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)

data/lib/solargraph/source_map.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
 require 'yard'
-require 'yard-solargraph'
-require 'set'
+require 'solargraph/yard_tags'
 
 module Solargraph
   # An index of pins and other ApiMap-related data for a Source.
@@ -18,7 +17,7 @@ module Solargraph
     # @return [Array<Pin::Base>]
     attr_reader :pins
 
-    # @return [Array<Pin::Base>]
+    # @return [Array<Pin::LocalVariable>]
     attr_reader :locals
 
     # @param source [Source]
@@ -30,19 +29,25 @@ module Solargraph
       @pins = pins
       @locals = locals
       environ.merge Convention.for_local(self) unless filename.nil?
+      self.convention_pins = environ.pins
       @pin_class_hash = pins.to_set.classify(&:class).transform_values(&:to_a)
       @pin_select_cache = {}
     end
 
+    # @param klass [Class]
+    # @return [Array<Pin::Base>]
     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
+    # A hash representing the state of the source map's API.
+    #
+    # ApiMap#catalog uses this value to determine whether it needs to clear its
+    # cache.
+    #
+    # @return [Integer]
+    def api_hash
+      @api_hash ||= (pins_by_class(Pin::Constant) + pins_by_class(Pin::Namespace).select { |pin| pin.namespace.to_s > '' } + pins_by_class(Pin::Reference) + pins_by_class(Pin::Method).map(&:node)).hash
     end
 
     # @return [String]
@@ -65,11 +70,12 @@ module Solargraph
       @environ ||= Environ.new
     end
 
+    # all pins except Solargraph::Pin::Reference::Reference
     # @return [Array<Pin::Base>]
     def document_symbols
-      @document_symbols ||= pins.select { |pin|
+      @document_symbols ||= (pins + convention_pins).select do |pin|
         pin.path && !pin.path.empty?
-      }
+      end
     end
 
     # @param query [String]
@@ -97,10 +103,16 @@ module Solargraph
       (pins + locals).select { |pin| pin.location == location }
     end
 
+    # @param line [Integer]
+    # @param character [Integer]
+    # @return [Pin::Method,Pin::Namespace]
     def locate_named_path_pin line, character
       _locate_pin line, character, Pin::Namespace, Pin::Method
     end
 
+    # @param line [Integer]
+    # @param character [Integer]
+    # @return [Pin::Namespace,Pin::Method,Pin::Block]
     def locate_block_pin line, character
       _locate_pin line, character, Pin::Namespace, Pin::Method, Pin::Block
     end
@@ -159,10 +171,23 @@ module Solargraph
 
     private
 
+    # @return [Array<Pin::Base>]
+    def convention_pins
+      @convention_pins || []
+    end
+
+    # @param pins [Array<Pin::Base>]
+    # @return [Array<Pin::Base>]
+    def convention_pins=(pins)
+      # unmemoizing the document_symbols in case it was called from any of convnetions
+      @document_symbols = nil
+      @convention_pins = pins
+    end
+
     # @param line [Integer]
     # @param character [Integer]
     # @param klasses [Array<Class>]
-    # @return [Pin::Base]
+    # @return [Pin::Base, nil]
     def _locate_pin line, character, *klasses
       position = Position.new(line, character)
       found = nil

data/lib/solargraph/type_checker/checks.rb

@@ -51,8 +51,13 @@ module Solargraph
       # @return [Boolean]
       def any_types_match? api_map, expected, inferred
         return duck_types_match?(api_map, expected, inferred) if expected.duck_type?
+        # walk through the union expected type and see if any members
+        # of the union match the inferred type
         expected.each do |exp|
           next if exp.duck_type?
+          # @todo: there should be a level of typechecking where all
+          #   unique types in the inferred must match one of the
+          #   expected unique types
           inferred.each do |inf|
             # return true if exp == inf || api_map.super_and_sub?(fuzz(inf), fuzz(exp))
             return true if exp == inf || either_way?(api_map, inf, exp)
@@ -103,9 +108,12 @@ module Solargraph
       # @param cls2 [ComplexType::UniqueType]
       # @return [Boolean]
       def either_way?(api_map, cls1, cls2)
-        f1 = fuzz(cls1)
-        f2 = fuzz(cls2)
+        # @todo there should be a level of typechecking which uses the
+        #   full tag with parameters to determine compatibility
+        f1 = cls1.name
+        f2 = cls2.name
         api_map.type_include?(f1, f2) || api_map.super_and_sub?(f1, f2) || api_map.super_and_sub?(f2, f1)
+        # api_map.type_include?(f1, f2) || api_map.super_and_sub?(f1, f2) || api_map.super_and_sub?(f2, f1)
       end
     end
   end