solargraph 0.54.0 → 0.54.5

data/lib/solargraph/source/chain.rb

@@ -5,10 +5,17 @@ require 'solargraph/source/chain/link'
 
 module Solargraph
   class Source
-    # A chain of constants, variables, and method calls for inferring types of
-    # values.
+    #
+    # Represents an expression as a single call chain at the parse
+    # tree level, made up of constants, variables, and method calls,
+    # each represented as a Link object.
+    #
+    # Computes Pins and/or ComplexTypes representing the interpreted
+    # expression.
     #
     class Chain
+      include Equality
+
       autoload :Link,             'solargraph/source/chain/link'
       autoload :Call,             'solargraph/source/chain/call'
       autoload :QCall,            'solargraph/source/chain/q_call'
@@ -40,6 +47,11 @@ module Solargraph
 
       attr_reader :node
 
+      # @sg-ignore Fix "Not enough arguments to Module#protected"
+      protected def equality_fields
+        [links, node]
+      end
+
       # @param node [Parser::AST::Node, nil]
       # @param links [::Array<Chain::Link>]
       # @param splat [Boolean]
@@ -61,13 +73,31 @@ module Solargraph
         @base ||= Chain.new(links[0..-2])
       end
 
+      # Determine potential Pins returned by this chain of words
+      #
       # @param api_map [ApiMap]
-      # @param name_pin [Pin::Base]
-      # @param locals [::Enumerable<Pin::LocalVariable>]
+      # @param name_pin [Pin::Closure] the surrounding closure pin for
+      #   the statement represented by this chain for type resolution
+      #   and method pin lookup.
+      #
+      #   For method calls (Chain::Call objects) as the first element
+      #   in the chain, 'name_pin.binder' should return the
+      #   ComplexType representing the LHS / "self type" of the call.
       #
-      # @return [::Array<Pin::Base>]
+      # @param locals [::Enumerable<Pin::LocalVariable>] Any local
+      #   variables / method parameters etc visible by the statement
+      #
+      # @return [::Array<Pin::Base>] Pins representing possible return
+      #   types of this method.
       def define api_map, name_pin, locals
         return [] if undefined?
+
+        # working_pin is the surrounding closure pin for the link
+        # being processed, whose #binder method will provide the LHS /
+        # 'self type' of the next link (same as the  #return_type method
+        # --the type of the result so far).
+        #
+        # @todo ProxyType uses 'type' for the binder, but '
         working_pin = name_pin
         links[0..-2].each do |link|
           pins = link.resolve(api_map, working_pin, locals)
@@ -75,37 +105,34 @@ module Solargraph
           return [] if type.undefined?
           working_pin = Pin::ProxyType.anonymous(type)
         end
-        links.last.last_context = name_pin
+        links.last.last_context = working_pin
         links.last.resolve(api_map, working_pin, locals)
       end
 
       # @param api_map [ApiMap]
       # @param name_pin [Pin::Base]
-      # @param locals [::Enumerable<Pin::LocalVariable>]
+      # @param locals [::Array<Pin::LocalVariable>]
       # @return [ComplexType]
       # @sg-ignore
       def infer api_map, name_pin, locals
-        out = nil
-        cached = @@inference_cache[[node, node.location, links.map(&:word), name_pin&.return_type, locals]] unless node.nil?
-        return cached if cached && @@inference_invalidation_key == api_map.hash
-        out = infer_uncached api_map, name_pin, locals
-        if @@inference_invalidation_key != api_map.hash
-          @@inference_cache = {}
+        cache_key = [node, node&.location, links, name_pin&.return_type, locals]
+        if @@inference_invalidation_key == api_map.hash
+          cached = @@inference_cache[cache_key]
+          return cached if cached
+        else
           @@inference_invalidation_key = api_map.hash
+          @@inference_cache = {}
         end
