solargraph 0.60.4 → 0.61.0

data/lib/solargraph/shell.rb

@@ -98,60 +98,37 @@ module Solargraph
     # @return [void]
     def clear
       puts 'Deleting all cached documentation (gems, core and stdlib)'
-      Solargraph::PinCache.clear
+      Solargraph::CacheDir.clear
     end
     map 'clear-cache' => :clear
     map 'clear-cores' => :clear
 
-    desc 'cache', 'Cache a gem', hide: true
-    option :rebuild, type: :boolean, desc: 'Rebuild existing documentation', default: false
-    # @return [void]
-    # @param gem [String]
-    # @param version [String, nil]
-    def cache gem, version = nil
-      gemspec = Gem::Specification.find_by_name(gem, version)
-
-      if options[:rebuild] || !PinCache.has_yard?(gemspec)
-        pins = GemPins.build_yard_pins(['yard-activesupport-concern'], gemspec)
-        PinCache.serialize_yard_gem(gemspec, pins)
-      end
-
-      workspace = Solargraph::Workspace.new(Dir.pwd) if File.exist?('rbs_collection.yaml')
-      rbs_map = RbsMap.from_gemspec(gemspec, workspace&.rbs_collection_path, workspace&.rbs_collection_config_path)
-      if options[:rebuild] || !PinCache.has_rbs_collection?(gemspec, rbs_map.cache_key)
-        PinCache.serialize_rbs_collection_gem(gemspec, rbs_map.cache_key, rbs_map.pins)
-      end
-    rescue Gem::MissingSpecError
-      warn "Gem '#{gem}' not found"
-    end
-
     desc 'uncache GEM [...GEM]', 'Delete specific cached gem documentation'
     long_desc %(
       Specify one or more gem names to clear. 'core' or 'stdlib' may
       also be specified to clear cached system documentation.
       Documentation will be regenerated as needed.
     )
+    option :directory, type: :string, desc: 'Workspace directory', default: Dir.pwd
     # @param gems [Array<String>]
     # @return [void]
     def uncache *gems
       raise ArgumentError, 'No gems specified.' if gems.empty?
+      repo = Solargraph::Repo.new(options[:directory])
+
       gems.each do |gem|
         if gem == 'core'
-          PinCache.uncache_core
-          next
-        end
-
-        if gem == 'stdlib'
-          PinCache.uncache_stdlib
-          next
+          Solargraph::Collection::Core.uncache
+        elsif gem == 'stdlib'
+          FileUtils.rm_rf CacheDir.stdlib_dir
+        else
+          metagem = repo.find_by_name(gem)
+          Solargraph::Collection::Gem.uncache(metagem) if metagem
         end
-
-        spec = Gem::Specification.find_by_name(gem)
-        PinCache.uncache_gem(spec, out: $stdout)
       end
     end
 
-    desc 'gems [GEM[=VERSION]...] [STDLIB...] [core]', 'Cache documentation for
+    desc 'cache GEM_NAME [...GEM_NAME] [core]', 'Cache documentation for
          installed libraries'
     long_desc %( This command will cache the
     generated type documentation for the specified libraries.  While
@@ -172,56 +149,51 @@ module Solargraph
         If the library is already cached, it will be rebuilt if the
         --rebuild option is set.
 
-        Cached documentation is stored in #{PinCache.base_dir}, which
+        Cached documentation is stored in #{CacheDir.base_dir}, which
         can be stored between CI runs.
     )
+    option :directory, type: :string, desc: 'Workspace directory', default: Dir.pwd
     option :rebuild, type: :boolean, desc: 'Rebuild existing documentation', default: false
     # @param names [Array<String>]
     # @return [void]
