declaredReplacements 'a->b'
        expect:
        resolvedModules 'b'
    }

    def "replaces already resolved module"() {
        declaredDependencies 'a', 'b'
        declaredReplacements 'a->b'
        expect:
        resolvedModules 'b'
    }

    def "replaces not yet resolved module"() {
        declaredDependencies 'b', 'a'
        declaredReplacements 'a->b'
        expect:

		{"(*Reader).Seek", Method, 0},
		{"(*Reader).Size", Method, 5},
		{"(*Reader).UnreadByte", Method, 0},
		{"(*Reader).UnreadRune", Method, 0},
		{"(*Reader).WriteTo", Method, 1},
		{"(*Replacer).Replace", Method, 0},
		{"(*Replacer).WriteString", Method, 0},
		{"Builder", Type, 10},
		{"Clone", Func, 18},
		{"Compare", Func, 5},
		{"Contains", Func, 0},
		{"ContainsAny", Func, 0},
		{"ContainsFunc", Func, 21},

# Conflicting replaces in workspace modules returns error that suggests
# overriding it in the go.work file.

! go list -m example.com/dep
stderr 'go: conflicting replacements for example.com/dep@v1.0.0:\n\t'$PWD${/}'dep1\n\t'$PWD${/}'dep2\nuse "go work edit -replace example.com/dep@v1.0.0=\[override\]" to resolve'
go work edit -replace example.com/dep@v1.0.0=./dep1
go list -m example.com/dep
stdout 'example.com/dep v1.0.0 => ./dep1'

-- foo --
-- go.work --

# Conflicting workspace module replaces can be overridden by a replace in the
# go.work file.

go list -m example.com/dep
stdout 'example.com/dep v1.0.0 => ./dep3'

-- go.work --
use m
use n
replace example.com/dep => ./dep3
-- m/go.mod --
module example.com/m

require example.com/dep v1.0.0
replace example.com/dep => ./dep1
-- m/m.go --
package m

import "example.com/dep"

func F() {
	dep.G()
}

  },

  /**
   * The entry itself was not actually removed, but its value was replaced by the user. This can
   * result from the user invoking {@link Cache#put}, {@link LoadingCache#refresh}, {@link Map#put},
   * {@link Map#putAll}, {@link ConcurrentMap#replace(Object, Object)}, or {@link
   * ConcurrentMap#replace(Object, Object, Object)}.
   */
  REPLACED {
    @Override
    boolean wasEvicted() {
      return false;
    }
  },

	prefix, replace := rewrite, ""
	if j := strings.LastIndex(rewrite, "=>"); j >= 0 {
		prefix, replace = rewrite[:j], rewrite[j+len("=>"):]
	}

	if prefix == "" || !hasPathPrefix(path, prefix) {
		return path, false
	}
	if len(path) == len(prefix) {
		return replace, true
	}
	if replace == "" {
		return path[len(prefix)+1:], true
	}
	return replace + path[len(prefix):], true
}

-- m.go --
package m

-- r/go.mod --
module example.com/r
require example.com/r/replaced v0.0.0
replace example.com/r/replaced => ../replaced
-- r/r.go --
package r
import _ "example.com/r/replaced"
-- r/test.out --
DELETE ME

-- replaced/go.mod --
module example.com/r/replaced
-- replaced/replaced.go --
package replaced
-- replaced/test.out --

// Helper class to temporarily remove, then replace, the back edges in a
// graph. Simple algorithms for shape inference don't work with cycles, and this
// class can be used to remove cycles before running inference and replace them
// after. Correct usage requires exactly one call to Remove(), followed by any
// number of calls to RemovedEdges() and at most one call to Replace(). The call

	fmt.Println()
}
*/

// rewriteFile applies the rewrite rule 'pattern -> replace' to an entire file.
func rewriteFile(fileSet *token.FileSet, pattern, replace ast.Expr, p *ast.File) *ast.File {
	cmap := ast.NewCommentMap(fileSet, p, p.Comments)
	m := make(map[string]reflect.Value)
	pat := reflect.ValueOf(pattern)
	repl := reflect.ValueOf(replace)

	var rewriteVal func(val reflect.Value) reflect.Value

## explicit; go 1.21
# example.com/q v1.0.0 => ./q
## explicit; go 1.21
-- missing_replacement_error.txt --
go: inconsistent vendoring in $GOPATH${/}src:
	example.com/p@v1.0.0: is replaced in a${/}go.mod, but not marked as replaced in vendor/modules.txt

	To ignore the vendor directory, use -mod=readonly or -mod=mod.
	To sync the vendor directory, run:
		go work vendor
-- modules.txt.different_replacement --
## workspace