solargraph 0.53.4 → 0.54.1

data/lib/solargraph/source.rb

@@ -19,13 +19,22 @@ module Solargraph
     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
+    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,57 +83,12 @@ 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
 
-    # 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.
     #
@@ -148,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>]
@@ -243,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
@@ -269,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.
@@ -295,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.
@@ -306,8 +237,9 @@ module Solargraph
       @associated_comments ||= begin
         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
@@ -339,12 +271,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|
@@ -385,12 +314,12 @@ module Solargraph
 
     # @return [Array<Parser::AST::Node>]
     def string_nodes
-      @string_nodes ||= string_nodes_in(@node)
+      @string_nodes ||= string_nodes_in(node)
     end
 
     # @return [Array<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
@@ -446,16 +375,58 @@ module Solargraph
 
     protected
 
+    def changes
+      @changes ||= []
+    end
+
     # @return [String]
     attr_writer :filename
 
     # @return [Integer]
     attr_writer :version
 
+    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
 
@@ -466,7 +437,12 @@ module Solargraph
     attr_writer :error_ranges
 
     # @return [String]
-    attr_accessor :repaired
+    attr_writer :repaired
+
+    def repaired
+      finalize
+      @repaired
+    end
 
     # @return [Boolean]
     attr_writer :parsed
@@ -477,9 +453,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]
@@ -53,10 +53,10 @@ module Solargraph
         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'
+          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)
+        cursor.chain.base.infer(api_map, block, locals)
       end
 
       # Get an array of all the locals that are visible from the cursors's

data/lib/solargraph/source_map/data.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class SourceMap
+    class Data
+      def initialize source
+        @source = source
+      end
+
+      def pins
+        generate
+        @pins || []
+      end
+
+      def locals
+        generate
+        @locals || []
+      end
+
+      private
+
+      def generate
+        return if @generated
+
+        @generated = true
+        @pins, @locals = Mapper.map(@source)
+      end
+    end
+  end
+end

data/lib/solargraph/source_map/mapper.rb

@@ -144,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}=",
@@ -153,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

data/lib/solargraph/source_map.rb

@@ -4,40 +4,51 @@ require 'yard'
 require 'solargraph/yard_tags'
 
 module Solargraph
-  # An index of pins and other ApiMap-related data for a Source.
+  # An index of Pins and other ApiMap-related data for a single Source
+  # that can be queried.
   #
   class SourceMap
     autoload :Mapper,        'solargraph/source_map/mapper'
     autoload :Clip,          'solargraph/source_map/clip'
     autoload :Completion,    'solargraph/source_map/completion'
+    autoload :Data,          'solargraph/source_map/data'
 
     # @return [Source]
     attr_reader :source
 
     # @return [Array<Pin::Base>]
-    attr_reader :pins
+    def pins
+      data.pins
+    end
 
     # @return [Array<Pin::LocalVariable>]
-    attr_reader :locals
+    def locals
+      data.locals
+    end
 
     # @param source [Source]
-    # @param pins [Array<Pin::Base>]
-    # @param locals [Array<Pin::Base>]
-    def initialize source, pins, locals
-      # HACK: Keep the library from changing this
-      @source = source.dup
-      @pins = pins
-      @locals = locals
+    def initialize source
+      @source = source
+
       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
+      @pin_select_cache[klass] ||= pin_class_hash.select { |key, _| key <= klass }.values.flatten
+    end
+
+    # 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) + locals).hash
     end
 
     # @return [String]
@@ -107,10 +118,13 @@ module Solargraph
       _locate_pin line, character, Pin::Namespace, Pin::Method, Pin::Block
     end
 
+    # @todo Candidate for deprecation
+    #
     # @param other_map [SourceMap]
     # @return [Boolean]
     def try_merge! other_map
       return false if pins.length != other_map.pins.length || locals.length != other_map.locals.length || requires.map(&:name).uniq.sort != other_map.requires.map(&:name).uniq.sort
+
       pins.each_index do |i|
         return false unless pins[i].try_merge!(other_map.pins[i])
       end
@@ -151,16 +165,24 @@ module Solargraph
         SourceMap.map(source)
       end
 
+      # @deprecated
       # @param source [Source]
       # @return [SourceMap]
       def map source
-        result = SourceMap::Mapper.map(source)
-        new(source, *result)
+        new(source)
       end
     end
 
     private
 
+    def pin_class_hash
+      @pin_class_hash ||= pins.to_set.classify(&:class).transform_values(&:to_a)
+    end
+
+    def data
+      @data ||= Data.new(source)
+    end
+
     # @return [Array<Pin::Base>]
     def convention_pins
       @convention_pins || []
@@ -169,7 +191,7 @@ module Solargraph
     # @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
+      # unmemoizing the document_symbols in case it was called from any of conventions
       @document_symbols = nil
       @convention_pins = pins
     end

data/lib/solargraph/type_checker/rules.rb

@@ -9,7 +9,8 @@ module Solargraph
         normal: 0,
         typed: 1,
         strict: 2,
-        strong: 3
+        strong: 3,
+        alpha: 4
       }.freeze
 
       # @return [Symbol]
@@ -52,6 +53,10 @@ module Solargraph
       def validate_tags?
         rank > LEVELS[:normal]
       end
+
+      def require_all_return_types_match_inferred?
+        rank >= LEVELS[:alpha]
+      end
     end
   end
 end