-    def gems *names
-      # print time with ms
-      workspace = Solargraph::Workspace.new('.')
-
-      if names.empty?
-        Gem::Specification.to_a.each { |spec| do_cache spec, rebuild: options[:rebuild] }
-        $stderr.puts "Documentation cached for all #{Gem::Specification.count} gems."
-      else
-        warn("Caching these gems: #{names}")
-        names.each do |name|
-          if name == 'core'
-            # @sg-ignore cache_core and core? are dynamically defined
-            PinCache.cache_core(out: $stdout) # if !PinCache.core? || options[:rebuild]
-            next
-          end
-
-          gemspec = workspace.find_gem(*name.split('='))
-          if gemspec.nil?
-            warn "Gem '#{name}' not found"
-          else
-            if options[:rebuild] || !PinCache.has_yard?(gemspec)
-              pins = GemPins.build_yard_pins(['yard-activesupport-concern'], gemspec)
-              PinCache.serialize_yard_gem(gemspec, pins)
-            end
-
-            workspace = Solargraph::Workspace.new(Dir.pwd)
-            rbs_map = RbsMap.from_gemspec(gemspec, workspace.rbs_collection_path, workspace.rbs_collection_config_path)
-            if options[:rebuild] || !PinCache.has_rbs_collection?(gemspec, rbs_map.cache_key)
-              # cache pins even if result is zero, so we don't retry building pins
-              pins = rbs_map.pins || []
-              PinCache.serialize_rbs_collection_gem(gemspec, rbs_map.cache_key, pins)
-            end
-          end
-        rescue Gem::MissingSpecError
-          warn "Gem '#{name}' not found"
-        rescue Gem::Requirement::BadRequirementError => e
-          warn "Gem '#{name}' failed while loading"
-          warn e.message
-          # @sg-ignore Need to add nil check here
-          warn e.backtrace.join("\n")
-        end
-        warn "Documentation cached for #{names.count} gems."
+    # @param [Array<Object>] gem_names
+    def cache *gem_names
+      repo = Solargraph::Repo.new(options[:directory])
+      metagems = if gem_names.empty?
+                   if repo.bundled?
+                     repo.bundled.select(&:cacheable?)
+                   else
+                     Gem::Specification.all_names
+                                       .map { |name| Gem::Specification.find_by_full_name(name) }
+                                       .map { |gemspec| Metagem.from_specification(gemspec) }
+                   end
+                 else
+                   gem_names.each_with_object([]) do |name, result|
+                     if name == 'core'
+                       Collection::Core.uncache if options[:rebuild]
+                       puts 'Caching core'
+                       Collection::Core.load
+                     else
+                       # @todo Quick and dirty hack for solargraph-rspec require bug
+                       #   (see https://github.com/lekemula/solargraph-rspec/pull/38)
+                       #   TL;DR: `repo.find_by_path` should not be necessary
+                       found = repo.find_by_name(name) || repo.find_by_path(name)
+                       if found
+                         result.push found
+                       else
+                         warn "Gem #{name} not found"
+                       end
+                     end
+                   end
+                 end
+      metagems.each do |metagem|
+        Collection::Gem.uncache(metagem) if options[:rebuild]
+        puts "Caching #{metagem.name} #{metagem.version} (#{metagem.cache_name})"
+        Collection::Gem.load(metagem)
       end
+      puts "Documentation cached for #{metagems.count} gems."
     end
+    map 'gems' => :cache
 
     desc 'reporters', 'Get a list of diagnostics reporters'
     # @return [void]
@@ -596,27 +568,5 @@ module Solargraph
         puts pin.inspect
       end
     end
-
-    # @param gemspec [Gem::Specification, nil]
-    # @param rebuild [Boolean]
-    # @return [void]
-    def do_cache gemspec, rebuild: false
-      if gemspec.nil?
-        warn "Gem '#{gemspec&.name}' not found"
-      else
-        if rebuild || !PinCache.has_yard?(gemspec)
-          pins = GemPins.build_yard_pins(['yard-activesupport-concern'], gemspec)
-          PinCache.serialize_yard_gem(gemspec, pins)
-        end
-
-        workspace = Solargraph::Workspace.new(Dir.pwd)
-        rbs_map = RbsMap.from_gemspec(gemspec, workspace.rbs_collection_path, workspace.rbs_collection_config_path)
-        if rebuild || !PinCache.has_rbs_collection?(gemspec, rbs_map.cache_key)
-          # cache pins even if result is zero, so we don't retry building pins
-          pins = rbs_map.pins || []
-          PinCache.serialize_rbs_collection_gem(gemspec, rbs_map.cache_key, pins)
-        end
-      end
-    end
   end
 end

data/lib/solargraph/source/chain/call.rb

@@ -64,7 +64,9 @@ module Solargraph
             [stack.first].compact
           end
           pin_groups = [] if !api_map.loose_unions && pin_groups.any?(&:empty?)
