@@ -346,7 +346,9 @@ def dependencies_for(groups)
     #
     # @return [SpecSet] resolved dependencies
     def resolve
-      @resolve ||= if Bundler.frozen_bundle?
+      return @resolve if @resolve
+
+      @resolve = if Bundler.frozen_bundle?
         Bundler.ui.debug "Frozen, using resolution from the lockfile"
         @locked_specs
       elsif no_resolve_needed?
@@ -366,6 +368,8 @@ def resolve
 
         start_resolution
       end
+      warn_inert_overrides(@resolve)
+      @resolve
     end
 
     def spec_git_paths
@@ -1109,6 +1113,16 @@ def converge_dependencies
       @changed_dependencies.any?
     end
 
+    # A misspelled `from:` gem leaves the override with nothing to rewrite.
+    def warn_inert_overrides(specs)
+      @overrides.each do |override|
+        next unless override.from
+        next if specs[override.from].any? {|s| s.dependencies.any? {|d| d.name == override.target } }
+
+        Bundler.ui.warn "#{override} has no effect because the bundle has no #{override.from} that depends on #{override.target}"
+      end
+    end
+
     def converge_overrides_outside_dependencies
       @overrides.each do |override|
         # :all and metadata overrides are intentionally not pre-unlocked. The
@@ -1356,7 +1370,7 @@ def remove_invalid_platforms!
     end
 
     def source_map
-      @source_map ||= SourceMap.new(sources, dependencies, @locked_specs)
+      @source_map ||= SourceMap.new(sources, dependencies, @locked_specs, @overrides.filter_map {|o| o.operation if o.from })
     end
 
     def new_resolver_for_full_update
 
@@ -200,6 +200,12 @@ def github(repo, options = {})
 
     def override(target, **operations)
       validate_override_target!(target)
+      source_location = caller_locations(1, 1)&.first
+
+      if operations.key?(:from) || operations.key?(:to)
+        add_dependency_override(target, operations, source_location)
+        return
+      end
 
       if target == :all && operations.key?(:version)
         raise ArgumentError, "`override :all, version:` is not allowed; version requirements are per-gem"
@@ -211,14 +217,14 @@ def override(target, **operations)
         validate_override_uniqueness!(target, field)
       end
 
-      source_location = caller_locations(1, 1)&.first
       operations.each do |field, operation|
         @overrides << Override.new(target, field, operation, source_location: source_location)
       end
     end
 
     def to_definition(lockfile, unlock)
       check_primary_source_safety
+      check_dropped_dependencies
       lockfile = @lockfile unless @lockfile.nil?
       Definition.new(lockfile, @dependencies, @sources, unlock, @ruby_version, @optional_groups, @gemfiles, @overrides)
     end
@@ -317,6 +323,54 @@ def validate_override_uniqueness!(target, field)
       raise ArgumentError, "duplicate override for #{target.inspect} `#{field}:`"
     end
 
+    def add_dependency_override(target, operations, source_location)
+      unless operations.key?(:from)
+        raise ArgumentError, "`override #{target.inspect}, to:` requires `from:` naming the gem whose dependency is rewritten"
+      end
+      unless operations.key?(:to)
+        raise ArgumentError, "`override #{target.inspect}, from:` requires `to:`; use `to: nil` to drop the dependency or `to: \"<gem>\"` to replace it"
+      end
+
+      from = operations[:from]
+      to = operations[:to]
+      requirement = operations[:version]
+
+      raise ArgumentError, "`override :all` does not accept `from:`" if target == :all
+      raise ArgumentError, "`from:` must be a gem name string, got #{from.inspect}" unless from.is_a?(String)
+      raise ArgumentError, "`to:` must be a gem name string or nil, got #{to.inspect}" unless to.nil? || to.is_a?(String)
+      raise ArgumentError, "`to:` must name a gem other than #{target.inspect} and #{from.inspect}" if to == target || to == from
+      validate_gem_name!(from)
+      validate_gem_name!(to) if to
+
+      unsupported = operations.keys - [:from, :to, :version]
+      if unsupported.any?
+        raise ArgumentError, "unsupported override field `#{unsupported.first}:` with `from:`; supported fields: `to:`, `version:`"
+      end
+
+      if operations.key?(:version)
+        raise ArgumentError, "`version:` with `from:` requires `to:` to name a replacement gem" if to.nil?
+        raise ArgumentError, "`version:` with `from:` must be a version requirement string, got #{requirement.inspect}" unless requirement.is_a?(String)
+        validate_override_operation!(requirement)
+      end
+
+      if @overrides.any? {|o| o.target == target && o.from == from }
+        raise ArgumentError, "duplicate override for #{target.inspect} `from: #{from.inspect}`"
+      end
+
+      @overrides << Override.new(target, :to, to, from: from, requirement: requirement, source_location: source_location)
+    end
+
+    # Dropping a gem the Gemfile requires directly would leave it installed
+    # anyway, with only the parent's requirement gone.
+    def check_dropped_dependencies
+      @overrides.each do |override|
+        next unless override.from && override.operation.nil?
+        next unless @dependencies.any? {|d| d.name == override.target }
+
+        raise GemfileError, "#{override} cannot drop #{override.target} because the Gemfile depends on it directly"
+      end
+    end
+
     def add_dependency(name, version = nil, options = {})
       options["gemfile"] = @gemfile
       options["source"] ||= @source
