# Test GOEXPERIMENT variable

# go env shows default empty GOEXPERIMENT
go env
stdout GOEXPERIMENT=

# go env shows valid experiments
env GOEXPERIMENT=fieldtrack,staticlockranking
go env GOEXPERIMENT
stdout '.*fieldtrack.*staticlockranking.*'
go env
stdout 'GOEXPERIMENT=.*fieldtrack.*staticlockranking.*'

# go env rejects unknown experiments
env GOEXPERIMENT=bad
! go env GOEXPERIMENT

	}
}

func (err *error_) empty() bool {
	return err.desc == nil
}

func (err *error_) pos() syntax.Pos {
	if err.empty() {
		return nopos
	}
	return err.desc[0].pos
}

// msg returns the formatted error message without the primary error position pos().
func (err *error_) msg() string {
	if err.empty() {
		return "no error"
	}

	var buf strings.Builder

	sourceFiles [n]uint32 - offset to source file (relative to start of index file)
	for each sourceFile:
		error - string offset // error is either produced by fmt.Errorf,errors.New or is io.EOF
		parseError - string offset // if non-empty, a json-encoded parseError struct (see below). Is either produced by io.ReadAll,os.ReadFile,errors.New or is scanner.Error,scanner.ErrorList
		synopsis - string offset
		name - string offset
		pkgName - string offset

[short] skip 'compiles and links executables'

# Set up fresh GOCACHE.
env GOCACHE=$WORK/gocache
mkdir $GOCACHE

# build without PGO
go build triv.go

# build with PGO, should trigger rebuild
# starting with an empty profile (the compiler accepts it)
go build -x -pgo=prof -o triv.exe triv.go
stderr 'preprofile.*-i.*prof'
stderr 'compile.*-pgoprofile=.*triv.go'

# check that PGO appears in build info

// build action for the "go test -cover" run action 'runAct'. Note
// that if the package has no functions the meta-data file will exist
// but will be empty; in this case the return is an empty string.
func BuildActionCoverMetaFile(runAct *Action) (string, error) {
	p := runAct.Package
	for i := range runAct.Deps {
		pred := runAct.Deps[i]
		if pred.Mode != "build" || pred.Package == nil {

	s.envMap[key] = value
	return nil
}

// Stdout returns the stdout output of the last command run,
// or the empty string if no command has been run.
func (s *State) Stdout() string { return s.stdout }

// Stderr returns the stderr output of the last command run,
// or the empty string if no command has been run.
func (s *State) Stderr() string { return s.stderr }

! stdout '\tf\t*[0-9]' # Check for no coverage on the assembly function

-- go.mod --
module coverasm

go 1.16
-- p.go --
package p

func f()

func g() {
	println("g")
}
-- p.s --
// empty asm file,
// so go test doesn't complain about declaration of f in p.go.
-- p_test.go --
package p

import "testing"

func Test(t *testing.T) {
	g()

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

type _ func /* ERROR function type must have no type parameters */ [ /* ERROR empty type parameter list */ ]()
type _ func /* ERROR function type must have no type parameters */ [ x /* ERROR missing type constraint */ ]()
type _ func /* ERROR function type must have no type parameters */ [P any]()

				v = b.Values[i]
				firstPosIndex = i
				firstPos = v.Pos
				v.Pos = firstPos.WithDefaultStmt() // default to default
				break
			}
		}

		if firstPosIndex == -1 { // Effectively empty block, check block's own Pos, consider preds.
			line := src.NoXPos
			for _, p := range b.Preds {
				pbi := p.Block().ID
				if !endlines[pbi].SameFileAndLine(line) {
					if line == src.NoXPos {

//
// The behavior of Implements is unspecified if V is Typ[Invalid] or an uninstantiated
// generic type.
func Implements(V Type, T *Interface) bool {
	if T.Empty() {
		// All types (even Typ[Invalid]) implement the empty interface.
		return true
	}
	// Checker.implements suppresses errors for invalid types, so we need special
	// handling here.
	if !isValid(V.Underlying()) {
		return false
	}