solargraph 0.47.2 → 0.54.0

data/lib/solargraph/cache.rb

@@ -0,0 +1,77 @@
+require 'fileutils'
+require 'rbs'
+
+module Solargraph
+  module Cache
+    class << self
+      # The base directory where cached documentation is installed.
+      #
+      # @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
+
+      # Append the given path to the current cache directory (`work_dir`).
+      #
+      # @example
+      #   Cache.join('date-3.4.1.ser')
+      #
+      # @param path [Array<String>]
+      # @return [String]
+      def join *path
+        File.join(work_dir, *path)
+      end
+
+      # @param path [Array<String>]
+      # @return [Array<Solargraph::Pin::Base>, nil]
+      def load *path
+        file = join(*path)
+        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 *path, pins
+        file = File.join(work_dir, *path)
+        base = File.dirname(file)
+        FileUtils.mkdir_p base unless File.directory?(base)
+        ser = Marshal.dump(pins)
+        File.write file, ser, mode: 'wb'
+      end
+
+      # @return [void]
+      # @param path [Array<String>]
+      def uncache *path
+        FileUtils.rm_rf File.join(work_dir, *path), secure: true
+      end
+
+      # @return [void]
+      def clear
+        FileUtils.rm_rf base_dir, secure: true
+      end
+    end
+  end
+end

data/lib/solargraph/complex_type/type_methods.rb

@@ -2,20 +2,38 @@
 
 module Solargraph
   class ComplexType
-    # Methods for accessing type data.
+    # Methods for accessing type data available from
+    # both ComplexType and UniqueType.
     #
+    # @abstract This mixin relies on these -
+    #   instance variables:
+    #     @name: String
+    #     @subtypes: Array<ComplexType>
+    #     @rooted: boolish
+    #   methods:
+    #     transform()
     module TypeMethods
+      # @!method transform(new_name = nil, &transform_type)
+      #   @param new_name [String, nil]
+      #   @yieldparam t [UniqueType]
+      #   @yieldreturn [UniqueType]
+      #   @return [UniqueType, nil]
+
       # @return [String]
       attr_reader :name
 
-      # @return [String]
-      attr_reader :substring
+      # @return [Array<ComplexType>]
+      attr_reader :subtypes
 
       # @return [String]
-      attr_reader :tag
+      def tag
+        @tag ||= "#{name}#{substring}"
+      end
 
-      # @return [Array<ComplexType>]
-      attr_reader :subtypes
+      # @return [String]
+      def rooted_tag
+        @rooted_tag ||= rooted_name + rooted_substring
+      end
 
       # @return [Boolean]
       def duck_type?
@@ -24,8 +42,7 @@ module Solargraph
 
       # @return [Boolean]
       def nil_type?
-        @nil_type = (name.casecmp('nil') == 0) if @nil_type.nil?
-        @nil_type
+        @nil_type ||= (name.casecmp('nil') == 0)
       end
 
       # @return [Boolean]
@@ -33,6 +50,10 @@ module Solargraph
         !substring.empty?
       end
 
+      def tuple?
+        @tuple_type ||= (name == 'Tuple') || (name == 'Array' && subtypes.length >= 1 && fixed_parameters?)
+      end
+
       def void?
         name == 'void'
       end
@@ -45,19 +66,44 @@ module Solargraph
         name == 'undefined'
       end
 
+      # @param generics_to_erase [Enumerable<String>]
+      # @return [self]
+      def erase_generics(generics_to_erase)
+        transform do |type|
+          if type.name == ComplexType::GENERIC_TAG_NAME
+            if type.all_params.length == 1 && generics_to_erase.include?(type.all_params.first.to_s)
+              ComplexType::UNDEFINED
+            else
+              type
+            end
+          else
+            type
+          end
+        end
+      end
+
+      # @return [Symbol, nil]
+      attr_reader :parameters_type
+
+      PARAMETERS_TYPE_BY_STARTING_TAG = {
+        '{' => :hash,
+        '(' => :fixed,
+        '<' => :list
+      }.freeze
+
       # @return [Boolean]
       def list_parameters?