-          pins = pin_groups.flatten.uniq(&:path)
+          # Several union members can end up with the same pin and return type.
+          # @sg-ignore Array#flatten returns a bare Array
+          pins = pin_groups.flatten.uniq { |p| [p.path, p.return_type.rooted_tags] }
           return [] if pins.empty?
           inferred_pins(pins, api_map, name_pin, locals)
         end
@@ -153,9 +155,11 @@ module Solargraph
           # qualify(), however, happens in the namespace where
           # the docs were written - from the method pin.
           # @todo Need to add nil check here
-          if new_return_type.defined?
-            type = with_params(new_return_type.self_to_type(self_type), self_type).qualify(api_map, *pin.gates)
-          end
+          type = if new_return_type.defined?
+                   with_params(new_return_type.self_to_type(self_type), self_type).qualify(api_map, *pin.gates)
+                 else
+                   inferr_from_factory_parameters(api_map, pin)
+                 end
           type ||= ComplexType::UNDEFINED
           [type, new_signature_pin]
         end
@@ -219,6 +223,27 @@ module Solargraph
           end
         end
 
+        # @param api_map [ApiMap]
+        # @param method_pin [Pin::Method]
+        # @return [ComplexType, nil]
+        def inferr_from_factory_parameters api_map, method_pin
+          factory_parameter = api_map.factory_parameters_for_method(method_pin).find do |factory_param|
+            method_pin.parameters.each_with_index.find do |param, index|
+              current_argument = arguments[index]
+              next unless current_argument&.literal?
+              # @type [Solargraph::Source::Chain::Literal]
+              last_link = current_argument.links.last
+              argument_value = last_link.value
+
+              param.name == factory_param.param_name && argument_value == factory_param.value
+            end
+          end
+
+          return nil if factory_parameter.nil?
+
+          factory_parameter.return_type.qualify(api_map, method_pin.namespace)
+        end
+
         # @param pin [Pin::Base]
         # @param api_map [ApiMap]
         # @param context [ComplexType, ComplexType::UniqueType]

data/lib/solargraph/source/chain/literal.rb

@@ -6,29 +6,29 @@ module Solargraph
   class Source
     class Chain
       class Literal < Link
-        attr_reader :word, :value
+        attr_reader :word
+
+        # @return [::String, ::Symbol]
+        attr_reader :value
+
+        # @return [Parser::AST::Node]
+        attr_reader :node
 
         # @param type [String]
         # @param node [Parser::AST::Node, Object]
         def initialize type, node
           super("<#{type}>")
+          @node = node
 
-          # @todo We might be able to do some light inference from literals and
-          #   tuples as long as literal values are intransitive.
-
-          # if node.is_a?(::Parser::AST::Node)
-          #   # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
-          #   if node.type == :true
-          #     @value = true
-          #   # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
-          #   elsif node.type == :false
-          #     @value = false
-          #   # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
-          #   elsif %i[int sym].include?(node.type)
-          #     # @sg-ignore flow sensitive typing needs to narrow down type with an if is_a? check
-          #     @value = node.children.first
-          #   end
-          # end
+          if node.is_a?(::Parser::AST::Node)
+            if node.type == :true
+              @value = true
+            elsif node.type == :false
+              @value = false
+            elsif %i[int sym].include?(node.type)
+              @value = node.children.first
+            end
+          end
           @type = type
           # @literal_type = ComplexType.try_parse(@value.inspect)
           @literal_type = ComplexType::UNDEFINED

