solargraph 0.54.0 → 0.58.0

data/lib/solargraph/source.rb

@@ -15,17 +15,26 @@ module Solargraph
 
     include EncodingFixes
 
-    # @return [String]
+    # @return [String, nil]
     attr_reader :filename
 
     # @return [String]
-    attr_reader :code
+    def code
+      finalize
+      @code
+    end
 
-    # @return [Parser::AST::Node]
-    attr_reader :node
+    # @return [Parser::AST::Node, nil]
+    def node
+      finalize
+      @node
+    end
 
-    # @return [Hash{Integer => Array<String>}]
-    attr_reader :comments
+    # @return [Hash{Integer => Solargraph::Parser::Snippet}]
+    def comments
+      finalize
+      @comments
+    end
 
     # @todo Deprecate?
     # @return [Integer]
@@ -39,17 +48,6 @@ module Solargraph
       @repaired = code
       @filename = filename
       @version = version
-      @domains = []
-      begin
-        @node, @comments = Solargraph::Parser.parse_with_comments(@code, filename)
-        @parsed = true
-      rescue Parser::SyntaxError, EncodingError => e
-        @node = nil
-        @comments = {}
-        @parsed = false
-      ensure
-        @code.freeze
-      end
     end
 
     # @param range [Solargraph::Range]
@@ -64,9 +62,9 @@ module Solargraph
     # @param c2 [Integer]
     # @return [String]
     def from_to l1, c1, l2, c2
-      b = Solargraph::Position.line_char_to_offset(@code, l1, c1)
-      e = Solargraph::Position.line_char_to_offset(@code, l2, c2)
-      @code[b..e-1]
+      b = Solargraph::Position.line_char_to_offset(code, l1, c1)
+      e = Solargraph::Position.line_char_to_offset(code, l2, c2)
+      code[b..e-1]
     end
 
     # Get the nearest node that contains the specified index.
@@ -85,10 +83,9 @@ module Solargraph
     # @param column [Integer]
     # @return [Array<AST::Node>]
     def tree_at(line, column)
-      # offset = Position.line_char_to_offset(@code, line, column)
       position = Position.new(line, column)
       stack = []
-      inner_tree_at @node, position, stack
+      inner_tree_at node, position, stack
       stack
     end
 
@@ -104,68 +101,53 @@ module Solargraph
         @version = updater.version
         return self
       end
-      synced = Source.new(real_code, filename)
-      if synced.parsed?
-        synced.version = updater.version
-        return synced
+      Source.new(@code, filename, updater.version).tap do |src|
+        src.repaired = @repaired
+        src.error_ranges.concat error_ranges
+        src.changes.concat(changes + updater.changes)
       end
-      incr_code = updater.repair(@repaired)
-      synced = Source.new(incr_code, filename)
-      synced.error_ranges.concat (error_ranges + updater.changes.map(&:range))
-      synced.code = real_code
-      synced.version = updater.version
-      synced
     end
 
     # @param position [Position, Array(Integer, Integer)]
     # @return [Source::Cursor]
     def cursor_at position
+      finalize
       Cursor.new(self, position)
     end
 
     # @return [Boolean]
     def parsed?
+      finalize
       @parsed
     end
 
     def repaired?
-      @is_repaired ||= (@code != @repaired)
+      code != @repaired
     end
 
     # @param position [Position]
     # @return [Boolean]
     def string_at? position