-        substring.start_with?('<')
+        parameters_type == :list
       end
 
       # @return [Boolean]
       def fixed_parameters?
-        substring.start_with?('(')
+        parameters_type == :fixed
       end
 
       # @return [Boolean]
       def hash_parameters?
-        substring.start_with?('{')
+        parameters_type == :hash
       end
 
       # @return [Array<ComplexType>]
@@ -80,12 +126,52 @@ module Solargraph
         end.call
       end
 
-      # @return [Symbol] :class or :instance
+      # @return [String]
+      def rooted_namespace
+        return namespace unless rooted?
+        "::#{namespace}"
+      end
+
+      # @return [String]
+      def rooted_name
+        return name unless rooted?
+        "::#{name}"
+      end
+
+      # @return [String]
+      def substring
+        @substring ||= generate_substring_from(&:tags)
+      end
+
+      # @return [String]
+      def rooted_substring
+        @rooted_substring = generate_substring_from(&:rooted_tags)
+      end
+
+      # @return [String]
+      def generate_substring_from(&to_str)
+        key_types_str = key_types.map(&to_str).join(', ')
+        subtypes_str = subtypes.map(&to_str).join(', ')
+        if key_types.none?(&:defined?) && subtypes.none?(&:defined?)
+          ''
+        elsif key_types.empty? && subtypes.empty?
+          ''
+        elsif hash_parameters?
+          "{#{key_types_str} => #{subtypes_str}}"
+        elsif fixed_parameters?
+          "(#{subtypes_str})"
+        else
+          "<#{subtypes_str}>"
+        end
+      end
+
+      # @return [::Symbol] :class or :instance
       def scope
         @scope ||= :instance if duck_type? || nil_type?
         @scope ||= (name == 'Class' || name == 'Module') && !subtypes.empty? ? :class : :instance
       end
 
+      # @param other [Object]
       def == other
         return false unless self.class == other.class
         tag == other.tag
@@ -99,32 +185,27 @@ module Solargraph
       #
       # @param api_map [ApiMap] The ApiMap that performs qualification
       # @param context [String] The namespace from which to resolve names
-      # @return [ComplexType] The generated ComplexType
+      # @return [self, ComplexType, UniqueType] The generated ComplexType
       def qualify api_map, context = ''
-        return ComplexType.new([self]) if duck_type? || void? || undefined?
-        recon = (rooted? ? '' : context)
-        fqns = api_map.qualify(name, recon)
-        if fqns.nil?
-          return UniqueType::BOOLEAN if tag == 'Boolean'
-          return UniqueType::UNDEFINED
-        end
-        fqns = "::#{fqns}" # Ensure the resulting complex type is rooted
-        ltypes = key_types.map do |t|
-          t.qualify api_map, context
-        end
-        rtypes = value_types.map do |t|
-          t.qualify api_map, context
-        end
-        if list_parameters?
-          Solargraph::ComplexType.parse("#{fqns}<#{rtypes.map(&:tag).join(', ')}>")
-        elsif fixed_parameters?
-          Solargraph::ComplexType.parse("#{fqns}(#{rtypes.map(&:tag).join(', ')})")
-        elsif hash_parameters?
-          Solargraph::ComplexType.parse("#{fqns}{#{ltypes.map(&:tag).join(', ')} => #{rtypes.map(&:tag).join(', ')}}")
-        else
-          Solargraph::ComplexType.parse(fqns)
+        transform do |t|
+          next t if t.name == GENERIC_TAG_NAME
+          next t if t.duck_type? || t.void? || t.undefined?
+          recon = (t.rooted? ? '' : context)
+          fqns = api_map.qualify(t.name, recon)
+          if fqns.nil?
+            next UniqueType::BOOLEAN if t.tag == 'Boolean'
+            next UniqueType::UNDEFINED
+          end
+          t.recreate(new_name: fqns, make_rooted: true)
         end
       end
+
+      # @yieldparam [UniqueType]
+      # @return [Enumerator<UniqueType>]
+      def each_unique_type &block
+        return enum_for(__method__) unless block_given?
+        yield self
+      end
     end
   end
 end

data/lib/solargraph/complex_type/unique_type.rb