data/lib/solargraph/source/chain/parameter.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Solargraph
+  class Source
+    class Chain
+      # A method parameter represented as a link in a method call chain.
+      #
+      # @example
+      #   some_method('literal_value')
+      #                ^^^^^^^^^^^^^
+      class Parameter < Link
+        # @param literal [Chain::Literal] - literal argument
+        # @param method_call_chain [Chain] method call that contains the argument
+        def initialize literal, method_call_chain # rubocop:disable Lint/MissingSuper
+          @literal = literal
+          @method_call_chain = method_call_chain
+        end
+
+        def word
+          @word ||= "#{method_name}(.., #{@literal.word}, ..)"
+        end
+
+        # @param api_map [ApiMap]
+        # @param name_pin [Pin::Base]
+        # @param locals [::Array<Pin::Parameter, Pin::LocalVariable>]
+        # @return [::Array<Pin::Base>]
+        def resolve api_map, name_pin, locals
+          # @type [Pin::Method]
+          method_pin = method_call_chain.define(api_map, name_pin, locals)&.first
+          return [] unless method_pin
+
+          # Use indexed lookup for better performance
+          api_map.factory_parameters_for_method(method_pin).select do |fp|
+            param_index = method_pin.parameters.find_index { |param| param.name == fp.param_name }
+            next if param_index.nil?
+            next false unless fp.value == literal_value
+
+            # a splat takes every argument from its position on
+            method_pin.parameters[param_index].restarg? ? current_index >= param_index : current_index == param_index
+          end
+        end
+
+        # @return [Boolean] true if this is a parameter of Kernel#require
+        def require_parameter?
+          method_call_chain.links.last.word == 'require'
+        end
+
+        private
+
+        # @return [Chain::Literal]
+        attr_reader :literal
+        # @ return [Chain]
+        attr_reader :method_call_chain
+
+        # @return [String] The name of the method that this parameter belongs to
+        def method_name
+          @method_name ||= method_call.word
+        end
+
+        # @return [Chain::Call]
+        def method_call
+          @method_call_chain.links.last
+        end
+
+        # The index of the literal in the method call chain.
+        # @return [Integer]
+        def current_index
+          @current_index ||= method_call_chain.node.children[2..].index(literal.node)
+        end
+
+        # @return [::String, ::Symbol] The literal value of the parameter
+        # @sg-ignore false "return type could not be inferred"
+        def literal_value
+          literal.node.children.first
+        end
+      end
+    end
+  end
+end

data/lib/solargraph/source/chain.rb

@@ -34,6 +34,7 @@ module Solargraph
       autoload :ZSuper,           'solargraph/source/chain/z_super'
       autoload :Hash,             'solargraph/source/chain/hash'
       autoload :Array,            'solargraph/source/chain/array'
+      autoload :Parameter,        'solargraph/source/chain/parameter'
 
       @@inference_stack = []
       @@inference_depth = 0
@@ -182,6 +183,13 @@ module Solargraph
         links.last.is_a?(Chain::Literal)
       end
 
+      # @return [Boolean]
+      # @sg-ignore false "return type could not be inferred"
+      def require_parameter?
+        # @sg-ignore false "Unresolved call to require_parameter? on Solargraph::Source::Chain::Link"
+        links.last.is_a?(Chain::Parameter) && links.last.require_parameter?
+      end
+
       def undefined?
         links.any?(&:undefined?)
       end

data/lib/solargraph/source/source_chainer.rb

@@ -31,55 +31,18 @@ module Solargraph
 
       # @return [Source::Chain]
       def chain
-        # Special handling for files that end with an integer and a period
-        # if phrase =~ /^[0-9]+\.$/
-        #   return Chain.new([Chain::Literal.new('Integer', Integer(phrase[0..-2])),
-        #                     Chain::UNDEFINED_CALL])
-        # end
-        if phrase.start_with?(':') && !phrase.start_with?('::')
-          return Chain.new([Chain::Literal.new('Symbol',
-                                               # @sg-ignore Need to add nil check here
-                                               phrase[1..].to_sym)])
-        end
-        if end_of_phrase.strip == '::' && source.code[Position.to_offset(
-          source.code, position
-        )].to_s.match?(/[a-z]/i)
-          return SourceChainer.chain(source,
-                                     Position.new(position.line,
-                                                  position.character + 1))
-        end
+        return SourceChainer.chain(source, Position.new(position.line, position.character + 1)) if end_of_phrase.strip == '::' && source.code[Position.to_offset(source.code, position)].to_s.match?(/[a-z]/i)
+
         begin
-          return Chain.new([]) if phrase.end_with?('..')
-          # @type [::Parser::AST::Node, nil]
-          node = nil
-          # @type [::Parser::AST::Node, nil]
-          parent = nil
-          if !source.repaired? && source.parsed? && source.synchronized?
-            tree = source.tree_at(position.line, position.column)
-            node, parent = tree[0..2]
-          elsif source.parsed? && source.repaired? && end_of_phrase == '.'
-            node, parent = source.tree_at(fixed_position.line, fixed_position.column)[0..2]
-            # provide filename and line so that we can look up local variables there later
-            node = Parser.parse(fixed_phrase, source.filename, fixed_position.line) if node.nil?
-          elsif source.repaired?
-            node = Parser.parse(fixed_phrase, source.filename, fixed_position.line)
-          else
-            unless source.error_ranges.any? do |r|
-              r.nil? || r.include?(fixed_position)
-            end
-              node, parent = source.tree_at(fixed_position.line,
-                                            fixed_position.column)[0..2]
-            end
-            # Exception for positions that chain literal nodes in unsynchronized sources
-            node = nil unless source.synchronized? || !Parser.infer_literal_node_type(node).nil?
-            node = Parser.parse(fixed_phrase, source.filename, fixed_position.line) if node.nil?
-          end
+          node, parent, tree = node_from_position
         rescue Parser::SyntaxError
           return Chain.new([Chain::UNDEFINED_CALL])
         end