-      if Parser.rubyvm?
-        string_ranges.each do |range|
-          if synchronized?
-            return true if range.include?(position) || range.ending == position
-          else
-            return true if last_updater && last_updater.changes.one? && range.contain?(last_updater.changes.first.range.start)
-          end
-        end
-        false
-      else
-        return false if Position.to_offset(code, position) >= code.length
-        string_nodes.each do |node|
-          range = Range.from_node(node)
-          next if range.ending.line < position.line
-          break if range.ending.line > position.line
-          return true if node.type == :str && range.include?(position) && range.start != position
-          return true if [:STR, :str].include?(node.type) && range.include?(position) && range.start != position
-          if node.type == :dstr
-            inner = node_at(position.line, position.column)
-            next if inner.nil?
-            inner_range = Range.from_node(inner)
-            next unless range.include?(inner_range.ending)
-            return true if inner.type == :str
-            inner_code = at(Solargraph::Range.new(inner_range.start, position))
-            return true if (inner.type == :dstr && inner_range.ending.character <= position.character) && !inner_code.end_with?('}') ||
-              (inner.type != :dstr && inner_range.ending.line == position.line && position.character <= inner_range.ending.character && inner_code.end_with?('}'))
-          end
-          break if range.ending.line > position.line
+      return false if Position.to_offset(code, position) >= code.length
+      string_nodes.each do |node|
+        range = Range.from_node(node)
+        next if range.ending.line < position.line
+        break if range.ending.line > position.line
+        return true if node.type == :str && range.include?(position) && range.start != position
+        return true if [:STR, :str].include?(node.type) && range.include?(position) && range.start != position
+        if node.type == :dstr
+          inner = node_at(position.line, position.column)
+          next if inner.nil?
+          inner_range = Range.from_node(inner)
+          next unless range.include?(inner_range.ending)
+          return true if inner.type == :str
+          inner_code = at(Solargraph::Range.new(inner_range.start, position))
+          return true if (inner.type == :dstr && inner_range.ending.character <= position.character) && !inner_code.end_with?('}') ||
+                         (inner.type != :dstr && inner_range.ending.line == position.line && position.character <= inner_range.ending.character && inner_code.end_with?('}'))
         end
-        false
+        break if range.ending.line > position.line
       end
+      false
     end
 
     # @return [::Array<Range>]
@@ -199,8 +181,8 @@ module Solargraph
     # @return [String]
     def code_for(node)
       rng = Range.from_node(node)
-      b = Position.line_char_to_offset(@code, rng.start.line, rng.start.column)
-      e = Position.line_char_to_offset(@code, rng.ending.line, rng.ending.column)
+      b = Position.line_char_to_offset(code, rng.start.line, rng.start.column)
+      e = Position.line_char_to_offset(code, rng.ending.line, rng.ending.column)
       frag = code[b..e-1].to_s
       frag.strip.gsub(/,$/, '')
     end
@@ -225,15 +207,9 @@ module Solargraph
       Location.new(filename, range)
     end
 
