// A Converter holds the state of a test-to-JSON conversion.
// It implements io.WriteCloser; the caller writes test output in,
// and the converter writes JSON output to w.
type Converter struct {
	w          io.Writer  // JSON output stream
	pkg        string     // package to name in events
	mode       Mode       // mode bits
	start      time.Time  // time converter started

		// converted by value, not by pointer.
		fn = typecheck.LookupRuntime(fnname)
		var arg ir.Node
		switch {
		case fromType == argType:
			// already in the right type, nothing to do
			arg = n
		case fromType.Kind() == argType.Kind(),
			fromType.IsPtrShaped() && argType.IsPtrShaped():
			// can directly convert (e.g. named type to underlying type, or one pointer to another)

	close(r.next)

	if a.Failed {
		// We were unable to build the binary.
		a.Failed = false
		fmt.Fprintf(stdout, "FAIL\t%s [build failed]\n", a.Package.ImportPath)
		// Tell the JSON converter that this was a failure, not a passing run.
		err = errors.New("build failed")
		base.SetExitStatus(1)
		return nil
	}

	coverProfTempFile := func(a *work.Action) string {
		if a.Objdir == "" {

// These functions take concrete types in the runtime. But they may
// be used for a wider range of types, which have the same memory
// layout as the parameter type. The compiler converts the
// to-be-converted type to the parameter type before calling the
// runtime function. This way, the call is ABI-insensitive.
func convT16(val uint16) unsafe.Pointer
func convT32(val uint32) unsafe.Pointer

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

// Test that a method *is* live if it matches an interface
// method and the type is "indirectly" converted to an
// interface through reflection.

package main

import "reflect"

type I interface{ M() }

type T int

func (T) M() { println("XXX") }

func main() {

// isASCII reports whether the input is an ASCII C-style string.
func isASCII(s string) bool {
	for _, c := range s {
		if c >= 0x80 || c == 0x00 {
			return false
		}
	}
	return true
}

// toASCII converts the input to an ASCII C-style string.
// This is a best effort conversion, so invalid characters are dropped.
func toASCII(s string) string {
	if isASCII(s) {
		return s
	}
	b := make([]byte, 0, len(s))

// license that can be found in the LICENSE file.

// Package issue25065 has a type with a method that is
//  1. referenced in a method expression
//  2. not called
//  3. not converted to an interface
//  4. is a value method but the reference is to the pointer method
//
// These cases avoid the call to makefuncsym from typecheckfunc, but we

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

// Like ifacemethod2.go, this tests that a method *is* live
// if the type is "indirectly" converted to an interface
// using reflection with a method descriptor as intermediate.

package main

import "reflect"

type S int

func (s S) M() { println("S.M") }

type I interface{ M() }

	ResultNoInfo ResultPropBits = 0
	// This result always contains allocated memory.
	ResultIsAllocatedMem ResultPropBits = 1 << iota
	// This result is always a single concrete type that is
	// implicitly converted to interface.
	ResultIsConcreteTypeConvertedToInterface
	// Result is always the same non-composite compile time constant.
	ResultAlwaysSameConstant
	// Result is always the same function or closure.
	ResultAlwaysSameFunc

			Exit("store")))
	Compile(fun.f)
	return fun
}

func TestShiftToExtensionAMD64(t *testing.T) {
	c := testConfig(t)
	// Test that eligible pairs of constant shifts are converted to extensions.
	// For example:
	//   (uint64(x) << 32) >> 32 -> uint64(uint32(x))
	ops := map[Op]int{
		OpAMD64SHLQconst: 0, OpAMD64SHLLconst: 0,
		OpAMD64SHRQconst: 0, OpAMD64SHRLconst: 0,