go mod tidy

# initial conditions: using sampler v1.3.0, not listed in go.mod.
go list -deps
stdout rsc.io/sampler
! grep 'rsc.io/sampler v1.3.0' go.mod

# update to v1.3.1, now indirect in go.mod.
go get rsc.io/sampler@v1.3.1
grep 'rsc.io/sampler v1.3.1 // indirect' go.mod
cp go.mod go.mod.good

# vendoring can but should not need to make changes.
go mod vendor
cmp go.mod go.mod.good

! stdout example.com/m/useC

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

require example.com/unused v0.0.0 // indirect
replace example.com/unused => ../unused

require example.com/m/nested v0.0.0 // indirect
replace example.com/m/nested => ../nested

-- m/useC/useC.go --
package useC
import _ "C" // "C" is a pseudo-package, not an actual one
-- m/useunicode/useunicode.go --

			rv := reflect.Indirect(reflect.ValueOf(value))
			appendToRelations(reflectValue, rv, clear && idx == 0)
			if association.Error != nil {
				return
			}
		}

		if len(values) > 0 {
			association.Error = associationDB.Updates(reflectValue.Addr().Interface()).Error
		}
	}

	for _, assignBack := range assignBacks {

# >
# > package A imports package B in go.mod, which imports package C in its own go.mod
# > package A drops direct dependency on package B …
#
# We infer from that that package C is still needed by some other indirect
# dependency, and must be at a higher version than what is required by that
# dependency (or else no new root would be needed). An additional package D
# in its own module satisfies that condition, reproducing the bug.

go get -u
grep 'rsc.io/quote v1.5.2$' go.mod
grep 'golang.org/x/text [v0-9a-f\.-]+ // indirect' go.mod

# get -u rsc.io/sampler should update only sampler's dependencies
cp go.mod-v1.5.1 go.mod
go get -u rsc.io/sampler
grep 'rsc.io/quote v1.5.1$' go.mod
grep 'golang.org/x/text [v0-9a-f\.-]+ // indirect' go.mod

# move to a pseudo-version after any tags
go get rsc.io/quote@dd9747d

require example.com/a v0.1.0

require example.com/b v0.1.0 // indirect

replace (
	example.com/a v0.1.0 => ./a
	example.com/b v0.1.0 => ./b
	example.com/c v0.1.0 => ./c1
	example.com/c v0.2.0 => ./c2
)
-- go.mod.new --
module example.com/lazy

go 1.17

require example.com/a v0.1.0

require (
	example.com/b v0.1.0 // indirect
	example.com/c v0.1.0 // indirect
)

replace (
	example.com/a v0.1.0 => ./a

// also already obeys the 1.17 lazy loading invariants.
go 1.15

require (
	example.com/a v0.1.0
	example.com/b v0.1.0 // indirect
	example.com/q v0.1.0
	example.com/r v0.1.0 // indirect
	example.com/t v0.1.0
	example.com/u v0.1.0 // indirect
)

replace (
	example.com/a v0.1.0 => ./a
	example.com/b v0.1.0 => ./b
	example.com/c v0.1.0 => ./c
	example.com/d v0.1.0 => ./d

	example.com/e => example.com/e v0.1.0-unused
)
-- foo.go --
package foo
import _ "example.com/a"
-- a/go.mod --
module example.com/a
require (
	example.com/b v0.1.0 // indirect
	example.com/c v0.1.0 // indirect
)
-- a/a.go --
package a
import _ "example.com/d"
-- b1/go.mod --
module example.com/b
require example.com/d v0.1.0
-- b2/go.mod --
module example.com/b
require example.com/c v0.2.0

		obj = castObj.Object.Object
	}

	// we use reflect.Indirect here in order to obtain the actual value from a pointer.
	// using reflect.Indirect indiscriminately is valid here, as all runtime.Objects are supposed to be pointers.
	// we need an actual value in order to retrieve the package path for an object.
	if InternalObjectPreventer.IsForbidden(reflect.Indirect(reflect.ValueOf(obj)).Type().PkgPath()) {

package prop.`in`.`companion`.indirect

class Test {
    fun test() {
        val x = <expr>indirectPointer</expr>
    }
    companion object {
        // effectively constant
        val someField = "something"
        val indirectPointer = someField
    }