+
         return Chain.new([Chain::UNDEFINED_CALL]) if node.nil? || (node.type == :sym && !phrase.start_with?(':'))
-        # chain = NodeChainer.chain(node, source.filename, parent && parent.type == :block)
-        chain = Parser.chain(node, source.filename, parent)
+
+        chain = Parser.chain(node, source.filename, parent, tree)
+
         if source.repaired? || !source.parsed? || !source.synchronized?
           if end_of_phrase.strip == '.'
             chain.links.push Chain::UNDEFINED_CALL
@@ -94,6 +57,39 @@ module Solargraph
 
       private
 
+      # @return [Array(Parser::AST::Node, Parser::AST::Node, Array<Parser::AST::Node>)]
+      #   parent node, child node, and the tree at the position
+      def node_from_position
+        node = nil
+        parent = nil
+        tree = nil
+
+        if source.parsed? && !source.repaired? && source.synchronized?
+          tree = source.tree_at(position.line, position.column)
+          node, parent = tree[0..2]
+        elsif source.parsed? && source.repaired? && end_of_phrase == '.'
+          tree = source.tree_at(fixed_position.line, fixed_position.column)
+          node, parent = tree[0..2]
+          # provide filename and line so that we can look up local variables there later
+          node = Parser.parse(fixed_phrase, source.filename, fixed_position.line) if node.nil?
+          tree = source.tree_at(fixed_position.line, fixed_position.column) if node
+        elsif source.repaired?
+          node = Parser.parse(fixed_phrase, source.filename, fixed_position.line)
+          tree = source.tree_at(fixed_position.line, fixed_position.column) if node
+        else
+          unless source.error_ranges.any? { |r| r.nil? || r.include?(fixed_position) }
+            tree = source.tree_at(fixed_position.line, fixed_position.column)
+            node, parent = tree[0..2]
+          end
+          # Exception for positions that chain literal nodes in unsynchronized sources
+          node = nil unless source.synchronized? || !Parser.infer_literal_node_type(node).nil?
+          node = Parser.parse(fixed_phrase, source.filename, fixed_position.line) if node.nil?
+          tree = source.tree_at(fixed_position.line, fixed_position.column) if node
+        end
+
+        [node, parent, tree]
+      end
+
       # @return [Position]
       attr_reader :position
 

data/lib/solargraph/source_map/clip.rb

@@ -13,14 +13,14 @@ module Solargraph
         @cursor = cursor
         closure_pin = closure
         # @sg-ignore Need to add nil check here
-        if closure_pin.is_a?(Pin::Block) && !Solargraph::Range.from_node(closure_pin.receiver).contain?(cursor.range.start)
+        if closure_pin.is_a?(Pin::Block) && !Solargraph::Range.from_node(closure_pin.receiver)&.contain?(cursor.range.start)
           closure_pin.rebind(api_map)
         end
       end
 
       # @return [Array<Pin::Base>] Relevant pins for infering the type of the Cursor's position
       def define
-        return [] if cursor.comment? || cursor.chain.literal?
+        return [] if cursor.comment? || cursor.chain.literal? || cursor.chain.require_parameter?
         result = cursor.chain.define(api_map, closure, locals)
         result.concat file_global_methods
         if result.empty?
@@ -40,7 +40,8 @@ module Solargraph
       # @return [Completion]
       def complete
         return package_completions([]) if !source_map.source.parsed? || cursor.string?
-        if cursor.chain.literal? && cursor.chain.links.last.word == '<Symbol>'
+        # TODO: Improve magic word comparsion == '<::Symbol>', too fragile
+        if cursor.chain.literal? && cursor.chain.links.last.word == '<::Symbol>'
           return package_completions(api_map.get_symbols)
         end
         return Completion.new([], cursor.range) if cursor.chain.literal?