@@ -8,6 +8,8 @@ module Solargraph
     class UniqueType
       include TypeMethods
 
+      attr_reader :all_params, :subtypes, :key_types
+
       # Create a UniqueType with the specified name and an optional substring.
       # The substring is the parameter section of a parametrized type, e.g.,
       # for the type `Array<String>`, the name is `Array` and the substring is
@@ -15,52 +17,278 @@ module Solargraph
       #
       # @param name [String] The name of the type
       # @param substring [String] The substring of the type
-      def initialize name, substring = ''
+      # @param make_rooted [Boolean, nil]
+      # @return [UniqueType]
+      def self.parse name, substring = '', make_rooted: nil
+        if name.start_with?(':::')
+          raise "Illegal prefix: #{name}"
+        end
         if name.start_with?('::')
-          @name = name[2..-1]
-          @rooted = true
+          name = name[2..-1]
+          rooted = true
         else
-          @name = name
-          @rooted = false
+          rooted = false
         end
-        @substring = substring
-        @tag = @name + substring
-        @key_types = []
-        @subtypes = []
-        return unless parameters?
-        if @substring.start_with?('<(') && @substring.end_with?(')>')
-          subs = ComplexType.parse(substring[2..-3], partial: true)
-        else
+        rooted = make_rooted unless make_rooted.nil?
+
+        # @type [Array<ComplexType>]
+        key_types = []
+        # @type [Array<ComplexType>]
+        subtypes = []
+        parameters_type = nil
+        unless substring.empty?
           subs = ComplexType.parse(substring[1..-2], partial: true)
+          parameters_type = PARAMETERS_TYPE_BY_STARTING_TAG.fetch(substring[0])
+          if parameters_type == :hash
+            raise ComplexTypeError, "Bad hash type" unless !subs.is_a?(ComplexType) and subs.length == 2 and !subs[0].is_a?(UniqueType) and !subs[1].is_a?(UniqueType)
+            # @todo should be able to resolve map; both types have it
+            #   with same return type
+            # @sg-ignore
+            key_types.concat(subs[0].map { |u| ComplexType.new([u]) })
+            # @sg-ignore
+            subtypes.concat(subs[1].map { |u| ComplexType.new([u]) })
+          else
+            subtypes.concat subs
+          end
         end
-        if hash_parameters?
-          raise ComplexTypeError, "Bad hash type" unless !subs.is_a?(ComplexType) and subs.length == 2 and !subs[0].is_a?(UniqueType) and !subs[1].is_a?(UniqueType)
-          @key_types.concat subs[0].map { |u| ComplexType.new([u]) }
-          @subtypes.concat subs[1].map { |u| ComplexType.new([u]) }
-        else
-          @subtypes.concat subs
+        new(name, key_types, subtypes, rooted: rooted, parameters_type: parameters_type)
+      end
+
+      # @param name [String]
+      # @param key_types [Array<ComplexType>]
+      # @param subtypes [Array<ComplexType>]
+      # @param rooted [Boolean]
+      # @param parameters_type [Symbol, nil]
+      def initialize(name, key_types = [], subtypes = [], rooted:, parameters_type: nil)
+        if parameters_type.nil?
+          raise "You must supply parameters_type if you provide parameters" unless key_types.empty? && subtypes.empty?
         end
+        raise "Please remove leading :: and set rooted instead - #{name}" if name.start_with?('::')
+        @name = name
+        @key_types = key_types
+        @subtypes = subtypes
+        @rooted = rooted
+        @all_params = []
+        @all_params.concat key_types
+        @all_params.concat subtypes
+        @parameters_type = parameters_type
       end
 
       def to_s
         tag
       end
 
