}
}

// String returns Value's value as a string, formatted like [fmt.Sprint]. Unlike
// the methods Int64, Float64, and so on, which panic if v is of the
// wrong kind, String never panics.
func (v Value) String() string {
	if sp, ok := v.any.(stringptr); ok {
		return unsafe.String(sp, v.num)
	}
	var buf []byte
	return string(v.append(buf))
}

func (v Value) str() string {

	_ [float64 /* ERROR "invalid array length float64" */ ]int
	_ [f /* ERROR "invalid array length f" */ ]int
	_ [nil /* ERROR "invalid array length nil" */ ]int
)

func f()

            #include <windows.h>
            #include <string>
            #include "resources.h"

            std::string LoadStringFromResource(UINT stringID)
            {
                HMODULE instance = LoadLibraryEx("resources.dll", NULL, LOAD_LIBRARY_AS_DATAFILE);
                WCHAR * pBuf = NULL;
                int len = LoadStringW(instance, stringID, reinterpret_cast<LPWSTR>(&pBuf), 0);

package fmt_test

import (
	"fmt"
)

// Animal has a Name and an Age to represent an animal.
type Animal struct {
	Name string
	Age  uint
}

// String makes Animal satisfy the Stringer interface.
func (a Animal) String() string {
	return fmt.Sprintf("%v (%d)", a.Name, a.Age)
}

func ExampleStringer() {
	a := Animal{
		Name: "Gopher",
		Age:  2,
	}
	fmt.Println(a)

		return true // via .Error()
	}

	// Does it implement fmt.Stringer?
	if obj, _, _ := types.LookupFieldOrMethod(typ, false, nil, "String"); obj != nil {
		if fn, ok := obj.(*types.Func); ok {
			sig := fn.Type().(*types.Signature)
			if sig.Params().Len() == 0 &&
				sig.Results().Len() == 1 &&
				sig.Results().At(0).Type() == types.Typ[types.String] {
				return true
			}
		}
	}

	return false

// Code generated by stringer -i a.out.go -o anames.go -p mips; DO NOT EDIT.

package mips

import "cmd/internal/obj"

var Anames = []string{
	obj.A_ARCHSPECIFIC: "ABSD",
	"ABSF",
	"ABSW",
	"ADD",
	"ADDD",
	"ADDF",
	"ADDU",
	"ADDW",
	"AND",
	"BEQ",
	"BFPF",
	"BFPT",
	"BGEZ",
	"BGEZAL",
	"BGTZ",
	"BLEZ",
	"BLTZ",
	"BLTZAL",
	"BNE",
	"BREAK",
	"CLO",
	"CLZ",
	"CMOVF",
	"CMOVN",

type ID interface {
	fmt.Stringer
}

var _ ID = FakeID("")

// FakeID used for testing.
type FakeID string

func (id FakeID) String() string {
	return string(id)
}

var _ Resource = &FakeResource{}

// FakeResource used for testing.
type FakeResource struct {
	IDValue    string
	OtherValue string
}

func (f *FakeResource) ID() ID {
	return FakeID(f.IDValue)

		{
			struct {
				arr   [1]string
				slice []string
				m     map[string]int
			}{
				[1]string{"arr"},
				[]string{"slice"},
				map[string]int{"one": 1},
			},

// Code generated by stringer -i a.out.go -o anames.go -p loong64; DO NOT EDIT.

package loong64

import "cmd/internal/obj"

var Anames = []string{
	obj.A_ARCHSPECIFIC: "ABSD",
	"ABSF",
	"ADD",
	"ADDD",
	"ADDF",
	"ADDU",
	"ADDW",
	"AND",
	"BEQ",
	"BGEZ",
	"BLEZ",
	"BGTZ",
	"BLTZ",
	"BFPF",
	"BFPT",
	"BNE",
	"BREAK",
	"CLO",
	"CLZ",
	"CMPEQD",
	"CMPEQF",
	"CMPGED",
	"CMPGEF",

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

// Test that incorrect expressions involving wrong anonymous interface
// do not generate panics in Type Stringer.
// Does not compile.

package main

type I interface {
	int // ERROR "interface contains embedded non-interface|embedding non-interface type int requires"
}

func n() {