solargraph 0.60.4 → 0.62.0

data/lib/solargraph/rbs_map.rb

@@ -1,207 +1,16 @@
 # frozen_string_literal: true
 
-require 'digest'
-require 'pathname'
 require 'rbs'
 
 module Solargraph
-  class RbsMap
+  module RbsMap
+    autoload :Base,        'solargraph/rbs_map/base'
     autoload :Conversions, 'solargraph/rbs_map/conversions'
-    autoload :CoreMap,     'solargraph/rbs_map/core_map'
+    autoload :Core,        'solargraph/rbs_map/core'
     autoload :CoreFills,   'solargraph/rbs_map/core_fills'
-    autoload :StdlibMap,   'solargraph/rbs_map/stdlib_map'
-
-    include Logging
-
-    # @type [Hash{String => RbsMap}]
-    @@rbs_maps_hash = {}
-
-    attr_reader :library, :rbs_collection_paths, :rbs_collection_config_path
-
-    # @param library [String]
-    # @param version [String, nil]
-    # @param rbs_collection_config_path [String, Pathname, nil]
-    # @param rbs_collection_paths [Array<Pathname, String>]
-    # @param out [StringIO, IO, nil] where to log messages
-    def initialize library, version = nil, rbs_collection_config_path: nil, rbs_collection_paths: [], out: $stderr
-      if rbs_collection_config_path.nil? && !rbs_collection_paths.empty?
-        raise 'Please provide rbs_collection_config_path if you provide rbs_collection_paths'
-      end
-      @library = library
-      @version = version
-      @rbs_collection_config_path = rbs_collection_config_path
-      @rbs_collection_paths = rbs_collection_paths
-      add_library loader, library, version
-    end
-
-    CACHE_KEY_GEM_EXPORT = 'gem-export'
-    CACHE_KEY_UNRESOLVED = 'unresolved'
-    CACHE_KEY_STDLIB = 'stdlib'
-    CACHE_KEY_LOCAL = 'local'
-
-    # @param cache_key [String, nil]
-    # @return [String, nil] a description of the source of the RBS info
-    def self.rbs_source_desc cache_key
-      case cache_key
-      when CACHE_KEY_GEM_EXPORT
-        'RBS gem export'
-      when CACHE_KEY_UNRESOLVED
-        nil
-      when CACHE_KEY_STDLIB
-        'RBS standard library'
-      when CACHE_KEY_LOCAL
-        'local RBS shims'
-      else
-        'RBS collection'
-      end
-    end
-
-    # @return [RBS::EnvironmentLoader]
-    def loader
-      @loader ||= RBS::EnvironmentLoader.new(core_root: nil, repository: repository)
-    end
-
-    # @return [String] representing the version of the RBS info fetched
-    #   for the given library.  Must change when the RBS info is
-    #   updated upstream for the same library and version.  May change
-    #   if the config for where information comes form changes.
-    def cache_key
-      return CACHE_KEY_UNRESOLVED unless resolved?
-
-      @cache_key ||= begin
-        # @type [String, nil]
-        data = nil
-        # @type gem_config [nil, Hash{String => Hash{String => String}}]
-        gem_config = nil
-        if rbs_collection_config_path
-          # @sg-ignore rbs_collection_config_path is not nil here
-          lockfile_path = RBS::Collection::Config.to_lockfile_path(Pathname.new(rbs_collection_config_path))
-          if lockfile_path.exist?
-            collection_config = RBS::Collection::Config.from_path lockfile_path
-            gem_config = collection_config.gem(library)
-            data = gem_config&.to_s
-          end
-        end
-        if gem_config.nil?
-          CACHE_KEY_STDLIB
-        else
-          # @type [String]
-          source = gem_config.dig('source', 'type')
-          case source
-          when 'rubygems'
-            CACHE_KEY_GEM_EXPORT
-          when 'local'
-            CACHE_KEY_LOCAL
-          when 'stdlib'
-            CACHE_KEY_STDLIB
-          else
-            Digest::SHA1.hexdigest(data || '')
-          end
-        end
-      end
-    end
-
-    # @param gemspec [Gem::Specification, Bundler::LazySpecification]
-    # @param rbs_collection_path [String, Pathname, nil]
-    # @param rbs_collection_config_path [String, Pathname, nil]
-    # @return [RbsMap]
-    def self.from_gemspec gemspec, rbs_collection_path, rbs_collection_config_path
-      # prefers stdlib RBS if available
-      rbs_map = RbsMap::StdlibMap.new(gemspec.name)
-      return rbs_map if rbs_map.resolved?
-
-      rbs_map = RbsMap.new(gemspec.name, gemspec.version,
-                           rbs_collection_paths: [rbs_collection_path].compact,
-                           rbs_collection_config_path: rbs_collection_config_path)
-      return rbs_map if rbs_map.resolved?
-
-      # try any version of the gem in the collection
-      RbsMap.new(gemspec.name, nil,
-                 rbs_collection_paths: [rbs_collection_path].compact,
-                 rbs_collection_config_path: rbs_collection_config_path)
-    end
-
-    # @param out [IO, nil] where to log messages
-    # @return [Array<Pin::Base>]
-    def pins out: $stderr
-      @pins ||= if resolved?
-                  conversions.pins
-                else
-                  []
-                end
-    end
-
-    # @generic T
-    # @param path [String]
-    # @param klass [Class<generic<T>>]
-    #
-    # @sg-ignore Need to be able to resolve generics based on a
-    #   Class<generic<T>> param
-    # @return [generic<T>, nil]
-    def path_pin path, klass = Pin::Base
-      pin = pins.find { |p| p.path == path }
-      pin if pin.is_a?(klass)
-    end
-
-    # @param path [String]
-    # @return [Array<Pin::Base>]
-    def path_pins path
-      pins.select { |p| p.path == path }
-    end
-
-    def resolved?
-      @resolved
-    end
-
-    # @return [RBS::Repository]
-    def repository
-      @repository ||= RBS::Repository.new(no_stdlib: false).tap do |repo|
-        @rbs_collection_paths.each do |dir|
-          dir_path = Pathname.new(dir)
-          repo.add(dir_path) if dir_path.exist? && dir_path.directory?
-        end
-      end
-    end
-
-    # @param library [String]
-    # @return [RbsMap]
-    def self.load library
-      @@rbs_maps_hash[library] ||= RbsMap.new(library)
-    end
-
-    private
-
-    # @return [Conversions]
-    def conversions
-      @conversions ||= Conversions.new(loader: loader)
-    end
-
-    def resolve_dependencies?
-      # we need to resolve dependencies via gemfile.lock manually for
-      # YARD regardless, so use same mechanism here so we don't
-      # duplicate work generating pins from dependencies
-      false
-    end
-
-    # @param loader [RBS::EnvironmentLoader]
-    # @param library [String]
-    # @param version [String, nil] the version of the library to load, or nil for any
-    # @param out [StringIO, IO, nil] where to log messages
-    # @return [Boolean] true if adding the library succeeded
-    def add_library loader, library, version, out: $stderr
-      @resolved = if loader.has_library?(library: library, version: version)
-                    loader.add library: library, version: version, resolve_dependencies: resolve_dependencies?
-                    logger.debug { "#{short_name} successfully loaded library #{library}:#{version}" }
-                    true
-                  else
-                    logger.info { "#{short_name} did not find data for library #{library}:#{version}" }
-                    false
-                  end
-    end
-
-    # @return [String]
-    def short_name
-      self.class.name.split('::').last
-    end
+    autoload :Gem,         'solargraph/rbs_map/gem'
+    autoload :Helpers,     'solargraph/rbs_map/helpers'
+    autoload :Path,        'solargraph/rbs_map/path'
+    autoload :Stdlib,      'solargraph/rbs_map/stdlib'
   end
 end

