solargraph 0.51.2 → 0.54.2

data/lib/solargraph/complex_type.rb

@@ -4,15 +4,31 @@ module Solargraph
   # A container for type data based on YARD type tags.
   #
   class ComplexType
+    GENERIC_TAG_NAME = 'generic'.freeze
     # @!parse
     #   include TypeMethods
 
     autoload :TypeMethods, 'solargraph/complex_type/type_methods'
     autoload :UniqueType,  'solargraph/complex_type/unique_type'
 
-    # @param types [Array<UniqueType>]
+    # @param types [Array<UniqueType, ComplexType>]
     def initialize types = [UniqueType::UNDEFINED]
-      @items = types.uniq(&:to_s)
+      # @todo @items here should not need an annotation
+      # @type [Array<UniqueType>]
+      @items = types.flat_map(&:items).uniq(&:to_s)
+    end
+
+    def eql?(other)
+      self.class == other.class &&
+        @items == other.items
+    end
+
+    def ==(other)
+      self.eql?(other)
+    end
+
+    def hash
+      [self.class, @items].hash
     end
 
     # @param api_map [ApiMap]
@@ -21,34 +37,61 @@ module Solargraph
     def qualify api_map, context = ''
       red = reduce_object
       types = red.items.map do |t|
-        next t if ['Boolean', 'nil', 'void', 'undefined'].include?(t.name)
+        next t if ['nil', 'void', 'undefined'].include?(t.name)
+        next t if ['::Boolean'].include?(t.rooted_name)
         t.qualify api_map, context
       end
       ComplexType.new(types).reduce_object
     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 [self]
+    def resolve_generics_from_context generics_to_resolve, context_type, resolved_generic_values: {}
+      return self unless generic?
+
+      ComplexType.new(@items.map { |i| i.resolve_generics_from_context(generics_to_resolve, context_type, resolved_generic_values: resolved_generic_values) })
+    end
+
+    # @return [UniqueType]
     def first
       @items.first
     end
 
+    # @return [String]
     def to_rbs
