super(message)
        }

        private Object writeReplace() {
            return new WriteReplaceException("replaced")
        }
    }

    static class ReadReplaceException extends Exception {
        static Exception singleton = new Exception("replaced")

        private Object readResolve() {
            return singleton
        }
    }

    @CompileStatic

		f: func(l *slog.Logger) {
			l.Info("msg", "k", &replace{"replaced"})
		},
		checks: []check{hasAttr("k", "replaced")},
	},
	{
		name:        "resolve-groups",
		explanation: withSource("a Handler should call Resolve on attribute values in groups"),
		f: func(l *slog.Logger) {
			l.Info("msg",
				slog.Group("G",
					slog.String("a", "v1"),
					slog.Any("b", &replace{"v2"})))
		},
		checks: []check{

# This test checks that 'go mod download' produces no output for
# the main module (when specified implicitly) and for a module replaced
# with a file path.
# Verifies golang.org/issue/35505.
go mod download -json all
cmp stdout no-output

-- go.mod --
module example.com/a

require example.com/b v1.0.0

replace example.com/b => ./local/b
-- local/b/go.mod --
module example.com/b

stderr '^go: localhost.fail imports\n\tnonexist: nonexist@v0.1.0: replacement directory ../nonexist does not exist$'

-- go.mod --
module example.com/m

replace (
	example.com/a => ./a
	example.com/a/b => ./b
)

replace (
	example.com/x => ./x
	example.com/x/v3 => ./v3
)

replace (
	example.com/y/z/w => ./w

fi

noncanonical=$(go list -m -json all | jq -r "
  select(.Replace.Version != null) |
  select(.Path != .Replace.Path) |
  select(.Path) |
  \"  \(.Path) is replaced with \(.Replace.Path)\"
")
if [[ -n "${noncanonical}" ]]; then
  echo ""
  echo "These modules are pinned to non-canonical repos."
  echo "Revert to using the canonical repo for these modules before merge"
  echo ""
  echo "${noncanonical}"
fi

			}
		}
	}

	for _, r := range modFile.Replace {
		if r.New != i.replace[r.Old] {
			return true
		}
	}

	for _, x := range modFile.Exclude {
		if !i.exclude[x.Mod] {
			return true
		}
	}

	return false
}

// rawGoVersion records the Go version parsed from each module's go.mod file.
//
// If a module is replaced, the version of the replacement is keyed by the

# 'go get' should resolve it to the minimum valid pseudo-version.

go mod edit -replace=example.com/x=./x
go get example.com/x

go list -m example.com/x
stdout '^example.com/x v0.0.0-00010101000000-000000000000 '

# If specific-version replacements exist, the highest matching version should be used.
go mod edit -replace=example.com/x@v0.1.0=./x
go mod edit -replace=example.com/x@v0.2.0=./x

go get example.com/x
go list -m example.com/x

        where:
        description               | api
        "using replace()"         | 'replace("foo", Second)'
        "using create(overwrite)" | 'create(name: "foo", type: Second, overwrite: true)'
    }

    def "throws exception when replace realized task"() {
        buildFile << '''
            tasks.register("foo", First).get()
            tasks.replace("foo", Second)
        '''

        expect:
        fails 'help'

     */
    BinaryCompatibility binaryCompatibility() default ACCESSORS_REMOVED;

    /**
     * Accessors that are replaced by the property
     */
    ReplacedAccessor[] replacedAccessors() default {};

    /**
     * Deprecation configuration for the replaced accessors
     */
    ReplacedDeprecation deprecation() default @ReplacedDeprecation();

    interface DefaultValue {
    }

# Unknown lines should be ignored in dependency go.mod files.
go list -m -mod=mod all

# ... and in replaced dependency go.mod files.
cp go.mod go.mod.usesub
go list -m -mod=mod all

# ... but not in the main module.
cp go.mod.bad go.mod
! go list -m -mod=mod all
stderr 'unknown directive: hello'

-- go.mod --
module m
require rsc.io/badmod v1.0.0
-- go.mod.bad --
module m
hello world
-- go.mod.usesub --
module m