solargraph 0.54.1 → 0.56.0

data/lib/solargraph/pin/parameter.rb

@@ -3,20 +3,39 @@
 module Solargraph
   module Pin
     class Parameter < LocalVariable
-      # @return [Symbol]
+      # @return [::Symbol]
       attr_reader :decl
 
       # @return [String]
       attr_reader :asgn_code
 
+      # allow this to be set to the method after the method itself has
+      # been created
+      attr_writer :closure
+
       # @param decl [::Symbol] :arg, :optarg, :kwarg, :kwoptarg, :restarg, :kwrestarg, :block, :blockarg
       # @param asgn_code [String, nil]
-      # @param return_type [ComplexType, nil]
-      def initialize decl: :arg, asgn_code: nil, return_type: nil, **splat
+      def initialize decl: :arg, asgn_code: nil, **splat
         super(**splat)
         @asgn_code = asgn_code
         @decl = decl
-        @return_type = return_type
+      end
+
+      def type_location
+        super || closure&.type_location
+      end
+
+      def location
+        super || closure&.type_location
+      end
+
+      def combine_with(other, attrs={})
+        new_attrs = {
+          decl: assert_same(other, :decl),
+          presence: choose(other, :presence),
+          asgn_code: choose(other, :asgn_code),
+        }.merge(attrs)
+        super(other, new_attrs)
       end
 
       def keyword?
@@ -27,6 +46,32 @@ module Solargraph
         decl == :kwrestarg || (assignment && [:HASH, :hash].include?(assignment.type))
       end
 
+      def needs_consistent_name?
+        keyword?
+      end
+
+      # @return [String]
+      def arity_decl
+        name = (self.name || '(anon)')
+        type = (return_type&.to_rbs || 'untyped')
+        case decl
+        when :arg
+          ""
+        when :optarg
+          "?"
+        when :kwarg
+          "#{name}:"
+        when :kwoptarg
+          "?#{name}:"
+        when :restarg
+          "*"
+        when :kwrestarg
+          "**"
+        else
+          "(unknown decl: #{decl})"
+        end
+      end
+
       def arg?
         decl == :arg
       end
@@ -115,17 +160,21 @@ module Solargraph
         closure.is_a?(Pin::Block) ? typify_block_param(api_map) : typify_method_param(api_map)
       end
 
+      # @param atype [ComplexType]
+      # @param api_map [ApiMap]
+      def compatible_arg?(atype, api_map)
+        # make sure we get types from up the method
+        # inheritance chain if we don't have them on this pin
+        ptype = typify api_map
+        ptype.undefined? || ptype.can_assign?(api_map, atype) || ptype.generic?
+      end
+
       def documentation
         tag = param_tag
         return '' if tag.nil? || tag.text.nil?
         tag.text
       end
 
-      def try_merge! pin
-        return false unless super && closure == pin.closure
-        true
-      end
-
       private
 
       # @return [YARD::Tags::Tag, nil]
@@ -140,8 +189,9 @@ module Solargraph
       # @param api_map [ApiMap]
       # @return [ComplexType]
       def typify_block_param api_map
-        if closure.is_a?(Pin::Block) && closure.receiver
-          return closure.typify_parameters(api_map)[index]
+        block_pin = closure
+        if block_pin.is_a?(Pin::Block) && block_pin.receiver
+          return block_pin.typify_parameters(api_map)[index]
         end
         ComplexType::UNDEFINED
       end

data/lib/solargraph/pin/proxy_type.rb

@@ -4,24 +4,30 @@ module Solargraph
   module Pin
     class ProxyType < Base
       # @param return_type [ComplexType]
-      def initialize return_type: ComplexType::UNDEFINED, **splat
+      def initialize return_type: ComplexType::UNDEFINED, binder: nil, **splat
         super(**splat)
         @return_type = return_type
+        @binder = binder if binder
       end
 
       def context
         @return_type
       end
 
-      # @param return_type [ComplexType]
+      # @param context [ComplexType, ComplexType::UniqueType] Used as context for this pin
+      # @param closure [Pin::Namespace, nil] Used as the closure for this pin
+      # @param binder [ComplexType, ComplexType::UniqueType, nil]
       # @return [ProxyType]