-      def self_to dst
-        return self unless selfy?
-        new_name = (@name == 'self' ? dst : @name)
-        new_key_types = @key_types.map { |t| t.self_to dst }
-        new_subtypes = @subtypes.map { |t| t.self_to dst }
-        if hash_parameters?
-          UniqueType.new(new_name, "{#{new_key_types.join(', ')} => #{new_subtypes.join(', ')}}")
-        elsif parameters?
-          if @substring.start_with?'<('
-            UniqueType.new(new_name, "<(#{new_subtypes.join(', ')})>")
+      # @return [Array<UniqueType>]
+      def items
+        [self]
+      end
+
+      # @return [String]
+      def rbs_name
+        if name == 'undefined'
+          'untyped'
+        else
+          rooted_name
+        end
+      end
+
+      # @return [String]
+      def to_rbs
+        if duck_type?
+          'untyped'
+        elsif name == 'Boolean'
+          'bool'
+        elsif name.downcase == 'nil'
+          'nil'
+        elsif name == GENERIC_TAG_NAME
+          all_params.first.name
+        elsif ['Class', 'Module'].include?(name)
+          rbs_name
+        elsif ['Tuple', 'Array'].include?(name) && fixed_parameters?
+          # tuples don't have a name; they're just [foo, bar, baz].
+          if substring == '()'
+            # but there are no zero element tuples, so we go with an array
+            'Array[]'
+          else
+            # already generated surrounded by []
+            parameters_as_rbs
+          end
+        else
+          "#{rbs_name}#{parameters_as_rbs}"
+        end
+      end
+
+      # @return [Boolean]
+      def parameters?
+        !all_params.empty?
+      end
+
+      # @param types [Array<UniqueType, ComplexType>]
+      # @return [String]
+      def rbs_union(types)
+        if types.length == 1
+          types.first.to_rbs
+        else
+          "(#{types.map(&:to_rbs).join(' | ')})"
+        end
+      end
+
+      # @return [String]
+      def parameters_as_rbs
+        return '' unless parameters?
+
+        return "[#{all_params.map(&:to_rbs).join(', ')}]" if key_types.empty?
+
+        # handle, e.g., Hash[K, V] case
+        key_types_str = rbs_union(key_types)
+        subtypes_str = rbs_union(subtypes)
+        "[#{key_types_str}, #{subtypes_str}]"
+      end
+
+      def generic?
+        name == GENERIC_TAG_NAME || all_params.any?(&:generic?)
+      end
+
+      # @param generics_to_resolve [Enumerable<String>]
+      # @param context_type [UniqueType, nil]
+      # @param resolved_generic_values [Hash{String => ComplexType}] Added to as types are encountered or resolved
+      # @return [UniqueType, ComplexType]
+      def resolve_generics_from_context generics_to_resolve, context_type, resolved_generic_values: {}
+        if name == ComplexType::GENERIC_TAG_NAME
+          type_param = subtypes.first&.name
+          return self unless generics_to_resolve.include? type_param
+          unless context_type.nil? || !resolved_generic_values[type_param].nil?
+            new_binding = true
+            resolved_generic_values[type_param] = context_type
+          end
+          if new_binding
+            resolved_generic_values.transform_values! do |complex_type|
+              complex_type.resolve_generics_from_context(generics_to_resolve, nil, resolved_generic_values: resolved_generic_values)
+            end
+          end
+          return resolved_generic_values[type_param] || self
+        end
+
+        # @todo typechecking should complain when the method being called has no @yieldparam tag
+        new_key_types = resolve_param_generics_from_context(generics_to_resolve, context_type, resolved_generic_values, &:key_types)
+        new_subtypes = resolve_param_generics_from_context(generics_to_resolve, context_type, resolved_generic_values, &:subtypes)
+        recreate(new_key_types: new_key_types, new_subtypes: new_subtypes)
+      end
+
+      # @param generics_to_resolve [Enumerable<String>]
+      # @param context_type [UniqueType]
+      # @param resolved_generic_values [Hash{String => ComplexType}]
+      # @yieldreturn [Array<ComplexType>]
+      # @return [Array<ComplexType>]
+      def resolve_param_generics_from_context(generics_to_resolve, context_type, resolved_generic_values)
+        types = yield self
+        types.each_with_index.flat_map do |ct, i|
+          ct.items.flat_map do |ut|
+            context_params = yield context_type if context_type
+            if context_params && context_params[i]
+              type_arg = context_params[i]
+              type_arg.map do |new_unique_context_type|
+                ut.resolve_generics_from_context generics_to_resolve, new_unique_context_type, resolved_generic_values: resolved_generic_values
+              end
+            else
+              ut.resolve_generics_from_context generics_to_resolve, nil, resolved_generic_values: resolved_generic_values
+            end
+          end
+        end
+      end
+
+      # Probe the concrete type for each of the generic type
+      # parameters used in this type, and return a new type if
+      # possible.
+      #
+      # @param definitions [Pin::Namespace, Pin::Method] The module/class/method which uses generic types
+      # @param context_type [ComplexType] The receiver type
+      # @return [UniqueType, ComplexType]
+      def resolve_generics definitions, context_type
+        return self if definitions.nil? || definitions.generics.empty?
+
+        transform(name) do |t|
+          if t.name == GENERIC_TAG_NAME
+            idx = definitions.generics.index(t.subtypes.first&.name)
+            next t if idx.nil?
+            context_type.all_params[idx] || ComplexType::UNDEFINED
           else