-      ((@items.length > 1 ? '(' : '') + @items.map do |item|
-        "#{item.namespace}#{item.parameters? ? "[#{item.subtypes.map { |s| s.to_rbs }.join(', ')}]" : ''}"
-      end.join(' | ') + (@items.length > 1 ? ')' : '')).gsub(/undefined/, 'untyped')
+      ((@items.length > 1 ? '(' : '') +
+       @items.map(&:to_rbs).join(' | ') +
+       (@items.length > 1 ? ')' : ''))
+    end
+
+    # @param dst [ComplexType]
+    # @return [ComplexType]
+    def self_to_type dst
+      object_type_dst = dst.reduce_class_type
+      transform do |t|
+        next t if t.name != 'self'
+        object_type_dst
+      end
     end
 
+    # @yieldparam [UniqueType]
+    # @return [Array]
     def map &block
       @items.map &block
     end
 
     # @yieldparam [UniqueType]
-    # @return [Array]
+    # @return [Enumerable<UniqueType>]
     def each &block
       @items.each &block
     end
 
     # @yieldparam [UniqueType]
-    # @return [Enumerator<UniqueType>]
+    # @return [void]
+    # @overload each_unique_type()
+    #   @return [Enumerator<UniqueType>]
     def each_unique_type &block
       return enum_for(__method__) unless block_given?
 
@@ -57,14 +100,27 @@ module Solargraph
       end
     end
 
+    # @return [Integer]
     def length
       @items.length
     end
 
+    # @return [Array<UniqueType>]
+    def to_a
+      @items
+    end
+
+    def tags
+      @items.map(&:tag).join(', ')
+    end
+
+    # @param index [Integer]
+    # @return [UniqueType]
     def [](index)
       @items[index]
     end
 
+    # @return [Array<UniqueType>]
     def select &block
       @items.select &block
     end
@@ -80,12 +136,16 @@ module Solargraph
       @items.map(&:namespace)
     end
 
+    # @param name [Symbol]
+    # @return [Object, nil]
     def method_missing name, *args, &block
       return if @items.first.nil?
       return @items.first.send(name, *args, &block) if respond_to_missing?(name)
       super
     end
 
+    # @param name [Symbol]
+    # @param include_private [Boolean]
     def respond_to_missing?(name, include_private = false)
       TypeMethods.public_instance_methods.include?(name) || super
     end
@@ -94,6 +154,10 @@ module Solargraph
       map(&:tag).join(', ')
     end
 
+    def rooted_tags
+      map(&:rooted_tag).join(', ')
+    end
+
     def all? &block
       @items.all? &block
     end
@@ -106,54 +170,84 @@ module Solargraph
       @items.any?(&:selfy?)
     end
 
-    def parameterized?
-      any?(&:parameterized?)
+    def generic?
+      any?(&:generic?)
     end
 
-    def resolve_parameters definitions, context
-      result = @items.map { |i| i.resolve_parameters(definitions, context) }
-      ComplexType.parse(*result.map(&:tag))
+    # @param new_name [String, nil]
+    # @yieldparam t [UniqueType]
+    # @yieldreturn [UniqueType]
+    # @return [ComplexType]
+    def transform(new_name = nil, &transform_type)
+      raise "Please remove leading :: and set rooted with recreate() instead - #{new_name}" if new_name&.start_with?('::')
+      ComplexType.new(map { |ut| ut.transform(new_name, &transform_type) })
     end
 
-    # @param dst [String]
+    # @return [self]
+    def force_rooted
+      transform do |t|
+        t.recreate(make_rooted: true)
+      end
+    end
+
+    # @param definitions [Pin::Namespace, Pin::Method]
+    # @param context_type [ComplexType]
     # @return [ComplexType]
-    def self_to dst
-      return self unless selfy?
-      red = reduce_class(dst)
-      result = @items.map { |i| i.self_to red }
-      ComplexType.parse(*result.map(&:tag))
+    def resolve_generics definitions, context_type
+      result = @items.map { |i| i.resolve_generics(definitions, context_type) }
+      ComplexType.new(result)
     end
 
     def nullable?
       @items.any?(&:nil_type?)
     end
 
+    # @return [Array<ComplexType>]
     def all_params
       @items.first.all_params || []
     end
 
-    protected
+    # @return [ComplexType]
+    def reduce_class_type
+      new_items = items.flat_map do |type|
+        next type unless ['Module', 'Class'].include?(type.name)
+
+        type.all_params
+      end
+      ComplexType.new(new_items)
+    end
+
+    # every type and subtype in this union have been resolved to be
+    # fully qualified
+    def all_rooted?
+      all?(&:all_rooted?)
+    end
+
+    # every top-level type has resolved to be fully qualified; see
+    # #all_rooted? to check their subtypes as well
+    def rooted?
+      all?(&:rooted?)
+    end
 
     attr_reader :items
 
-    def reduce_object
-      return self if name != 'Object' || subtypes.empty?
-      ComplexType.try_parse(reduce_class(subtypes.join(', ')))
+    def rooted?
+      @items.all?(&:rooted?)
     end
 
-    private
+    protected
 
-    # @todo This is a quick and dirty hack that forces `self` keywords
-    #   to reference an instance of their class and never the class itself.
-    #   This behavior may change depending on which result is expected
-    #   from YARD conventions. See https://github.com/lsegal/yard/issues/1257
-    # @param dst [String]
-    # @return [String]
-    def reduce_class dst
-      while dst =~ /^(Class|Module)\<(.*?)\>$/
-        dst = dst.sub(/^(Class|Module)\</, '').sub(/\>$/, '')
+    # @return [ComplexType]
+    def reduce_object
+      new_items = items.flat_map do |ut|
+        next [ut] if ut.name != 'Object' || ut.subtypes.empty?
+        ut.subtypes
       end
-      dst
+      ComplexType.new(new_items)
+    end
+
+    def bottom?
+      @items.all?(&:bot?)
     end
 
     class << self
@@ -170,9 +264,18 @@ module Solargraph
       #   used internally.
       #
       # @param *strings [Array<String>] The type definitions to parse
-      # @param partial [Boolean] True if the string is part of a another type
-      # @return [ComplexType, Array, nil]
+      # @return [ComplexType]
+      # # @overload parse(*strings, partial: false)
+      # #  @todo Need ability to use a literal true as a type below
+      # #  @param partial [Boolean] True if the string is part of a another type
+      # #  @return [Array<UniqueType>]
+      # @sg-ignore
+      # @todo To be able to select the right signature above,
+      #   Chain::Call needs to know the decl type (:arg, :optarg,
+      #   :kwarg, etc) of the arguments given, instead of just having
+      #   an array of Chains as the arguments.
       def parse *strings, partial: false
+        # @type [Hash{Array<String> => ComplexType}]
         @cache ||= {}
         unless partial
           cached = @cache[strings]
@@ -197,7 +300,10 @@ module Solargraph
               elsif base.end_with?('=')
                 raise ComplexTypeError, "Invalid hash thing" unless key_types.nil?
                 # types.push ComplexType.new([UniqueType.new(base[0..-2].strip)])
-                types.push UniqueType.new(base[0..-2].strip)
+                types.push UniqueType.parse(base[0..-2].strip, subtype_string)
+                # @todo this should either expand key_type's type
+                #   automatically or complain about not being
+                #   compatible with key_type's type in type checking
                 key_types = types
                 types = []
                 base.clear
@@ -220,12 +326,12 @@ module Solargraph
               paren_stack += 1
             elsif char == ')'
               paren_stack -= 1
-              subtype_string += char if paren_stack == 0
+              subtype_string += char
               raise ComplexTypeError, "Invalid close in type #{type_string}" if paren_stack < 0
               next
             elsif char == ',' && point_stack == 0 && curly_stack == 0 && paren_stack == 0
               # types.push ComplexType.new([UniqueType.new(base.strip, subtype_string.strip)])
-              types.push UniqueType.new(base.strip, subtype_string.strip)
+              types.push UniqueType.parse(base.strip, subtype_string.strip)
               base.clear
               subtype_string.clear
               next
@@ -238,7 +344,7 @@ module Solargraph
           end
           raise ComplexTypeError, "Unclosed subtype in #{type_string}" if point_stack != 0 || curly_stack != 0 || paren_stack != 0
           # types.push ComplexType.new([UniqueType.new(base, subtype_string)])
-          types.push UniqueType.new(base.strip, subtype_string.strip)
+          types.push UniqueType.parse(base.strip, subtype_string.strip)
         end
         unless key_types.nil?
           raise ComplexTypeError, "Invalid use of key/value parameters" unless partial
@@ -255,17 +361,33 @@ module Solargraph
       def try_parse *strings
         parse *strings
       rescue ComplexTypeError => e
-        Solargraph.logger.info "Error parsing complex type: #{e.message}"
+        Solargraph.logger.info "Error parsing complex type `#{strings.join(', ')}`: #{e.message}"
         ComplexType::UNDEFINED
       end
     end
 
     VOID = ComplexType.parse('void')
     UNDEFINED = ComplexType.parse('undefined')
-    SYMBOL = ComplexType.parse('Symbol')
-    ROOT = ComplexType.parse('Class<>')
+    SYMBOL = ComplexType.parse('::Symbol')
+    ROOT = ComplexType.parse('::Class<>')
     NIL = ComplexType.parse('nil')
     SELF = ComplexType.parse('self')
-    BOOLEAN = ComplexType.parse('Boolean')
+    BOOLEAN = ComplexType.parse('::Boolean')
+    BOT = ComplexType.parse('bot')
+
+    private
+
+    # @todo This is a quick and dirty hack that forces `self` keywords
+    #   to reference an instance of their class and never the class itself.
+    #   This behavior may change depending on which result is expected
+    #   from YARD conventions. See https://github.com/lsegal/yard/issues/1257
+    # @param dst [String]
+    # @return [String]
+    def reduce_class dst
+      while dst =~ /^(Class|Module)\<(.*?)\>$/
+        dst = dst.sub(/^(Class|Module)\</, '').sub(/\>$/, '')
+      end
+      dst
+    end
   end
 end

data/lib/solargraph/convention.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
 
 module Solargraph
   # Conventions provide a way to modify an ApiMap based on expectations about

data/lib/solargraph/converters/dd.rb

@@ -1,6 +1,11 @@
+require 'nokogiri'
+
 module ReverseMarkdown
   module Converters
     class Dd < Base
+      # @return [String]
+      # @param node [Nokogiri::XML::Element]
+      # @param state [Hash]
       def convert node, state = {}
         content = treat_children(node, state)
         ": #{content.strip}\n"

data/lib/solargraph/converters/dl.rb

@@ -1,6 +1,9 @@
 module ReverseMarkdown
   module Converters
     class Dl < Base
+      # @return [String]
+      # @param node [Nokogiri::XML::Element]
+      # @param state [Hash]
       def convert node, state = {}
         content = treat_children(node, state).strip
         "\n\n#{content}\n"

data/lib/solargraph/converters/dt.rb

@@ -1,6 +1,9 @@
 module ReverseMarkdown
   module Converters
     class Dt < Base
+      # @return [String]
+      # @param node [Nokogiri::XML::Element]
+      # @param state [Hash]
       def convert node, state = {}
         content = treat_children(node, state)
         "\n#{content.strip}\n"

data/lib/solargraph/diagnostics/rubocop.rb

@@ -29,9 +29,9 @@ module Solargraph
         store = RuboCop::ConfigStore.new
         runner = RuboCop::Runner.new(options, store)
         result = redirect_stdout{ runner.run(paths) }
-        
+
         return [] if result.empty?
-        
+
         make_array JSON.parse(result)
       rescue RuboCop::ValidationError, RuboCop::ConfigNotFoundError => e
         raise DiagnosticsError, "Error in RuboCop configuration: #{e.message}"
@@ -48,7 +48,7 @@ module Solargraph
         args.find { |a| a =~ /version=/ }.to_s.split('=').last
       end
 
-      # @param resp [Hash]
+      # @param resp [Hash{String => Array<Hash{String => Array<Hash{String => undefined}>}>}]
       # @return [Array<Hash>]
       def make_array resp
         diagnostics = []
@@ -62,8 +62,8 @@ module Solargraph
 
       # Convert a RuboCop offense to an LSP diagnostic
       #
-      # @param off [Hash] Offense received from Rubocop
-      # @return [Hash] LSP diagnostic
+      # @param off [Hash{String => unknown}] Offense received from Rubocop
+      # @return [Hash{Symbol => Hash, String, Integer}] LSP diagnostic
       def offense_to_diagnostic off
         {
           range: offense_range(off).to_hash,
@@ -81,19 +81,20 @@ module Solargraph
         Range.new(offense_start_position(off), offense_ending_position(off))
       end
 
-      # @param off [Hash]
+      # @param off [Hash{String => Hash{String => Integer}}]
       # @return [Position]
       def offense_start_position off
         Position.new(off['location']['start_line'] - 1, off['location']['start_column'] - 1)
       end
 
-      # @param off [Hash]
+      # @param off [Hash{String => Hash{String => Integer}}]
       # @return [Position]
       def offense_ending_position off
         if off['location']['start_line'] != off['location']['last_line']
           Position.new(off['location']['start_line'], 0)
         else
           start_line = off['location']['start_line'] - 1
+          # @type [Integer]
           last_column = off['location']['last_column']
           line = @source.code.lines[start_line]
           col_off = if line.nil? || line.empty?

data/lib/solargraph/diagnostics/rubocop_helpers.rb

@@ -12,6 +12,7 @@ module Solargraph
       #
       # @param version [String, nil]
       # @raise [InvalidRubocopVersionError] if _version_ is not installed
+      # @return [void]
       def require_rubocop(version = nil)
         begin
           gem_path = Gem::Specification.find_by_name('rubocop', version).full_gem_path

data/lib/solargraph/diagnostics/type_check.rb

@@ -6,6 +6,7 @@ module Solargraph
     # parameters, and invalid param tags.
     #
     class TypeCheck < Base
+      # @return [Array<Hash>]
       def diagnose source, api_map
         # return [] unless args.include?('always') || api_map.workspaced?(source.filename)
         severity = Diagnostics::Severities::ERROR

data/lib/solargraph/diagnostics.rb

@@ -33,14 +33,14 @@ module Solargraph
       # Find a reporter by name.
       #
       # @param name [String] The name with which the reporter was registered
-      # @return [Class<Solargraph::Diagnostics::Base>]
+      # @return [Class<Solargraph::Diagnostics::Base>, nil]
       def reporter name
         reporter_hash[name]
       end
 
       private
 
-      # @return [Hash]
+      # @return [Hash{String => Class<Solargraph::Diagnostics::Base>}]
       def reporter_hash
         @reporter_hash ||= {}
       end

data/lib/solargraph/doc_map.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module Solargraph
+  # A collection of pins generated from required gems.
+  #
+  class DocMap
+    # @return [Array<String>]
+    attr_reader :requires
+
+    # @return [Array<Gem::Specification>]
+    attr_reader :preferences
+
+    # @return [Array<Pin::Base>]
+    attr_reader :pins
+
+    # @return [Array<Gem::Specification>]
+    attr_reader :uncached_gemspecs
+
+    # @param requires [Array<String>]
+    # @param preferences [Array<Gem::Specification>]
+    # @param rbs_path [String, Pathname, nil]
+    def initialize(requires, preferences, rbs_path = nil)
+      @requires = requires.compact
+      @preferences = preferences.compact
+      @rbs_path = rbs_path
+      generate
+    end
+
+    # @return [Array<Gem::Specification>]
+    def gemspecs
+      @gemspecs ||= required_gem_map.values.compact
+    end
+
+    # @return [Array<String>]
+    def unresolved_requires
+      @unresolved_requires ||= required_gem_map.select { |_, gemspec| gemspec.nil? }.keys
+    end
+
+    # @return [Hash{Gem::Specification => Array[Pin::Base]}]
+    def self.gems_in_memory
+      @gems_in_memory ||= {}
+    end
+
+    # @return [Set<Gem::Specification>]
+    def dependencies
+      @dependencies ||= (gemspecs.flat_map { |spec| fetch_dependencies(spec) } - gemspecs).to_set
+    end
+
+    private
+
+    # @return [void]
+    def generate
+      @pins = []
+      @uncached_gemspecs = []
+      required_gem_map.each do |path, gemspec|
+        if gemspec
+          try_cache gemspec
+        else
+          try_stdlib_map path
+        end
+      end
+      dependencies.each { |dep| try_cache dep }
+      @uncached_gemspecs.uniq!
+    end
+
+    # @return [Hash{String => Gem::Specification, nil}]
+    def required_gem_map
+      @required_gem_map ||= requires.to_h { |path| [path, resolve_path_to_gemspec(path)] }
+    end
+
+    # @return [Hash{String => Gem::Specification}]
+    def preference_map
+      @preference_map ||= preferences.to_h { |gemspec| [gemspec.name, gemspec] }
+    end
+
+    # @param gemspec [Gem::Specification]
+    # @return [void]
+    def try_cache gemspec
+      return if try_gem_in_memory(gemspec)
+      cache_file = File.join('gems', "#{gemspec.name}-#{gemspec.version}.ser")
+      if Cache.exist?(cache_file)
+        cached = Cache.load(cache_file)
+        gempins = update_from_collection(gemspec, cached)
+        self.class.gems_in_memory[gemspec] = gempins
+        @pins.concat gempins
+      else
+        Solargraph.logger.debug "No pin cache for #{gemspec.name} #{gemspec.version}"
+        @uncached_gemspecs.push gemspec
+      end
+    end
+
+    # @param path [String] require path that might be in the RBS stdlib collection
+    # @return [void]
+    def try_stdlib_map path
+      map = RbsMap::StdlibMap.load(path)
+      if map.resolved?
+        Solargraph.logger.debug "Loading stdlib pins for #{path}"
+        @pins.concat map.pins
+      else
+        # @todo Temporarily ignoring unresolved `require 'set'`
+        Solargraph.logger.debug "Require path #{path} could not be resolved" unless path == 'set'
+      end
+    end
+
+    # @param gemspec [Gem::Specification]
+    # @return [Boolean]
+    def try_gem_in_memory gemspec
+      gempins = DocMap.gems_in_memory[gemspec]
+      return false unless gempins
+      Solargraph.logger.debug "Found #{gemspec.name} #{gemspec.version} in memory"
+      @pins.concat gempins
+      true
+    end
+
+    def update_from_collection gemspec, gempins
+      return gempins unless @rbs_path && File.directory?(@rbs_path)
+      return gempins if RbsMap.new(gemspec.name, gemspec.version).resolved?
+
+      rbs_map = RbsMap.new(gemspec.name, gemspec.version, directories: [@rbs_path])
+      return gempins unless rbs_map.resolved?
+
+      Solargraph.logger.info "Updating #{gemspec.name} #{gemspec.version} from collection"
+      GemPins.combine(gempins, rbs_map)
+    end
+
+    # @param path [String]
+    # @return [Gem::Specification, nil]
+    def resolve_path_to_gemspec path
+      return nil if path.empty?
+
+      gemspec = Gem::Specification.find_by_path(path)
+      if gemspec.nil?
+        gem_name_guess = path.split('/').first
+        begin
+          # this can happen when the gem is included via a local path in
+          # a Gemfile; Gem doesn't try to index the paths in that case.
+          #
+          # See if we can make a good guess:
+          potential_gemspec = Gem::Specification.find_by_name(gem_name_guess)
+          file = "lib/#{path}.rb"
+          gemspec = potential_gemspec if potential_gemspec.files.any? { |gemspec_file| file == gemspec_file }
+        rescue Gem::MissingSpecError
+          Solargraph.logger.debug "Require path #{path} could not be resolved to a gem via find_by_path or guess of #{gem_name_guess}"
+          nil
+        end
+      end
+      gemspec_or_preference gemspec
+    end
+
+    # @param gemspec [Gem::Specification, nil]
+    # @return [Gem::Specification, nil]
+    def gemspec_or_preference gemspec
+      return gemspec unless gemspec && preference_map.key?(gemspec.name)
+      return gemspec if gemspec.version == preference_map[gemspec.name].version
+
+      change_gemspec_version gemspec, preference_map[by_path.name].version
+    end
+
+    # @param gemspec [Gem::Specification]
+    # @param version [Gem::Version]
+    # @return [Gem::Specification]
+    def change_gemspec_version gemspec, version
+      Gem::Specification.find_by_name(gemspec.name, "= #{version}")
+    rescue Gem::MissingSpecError
+      Solargraph.logger.info "Gem #{gemspec.name} version #{version} not found. Using #{gemspec.version} instead"
+      gemspec
+    end
+
+    # @param gemspec [Gem::Specification]
+    # @return [Array<Gem::Specification>]
+    def fetch_dependencies gemspec
+      only_runtime_dependencies(gemspec).each_with_object(Set.new) do |spec, deps|
+        Solargraph.logger.info "Adding #{spec.name} dependency for #{gemspec.name}"
+        dep = Gem::Specification.find_by_name(spec.name, spec.requirement)
+        deps.merge fetch_dependencies(dep) if deps.add?(dep)
+      rescue Gem::MissingSpecError
+        Solargraph.logger.warn "Gem dependency #{spec.name} #{spec.requirements} for #{gemspec.name} not found."
+      end.to_a
+    end
+
+    # @param gemspec [Gem::Specification]
+    # @return [Array<Gem::Dependency>]
+    def only_runtime_dependencies gemspec
+      gemspec.dependencies - gemspec.development_dependencies
+    end
+  end
+end