-      def self.anonymous return_type
-        parts = return_type.namespace.split('::')
-        namespace = parts[0..-2].join('::').to_s
+      def self.anonymous context, closure: nil, binder: nil, **kwargs
+        unless closure
+          parts = context.namespace.split('::')
+          namespace = parts[0..-2].join('::').to_s
+          closure = Solargraph::Pin::Namespace.new(name: namespace, source: :proxy_type)
+        end
         # name = parts.last.to_s
         # ProxyType.new(nil, namespace, name, return_type)
         ProxyType.new(
-          closure: Solargraph::Pin::Namespace.new(name: namespace), return_type: return_type
+          closure: closure, return_type: context, binder: binder || context, **kwargs
         )
       end
     end

data/lib/solargraph/pin/reference/override.rb

@@ -10,18 +10,22 @@ module Solargraph
         # @return [::Array<Symbol>]
         attr_reader :delete
 
-        def initialize location, name, tags, delete = []
-          super(location: location, name: name)
+        def closure
+          nil
+        end
+
+        def initialize location, name, tags, delete = [], **splat
+          super(location: location, name: name, **splat)
           @tags = tags
           @delete = delete
         end
 
-        def self.method_return name, *tags, delete: []
-          new(nil, name, [YARD::Tags::Tag.new('return', nil, tags)], delete)
+        def self.method_return name, *tags, delete: [], **splat
+          new(nil, name, [YARD::Tags::Tag.new('return', nil, tags)], delete, **splat)
         end
 
-        def self.from_comment name, comment
-          new(nil, name, Solargraph::Source.parse_docstring(comment).to_docstring.tags)
+        def self.from_comment name, comment, **splat
+          new(nil, name, Solargraph::Source.parse_docstring(comment).to_docstring.tags, **splat)
         end
       end
     end

data/lib/solargraph/pin/reference/require.rb

@@ -4,9 +4,9 @@ module Solargraph
   module Pin
     class Reference
       class Require < Reference
-        def initialize location, name
+        def initialize location, name, **splat
           # super(location, '', name)
-          super(location: location, name: name)
+          super(location: location, name: name, closure: Pin::ROOT_PIN, **splat)
         end
       end
     end

data/lib/solargraph/pin/signature.rb

@@ -1,6 +1,10 @@
 module Solargraph
   module Pin
     class Signature < Callable
+      # allow signature to be created before method pin, then set this
+      # to the method pin
+      attr_writer :closure
+
       def initialize **splat
         super(**splat)
       end
@@ -12,6 +16,44 @@ module Solargraph
       def identity
         @identity ||= "signature#{object_id}"
       end
+
+      attr_writer :closure
+
+      def dodgy_return_type_source?
+        super || closure&.dodgy_return_type_source?
+      end
+
+      def type_location
+        super || closure&.type_location
+      end
+
+      def location
+        super || closure&.location
+      end
+
+      def typify api_map
+        if return_type.defined?
+          qualified = return_type.qualify(api_map, closure.namespace)
+          logger.debug { "Signature#typify(self=#{self}) => #{qualified.rooted_tags.inspect}" }
+          return qualified
+        end
+        return ComplexType::UNDEFINED if closure.nil?
+        return ComplexType::UNDEFINED unless closure.is_a?(Pin::Method)
+        method_stack = closure.rest_of_stack api_map
+        logger.debug { "Signature#typify(self=#{self}) - method_stack: #{method_stack}" }
+        method_stack.each do |pin|
+          sig = pin.signatures.find { |s| s.arity == self.arity }
+          next unless sig
+          unless sig.return_type.undefined?
+            qualified = sig.return_type.qualify(api_map, closure.namespace)
+            logger.debug { "Signature#typify(self=#{self}) => #{qualified.rooted_tags.inspect}" }
+            return qualified
+          end
+        end
+        out = super
+        logger.debug { "Signature#typify(self=#{self}) => #{out}" }
+        out
+      end
     end
   end
 end

data/lib/solargraph/pin/singleton.rb

@@ -3,7 +3,7 @@
 module Solargraph
   module Pin
     class Singleton < Closure
-      def initialize name: '', location: nil, closure: nil
+      def initialize name: '', location: nil, closure: nil, **splat
         super
       end
     end

data/lib/solargraph/pin/symbol.rb

@@ -5,8 +5,9 @@ module Solargraph
     class Symbol < Base
       # @param location [Solargraph::Location]
       # @param name [String]
-      def initialize location, name
-        super(location: location, name: name)
+      def initialize(location, name, **kwargs)
+        # @sg-ignore "Unrecognized keyword argument kwargs to Solargraph::Pin::Base#initialize"
+        super(location: location, name: name, **kwargs)
         # @name = name
         # @location = location
       end