@@ -460,14 +514,18 @@ def valid_keys
       @valid_keys ||= VALID_KEYS
     end
 
-    def normalize_options(name, version, opts)
+    def validate_gem_name!(name)
       if name.is_a?(Symbol)
         raise GemfileError, %(You need to specify gem names as Strings. Use 'gem "#{name}"' instead)
       end
       if /\s/.match?(name)
         raise GemfileError, %('#{name}' is not a valid gem name because it contains whitespace)
       end
       raise GemfileError, %(an empty gem name is not valid) if name.empty?
+    end
+
+    def normalize_options(name, version, opts)
+      validate_gem_name!(name)
 
       normalize_hash(opts)
 
 
@@ -103,7 +103,7 @@ def generate_bundler_executable_stubs(spec, options = {})
 
       if options[:binstubs_cmd] && spec.executables.empty?
         options = {}
-        spec.runtime_dependencies.each do |dep|
+        Override.rewrite_dependencies(@definition.overrides, spec.name, spec.runtime_dependencies).each do |dep|
           bins = @definition.specs[dep].first.executables
           options[dep.name] = bins unless bins.empty?
         end
 
@@ -69,7 +69,8 @@ def initialize(installer, all_specs, size, standalone, force, local: false, skip
       @specs = all_specs.map {|s| SpecInstallation.new(s) }
       specs_by_name = @specs.to_h {|s| [s.name, s] }
       @specs.each do |spec_install|
-        spec_install.dependencies = spec_install.spec.dependencies.filter_map do |dep|
+        dependencies = Override.rewrite_dependencies(installer.definition.overrides, spec_install.name, spec_install.spec.dependencies)
+        spec_install.dependencies = dependencies.filter_map do |dep|
           specs_by_name[dep.name] unless dep.type == :development || dep.name == spec_install.name
         end
       end
 
@@ -286,7 +286,7 @@ def choose_compatible(candidates, fallback_to_non_installable: Bundler.frozen_bu
     # which would affect `bundler/setup` performance.
     def validate_dependencies(spec)
       if !@materialization_options[:strict] && spec.is_a?(StubSpecification)
-        spec.dependencies = dependencies
+        spec.dependencies = Override.rewrite_dependencies(overrides, name, dependencies)
       else
         if !source.is_a?(Source::Path) && spec.runtime_dependencies.sort != dependencies.sort
           raise IncorrectLockfileDependencies.new(self, spec.runtime_dependencies, dependencies)
 
@@ -30,7 +30,9 @@ def specs
     end
 
     def dependencies
-      (materialized_spec || specs.first).runtime_dependencies.map {|d| [d, platform] }
+      spec = materialized_spec || specs.first
+      overrides = specs.first.overrides if specs.first.is_a?(LazySpecification)
+      Override.rewrite_dependencies(overrides, spec.name, spec.runtime_dependencies).map {|d| [d, platform] }
     end
 
     def materialized_spec
 
@@ -9,6 +9,20 @@ def self.find_for(overrides, name, field)
         overrides.find {|o| o.target == :all && o.field == field }
     end
 
+    # Drops or replaces the dependencies of the gem named `from` that a
+    # `from:`/`to:` override targets. The requirement `from` put on the
+    # replaced gem is discarded.
+    def self.rewrite_dependencies(overrides, from, dependencies)
+      return dependencies if overrides.nil? || overrides.none? {|o| o.from == from }
+
+      dependencies.filter_map do |dep|
+        override = overrides.find {|o| o.from == from && o.target == dep.name }
+        next dep unless override
+        next unless override.operation
+        Gem::Dependency.new(override.operation, *Array(override.requirement))
+      end
+    end
+
     # Attach the given overrides onto every LazySpecification in `specs` so
     # downstream consumers (LazySpecification#choose_compatible, the install-
     # time compatibility check, etc.) can read the override list off the spec
@@ -19,12 +33,14 @@ def self.attach(specs, overrides)
       specs.each {|s| s.overrides = overrides if s.is_a?(LazySpecification) }
     end
 
-    attr_reader :target, :field, :operation, :source_location
+    attr_reader :target, :field, :operation, :from, :requirement, :source_location
 
-    def initialize(target, field, operation, source_location: nil)
+    def initialize(target, field, operation, from: nil, requirement: nil, source_location: nil)
       @target = target
       @field = field
       @operation = operation
+      @from = from
+      @requirement = requirement
       @source_location = source_location
     end
 
@@ -33,7 +49,19 @@ def source_location_label
       "#{File.basename(@source_location.path)}:#{@source_location.lineno}"
     end
 
+    def to_s
+      options = if @from
+        ["from: #{@from.inspect}", "to: #{@operation.inspect}", *("version: #{@requirement.inspect}" if @requirement)].join(", ")
+      else
+        "#{@field}: #{@operation.inspect}"
+      end
+      location = source_location_label
+      "override #{@target == :all ? ":all" : @target.inspect}, #{options}#{" (declared at #{location})" if location}"
+    end
+
     def apply_to(requirement)
+      raise ArgumentError, "#{self} rewrites a dependency and has no requirement to apply" if @from
+
       case operation
       when nil
         Gem::Requirement.default
 
@@ -71,6 +71,7 @@ def setup_solver
       @cached_dependencies = Hash.new do |dependencies, package|
         dependencies[package] = Hash.new do |versions, version|
           deps = version.dependencies.reject {|d| d.name == package.name }
+          deps = Override.rewrite_dependencies(@base.overrides, package.name, deps)
           deps = apply_metadata_overrides(deps, package.name)
           versions[version] = to_dependency_hash(deps, @packages)
         end
@@ -88,6 +89,7 @@ def solve_versions(root:, logger:)
       solver = Gem::PubGrub::VersionSolver.new(source: self, root: root, strategy: Strategy.new(self), logger: logger)
       result = solver.solve
       resolved_specs = result.flat_map {|package, version| version.to_specs(package, @most_specific_locked_platform) }
+      check_replaced_gems(resolved_specs)
       Override.attach(resolved_specs, @base.overrides)
       spec_set = SpecSet.new(resolved_specs).specs_with_additional_variants_from(@base.locked_specs)
       @cooldown_skipped = cooldown_skipped_summary(spec_set)
@@ -137,15 +139,37 @@ def solve_versions(root:, logger:)
       raise SolveFailure.new(explanation)
     end
 
+    # A replacement is only useful when it provides the files of the gem it
+    # replaces, so the two cannot be loaded side by side.
+    def check_replaced_gems(specs)
+      names = specs.map(&:name)
+
+      @base.overrides.each do |override|
+        next unless override.from && override.operation
+        next unless names.include?(override.target) && names.include?(override.operation)
+        next unless specs.any? {|s| s.name == override.from && s.dependencies.any? {|d| d.name == override.target } }
+
+        dependents = specs.select do |spec|
+          Override.rewrite_dependencies(@base.overrides, spec.name, spec.dependencies).any? {|d| d.name == override.target }
+        end.map(&:name).uniq
+
+        lines = ["#{override} would leave both #{override.target} and #{override.operation} in the bundle because #{override.target} is still required by:"]
+        lines << "  the Gemfile" if @base.requirements.any? {|d| d.name == override.target }
+        lines.concat(dependents.map {|name| "  #{name}" })
+        if dependents.any?
+          lines << "Replace it for each of them, for example:"
+          lines << "  #{Override.new(override.target, :to, override.operation, from: dependents.first)}"
+        end
+        raise GemfileError, lines.join("\n")
+      end
+    end
+
     def override_diagnostic_summary
       return nil if @base.overrides.empty?
 
       lines = ["Bundler applied the following overrides while resolving:"]
       @base.overrides.each do |override|
-        target = override.target == :all ? ":all" : override.target.inspect
-        location = override.source_location_label
-        lines << "  override #{target}, #{override.field}: #{override.operation.inspect}" \
-          "#{location ? " (declared at #{location})" : ""}"
+        lines << "  #{override}"
       end
       "\n\n#{lines.join("\n")}"
     end
 
@@ -29,7 +29,7 @@ def to_s
 
       def build_index
         Index.build do |idx|
-          dependency_names = source_map.pinned_spec_names
+          dependency_names = source_map.pinned_spec_names | source_map.replacement_names
 
           sources.all_sources.each do |source|
             next if @excluded_sources.include?(source)
 
@@ -2,12 +2,15 @@
 
 module Bundler
   class SourceMap
-    attr_reader :sources, :dependencies, :locked_specs
+    attr_reader :sources, :dependencies, :locked_specs, :replacement_names
 
-    def initialize(sources, dependencies, locked_specs)
+    def initialize(sources, dependencies, locked_specs, replacement_names = [])
       @sources = sources
       @dependencies = dependencies
       @locked_specs = locked_specs
+      # No gemspec names a gem that a `from:`/`to:` override substitutes, so
+      # the dependency API never fetches it unless asked.
+      @replacement_names = replacement_names
     end
 
     def pinned_spec_names(skip = nil)
@@ -22,6 +25,7 @@ def all_requirements(excluded_sources = [])
       end
 
       unmet_deps = explicit_sources.map do |source|
+        source.add_dependency_names(replacement_names)
         (source.spec_names - pinned_spec_names).each do |indirect_dependency_name|
           previous_source = requirements[indirect_dependency_name]
           if previous_source.nil?
@@ -39,7 +43,7 @@ def all_requirements(excluded_sources = [])
         source.unmet_deps
       end
 
-      sources.default_source.add_dependency_names(unmet_deps.flatten - requirements.keys)
+      sources.default_source.add_dependency_names(unmet_deps.flatten + replacement_names - requirements.keys)
 
       requirements
     end