solargraph 0.54.0 → 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,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|
@@ -341,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
@@ -402,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
 
@@ -422,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
@@ -433,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.rb

@@ -4,40 +4,41 @@ 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.
@@ -47,7 +48,7 @@ module Solargraph
     #
     # @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
+      @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]
@@ -117,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
@@ -161,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 || []
@@ -179,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

data/lib/solargraph/type_checker.rb

@@ -90,11 +90,11 @@ module Solargraph
     def method_return_type_problems_for pin
       return [] if pin.is_a?(Pin::MethodAlias)
       result = []
-      declared = pin.typify(api_map).self_to(pin.full_context.namespace)
+      declared = pin.typify(api_map).self_to_type(pin.full_context).qualify(api_map, pin.full_context.tag)
       if declared.undefined?
         if pin.return_type.undefined? && rules.require_type_tags?
           if pin.attribute?
-            inferred = pin.probe(api_map).self_to(pin.full_context.namespace)
+            inferred = pin.probe(api_map).self_to_type(pin.full_context)
             result.push Problem.new(pin.location, "Missing @return tag for #{pin.path}", pin: pin) unless inferred.defined?
           else
             result.push Problem.new(pin.location, "Missing @return tag for #{pin.path}", pin: pin)
@@ -106,14 +106,14 @@ module Solargraph
         end
       elsif rules.validate_tags?
         unless pin.node.nil? || declared.void? || virtual_pin?(pin) || abstract?(pin)
-          inferred = pin.probe(api_map).self_to(pin.full_context.namespace)
+          inferred = pin.probe(api_map).self_to_type(pin.full_context)
           if inferred.undefined?
             unless rules.ignore_all_undefined? || external?(pin)
               result.push Problem.new(pin.location, "#{pin.path} return type could not be inferred", pin: pin)
             end
           else
-            unless (rules.rank > 1 ? all_types_match?(api_map, inferred, declared) : any_types_match?(api_map, declared, inferred))
-              result.push Problem.new(pin.location, "Declared return type #{declared} does not match inferred type #{inferred} for #{pin.path}", pin: pin)
+            unless (rules.require_all_return_types_match_inferred? ? all_types_match?(api_map, inferred, declared) : any_types_match?(api_map, declared, inferred))
+              result.push Problem.new(pin.location, "Declared return type #{declared.rooted_tags} does not match inferred type #{inferred.rooted_tags} for #{pin.path}", pin: pin)
             end
           end
         end
@@ -154,7 +154,7 @@ module Solargraph
             break if par.decl == :restarg || par.decl == :kwrestarg || par.decl == :blockarg
             unless params[par.name]
               if pin.attribute?
-                inferred = pin.probe(api_map).self_to(pin.full_context.namespace)
+                inferred = pin.probe(api_map).self_to_type(pin.full_context)
                 if inferred.undefined?
                   result.push Problem.new(pin.location, "Missing @param tag for #{par.name} on #{pin.path}", pin: pin)
                 end
@@ -377,7 +377,7 @@ module Solargraph
                     break
                   end
                   ptype = params.key?(par.name) ? params[par.name][:qualified] : ComplexType::UNDEFINED
-                  ptype = ptype.self_to(par.context.namespace)
+                  ptype = ptype.self_to_type(par.context)
                   if ptype.nil?
                     # @todo Some level (strong, I guess) should require the param here
                   else

data/lib/solargraph/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Solargraph
-  VERSION = '0.54.0'
+  VERSION = '0.54.1'
 end

data/lib/solargraph/views/environment.erb

@@ -35,11 +35,9 @@
     <li>
       Core Cache Directory: N/A <%# @todo Fix %>
     </li>
-    <% unless Solargraph::Parser.rubyvm? %>
-      <li>
-        Parser Target Version: <%= Solargraph::Parser.version %>
-      </li>
-    <% end %>
+    <li>
+      Parser Target Version: <%= Solargraph::Parser.version %>
+    </li>
     <li>
       Using Bundler: <%= ENV.key?('BUNDLE_BIN_PATH') %>
     </li>

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solargraph
 version: !ruby/object:Gem::Version
-  version: 0.54.0
+  version: 0.54.1
 platform: ruby
 authors:
 - Fred Snyder
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-14 00:00:00.000000000 Z
+date: 2025-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: backport
@@ -524,6 +524,7 @@ files:
 - lib/solargraph/pin/base.rb
 - lib/solargraph/pin/base_variable.rb
 - lib/solargraph/pin/block.rb
+- lib/solargraph/pin/callable.rb
 - lib/solargraph/pin/class_variable.rb
 - lib/solargraph/pin/closure.rb
 - lib/solargraph/pin/common.rb
@@ -589,6 +590,7 @@ files:
 - lib/solargraph/source_map.rb
 - lib/solargraph/source_map/clip.rb
 - lib/solargraph/source_map/completion.rb
+- lib/solargraph/source_map/data.rb
 - lib/solargraph/source_map/mapper.rb
 - lib/solargraph/type_checker.rb
 - lib/solargraph/type_checker/checks.rb