data/lib/solargraph/pin/until.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class Until < Base
+      include Breakable
+
+      # @param receiver [Parser::AST::Node, nil]
+      # @param node [Parser::AST::Node, nil]
+      # @param context [ComplexType, nil]
+      # @param args [::Array<Parameter>]
+      def initialize node: nil, **splat
+        super(**splat)
+        @node = node
+      end
+    end
+  end
+end

data/lib/solargraph/pin/while.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Solargraph
+  module Pin
+    class While < Base
+      include Breakable
+
+      # @param receiver [Parser::AST::Node, nil]
+      # @param node [Parser::AST::Node, nil]
+      # @param context [ComplexType, nil]
+      # @param args [::Array<Parameter>]
+      def initialize node: nil, **splat
+        super(**splat)
+        @node = node
+      end
+    end
+  end
+end

data/lib/solargraph/pin.rb

@@ -34,8 +34,11 @@ module Solargraph
     autoload :Singleton,        'solargraph/pin/singleton'
     autoload :KeywordParam,     'solargraph/pin/keyword_param'
     autoload :Search,           'solargraph/pin/search'
+    autoload :Breakable,        'solargraph/pin/breakable'
+    autoload :Until,            'solargraph/pin/until'
+    autoload :While,            'solargraph/pin/while'
     autoload :Callable,         'solargraph/pin/callable'
 
-    ROOT_PIN = Pin::Namespace.new(type: :class, name: '', closure: nil)
+    ROOT_PIN = Pin::Namespace.new(type: :class, name: '', closure: nil, source: :pin_rb)
   end
 end

data/lib/solargraph/pin_cache.rb