-    FOLDING_NODE_TYPES = if Parser.rubyvm?
-      %i[
-        CLASS SCLASS MODULE DEFN DEFS IF WHILE UNLESS ITER STR HASH ARRAY LIST
-      ].freeze
-    else
-      %i[
+    FOLDING_NODE_TYPES = %i[
         class sclass module def defs if str dstr array while unless kwbegin hash block
       ].freeze
-    end
 
     # Get an array of ranges that can be folded, e.g., the range of a class
     # definition or an if condition.
@@ -251,8 +227,7 @@ module Solargraph
     end
 
     def synchronized?
-      @synchronized = true if @synchronized.nil?
-      @synchronized
+      true
     end
 
     # Get a hash of comments grouped by the line numbers of the associated code.
@@ -260,10 +235,12 @@ module Solargraph
     # @return [Hash{Integer => String}]
     def associated_comments
       @associated_comments ||= begin
+        # @type [Hash{Integer => String}]
         result = {}
         buffer = String.new('')
+        # @type [Integer, nil]
         last = nil
-        @comments.each_pair do |num, snip|
+        comments.each_pair do |num, snip|
           if !last || num == last + 1
             buffer.concat "#{snip.text}\n"
           else
@@ -295,12 +272,9 @@ module Solargraph
     def inner_folding_ranges top, result = [], parent = nil
       return unless Parser.is_ast_node?(top)
       if FOLDING_NODE_TYPES.include?(top.type)
-        # @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
+        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
       top.children.each do |child|
@@ -334,19 +308,19 @@ module Solargraph
 
     # A hash of line numbers and their associated comments.
     #
-    # @return [Hash{Integer => Array<String>}]
+    # @return [Hash{Integer => Array<String>, nil}]
     def stringified_comments
       @stringified_comments ||= {}
     end
 
     # @return [Array<Parser::AST::Node>]
     def string_nodes
-      @string_nodes ||= string_nodes_in(@node)
+      @string_nodes ||= string_nodes_in(node)
     end
 
-    # @return [Array<Range>]
+    # @return [Array<Solargraph::Range>]
     def comment_ranges
-      @comment_ranges ||= @comments.values.map(&:range)
+      @comment_ranges ||= comments.values.map(&:range)
     end
 
     # Get an array of foldable comment block ranges. Blocks are excluded if
@@ -402,16 +376,60 @@ module Solargraph
 
     protected
 
+    # @return [Array<Change>]
+    def changes
+      @changes ||= []
+    end
+
     # @return [String]
     attr_writer :filename
 
     # @return [Integer]
     attr_writer :version
 
+    # @return [void]
+    def finalize
+      return if @finalized && changes.empty?
+
+      changes.each do |change|
+        @code = change.write(@code)
+      end
+      @finalized = true
+      begin
+        @node, @comments = Solargraph::Parser.parse_with_comments(@code, filename)
+        @parsed = true
+        @repaired = @code
+      rescue Parser::SyntaxError, EncodingError => e
+        @node = nil
+        @comments = {}
+        @parsed = false
+      ensure
+        @code.freeze
+      end
+      if !@parsed && !changes.empty?
+        changes.each do |change|
+          @repaired = change.repair(@repaired)
+        end
+        error_ranges.concat(changes.map(&:range))
+        begin
+          @node, @comments = Solargraph::Parser.parse_with_comments(@repaired, filename)
+          @parsed = true
+        rescue Parser::SyntaxError, EncodingError => e
+          @node = nil
+          @comments = {}
+          @parsed = false
+        end
+      elsif @parsed
+        error_ranges.clear
+      end
+      changes.clear
+    end
+
     # @param val [String]
     # @return [String]
     def code=(val)
-      @code_lines= nil
+      @code_lines = nil
+      @finalized = false
       @code = val
     end
 
@@ -422,7 +440,13 @@ module Solargraph
     attr_writer :error_ranges
 
     # @return [String]
-    attr_accessor :repaired
+    attr_writer :repaired
+
+    # @return [String]
+    def repaired
+      finalize
+      @repaired
+    end
 
     # @return [Boolean]
     attr_writer :parsed
@@ -433,9 +457,6 @@ module Solargraph
     # @return [Boolean]
     attr_writer :synchronized
 
-    # @return [Source::Updater]
-    attr_accessor :last_updater
-
     private
 
     # @return [Array<String>]

data/lib/solargraph/source_map/clip.rb

@@ -2,8 +2,8 @@
 
 module Solargraph
   class SourceMap
-    # A static analysis tool for obtaining definitions, completions,
-    # signatures, and type inferences from a cursor.
+    # A static analysis tool for obtaining definitions, Completions,
+    # signatures, and type inferences from a Cursor.
     #
     class Clip
       # @param api_map [ApiMap]
@@ -11,13 +11,14 @@ module Solargraph
       def initialize api_map, cursor
         @api_map = api_map
         @cursor = cursor
-        block.rebind(api_map) if block.is_a?(Pin::Block)
+        closure_pin = closure
+        closure_pin.rebind(api_map) if closure_pin.is_a?(Pin::Block) && !Solargraph::Range.from_node(closure_pin.receiver).contain?(cursor.range.start)
       end
 
       # @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 = cursor.chain.define(api_map, closure, 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
@@ -40,7 +41,7 @@ module Solargraph
         end
       end
 
-      # @return [Array<Pin::Base>]
+      # @return [Array<Pin::Method>]
       def signify
         return [] unless cursor.argument?
         chain = Parser.chain(cursor.recipient_node, cursor.filename)
@@ -49,43 +50,36 @@ module Solargraph
 
       # @return [ComplexType]
       def infer
-        result = cursor.chain.infer(api_map, block, locals)
+        result = cursor.chain.infer(api_map, closure, 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'
+          dfn = cursor.chain.define(api_map, closure, 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).tag)
+        # should receive result with selfs resolved from infer()
+        Solargraph.assert_or_log(:clip_infer_self, 'Received selfy inference') if result.selfy?
+        result
       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::LocalVariable>]
       def locals
         @locals ||= source_map.locals_at(location)
       end
 
       # @return [::Array<String>]
       def gates