data/lib/solargraph/rbs_translator.rb

@@ -10,36 +10,43 @@ module Solargraph
       'int' => 'Integer',
       'untyped' => '',
       'NilClass' => 'nil'
-    }
+    }.freeze
 
-    # @param type [RBS::Types::Bases::Base]
+    # Relative type names (e.g. `Bar` in an inline `#: () -> Bar`) stay
+    # unrooted so they resolve against the pin's namespace like YARD tags
+    # do. Absolute names (`::Bar`, or any name from an RBS environment
+    # after `resolve_type_names`) and RBS builtins stay rooted.
+    #
+    # @param type [RBS::Types::t]
+    # @param type_alias_decls [Hash{String => RBS::AST::Declarations::TypeAlias}]
     # @return [ComplexType]
-    def self.to_complex_type(type)
-      tag = type_to_tag(type)
-      ComplexType.try_parse(tag).force_rooted
+    def self.to_complex_type type, type_alias_decls: {}
+      ComplexType.try_parse(type_to_tag(type, type_alias_decls))
     end
 
     # @param param_type [RBS::Types::Function::Param]
     # @param name [String]
     # @param decl [Symbol]
     # @param closure [Pin::Closure]
+    # @param type_alias_decls [Hash{String => RBS::AST::Declarations::TypeAlias}]
     # @return [Pin::Parameter]