@@ -0,0 +1,185 @@
+require 'fileutils'
+require 'rbs'
+
+module Solargraph
+  module PinCache
+    class << self
+      include Logging
+
+      # The base directory where cached YARD documentation and serialized pins are serialized
+      #
+      # @return [String]
+      def base_dir
+        # The directory is not stored in a variable so it can be overridden
+        # in specs.
+        ENV['SOLARGRAPH_CACHE'] ||
+          (ENV['XDG_CACHE_HOME'] ? File.join(ENV['XDG_CACHE_HOME'], 'solargraph') : nil) ||
+          File.join(Dir.home, '.cache', 'solargraph')
+      end
+
+      # The working directory for the current Ruby, RBS, and Solargraph versions.
+      #
+      # @return [String]
+      def work_dir
+        # The directory is not stored in a variable so it can be overridden
+        # in specs.
+        File.join(base_dir, "ruby-#{RUBY_VERSION}", "rbs-#{RBS::VERSION}", "solargraph-#{Solargraph::VERSION}")
+      end
+
+      def yardoc_path gemspec
+        File.join(base_dir, "yard-#{YARD::VERSION}", "#{gemspec.name}-#{gemspec.version}.yardoc")
+      end
+
+      def stdlib_path
+        File.join(work_dir, 'stdlib')
+      end
+
+      def stdlib_require_path require
+        File.join(stdlib_path, "#{require}.ser")
+      end
+
+      def deserialize_stdlib_require require
+        load(stdlib_require_path(require))
+      end
+
+      def serialize_stdlib_require require, pins
+        save(stdlib_require_path(require), pins)
+      end
+
+      def core_path
+        File.join(work_dir, 'core.ser')
+      end
+
+      def deserialize_core
+        load(core_path)
+      end
+
+      def serialize_core pins
+        save(core_path, pins)
+      end
+
+      def yard_gem_path gemspec
+        File.join(work_dir, 'yard', "#{gemspec.name}-#{gemspec.version}.ser")
+      end
+
+      def deserialize_yard_gem(gemspec)
+        load(yard_gem_path(gemspec))
+      end
+
+      def serialize_yard_gem(gemspec, pins)
+        save(yard_gem_path(gemspec), pins)
+      end
+
+      def has_yard?(gemspec)
+        exist?(yard_gem_path(gemspec))
+      end
+
+      def rbs_collection_path(gemspec, hash)
+        File.join(work_dir, 'rbs', "#{gemspec.name}-#{gemspec.version}-#{hash || 0}.ser")
+      end
+
+      def rbs_collection_path_prefix(gemspec)
+        File.join(work_dir, 'rbs', "#{gemspec.name}-#{gemspec.version}-")
+      end
+
+      def deserialize_rbs_collection_gem(gemspec, hash)
+        load(rbs_collection_path(gemspec, hash))
+      end
+
+      def serialize_rbs_collection_gem(gemspec, hash, pins)
+        save(rbs_collection_path(gemspec, hash), pins)
+      end
+
+      def combined_path(gemspec, hash)
+        File.join(work_dir, 'combined', "#{gemspec.name}-#{gemspec.version}-#{hash || 0}.ser")
+      end
+
+      def combined_path_prefix(gemspec)
+        File.join(work_dir, 'combined', "#{gemspec.name}-#{gemspec.version}-")
+      end
+
+      def serialize_combined_gem(gemspec, hash, pins)
+        save(combined_path(gemspec, hash), pins)
+      end
+
+      def deserialize_combined_gem gemspec, hash
+        load(combined_path(gemspec, hash))
+      end
+
+      def has_rbs_collection?(gemspec, hash)
+        exist?(rbs_collection_path(gemspec, hash))
+      end
+
+      def uncache_core
+        uncache(core_path)
+      end
+
+      def uncache_stdlib
+        uncache(stdlib_path)
+      end
+
+      def uncache_gem(gemspec, out: nil)
+        uncache(yardoc_path(gemspec), out: out)
+        uncache_by_prefix(rbs_collection_path_prefix(gemspec), out: out)
+        uncache(yard_gem_path(gemspec), out: out)
+        uncache_by_prefix(combined_path_prefix(gemspec), out: out)
+      end
+
+      # @return [void]
+      def clear
+        FileUtils.rm_rf base_dir, secure: true
+      end
+
+      private
+
+      # @param file [String]
+      # @return [Array<Solargraph::Pin::Base>, nil]
+      def load file
+        return nil unless File.file?(file)
+        Marshal.load(File.read(file, mode: 'rb'))
+      rescue StandardError => e
+        Solargraph.logger.warn "Failed to load cached file #{file}: [#{e.class}] #{e.message}"
+        FileUtils.rm_f file
+        nil
+      end
+
+      def exist? *path
+        File.file? join(*path)
+      end
+
+      # @param path [Array<String>]
+      # @param pins [Array<Pin::Base>]
+      # @return [void]
+      def save file, pins
+        base = File.dirname(file)
+        FileUtils.mkdir_p base unless File.directory?(base)
+        ser = Marshal.dump(pins)
+        File.write file, ser, mode: 'wb'
+        logger.debug { "Cache#save: Saved #{pins.length} pins to #{file}" }
+      end
+
+      # @return [void]
+      # @param path_segments [Array<String>]
+      def uncache *path_segments, out: nil
+        path = File.join(*path_segments)
+        if File.exist?(path)
+          FileUtils.rm_rf path, secure: true
+          out.puts "Clearing pin cache in #{path}" unless out.nil?
+        end
+      end
+
+      # @return [void]
+      # @param path_segments [Array<String>]
+      def uncache_by_prefix *path_segments, out: nil
+        path = File.join(*path_segments)
+        glob = "#{path}*"
+        out.puts "Clearing pin cache in #{glob}" unless out.nil?
+        Dir.glob(glob).each do |file|
+          next unless File.file?(file)
+          FileUtils.rm_rf file, secure: true
+          out.puts "Clearing pin cache in #{file}" unless out.nil?
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/position.rb

@@ -4,6 +4,8 @@ module Solargraph
   # The zero-based line and column numbers of a position in a string.
   #
   class Position
+    include Equality
+
     # @return [Integer]
     attr_reader :line
 
@@ -19,6 +21,20 @@ module Solargraph
       @character = character
     end
 
+    # @sg-ignore Fix "Not enough arguments to Module#protected"
+    protected def equality_fields
+      [line, character]
+    end
+
+    def <=>(other)
+      return nil unless other.is_a?(Position)
+      if line == other.line
+        character <=> other.character
+      else
+        line <=> other.line
+      end
+    end
+
     # Get a hash of the position. This representation is suitable for use in
     # the language server protocol.
     #

data/lib/solargraph/range.rb

@@ -4,6 +4,8 @@ module Solargraph
   # A pair of Positions that compose a section of text in code.
   #
   class Range
+    include Equality
+
     # @return [Position]
     attr_reader :start
 
@@ -17,6 +19,20 @@ module Solargraph
       @ending = ending
     end
 
+    # @sg-ignore Fix "Not enough arguments to Module#protected"
+    protected def equality_fields
+      [start, ending]
+    end
+
+    def <=>(other)
+      return nil unless other.is_a?(Range)
+      if start == other.start
+        ending <=> other.ending
+      else
+        start <=> other.start
+      end
+    end
+
     # Get a hash of the range. This representation is suitable for use in
     # the language server protocol.
     #