-            UniqueType.new(new_name, "<#{new_subtypes.join(', ')}>")
+            t
           end
+        end
+      end
+
+      # @yieldparam t [self]
+      # @yieldreturn [self]
+      # @return [Array<self>]
+      def map &block
+        [block.yield(self)]
+      end
+
+      # @return [Array<UniqueType>]
+      def to_a
+        [self]
+      end
+
+      # @param new_name [String, nil]
+      # @param make_rooted [Boolean, nil]
+      # @param new_key_types [Array<UniqueType>, nil]
+      # @param rooted [Boolean, nil]
+      # @param new_subtypes [Array<UniqueType>, nil]
+      # @return [self]
+      def recreate(new_name: nil, make_rooted: nil, new_key_types: nil, new_subtypes: nil)
+        raise "Please remove leading :: and set rooted instead - #{new_name}" if new_name&.start_with?('::')
+        new_name ||= name
+        new_key_types ||= @key_types
+        new_subtypes ||= @subtypes
+        make_rooted = @rooted if make_rooted.nil?
+        UniqueType.new(new_name, new_key_types, new_subtypes, rooted: make_rooted, parameters_type: parameters_type)
+      end
+
+      # @return [String]
+      def rooted_tags
+        rooted_tag
+      end
+
+      # @return [String]
+      def tags
+        tag
+      end
+
+      # @return [self]
+      def force_rooted
+        transform do |t|
+          t.recreate(make_rooted: true)
+        end
+      end
+
+      # Apply the given transformation to each subtype and then finally to this type
+      #
+      # @param new_name [String, nil]
+      # @yieldparam t [UniqueType]
+      # @yieldreturn [self]
+      # @return [self]
+      def transform(new_name = nil, &transform_type)
+        raise "Please remove leading :: and set rooted with recreate() instead - #{new_name}" if new_name&.start_with?('::')
+        if name == ComplexType::GENERIC_TAG_NAME
+          # doesn't make sense to manipulate the name of the generic
+          new_key_types = @key_types
+          new_subtypes = @subtypes
         else
-          UniqueType.new(new_name)
+          new_key_types = @key_types.flat_map { |ct| ct.items.map { |ut| ut.transform(&transform_type) } }
+          new_subtypes = @subtypes.flat_map { |ct| ct.items.map { |ut| ut.transform(&transform_type) } }
+        end
+        new_type = recreate(new_name: new_name || name, new_key_types: new_key_types, new_subtypes: new_subtypes)
+        yield new_type
+      end
+
+      # Transform references to the 'self' type to the specified concrete namespace
+      # @param dst [String]
+      # @return [UniqueType]
+      def self_to dst
+        transform do |t|
+          next t if t.name != 'self'
+          t.recreate(new_name: dst, new_key_types: [], new_subtypes: [])
         end
       end
 
@@ -68,8 +296,8 @@ module Solargraph
         @name == 'self' || @key_types.any?(&:selfy?) || @subtypes.any?(&:selfy?)
       end
 
-      UNDEFINED = UniqueType.new('undefined')
-      BOOLEAN = UniqueType.new('Boolean')
+      UNDEFINED = UniqueType.new('undefined', rooted: false)
+      BOOLEAN = UniqueType.new('Boolean', rooted: true)
     end
   end
 end