solargraph 0.53.0 → 0.54.0

data/lib/solargraph/complex_type/unique_type.rb

@@ -8,7 +8,7 @@ module Solargraph
     class UniqueType
       include TypeMethods
 
-      attr_reader :all_params
+      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.,
@@ -17,43 +17,61 @@ 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
-        # @type [Array<ComplexType>]
-        @key_types = []
+        rooted = make_rooted unless make_rooted.nil?
+
         # @type [Array<ComplexType>]
-        @subtypes = []
+        key_types = []
         # @type [Array<ComplexType>]
-        @all_params = []
-        return unless parameters?
-        # @todo we should be able to probe the type of 'subs' without
-        #   hoisting the definition outside of the if statement
-        subs = if @substring.start_with?('<(') && @substring.end_with?(')>')
-                 ComplexType.parse(substring[2..-3], partial: true)
-               else
-                 ComplexType.parse(substring[1..-2], partial: true)
-               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)
-          # @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
+        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
+        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
-        @all_params.concat @key_types
-        @all_params.concat @subtypes
+        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
@@ -76,7 +94,17 @@ module Solargraph
 
       # @return [String]
       def to_rbs
-        if ['Tuple', 'Array'].include?(name) && fixed_parameters?
+        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
@@ -90,28 +118,45 @@ module Solargraph
         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
-        parameters? ? "[#{all_params.map { |s| s.to_rbs }.join(', ')}]" : ''
+        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: {}
-        transform(name) do |t|
-          next t unless t.name == ComplexType::GENERIC_TAG_NAME
-
-          new_binding = false
-
-          type_param = t.subtypes.first&.name
-          next t unless generics_to_resolve.include? type_param
+        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
@@ -121,7 +166,34 @@ module Solargraph
               complex_type.resolve_generics_from_context(generics_to_resolve, nil, resolved_generic_values: resolved_generic_values)
             end
           end
-          resolved_generic_values[type_param] || t
+          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
 
@@ -159,39 +231,34 @@ module Solargraph
       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, new_key_types: nil, new_subtypes: nil)
+      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
-        if new_key_types.none?(&:defined?) && new_subtypes.none?(&:defined?)
-          # if all subtypes are undefined, erase down to the non-parametric type
-          UniqueType.new(new_name)
-        elsif new_key_types.empty? && new_subtypes.empty?
-          UniqueType.new(new_name)
-        elsif hash_parameters?
-          UniqueType.new(new_name, "{#{new_key_types.join(', ')} => #{new_subtypes.join(', ')}}")
-        elsif @substring.start_with?('<(')
-          # @todo This clause is probably wrong, and if so, fixing it
-          #    will be some level of breaking change.  Probably best
-          #    handled before real tuple support is rolled out and
-          #    folks start relying on it more.
-          #
-          #   (String) is a one element tuple in https://yardoc.org/types
-          #   <String> is an array of zero or more Strings in https://yardoc.org/types
-          #   Array<(String)> could be an Array of one-element tuples or a
-          #     one element tuple.  https://yardoc.org/types treats it
-          #     as the former.
-          #   Array<(String), Integer> is not ambiguous if we accept
-          #     (String) as a tuple type, but not currently understood
-          #     by Solargraph.
-          UniqueType.new(new_name, "<(#{new_subtypes.join(', ')})>")
-        elsif fixed_parameters?
-          UniqueType.new(new_name, "(#{new_subtypes.join(', ')})")
-        else
-          UniqueType.new(new_name, "<#{new_subtypes.join(', ')}>")
+        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
 
@@ -202,9 +269,16 @@ module Solargraph
       # @yieldreturn [self]
       # @return [self]
       def transform(new_name = nil, &transform_type)
-        new_key_types = @key_types.flat_map { |ct| ct.map { |ut| ut.transform(&transform_type) } }.compact
-        new_subtypes = @subtypes.flat_map { |ct| ct.map { |ut| ut.transform(&transform_type) } }.compact
-        new_type = recreate(new_name: new_name || rooted_name, new_key_types: new_key_types, new_subtypes: new_subtypes)
+        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
+          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
 
@@ -222,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

data/lib/solargraph/complex_type.rb

@@ -11,7 +11,7 @@ module Solargraph
     autoload :TypeMethods, 'solargraph/complex_type/type_methods'
     autoload :UniqueType,  'solargraph/complex_type/unique_type'
 
-    # @param types [Array<[UniqueType, ComplexType]>]
+    # @param types [Array<UniqueType, ComplexType>]
     def initialize types = [UniqueType::UNDEFINED]
       # @todo @items here should not need an annotation
       # @type [Array<UniqueType>]
@@ -86,6 +86,10 @@ module Solargraph
       @items
     end
 
+    def tags
+      @items.map(&:tag).join(', ')
+    end
+
     # @param index [Integer]
     # @return [UniqueType]
     def [](index)
@@ -126,6 +130,10 @@ module Solargraph
       map(&:tag).join(', ')
     end
 
+    def rooted_tags
+      map(&:rooted_tag).join(', ')
+    end
+
     def all? &block
       @items.all? &block
     end
@@ -147,15 +155,23 @@ module Solargraph
     # @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
 
+    # @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 resolve_generics definitions, context_type
       result = @items.map { |i| i.resolve_generics(definitions, context_type) }
-      ComplexType.parse(*result.map(&:tag))
+      ComplexType.try_parse(*result.map(&:tag))
     end
 
     # @param dst [String]
@@ -164,7 +180,7 @@ module Solargraph
       return self unless selfy?
       red = reduce_class(dst)
       result = @items.map { |i| i.self_to red }