-        @@inference_cache[[node, node.location, links.map(&:word), name_pin&.return_type, locals]] = out unless node.nil?
-        out
+        out = infer_uncached api_map, name_pin, locals
+        logger.debug { "Chain#infer() - caching result - cache_key_hash=#{cache_key.hash}, links.map(&:hash)=#{links.map(&:hash)}, links=#{links}, cache_key.map(&:hash) = #{cache_key.map(&:hash)}, cache_key=#{cache_key}" }
+        @@inference_cache[cache_key] = out
       end
 
       # @param api_map [ApiMap]
       # @param name_pin [Pin::Base]
-      # @param locals [::Enumerable<Pin::LocalVariable>]
+      # @param locals [::Array<Pin::LocalVariable>]
       # @return [ComplexType]
       def infer_uncached 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, locals)
         maybe_nil(type)
@@ -137,6 +164,16 @@ module Solargraph
         links.any?(&:nullable?)
       end
 
+      include Logging
+
+      def desc
+        links.map(&:desc).to_s
+      end
+
+      def to_s
+        desc
+      end
+
       private
 
       # @param pins [::Array<Pin::Base>]
@@ -151,9 +188,9 @@ module Solargraph
         # @param pin [Pin::Base]
         pins.each do |pin|
           # Avoid infinite recursion
-          next if @@inference_stack.include?(pin.identity)
+          next if @@inference_stack.include?(pin)
 
-          @@inference_stack.push pin.identity
+          @@inference_stack.push pin
           type = pin.typify(api_map)
           @@inference_stack.pop
           if type.defined?
@@ -161,7 +198,7 @@ module Solargraph
               # @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)
+              type = type.resolve_generics(pin.closure, context.binder)
             end
             if type.defined?
               possibles.push type
@@ -177,9 +214,9 @@ module Solargraph
           # @param pin [Pin::Base]
           pins.each do |pin|
             # Avoid infinite recursion
-            next if @@inference_stack.include?(pin.identity)
+            next if @@inference_stack.include?(pin)
 
-            @@inference_stack.push pin.identity
+            @@inference_stack.push pin
             type = pin.probe(api_map)
             @@inference_stack.pop
             if type.defined?
@@ -192,14 +229,15 @@ module Solargraph
         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)
+          # Move nil to the end by convention
+          sorted = possibles.sort { |a, _| a.tag == 'nil' ? 1 : 0 }
+          ComplexType.new(sorted.uniq)
         else
-          ComplexType.parse(possibles.map(&:to_s).join(', '))
+          ComplexType.new(possibles)
         end
         return type if context.nil? || context.return_type.undefined?
 
-        type.self_to(context.return_type.tag)
+        type.self_to_type(context.return_type)
       end
 
       # @param type [ComplexType]
@@ -207,7 +245,7 @@ module Solargraph
       def maybe_nil type
         return type if type.undefined? || type.void? || type.nullable?
         return type unless nullable?
-        ComplexType.try_parse("#{type}, nil")
+        ComplexType.new(type.items + [ComplexType::NIL])
       end
     end
   end

data/lib/solargraph/source/cursor.rb

@@ -2,8 +2,8 @@
 
 module Solargraph
   class Source
-    # Information about a position in a source, including the word located
-    # there.
+    # Information about a single Position in a Source, including the
+    # word located there.
     #
     class Cursor
       # @return [Position]
@@ -35,6 +35,7 @@ module Solargraph
       # The part of the word before the current position. Given the text
       # `foo.bar`, the start_of_word at position(0, 6) is `ba`.
       #
+      # @sg-ignore Improve resolution of String#match below
       # @return [String]
       def start_of_word
         @start_of_word ||= begin

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,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.
@@ -262,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
@@ -295,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|
@@ -334,19 +307,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>]
     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 +375,59 @@ module Solargraph
 
     protected
 
+    # @return [Array<Change>]
+    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
 
@@ -422,7 +438,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
@@ -433,9 +454,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]
@@ -40,7 +40,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)
@@ -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