type I interface {
	M()
}

var i I

type I2 interface {
	M()
	N()
}

var i2 I2

type E interface{}

var e E

func main() {
	e = t // ok
	t = e // ERROR "need explicit|need type assertion"

	// neither of these can work,
	// because i has an extra method
	// that t does not, so i cannot contain a t.
	i = t // ERROR "incompatible|missing method M"

package explicit

import (
	"testshared/implicit"
)

func E() int {
	return implicit.I()

Tamas Cservenak <******@****.***> 1706804704 +0100

John Howard <******@****.***> 1607385305 -0800

John Howard <******@****.***> 1709052916 -0800

//
// On the other hand, if it said [EXPLICIT CONTEXT-SPECIFIC 10], then an
// /additional/ tag would wrap the default tag. This explicit tag will have the
// compound flag set.
//
// (This is used in order to remove ambiguity with optional elements.)
//
// You can layer EXPLICIT and IMPLICIT tags to an arbitrary depth, however we
// don't support that here. We support a single layer of EXPLICIT or IMPLICIT

        variants.size() == 2

        def implicit = variants.first()
        implicit.displayName == displayName
        implicit.attributes == AttributeTestUtil.attributes(["thing": "value1"])
        implicit.artifacts == allArtifacts

        def explicit = (variants as List)[1]
        explicit.displayName.displayName == '<config> variant child'
        explicit.attributes == AttributeTestUtil.attributes(["thing": "value2"])

	var t int
	p := unsafe.Pointer(&t)
	implicit(uintptr(p)) // ERROR "live at call to implicit: .?autotmp" "stack object .autotmp_[0-9]+ unsafe.Pointer$"
}

func localExplicit() { // ERROR "can inline localExplicit"
	var t int
	p := unsafe.Pointer(&t)
	explicit(uintptr(p)) // ERROR "live at call to explicit: .?autotmp" "stack object .autotmp_[0-9]+ unsafe.Pointer$"
}

func localSyscall() { // ERROR "can inline localSyscall"
	var v int

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

    Initializer(const T& v) {  // NOLINT(runtime/explicit)
      typedef typename RealType<T>::type RealT;
      Tensor t(DataTypeToEnum<RealT>::v(), TensorShape());
      t.flat<RealT>()(0) = RealT(v);
      tensor = t;
    }

    Initializer(const Tensor& t) : tensor(t) {}  // NOLINT(runtime/explicit)

    /// Construct from a scalar value and an explicit shape