@@ -211,6 +212,7 @@ module Solargraph
               result.concat api_map.get_constants('', cursor.start_of_constant? ? '' : context_pin.full_context.namespace, *gates) # .select { |pin| pin.name.start_with?(full) }
             end
           else
+            type = type.qualify(api_map, *gates)
             result.concat api_map.get_constants(type.namespace,
                                                 cursor.start_of_constant? ? '' : context_pin.full_context.namespace, *gates)
           end

data/lib/solargraph/source_map/mapper.rb

@@ -12,7 +12,7 @@ module Solargraph
 
       private_class_method :new
 
-      DIRECTIVE_REGEXP = /(@!method|@!attribute|@!visibility|@!domain|@!macro|@!parse|@!override)/
+      DIRECTIVE_REGEXP = /(@!method|@!attribute|@!visibility|@!scope|@!domain|@!macro|@!parse|@!override)/
 
       # Generate the data.
       #
@@ -104,9 +104,13 @@ module Solargraph
         directive_processor = YardMap::Directives.for(directive)
         return unless directive_processor
 
-        @pins += directive_processor.process_directive(
+        new_pins = directive_processor.process_directive(
           @source, @pins, source_position, comment_position, directive
         )
+        # A @!scope directive in the indented text of another directive applies
+        # only to the object that directive defines.
+        YardMap::Directives::ScopeDirective.apply_nested directive, new_pins
+        @pins += new_pins
       end
 
       # @param comment [String]

data/lib/solargraph/source_map.rb

@@ -190,10 +190,12 @@ module Solargraph
       end
     end
 
-    private
-
     # @return [Array<Pin::Base>]
-    attr_writer :convention_pins
+    def convention_pins
+      @convention_pins || []
+    end
+
+    private
 
     # @return [Hash{Class<Pin::Base> => Array<Pin::Base>}]
     def pin_class_hash
@@ -206,9 +208,12 @@ module Solargraph
       @data ||= Data.new(source)
     end
 
+    # @param pins [Array<Pin::Base>]
     # @return [Array<Pin::Base>]
-    def convention_pins
-      @convention_pins || []
+    def convention_pins= pins
+      # unmemoizing the document_symbols in case it was called from any of conventions
+      @document_symbols = nil
+      @convention_pins = pins
     end
 
     # @generic T

data/lib/solargraph/type_checker/rules.rb

@@ -75,7 +75,7 @@ module Solargraph
       # @todo 22: Translate to something flow sensitive typing understands
       # @todo 3: Need a downcast here
       #
-      # flow sensitive typing could handle (96):
+      # flow sensitive typing could handle (97):
       #
       # @todo 36: flow sensitive typing needs to handle attrs
       # @todo 29: flow sensitive typing should be able to handle redefinition
@@ -113,6 +113,7 @@ module Solargraph
       # @todo 1: flow sensitive typing needs to create separate ranges for postfix if
       # @todo 1: flow sensitive typing needs to handle constants
       # @todo 1: flow sensitive typing needs to eliminate literal from union with return if foo == :bar
+      # @todo 1: Array#flatten returns a bare Array
       def require_all_unique_types_match_expected?
         report?(:require_all_unique_types_match_expected, :strong)
       end

data/lib/solargraph/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Solargraph
-  VERSION = ENV.fetch('SOLARGRAPH_FORCE_VERSION', '0.60.4')
+  VERSION = ENV.fetch('SOLARGRAPH_FORCE_VERSION', '0.61.0')
 end

data/lib/solargraph/workspace.rb

@@ -10,7 +10,6 @@ module Solargraph
   #
   class Workspace
     autoload :Config, 'solargraph/workspace/config'
-    autoload :Gemspecs, 'solargraph/workspace/gemspecs'
     autoload :RequirePaths, 'solargraph/workspace/require_paths'
 
     # @return [String]

data/lib/solargraph/yard_map/cache.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Solargraph
-  class YardMap
+  module YardMap
     class Cache
       def initialize
         # @type [Hash{String => Array<Solargraph::Pin::Base>}]

data/lib/solargraph/yard_map/directives/attribute_directive.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Solargraph
-  class YardMap
+  module YardMap
     module Directives
       module AttributeDirective
         module_function

data/lib/solargraph/yard_map/directives/domain_directive.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Solargraph
-  class YardMap
+  module YardMap
     module Directives
       module DomainDirective
         module_function