-        block.gates
-      end
-
-      def in_block?
-        return @in_block unless @in_block.nil?
-        @in_block = begin
-          tree = cursor.source.tree_at(cursor.position.line, cursor.position.column)
-          Parser.is_ast_node?(tree[1]) && [:block, :ITER].include?(tree[1].type)
-        end
+        closure.gates
       end
 
       # @param phrase [String]
       # @return [Array<Solargraph::Pin::Base>]
       def translate phrase
         chain = Parser.chain(Parser.parse(phrase))
-        chain.define(api_map, block, locals)
+        chain.define(api_map, closure, locals)
       end
 
       private
@@ -107,8 +101,8 @@ module Solargraph
       end
 
       # @return [Solargraph::Pin::Closure]
-      def block
-        @block ||= source_map.locate_block_pin(cursor.node_position.line, cursor.node_position.character)
+      def closure
+        @closure ||= source_map.locate_closure_pin(cursor.node_position.line, cursor.node_position.character)
       end
 
       # The context at the current position.
@@ -199,20 +193,20 @@ module Solargraph
             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)
+          type = cursor.chain.base.infer(api_map, closure, locals)
+          result.concat api_map.get_complex_type_methods(type, closure.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))
+              return package_completions(api_map.get_instance_variable_pins(closure.binder.namespace, closure.binder.scope))
             elsif cursor.word.start_with?('$')
               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 file_global_methods unless closure.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(closure.binder.namespace, scope: closure.binder.scope, visibility: [:public, :private, :protected])
             result.concat api_map.get_methods('Kernel')
             result.concat api_map.keyword_pins.to_a
           end

data/lib/solargraph/source_map/data.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class SourceMap
+    class Data
+      # @param source [Solargraph::Source]
+      def initialize source
+        @source = source
+      end
+
+      # @return [Array<Solargraph::Pin::Base>]
+      def pins
+        generate
+        @pins || []
+      end
+
+      # @return [Array<Solargraph::LocalVariable>]
+      def locals
+        generate
+        @locals || []
+      end
+
+      private
+
+      # @return [void]
+      def generate
+        return if @generated
+
+        @generated = true
+        @pins, @locals = Mapper.map(@source)
+      end
+    end
+  end
+end

data/lib/solargraph/source_map/mapper.rb

@@ -41,7 +41,7 @@ module Solargraph
         s = Position.new(0, 0)
         e = Position.from_offset(code, code.length)
         location = Location.new(filename, Range.new(s, e))
-        [[Pin::Namespace.new(location: location, name: '')], []]
+        [[Pin::Namespace.new(location: location, name: '', source: :source_map)], []]
       end
 
       class << self
@@ -55,6 +55,7 @@ module Solargraph
 
       # @return [Array<Solargraph::Pin::Base>]
       def pins
+        # @type [Array<Solargraph::Pin::Base>]
         @pins ||= []
       end
 
@@ -140,7 +141,8 @@ module Solargraph
               scope: namespace.is_a?(Pin::Singleton) ? :class : :instance,
               visibility: :public,
               explicit: false,
-              attribute: true
+              attribute: true,
+              source: :source_map
             )
           end
           if t.nil? || t.include?('w')
@@ -151,16 +153,17 @@ module Solargraph
               comments: docstring.all.to_s,
               scope: namespace.is_a?(Pin::Singleton) ? :class : :instance,
               visibility: :public,
-              attribute: true
+              attribute: true,
+              source: :source_map
             )
             pins.push method_pin
-            method_pin.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last)
+            method_pin.parameters.push Pin::Parameter.new(name: 'value', decl: :arg, closure: pins.last, source: :source_map)
             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 'visibility'
-          begin
+
             kind = directive.tag.text&.to_sym
             return unless [:private, :protected, :public].include?(kind)
 
@@ -179,7 +182,7 @@ module Solargraph
                 pin.instance_variable_set(:@visibility, kind)
               end
             end
-          end
+
         when 'parse'
           begin
             ns = closure_at(source_position)
@@ -205,7 +208,8 @@ module Solargraph
           namespace = closure_at(source_position) || Pin::ROOT_PIN
           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)
+          pins.push Pin::Reference::Override.new(location, directive.tag.name, docstring.tags,
+                                                 source: :source_map)
         when 'macro'
           # @todo Handle macros
         end