-      ComplexType.parse(*result.map(&:tag))
+      ComplexType.try_parse(*result.map(&:tag))
     end
 
     def nullable?
@@ -190,21 +206,6 @@ module Solargraph
       @items.all?(&:bot?)
     end
 
-    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
-
     class << self
       # Parse type strings into a ComplexType.
       #
@@ -250,7 +251,7 @@ 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
@@ -281,7 +282,7 @@ module Solargraph
               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
@@ -294,7 +295,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
@@ -311,18 +312,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/doc_map.rb

@@ -8,7 +8,7 @@ module Solargraph
     attr_reader :requires
 
     # @return [Array<Gem::Specification>]
-    attr_reader :dependencies
+    attr_reader :preferences
 
     # @return [Array<Pin::Base>]
     attr_reader :pins
@@ -17,10 +17,12 @@ module Solargraph
     attr_reader :uncached_gemspecs
 
     # @param requires [Array<String>]
-    # @param dependencies [Array<Gem::Specification>]
-    def initialize(requires, dependencies)
-      @requires = requires
-      @dependencies = dependencies
+    # @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
 
@@ -39,17 +41,12 @@ module Solargraph
       @gems_in_memory ||= {}
     end
 
-    private
-
-    # @return [Hash{String => Gem::Specification, nil}]
-    def required_gem_map
-      @required_gem_map ||= requires.to_h { |path| [path, resolve_path_to_gemspec(path)] }
+    # @return [Set<Gem::Specification>]
+    def dependencies
+      @dependencies ||= (gemspecs.flat_map { |spec| fetch_dependencies(spec) } - gemspecs).to_set
     end
 
-    # @return [Hash{String => Gem::Specification}]
-    def dependency_map
-      @dependency_map ||= dependencies.to_h { |gemspec| [gemspec.name, gemspec] }
-    end
+    private
 
     # @return [void]
     def generate
@@ -62,6 +59,18 @@ module Solargraph
           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]
@@ -70,7 +79,8 @@ module Solargraph
       return if try_gem_in_memory(gemspec)
       cache_file = File.join('gems', "#{gemspec.name}-#{gemspec.version}.ser")
       if Cache.exist?(cache_file)
-        gempins = Cache.load(cache_file)
+        cached = Cache.load(cache_file)
+        gempins = update_from_collection(gemspec, cached)
         self.class.gems_in_memory[gemspec] = gempins
         @pins.concat gempins
       else
@@ -88,7 +98,7 @@ module Solargraph
         @pins.concat map.pins
       else
         # @todo Temporarily ignoring unresolved `require 'set'`
-        Solargraph.logger.warn "Require path #{path} could not be resolved" unless path == 'set'
+        Solargraph.logger.debug "Require path #{path} could not be resolved" unless path == 'set'
       end
     end
 
@@ -102,9 +112,22 @@ module Solargraph
       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
@@ -121,16 +144,16 @@ module Solargraph
           nil
         end
       end
-      return gemspec if dependencies.empty? || gemspec.nil?
+      gemspec_or_preference gemspec
+    end
 
-      if dependency_map.key?(gemspec.name)
-        return gemspec if gemspec.version == dependency_map[gemspec.name].version
+    # @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, dependency_map[by_path.name].version
-      else
-        Solargraph.logger.warn "Gem #{gemspec.name} is not an expected dependency"
-        gemspec
-      end
+      change_gemspec_version gemspec, preference_map[by_path.name].version
     end
 
     # @param gemspec [Gem::Specification]
@@ -142,5 +165,23 @@ module Solargraph
       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

data/lib/solargraph/gem_pins.rb

@@ -16,13 +16,21 @@ module Solargraph
     def self.build(gemspec)
       yard_pins = build_yard_pins(gemspec)
       rbs_map = RbsMap.from_gemspec(gemspec)
+      combine yard_pins, rbs_map
+    end
+
+    # @param yard_pins [Array<Pin::Base>]
+    # @param rbs_map [RbsMap]
+    # @return [Array<Pin::Base>]
+    def self.combine(yard_pins, rbs_map)
       in_yard = Set.new
       combined = yard_pins.map do |yard|
         in_yard.add yard.path
         next yard unless yard.is_a?(Pin::Method)
-        rbs = rbs_map.path_pin(yard.path)
+
+        rbs = rbs_map.path_pin(yard.path, Pin::Method)
         next yard unless rbs
-        # @todo Could not include: attribute and anon_splat
+
         # @sg-ignore
         yard.class.new(
           location: yard.location,

data/lib/solargraph/language_server/host/dispatch.rb

@@ -34,7 +34,7 @@ module Solargraph
         def update_libraries uri
           src = sources.find(uri)
           using = libraries.select { |lib| lib.contain?(src.filename) }
-          using.push generic_library_for(uri) if using.empty?
+          using.push library_for(uri) if using.empty?
           using.each { |lib| lib.merge src }
           diagnoser.schedule uri
         end
@@ -95,6 +95,10 @@ module Solargraph
           nil
         end
 
+        def options
+          @options ||= {}.freeze
+        end
+
         # Get a generic library for the given URI and attach the corresponding
         # source.
         #
@@ -109,7 +113,14 @@ module Solargraph
 
         # @return [Library]
         def generic_library
-          @generic_library ||= Solargraph::Library.new
+          @generic_library ||= Solargraph::Library.new(Solargraph::Workspace.new('', nil, options), nil)
+                                                  .tap { |lib| lib.add_observer self }
+        end
+
+        # @param library [Solargraph::Library]
+        # @return [void]
+        def update progress
+          progress&.send(self)
         end
       end
     end