-    def self.to_parameter_pin(param_type, name, decl, closure)
+    def self.to_parameter_pin param_type, name, decl, closure, type_alias_decls: {}
       return_type = if decl == :restarg
-        ComplexType.parse('Array')
-      elsif decl == :kwrestarg
-        ComplexType.parse('Hash{Symbol => Object}')
-      else
-        RbsTranslator.to_complex_type(param_type.type)
-      end
+                      ComplexType.parse('Array')
+                    elsif decl == :kwrestarg
+                      ComplexType.parse('Hash{Symbol => Object}')
+                    else
+                      RbsTranslator.to_complex_type(param_type.type, type_alias_decls: type_alias_decls)
+                    end
       Solargraph::Pin::Parameter.new(decl: decl, name: name, closure: closure, return_type: return_type, source: :rbs, type_location: to_sg_location(param_type.location) || closure.type_location)
     end
 
-    # @param method_type [RBS::MethodType]
+    # @param method_type [RBS::MethodType, RBS::Types::Block]
     # @param closure [Pin::Closure]
     # @param parameter_names [Array<String>]
+    # @param type_alias_decls [Hash{String => RBS::AST::Declarations::TypeAlias}]
     # @return [Array<Pin::Parameter>]
-    def self.to_parameter_pins method_type, closure, parameter_names = []
+    def self.to_parameter_pins method_type, closure, parameter_names = [], type_alias_decls: {}
       if defined?(RBS::Types::UntypedFunction) && method_type.type.is_a?(RBS::Types::UntypedFunction)
         return [
           Solargraph::Pin::Parameter.new(decl: :restarg, name: 'arg', closure: closure, source: :rbs)
@@ -49,27 +56,37 @@ module Solargraph
       arg_num = 0
       params = []
       method_type.type.required_positionals.each do |param|
-        params.push RbsTranslator.to_parameter_pin(param, param.name&.to_s || parameter_names[arg_num] || "arg_#{arg_num}", :arg, closure)
+        # @sg-ignore Unresolved call to name on RBS::Types::Function::Param
+        params.push RbsTranslator.to_parameter_pin(param, param.name&.to_s || parameter_names[arg_num] || "arg_#{arg_num}", :arg, closure, type_alias_decls: type_alias_decls)
         arg_num += 1
       end
       method_type.type.optional_positionals.each do |param|
-        params.push RbsTranslator.to_parameter_pin(param, param.name&.to_s || parameter_names[arg_num] || "arg_#{arg_num}", :optarg, closure)
+        # @sg-ignore Unresolved call to name on RBS::Types::Function::Param
+        params.push RbsTranslator.to_parameter_pin(param, param.name&.to_s || parameter_names[arg_num] || "arg_#{arg_num}", :optarg, closure, type_alias_decls: type_alias_decls)
         arg_num += 1
       end
       if method_type.type.rest_positionals
-        params.push RbsTranslator.to_parameter_pin(method_type.type.rest_positionals, method_type.type.rest_positionals.name&.to_s || parameter_names[arg_num] || "arg_#{arg_num}", :restarg, closure)
+        rest_positionals = method_type.type.rest_positionals
+        # @sg-ignore Unresolved call to name on RBS::Types::Function::Param
+        rest_name = rest_positionals.name&.to_s || parameter_names[arg_num] || "arg_#{arg_num}"
+        params.push RbsTranslator.to_parameter_pin(rest_positionals, rest_name, :restarg, closure, type_alias_decls: type_alias_decls)
         arg_num += 1
       end
       method_type.type.required_keywords.each do |param|
-        params.push RbsTranslator.to_parameter_pin(param.last, param.first.to_s, :kwarg, closure)
+        # @sg-ignore Unresolved calls to last, first on generic<D>
+        params.push RbsTranslator.to_parameter_pin(param.last, param.first.to_s, :kwarg, closure, type_alias_decls: type_alias_decls)
         arg_num += 1
       end
       method_type.type.optional_keywords.each do |param|
-        params.push RbsTranslator.to_parameter_pin(param.last, param.first.to_s, :kwoptarg, closure)
+        # @sg-ignore Unresolved calls to last, first on generic<D>
+        params.push RbsTranslator.to_parameter_pin(param.last, param.first.to_s, :kwoptarg, closure, type_alias_decls: type_alias_decls)
         arg_num += 1
       end
       if method_type.type.rest_keywords
-        params.push RbsTranslator.to_parameter_pin(method_type.type.rest_keywords, method_type.type.rest_keywords.name&.to_s || parameter_names[arg_num] || "arg_#{arg_num}", :kwrestarg, closure)
+        rest_keywords = method_type.type.rest_keywords
+        # @sg-ignore Unresolved call to name on RBS::Types::Function::Param
+        rest_keywords_name = rest_keywords.name&.to_s || parameter_names[arg_num] || "arg_#{arg_num}"
+        params.push RbsTranslator.to_parameter_pin(rest_keywords, rest_keywords_name, :kwrestarg, closure, type_alias_decls: type_alias_decls)
       end
       params
     end
@@ -77,41 +94,29 @@ module Solargraph
     # @param method_type [RBS::MethodType]
     # @param closure [Pin::Closure]
     # @param parameter_names [Array<String>]
+    # @param type_alias_decls [Hash{String => RBS::AST::Declarations::TypeAlias}]
     # @return [Pin::Signature]
-    def self.to_signature method_type, closure, parameter_names = []
+    def self.to_signature method_type, closure, parameter_names = [], type_alias_decls: {}
       # There may be edge cases here around different signatures
       # having different type params / orders - we may need to match
       # this data model and have generics live in signatures to
       # handle those correctly
       generics = method_type.type_params.map(&:name).map(&:to_s).uniq
-      parameters = to_parameter_pins(method_type, closure, parameter_names)
-      return_type = to_complex_type(method_type.type.return_type)
+      parameters = to_parameter_pins(method_type, closure, parameter_names, type_alias_decls: type_alias_decls)
+      return_type = to_complex_type(method_type.type.return_type, type_alias_decls: type_alias_decls)
       block = if method_type.block
-        block_parameters = to_parameter_pins(method_type.block, closure)
-        block_return_type = to_complex_type(method_type.block.type.return_type)
-        Pin::Signature.new(generics: generics, parameters: block_parameters, return_type: block_return_type, source: :rbs, type_location: closure.location, closure: closure)
-      end
-      Pin::Signature.new(generics: generics, parameters: parameters, return_type: return_type, block: block, source: :rbs, type_location: closure.location, closure: closure)
-    end
-
-    # @param type_name [RBS::TypeName]
-    # @param type_args [Enumerable<RBS::Types::Bases::Base>]
-    # @return [ComplexType::UniqueType]
-    def self.build_unique_type(type_name, type_args = [])
-      base = RBS_TO_YARD_TYPE[type_name.relative!.to_s] || type_name.relative!.to_s
-      params = type_args.map do |a|
-        RbsTranslator.to_complex_type(a)
-      end
-      if base == 'Hash' && params.length == 2
-        ComplexType::UniqueType.new(base, [params.first], [params.last], rooted: true, parameters_type: :hash)
-      else
-        ComplexType::UniqueType.new(base, [], params.reject(&:undefined?), rooted: true, parameters_type: :list)
-      end
+                # @sg-ignore https://github.com/castwide/solargraph/issues/1249
+                block_parameters = to_parameter_pins(method_type.block, closure, type_alias_decls: type_alias_decls)
+                block_return_type = to_complex_type(method_type.block.type.return_type, type_alias_decls: type_alias_decls)
+                Pin::Signature.new(generics: generics, parameters: block_parameters, return_type: block_return_type, source: :rbs, type_location: closure.location, closure: closure)
+              end
+      Pin::Signature.new(generics: generics, parameters: parameters, return_type: return_type, block: block,
+                         block_required: method_type.block&.required || false, source: :rbs, type_location: closure.location, closure: closure)
     end
 
     # @param location [RBS::Location, nil]
     # @return [Solargraph::Location, nil]
-    def self.to_sg_location(location)
+    def self.to_sg_location location
       return nil if location&.name.nil?
 
       start_pos = Position.new(location.start_line - 1, location.start_column)
@@ -123,50 +128,74 @@ module Solargraph
     class << self
       private
 
-      # @param type [RBS::Types::Bases::Base]
+      # @param type [RBS::Types::t]
+      # @param type_alias_decls [Hash{String => RBS::AST::Declarations::TypeAlias}]
+      # @param expanding_aliases [Array<String>] Names of aliases already
+      #   being expanded in this call chain, to detect recursive aliases
       # @return [String]
-      def type_to_tag type
+      def type_to_tag type, type_alias_decls = {}, expanding_aliases = []
         case type
         when RBS::Types::Optional
-          "#{type_to_tag(type.type)}, nil"
+          # @sg-ignore flow sensitive typing should support case/when
+          "#{type_to_tag(type.type, type_alias_decls, expanding_aliases)}, nil"
         when RBS::Types::Bases::Bool
-          'Boolean'
+          '::Boolean'
         when RBS::Types::Tuple
-          "Array(#{type.types.map { |t| type_to_tag(t) }.join(', ')})"
+          # @sg-ignore flow sensitive typing should support case/when
+          "::Array(#{type.types.map { |t| type_to_tag(t, type_alias_decls, expanding_aliases) }.join(', ')})"
         when RBS::Types::Literal
+          # @sg-ignore flow sensitive typing should support case/when
           type.literal.inspect
         when RBS::Types::Union
-          type.types.map { |t| type_to_tag(t) }.join(', ')
+          # @sg-ignore flow sensitive typing should support case/when
+          type.types.map { |t| type_to_tag(t, type_alias_decls, expanding_aliases) }.join(', ')
         when RBS::Types::Record
           # @todo Better record support
-          'Hash'
+          '::Hash'
         when RBS::Types::Bases::Nil
           'nil'
         when RBS::Types::Bases::Void
           'void'
         when RBS::Types::Variable
+          # @sg-ignore flow sensitive typing should support case/when
           "#{Solargraph::ComplexType::GENERIC_TAG_NAME}<#{type.name}>"
         when RBS::Types::Bases::Self, RBS::Types::Bases::Instance
           'self'
         when RBS::Types::Bases::Top
           # `Top` is the most super superclass
-          'BasicObject'
+          '::BasicObject'
         when RBS::Types::Intersection
-          type.types.map { |member| type_to_tag(member) }.join(', ')
+          # @sg-ignore flow sensitive typing should support case/when
+          type.types.map { |member| type_to_tag(member, type_alias_decls, expanding_aliases) }.join(', ')
         when RBS::Types::Proc
-          'Proc'
-        when RBS::Types::ClassInstance, RBS::Types::Alias, RBS::Types::Interface
-          # `Alias` is a top-level type alias, e.g., 'bool' in "type bool = true | false"
-          # @todo ensure these get resolved after processing all aliases
-          # @todo handle recursive aliases
-          #
-          # `Interface represents a mix-in module which can be considered a
+          '::Proc'
+        when RBS::Types::Alias
+          # Expand so conformance checks see the members, not the name. A
+          # generic alias falls back: args are not substituted, so expanding
+          # would leak an unbound generic<T>.
+          # @sg-ignore flow sensitive typing should support case/when
+          alias_name = type.name.to_s
+          alias_decl = type_alias_decls[alias_name]
+          # @sg-ignore flow sensitive typing should support case/when
+          if alias_decl.nil? || expanding_aliases.include?(alias_name) || !type.args.empty?
+            # @sg-ignore flow sensitive typing should support case/when
+            type_tag(type.name, type.args, type_alias_decls, expanding_aliases)
+          else
+            # The alias body belongs to the alias's declaration, not the
+            # use site, so its names stay rooted even when a core-less
+            # environment left them relative.
+            expanded = type_to_tag(alias_decl.type, type_alias_decls, expanding_aliases + [alias_name])
+            ComplexType.try_parse(expanded).force_rooted.rooted_tags
+          end
+        when RBS::Types::ClassInstance, RBS::Types::Interface
+          # `Interface` represents a mix-in module which can be considered a
           # subtype of a consumer of it
-          #
-          type_tag(type.name, type.args)
+          # @sg-ignore flow sensitive typing should support case/when
+          type_tag(type.name, type.args, type_alias_decls, expanding_aliases)
         when RBS::Types::ClassSingleton
           # e.g., singleton(String)
-          type_tag(type.name)
+          # @sg-ignore flow sensitive typing should support case/when
+          type_tag(type.name, [], type_alias_decls, expanding_aliases)
         when RBS::Types::Bases::Any, RBS::Types::Bases::Bottom
           # `Bottom`` is used in contexts where nothing will ever return
           # - e.g., it could be the return type of 'exit()' or 'raise'
@@ -182,23 +211,29 @@ module Solargraph
 
       # @param type_name [RBS::TypeName]
       # @param type_args [Enumerable<RBS::Types::Bases::Base>]
+      # @param type_alias_decls [Hash{String => RBS::AST::Declarations::TypeAlias}]
+      # @param expanding_aliases [Array<String>]
       # @return [String]
-      def type_tag(type_name, type_args = [])
-        build_type(type_name, type_args).tags
+      def type_tag type_name, type_args = [], type_alias_decls = {}, expanding_aliases = []
+        build_type(type_name, type_args, type_alias_decls, expanding_aliases).rooted_tags
       end
 
       # @param type_name [RBS::TypeName]
       # @param type_args [Enumerable<RBS::Types::Bases::Base>]
+      # @param type_alias_decls [Hash{String => RBS::AST::Declarations::TypeAlias}]
+      # @param expanding_aliases [Array<String>]
       # @return [ComplexType::UniqueType]
-      def build_type(type_name, type_args = [])
-        base = RBS_TO_YARD_TYPE[type_name.relative!.to_s] || type_name.relative!.to_s
-        params = type_args.map { |a| type_to_tag(a) }.map do |t|
+      def build_type type_name, type_args = [], type_alias_decls = {}, expanding_aliases = []
+        yard_base = RBS_TO_YARD_TYPE[type_name.relative!.to_s]
+        base = yard_base || type_name.relative!.to_s
+        rooted = !yard_base.nil? || type_name.absolute?
+        params = type_args.map { |a| type_to_tag(a, type_alias_decls, expanding_aliases) }.map do |t|
           ComplexType.try_parse(t)
         end
         if base == 'Hash' && params.length == 2
-          ComplexType::UniqueType.new(base, [params.first], [params.last], rooted: true, parameters_type: :hash)
+          ComplexType::UniqueType.new(base, [params.first], [params.last], rooted: rooted, parameters_type: :hash)
         else
-          ComplexType::UniqueType.new(base, [], params.reject(&:undefined?), rooted: true, parameters_type: :list)
+          ComplexType::UniqueType.new(base, [], params.reject(&:undefined?), rooted: rooted, parameters_type: :list)
         end
       end
     end

data/lib/solargraph/repo.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'json'
+
+module Solargraph
+  # A repository for the gems available in the specified directory. If the
+  # directory has a Gemfile, Repo will use its gem definitions. Otherwise it
+  # uses the system gems.
+  #
+  class Repo
+    # @return [String, nil]
+    attr_reader :directory
+
+    # @param directory [String, nil]
+    def initialize directory
+      @directory = File.expand_path(directory) if directory
+      build_from_directory
+    end
+
+    # Find a metagem by path from the directory's bundle definition or the
+    # system gems.
+    #
+    # @param path [String]
+    # @return [Metagem, nil]
+    def find_by_path path
+      return system_find_by_path(path) unless bundled?
+
+      bundled_metagem_path_map[path]
+    end
+
+    # Find a metagem by name from the directory's bundle definition or the
+    # system gems.
+    #
+    # @param name [String]
+    # @return [Metagem, nil]
+    def find_by_name name
+      return system_find_by_name(name) unless bundled?
+
+      bundled_metagem_name_map[name]
+    end
+
+    # Get an array of metagems by its bundle group name. Returns an empty array
+    # if the repo isn't bundled or the group doesn't exist.
+    #
+    # @param group [Symbol]
+    # @return [Array<Metagem>]
+    def find_by_group group
+      return system_find_by_group(group) unless bundled?
+
+      bundled_group_map[group] || []
+    end
+
+    # True if the directory has a bundle definition.
+    #
+    # @note If Solargraph itself is running in this directory's bundled
+    #   environment, `bundled?` is false.
+    #
+    def bundled?
+      !!@metagems
+    end
+    alias bundle? bundled?
+
+    # Metagems from the directory's bundle definition, or an empty array if a
+    # bundle definition does not exist.
+    #
+    # @return [Array<Solargraph::Metagem>]
+    def bundled
+      @metagems || []
+    end
+
+    private
+
+    # @return [String, nil]
+    def gemfile
+      @gemfile ||= File.expand_path('Gemfile', directory) if directory
+    end
+
+    # @return [String, nil]
+    def lockfile
+      @lockfile ||= File.expand_path('Gemfile.lock', directory) if directory
+    end
+
+    def bundled_directory?
+      directory && File.file?(gemfile) && File.file?(lockfile)
+    end
+
+    # Load metagems from the directory's bundle definition if available.
+    #
+    # This method performs gem collection in a separate process to suppress
+    # output from the `Bundler.definition.specs` call.
+    #
+    # @return [Array<Metagem>, nil]
+    def build_from_directory
+      return unless bundled_directory? && ENV['BUNDLE_GEMFILE'] != gemfile
+
+      Solargraph.with_clean_env do
+        cmd = ['ruby', '-e', bundle_script]
+        o, e, s = Open3.capture3(*cmd, chdir: directory)
+        if s.success?
+          json = o && !o.empty? ? JSON.parse(o.strip.split("\n").last, symbolize_names: true) : []
+          @metagems = json[:metagems].map { |data| Metagem.new(**data) }
+          @bundled_group_map = json[:groups].transform_values { |names| names.map { |name| bundled_metagem_name_map[name] } }
+        else
+          Solargraph.logger.warn "Failed to load gems from bundle at #{directory}: #{e}"
+          nil
+        end
+      end
+    end
+
+    def bundle_script
+      "
+        require 'bundler/setup'
+        require 'json'
+
+        puts Bundler.definition.specs.length
+        metagems = Bundler.definition.specs.map do |spec|
+          {
+            name: spec.name,
+            full_path: spec.full_gem_path,
+            spec_file: spec.spec_file,
+            source: spec.source.to_s,
+            version: spec.version,
+            require_paths: spec.require_paths,
+            dependencies: spec.runtime_dependencies.map(&:name)
+          }
+        end
+        groups = Bundler.definition.groups.to_h do |group|
+          [group, Bundler.definition.specs_for([group]).map(&:name)]
+        end
+        puts({ groups: groups, metagems: metagems }.to_json)
+      "
+    end
+
+    # @param path [String]
+    # @return [Metagem, nil]
+    def system_find_by_path path
+      gem = Gem::Specification.find_by_path(path)
+      gem && Metagem.from_specification(gem)
+    end
+
+    # @param name [String]
+    # @return [Metagem, nil]
+    def system_find_by_name name
+      gem = Gem::Specification.find_by_name(name)
+      gem && Metagem.from_specification(gem)
+    rescue Gem::MissingSpecError => _e
+      nil
+    end
+
+    # @param group [Symbol]
+    # @return [Array<Metagem>]
+    def system_find_by_group group
+      return [] unless ENV['BUNDLE_GEMFILE']
+
+      Bundler.definition
+             .specs_for([group])
+             .map { |spec| Metagem.from_specification(spec) }
+    end
+
+    def bundled_metagem_name_map
+      @bundled_metagem_name_map ||= bundled.to_set
+                                           .classify(&:name)
+                                           .transform_values(&:first)
+    end
+
+    def bundled_metagem_path_map
+      @bundled_metagem_path_map ||= Hash.new do |hash, path|
+        hash[path] = bundled.find { |mg| mg.require?(path) }
+      end
+    end
+
+    def bundled_group_map
+      @bundled_group_map ||= {}
+    end
+  end
+end