cmd/compile: trim function name prefix from escape diagnostics

This information is redundant with the position information already
provided. Also, no other -m diagnostics print out function name.

While here, report parameter leak diagnostics against the parameter
declaration position rather than the function, and use Warnl for
"moved to heap" messages.

Test cases updated programmatically by removing the first word from
every "no match for" error emitted by run.go:

go run run.go |& \
  sed -E -n 's/^(.*):(.*): no match for `([^ ]* (.*))` in:$/\1!\2!\3!\4/p' | \
  while IFS='!' read -r fn line before after; do
    before=$(echo "$before" | sed 's/[.[\*^$()+?{|]/\\&/g')
    after=$(echo "$after" | sed -E 's/(\&|\\)/\\&/g')
    fn=$(find . -name "${fn}" | head -1)
    sed -i -E -e "${line}s/\"${before}\"/\"${after}\"/" "${fn}"
  done

Passes toolstash-check.

Change-Id: I6e02486b1409e4a8dbb2b9b816d22095835426b5
Reviewed-on: https://go-review.googlesource.com/c/go/+/195040
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>

src/cmd/compile/internal/gc/esc.go

@@ -392,7 +392,7 @@ func moveToHeap(n *Node) {
 	n.Name.Param.Heapaddr = heapaddr
 	n.Esc = EscHeap
 	if Debug['m'] != 0 {
-		fmt.Printf("%v: moved to heap: %v\n", n.Line(), n)
+		Warnl(n.Pos, "moved to heap: %v", n)
 	}
 }
 
@@ -422,7 +422,7 @@ func (e *Escape) paramTag(fn *Node, narg int, f *types.Field) string {
 		// argument and pass those annotations along to importing code.
 		if f.Type.Etype == TUINTPTR {
 			if Debug['m'] != 0 {
-				Warnl(fn.Pos, "%v assuming %v is unsafe uintptr", funcSym(fn), name())
+				Warnl(f.Pos, "assuming %v is unsafe uintptr", name())
 			}
 			return unsafeUintptrTag
 		}
@@ -435,13 +435,13 @@ func (e *Escape) paramTag(fn *Node, narg int, f *types.Field) string {
 		// //go:noescape is given before the declaration.
 		if fn.Noescape() {
 			if Debug['m'] != 0 && f.Sym != nil {
-				Warnl(fn.Pos, "%S %v does not escape", funcSym(fn), name())
+				Warnl(f.Pos, "%v does not escape", name())
 			}
 			return mktag(EscNone)
 		}
 
 		if Debug['m'] != 0 && f.Sym != nil {
-			Warnl(fn.Pos, "leaking param: %v", name())
+			Warnl(f.Pos, "leaking param: %v", name())
 		}
 		return mktag(EscHeap)
 	}
@@ -449,14 +449,14 @@ func (e *Escape) paramTag(fn *Node, narg int, f *types.Field) string {
 	if fn.Func.Pragma&UintptrEscapes != 0 {
 		if f.Type.Etype == TUINTPTR {
 			if Debug['m'] != 0 {
-				Warnl(fn.Pos, "%v marking %v as escaping uintptr", funcSym(fn), name())
+				Warnl(f.Pos, "marking %v as escaping uintptr", name())
 			}
 			return uintptrEscapesTag
 		}
 		if f.IsDDD() && f.Type.Elem().Etype == TUINTPTR {
 			// final argument is ...uintptr.
 			if Debug['m'] != 0 {
-				Warnl(fn.Pos, "%v marking %v as escaping ...uintptr", funcSym(fn), name())
+				Warnl(f.Pos, "marking %v as escaping ...uintptr", name())
 			}
 			return uintptrEscapesTag
 		}
@@ -477,17 +477,17 @@ func (e *Escape) paramTag(fn *Node, narg int, f *types.Field) string {
 
 	if Debug['m'] != 0 && !loc.escapes {
 		if esc == EscNone {
-			Warnl(n.Pos, "%S %S does not escape", funcSym(fn), n)
+			Warnl(f.Pos, "%v does not escape", name())
 		} else if esc == EscHeap {
-			Warnl(n.Pos, "leaking param: %S", n)
+			Warnl(f.Pos, "leaking param: %v", name())
 		} else {
 			if esc&EscContentEscapes != 0 {
-				Warnl(n.Pos, "leaking param content: %S", n)
+				Warnl(f.Pos, "leaking param content: %v", name())
 			}
 			for i := 0; i < numEscReturns; i++ {
 				if x := getEscReturn(esc, i); x >= 0 {
-					res := n.Name.Curfn.Type.Results().Field(i).Sym
-					Warnl(n.Pos, "leaking param: %S to result %v level=%d", n, res, x)
+					res := fn.Type.Results().Field(i).Sym
+					Warnl(f.Pos, "leaking param: %v to result %v level=%d", name(), res, x)
 				}
 			}
 		}

src/cmd/compile/internal/gc/escape.go

@@ -1289,7 +1289,7 @@ func (e *Escape) finish(fns []*Node) {
 			addrescapes(n)
 		} else {
 			if Debug['m'] != 0 && n.Op != ONAME && n.Op != OTYPESW && n.Op != ORANGE && n.Op != ODEFER {
-				Warnl(n.Pos, "%S %S does not escape", funcSym(loc.curfn), n)
+				Warnl(n.Pos, "%S does not escape", n)
 			}
 			n.Esc = EscNone
 			if loc.transient {

test/escape_array.go

@@ -71,7 +71,7 @@ func fuo(x *U, y *U) *string { // ERROR "leaking param: x to result ~r2 level=1$
 // pointers stored in small array literals do not escape;
 // large array literals are heap allocated;
 // pointers stored in large array literals escape.
-func hugeLeaks1(x **string, y **string) { // ERROR "leaking param content: x" "hugeLeaks1 y does not escape"
+func hugeLeaks1(x **string, y **string) { // ERROR "leaking param content: x" "y does not escape"
 	a := [10]*string{*y}
 	_ = a
 	// 4 x 4,000,000 exceeds MaxStackVarSize, therefore it must be heap allocated if pointers are 4 bytes or larger.
@@ -79,7 +79,7 @@ func hugeLeaks1(x **string, y **string) { // ERROR "leaking param content: x" "h
 	_ = b
 }
 
-func hugeLeaks2(x *string, y *string) { // ERROR "leaking param: x" "hugeLeaks2 y does not escape"
+func hugeLeaks2(x *string, y *string) { // ERROR "leaking param: x" "y does not escape"
 	a := [10]*string{y}
 	_ = a
 	// 4 x 4,000,000 exceeds MaxStackVarSize, therefore it must be heap allocated if pointers are 4 bytes or larger.

test/escape_calls.go

@@ -44,7 +44,7 @@ func walk(np **Node) int { // ERROR "leaking param content: np"
 }
 
 // Test for bug where func var f used prototype's escape analysis results.
-func prototype(xyz []string) {} // ERROR "prototype xyz does not escape"
+func prototype(xyz []string) {} // ERROR "xyz does not escape"
 func bar() {
 	var got [][]string
 	f := prototype

test/escape_closure.go

@@ -139,28 +139,28 @@ func ClosureCallArgs15() {
 	}(&p)
 }
 
-func ClosureLeak1(s string) string { // ERROR "ClosureLeak1 s does not escape"
+func ClosureLeak1(s string) string { // ERROR "s does not escape"
 	t := s + "YYYY"         // ERROR "escapes to heap"
-	return ClosureLeak1a(t) // ERROR "ClosureLeak1 ... argument does not escape"
+	return ClosureLeak1a(t) // ERROR "... argument does not escape"
 }
 
 // See #14409 -- returning part of captured var leaks it.
 func ClosureLeak1a(a ...string) string { // ERROR "leaking param: a to result ~r1 level=1$"
-	return func() string { // ERROR "ClosureLeak1a func literal does not escape"
+	return func() string { // ERROR "func literal does not escape"
 		return a[0]
 	}()
 }
 
-func ClosureLeak2(s string) string { // ERROR "ClosureLeak2 s does not escape"
+func ClosureLeak2(s string) string { // ERROR "s does not escape"
 	t := s + "YYYY"       // ERROR "escapes to heap"
-	c := ClosureLeak2a(t) // ERROR "ClosureLeak2 ... argument does not escape"
+	c := ClosureLeak2a(t) // ERROR "... argument does not escape"
 	return c
 }
 func ClosureLeak2a(a ...string) string { // ERROR "leaking param content: a"
-	return ClosureLeak2b(func() string { // ERROR "ClosureLeak2a func literal does not escape"
+	return ClosureLeak2b(func() string { // ERROR "func literal does not escape"
 		return a[0]
 	})
 }
-func ClosureLeak2b(f func() string) string { // ERROR "ClosureLeak2b f does not escape"
+func ClosureLeak2b(f func() string) string { // ERROR "f does not escape"
 	return f()
 }

test/escape_field.go

@@ -127,14 +127,14 @@ func field12() {
 
 func field13() {
 	i := 0          // ERROR "moved to heap: i$"
-	x := &X{p1: &i} // ERROR "field13 &X literal does not escape$"
+	x := &X{p1: &i} // ERROR "&X literal does not escape$"
 	sink = x.p1
 }
 
 func field14() {
 	i := 0 // ERROR "moved to heap: i$"
 	// BAD: &i should not escape
-	x := &X{p1: &i} // ERROR "field14 &X literal does not escape$"
+	x := &X{p1: &i} // ERROR "&X literal does not escape$"
 	sink = x.p2
 }
 
@@ -149,7 +149,7 @@ func field16() {
 	var x X
 	// BAD: &i should not escape
 	x.p1 = &i
-	var iface interface{} = x // ERROR "field16 x does not escape"
+	var iface interface{} = x // ERROR "x does not escape"
 	x1 := iface.(X)
 	sink = x1.p2
 }
@@ -158,7 +158,7 @@ func field17() {
 	i := 0 // ERROR "moved to heap: i$"
 	var x X
 	x.p1 = &i
-	var iface interface{} = x // ERROR "field17 x does not escape"
+	var iface interface{} = x // ERROR "x does not escape"
 	x1 := iface.(X)
 	sink = x1.p1
 }
@@ -168,7 +168,7 @@ func field18() {
 	var x X
 	// BAD: &i should not escape
 	x.p1 = &i
-	var iface interface{} = x // ERROR "field18 x does not escape"
+	var iface interface{} = x // ERROR "x does not escape"
 	y, _ := iface.(Y)         // Put X, but extracted Y. The cast will fail, so y is zero initialized.
 	sink = y                  // ERROR "y escapes to heap"
 }

test/escape_iface.go

@@ -110,7 +110,7 @@ func efaceEscape1() {
 	{
 		i := 0         // ERROR "moved to heap: i"
 		v := M1{&i, 0}
-		var x M = v // ERROR "efaceEscape1 v does not escape"
+		var x M = v // ERROR "v does not escape"
 		v1 := x.(M1)
 		sink = v1 // ERROR "v1 escapes to heap"
 	}

test/escape_indir.go

@@ -127,7 +127,7 @@ func constptr11() *ConstPtr {
 	return p
 }
 
-func foo(p **int) { // ERROR "foo p does not escape"
+func foo(p **int) { // ERROR "p does not escape"
 	i := 0 // ERROR "moved to heap: i"
 	y := p
 	*y = &i

test/escape_param.go

@@ -42,7 +42,7 @@ func caller1() {
 }
 
 // in -> other in
-func param2(p1 *int, p2 **int) { // ERROR "leaking param: p1$" "param2 p2 does not escape$"
+func param2(p1 *int, p2 **int) { // ERROR "leaking param: p1$" "p2 does not escape$"
 	*p2 = p1
 }
 
@@ -137,7 +137,7 @@ type Pair struct {
 	p2 *int
 }
 
-func param3(p *Pair) { // ERROR "param3 p does not escape"
+func param3(p *Pair) { // ERROR "p does not escape"
 	p.p1 = p.p2 // ERROR "param3 ignoring self-assignment in p.p1 = p.p2"
 }
 
@@ -158,7 +158,7 @@ func caller3b() {
 }
 
 // in -> rcvr
-func (p *Pair) param4(i *int) { // ERROR "\(\*Pair\).param4 p does not escape$" "leaking param: i$"
+func (p *Pair) param4(i *int) { // ERROR "p does not escape$" "leaking param: i$"
 	p.p1 = i
 }
 
@@ -211,7 +211,7 @@ func caller7() {
 }
 
 // **in -> heap
-func param8(i **int) { // ERROR "param8 i does not escape$"
+func param8(i **int) { // ERROR "i does not escape$"
 	sink = **i // ERROR "\* \(\*i\) escapes to heap"
 }
 
@@ -294,7 +294,7 @@ type Indir struct {
 	p ***int
 }
 
-func (r *Indir) param12(i **int) { // ERROR "\(\*Indir\).param12 r does not escape$" "moved to heap: i$"
+func (r *Indir) param12(i **int) { // ERROR "r does not escape$" "moved to heap: i$"
 	r.p = &i
 }
 
@@ -309,7 +309,7 @@ func caller12a() {
 func caller12b() {
 	i := 0        // ERROR "moved to heap: i$"
 	p := &i       // ERROR "moved to heap: p$"
-	r := &Indir{} // ERROR "caller12b &Indir literal does not escape$"
+	r := &Indir{} // ERROR "&Indir literal does not escape$"
 	r.param12(&p)
 	_ = r
 }
@@ -335,7 +335,7 @@ type Val struct {
 	p **int
 }
 
-func (v Val) param13(i *int) { // ERROR "Val.param13 v does not escape$" "leaking param: i$"
+func (v Val) param13(i *int) { // ERROR "v does not escape$" "leaking param: i$"
 	*v.p = i
 }
 
@@ -359,7 +359,7 @@ func caller13b() {
 func caller13c() {
 	i := 0 // ERROR "moved to heap: i$"
 	var p *int
-	v := &Val{&p} // ERROR "caller13c &Val literal does not escape$"
+	v := &Val{&p} // ERROR "&Val literal does not escape$"
 	v.param13(&i)
 	_ = v
 }
@@ -400,7 +400,7 @@ func caller13g() {
 func caller13h() {
 	i := 0 // ERROR "moved to heap: i$"
 	var p *int
-	v := &Val{&p} // ERROR "caller13h &Val literal does not escape$"
+	v := &Val{&p} // ERROR "&Val literal does not escape$"
 	v.param13(&i)
 	sink = **v.p  // ERROR "\* \(\*v\.p\) escapes to heap"
 }
@@ -420,7 +420,7 @@ func g(x *Node) *Node { // ERROR "leaking param content: x"
 }
 
 func h(x *Node) { // ERROR "leaking param: x"
-	y := &Node{x} // ERROR "h &Node literal does not escape"
+	y := &Node{x} // ERROR "&Node literal does not escape"
 	Sink = g(y)
 	f(y)
 }

test/escape_struct_param1.go

@@ -38,7 +38,7 @@ func tSPPi() {
 	s := "cat"        // ERROR "moved to heap: s$"
 	ps := &s
 	pps := &ps
-	pu := &U{ps, pps} // ERROR "tSPPi &U literal does not escape$"
+	pu := &U{ps, pps} // ERROR "&U literal does not escape$"
 	Ssink = pu.SPPi()
 }
 
@@ -46,7 +46,7 @@ func tiSPP() {
 	s := "cat"        // ERROR "moved to heap: s$"
 	ps := &s
 	pps := &ps
-	pu := &U{ps, pps} // ERROR "tiSPP &U literal does not escape$"
+	pu := &U{ps, pps} // ERROR "&U literal does not escape$"
 	Ssink = *pu.SPP()
 }
 
@@ -55,7 +55,7 @@ func tSP() {
 	s := "cat"        // ERROR "moved to heap: s$"
 	ps := &s          // ERROR "moved to heap: ps$"
 	pps := &ps
-	pu := &U{ps, pps} // ERROR "tSP &U literal does not escape$"
+	pu := &U{ps, pps} // ERROR "&U literal does not escape$"
 	Ssink = pu.SP()
 }
 
@@ -123,9 +123,9 @@ func tUPiSPa() {
 	ps4 := &s4           // ERROR "moved to heap: ps4$"
 	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
-	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPa &U literal does not escape$"
+	u2 := &U{&s3, &ps4}  // ERROR "&U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "&U literal escapes to heap$"
-	v := &V{u1, u2, &u3} // ERROR "tUPiSPa &V literal does not escape$"
+	v := &V{u1, u2, &u3} // ERROR "&V literal does not escape$"
 	Ssink = v.UPiSPa()   // Ssink = &s3 (only &s3 really escapes)
 }
 
@@ -141,9 +141,9 @@ func tUPiSPb() {
 	ps4 := &s4           // ERROR "moved to heap: ps4$"
 	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
-	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPb &U literal does not escape$"
+	u2 := &U{&s3, &ps4}  // ERROR "&U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "&U literal escapes to heap$"
-	v := &V{u1, u2, &u3} // ERROR "tUPiSPb &V literal does not escape$"
+	v := &V{u1, u2, &u3} // ERROR "&V literal does not escape$"
 	Ssink = v.UPiSPb()   // Ssink = &s3 (only &s3 really escapes)
 }
 
@@ -159,9 +159,9 @@ func tUPiSPc() {
 	ps4 := &s4           // ERROR "moved to heap: ps4$"
 	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
-	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPc &U literal does not escape$"
+	u2 := &U{&s3, &ps4}  // ERROR "&U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "&U literal escapes to heap$"
-	v := &V{u1, u2, &u3} // ERROR "tUPiSPc &V literal does not escape$"
+	v := &V{u1, u2, &u3} // ERROR "&V literal does not escape$"
 	Ssink = v.UPiSPc()   // Ssink = &s3 (only &s3 really escapes)
 }
 
@@ -177,9 +177,9 @@ func tUPiSPd() {
 	ps4 := &s4           // ERROR "moved to heap: ps4$"
 	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
-	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPd &U literal does not escape$"
+	u2 := &U{&s3, &ps4}  // ERROR "&U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "&U literal escapes to heap$"
-	v := &V{u1, u2, &u3} // ERROR "tUPiSPd &V literal does not escape$"
+	v := &V{u1, u2, &u3} // ERROR "&V literal does not escape$"
 	Ssink = v.UPiSPd()   // Ssink = &s3 (only &s3 really escapes)
 }
 
@@ -211,9 +211,9 @@ func tUPiSPPia() {
 	ps4 := &s4
 	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
-	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPPia &U literal does not escape$"
-	u3 := &U{&s5, &ps6}  // ERROR "tUPiSPPia &U literal does not escape$"
-	v := &V{u1, u2, &u3} // ERROR "tUPiSPPia &V literal does not escape$"
+	u2 := &U{&s3, &ps4}  // ERROR "&U literal does not escape$"
+	u3 := &U{&s5, &ps6}  // ERROR "&U literal does not escape$"
+	v := &V{u1, u2, &u3} // ERROR "&V literal does not escape$"
 	Ssink = v.UPiSPPia() // Ssink = *&ps4 = &s4 (only &s4 really escapes)
 }
 
@@ -229,9 +229,9 @@ func tUPiSPPib() {
 	ps4 := &s4
 	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
-	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPPib &U literal does not escape$"
-	u3 := &U{&s5, &ps6}  // ERROR "tUPiSPPib &U literal does not escape$"
-	v := &V{u1, u2, &u3} // ERROR "tUPiSPPib &V literal does not escape$"
+	u2 := &U{&s3, &ps4}  // ERROR "&U literal does not escape$"
+	u3 := &U{&s5, &ps6}  // ERROR "&U literal does not escape$"
+	v := &V{u1, u2, &u3} // ERROR "&V literal does not escape$"
 	Ssink = v.UPiSPPib() // Ssink = *&ps4 = &s4 (only &s4 really escapes)
 }
 
@@ -247,9 +247,9 @@ func tUPiSPPic() {
 	ps4 := &s4
 	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
-	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPPic &U literal does not escape$"
-	u3 := &U{&s5, &ps6}  // ERROR "tUPiSPPic &U literal does not escape$"
-	v := &V{u1, u2, &u3} // ERROR "tUPiSPPic &V literal does not escape$"
+	u2 := &U{&s3, &ps4}  // ERROR "&U literal does not escape$"
+	u3 := &U{&s5, &ps6}  // ERROR "&U literal does not escape$"
+	v := &V{u1, u2, &u3} // ERROR "&V literal does not escape$"
 	Ssink = v.UPiSPPic() // Ssink = *&ps4 = &s4 (only &s4 really escapes)
 }
 
@@ -265,9 +265,9 @@ func tUPiSPPid() {
 	ps4 := &s4
 	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
-	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPPid &U literal does not escape$"
-	u3 := &U{&s5, &ps6}  // ERROR "tUPiSPPid &U literal does not escape$"
-	v := &V{u1, u2, &u3} // ERROR "tUPiSPPid &V literal does not escape$"
+	u2 := &U{&s3, &ps4}  // ERROR "&U literal does not escape$"
+	u3 := &U{&s5, &ps6}  // ERROR "&U literal does not escape$"
+	v := &V{u1, u2, &u3} // ERROR "&V literal does not escape$"
 	Ssink = v.UPiSPPid() // Ssink = *&ps4 = &s4 (only &s4 really escapes)
 }
 
@@ -291,8 +291,8 @@ func tUPPiSPPia() {
 	ps4 := &s4
 	ps6 := &s6
 	u1 := U{&s1, &ps2}
-	u2 := &U{&s3, &ps4}   // ERROR "tUPPiSPPia &U literal does not escape$"
-	u3 := &U{&s5, &ps6}   // ERROR "tUPPiSPPia &U literal does not escape$"
-	v := &V{u1, u2, &u3}  // ERROR "tUPPiSPPia &V literal does not escape$"
+	u2 := &U{&s3, &ps4}   // ERROR "&U literal does not escape$"
+	u3 := &U{&s5, &ps6}   // ERROR "&U literal does not escape$"
+	v := &V{u1, u2, &u3}  // ERROR "&V literal does not escape$"
 	Ssink = v.UPPiSPPia() // Ssink = *&ps6 = &s6 (only &s6 really escapes)
 }

test/escape_struct_param2.go

@@ -38,7 +38,7 @@ func tSPPi() {
 	s := "cat"        // ERROR "moved to heap: s$"
 	ps := &s
 	pps := &ps
-	pu := &U{ps, pps} // ERROR "tSPPi &U literal does not escape$"
+	pu := &U{ps, pps} // ERROR "&U literal does not escape$"
 	Ssink = pu.SPPi()
 }
 
@@ -46,7 +46,7 @@ func tiSPP() {
 	s := "cat"        // ERROR "moved to heap: s$"
 	ps := &s
 	pps := &ps
-	pu := &U{ps, pps} // ERROR "tiSPP &U literal does not escape$"
+	pu := &U{ps, pps} // ERROR "&U literal does not escape$"
 	Ssink = *pu.SPP()
 }
 
@@ -55,7 +55,7 @@ func tSP() {
 	s := "cat"        // ERROR "moved to heap: s$"
 	ps := &s          // ERROR "moved to heap: ps$"
 	pps := &ps
-	pu := &U{ps, pps} // ERROR "tSP &U literal does not escape$"
+	pu := &U{ps, pps} // ERROR "&U literal does not escape$"
 	Ssink = pu.SP()
 }
 
@@ -123,9 +123,9 @@ func tUPiSPa() {
 	ps4 := &s4           // ERROR "moved to heap: ps4$"
 	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
-	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPa &U literal does not escape$"
+	u2 := &U{&s3, &ps4}  // ERROR "&U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "&U literal escapes to heap$"
-	v := &V{u1, u2, &u3} // ERROR "tUPiSPa &V literal does not escape$"
+	v := &V{u1, u2, &u3} // ERROR "&V literal does not escape$"
 	Ssink = v.UPiSPa()   // Ssink = &s3 (only &s3 really escapes)
 }
 
@@ -141,9 +141,9 @@ func tUPiSPb() {
 	ps4 := &s4           // ERROR "moved to heap: ps4$"
 	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
-	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPb &U literal does not escape$"
+	u2 := &U{&s3, &ps4}  // ERROR "&U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "&U literal escapes to heap$"
-	v := &V{u1, u2, &u3} // ERROR "tUPiSPb &V literal does not escape$"
+	v := &V{u1, u2, &u3} // ERROR "&V literal does not escape$"
 	Ssink = v.UPiSPb()   // Ssink = &s3 (only &s3 really escapes)
 }
 
@@ -159,9 +159,9 @@ func tUPiSPc() {
 	ps4 := &s4           // ERROR "moved to heap: ps4$"
 	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
-	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPc &U literal does not escape$"
+	u2 := &U{&s3, &ps4}  // ERROR "&U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "&U literal escapes to heap$"
-	v := &V{u1, u2, &u3} // ERROR "tUPiSPc &V literal does not escape$"
+	v := &V{u1, u2, &u3} // ERROR "&V literal does not escape$"
 	Ssink = v.UPiSPc()   // Ssink = &s3 (only &s3 really escapes)
 }
 
@@ -177,9 +177,9 @@ func tUPiSPd() {
 	ps4 := &s4           // ERROR "moved to heap: ps4$"
 	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
-	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPd &U literal does not escape$"
+	u2 := &U{&s3, &ps4}  // ERROR "&U literal does not escape$"
 	u3 := &U{&s5, &ps6}  // ERROR "&U literal escapes to heap$"
-	v := &V{u1, u2, &u3} // ERROR "tUPiSPd &V literal does not escape$"
+	v := &V{u1, u2, &u3} // ERROR "&V literal does not escape$"
 	Ssink = v.UPiSPd()   // Ssink = &s3 (only &s3 really escapes)
 }
 
@@ -211,9 +211,9 @@ func tUPiSPPia() {
 	ps4 := &s4
 	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
-	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPPia &U literal does not escape$"
-	u3 := &U{&s5, &ps6}  // ERROR "tUPiSPPia &U literal does not escape$"
-	v := &V{u1, u2, &u3} // ERROR "tUPiSPPia &V literal does not escape$"
+	u2 := &U{&s3, &ps4}  // ERROR "&U literal does not escape$"
+	u3 := &U{&s5, &ps6}  // ERROR "&U literal does not escape$"
+	v := &V{u1, u2, &u3} // ERROR "&V literal does not escape$"
 	Ssink = v.UPiSPPia() // Ssink = *&ps4 = &s4 (only &s4 really escapes)
 }
 
@@ -229,9 +229,9 @@ func tUPiSPPib() {
 	ps4 := &s4
 	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
-	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPPib &U literal does not escape$"
-	u3 := &U{&s5, &ps6}  // ERROR "tUPiSPPib &U literal does not escape$"
-	v := &V{u1, u2, &u3} // ERROR "tUPiSPPib &V literal does not escape$"
+	u2 := &U{&s3, &ps4}  // ERROR "&U literal does not escape$"
+	u3 := &U{&s5, &ps6}  // ERROR "&U literal does not escape$"
+	v := &V{u1, u2, &u3} // ERROR "&V literal does not escape$"
 	Ssink = v.UPiSPPib() // Ssink = *&ps4 = &s4 (only &s4 really escapes)
 }
 
@@ -247,9 +247,9 @@ func tUPiSPPic() {
 	ps4 := &s4
 	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
-	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPPic &U literal does not escape$"
-	u3 := &U{&s5, &ps6}  // ERROR "tUPiSPPic &U literal does not escape$"
-	v := &V{u1, u2, &u3} // ERROR "tUPiSPPic &V literal does not escape$"
+	u2 := &U{&s3, &ps4}  // ERROR "&U literal does not escape$"
+	u3 := &U{&s5, &ps6}  // ERROR "&U literal does not escape$"
+	v := &V{u1, u2, &u3} // ERROR "&V literal does not escape$"
 	Ssink = v.UPiSPPic() // Ssink = *&ps4 = &s4 (only &s4 really escapes)
 }
 
@@ -265,9 +265,9 @@ func tUPiSPPid() {
 	ps4 := &s4
 	ps6 := &s6           // ERROR "moved to heap: ps6$"
 	u1 := U{&s1, &ps2}
-	u2 := &U{&s3, &ps4}  // ERROR "tUPiSPPid &U literal does not escape$"
-	u3 := &U{&s5, &ps6}  // ERROR "tUPiSPPid &U literal does not escape$"
-	v := &V{u1, u2, &u3} // ERROR "tUPiSPPid &V literal does not escape$"
+	u2 := &U{&s3, &ps4}  // ERROR "&U literal does not escape$"
+	u3 := &U{&s5, &ps6}  // ERROR "&U literal does not escape$"
+	v := &V{u1, u2, &u3} // ERROR "&V literal does not escape$"
 	Ssink = v.UPiSPPid() // Ssink = *&ps4 = &s4 (only &s4 really escapes)
 }
 
@@ -291,8 +291,8 @@ func tUPPiSPPia() { // This test is sensitive to the level cap in function summa
 	ps4 := &s4
 	ps6 := &s6
 	u1 := U{&s1, &ps2}
-	u2 := &U{&s3, &ps4}   // ERROR "tUPPiSPPia &U literal does not escape$"
-	u3 := &U{&s5, &ps6}   // ERROR "tUPPiSPPia &U literal does not escape$"
-	v := &V{u1, u2, &u3}  // ERROR "tUPPiSPPia &V literal does not escape$"
+	u2 := &U{&s3, &ps4}   // ERROR "&U literal does not escape$"
+	u3 := &U{&s5, &ps6}   // ERROR "&U literal does not escape$"
+	v := &V{u1, u2, &u3}  // ERROR "&V literal does not escape$"
 	Ssink = v.UPPiSPPia() // Ssink = *&ps6 = &s6 (only &s6 really escapes)
 }

test/fixedbugs/issue12006.go

@@ -8,7 +8,7 @@
 
 package foo
 
-func FooN(vals ...*int) (s int) { // ERROR "FooN vals does not escape"
+func FooN(vals ...*int) (s int) { // ERROR "vals does not escape"
 	for _, v := range vals {
 		s += *v
 	}
@@ -37,14 +37,14 @@ func FooNz(vals ...*int) (s int) { // ERROR "leaking param: vals"
 func TFooN() {
 	for i := 0; i < 1000; i++ {
 		var i, j int
-		FooN(&i, &j) // ERROR "TFooN ... argument does not escape"
+		FooN(&i, &j) // ERROR "... argument does not escape"
 	}
 }
 
 func TFooNx() {
 	for i := 0; i < 1000; i++ {
 		var i, j, k int   // ERROR "moved to heap: i" "moved to heap: j" "moved to heap: k"
-		FooNx(&k, &i, &j) // ERROR "TFooNx ... argument does not escape"
+		FooNx(&k, &i, &j) // ERROR "... argument does not escape"
 	}
 }
 
@@ -84,7 +84,7 @@ func TFooI() {
 	a := int32(1) // ERROR "moved to heap: a"
 	b := "cat"
 	c := &a
-	FooI(a, b, c) // ERROR "a escapes to heap" "b escapes to heap" "TFooI ... argument does not escape"
+	FooI(a, b, c) // ERROR "a escapes to heap" "b escapes to heap" "... argument does not escape"
 }
 
 func FooJ(args ...interface{}) *int32 { // ERROR "leaking param: args to result ~r1 level=1"
@@ -108,14 +108,14 @@ func TFooJ1() {
 	a := int32(1)
 	b := "cat"
 	c := &a
-	FooJ(a, b, c) // ERROR "TFooJ1 a does not escape" "TFooJ1 b does not escape" "TFooJ1 ... argument does not escape"
+	FooJ(a, b, c) // ERROR "a does not escape" "b does not escape" "... argument does not escape"
 }
 
 func TFooJ2() {
 	a := int32(1) // ERROR "moved to heap: a"
 	b := "cat"
 	c := &a
-	isink = FooJ(a, b, c) // ERROR "a escapes to heap" "b escapes to heap" "TFooJ2 ... argument does not escape"
+	isink = FooJ(a, b, c) // ERROR "a escapes to heap" "b escapes to heap" "... argument does not escape"
 }
 
 type fakeSlice struct {
@@ -144,7 +144,7 @@ func TFooK2() {
 	a := int32(1) // ERROR "moved to heap: a"
 	b := "cat"
 	c := &a
-	fs := fakeSlice{3, &[4]interface{}{a, b, c, nil}} // ERROR "a escapes to heap" "b escapes to heap" "TFooK2 &\[4\]interface {} literal does not escape"
+	fs := fakeSlice{3, &[4]interface{}{a, b, c, nil}} // ERROR "a escapes to heap" "b escapes to heap" "&\[4\]interface {} literal does not escape"
 	isink = FooK(fs)
 }
 
@@ -169,6 +169,6 @@ func TFooL2() {
 	a := int32(1) // ERROR "moved to heap: a"
 	b := "cat"
 	c := &a
-	s := []interface{}{a, b, c} // ERROR "a escapes to heap" "b escapes to heap" "TFooL2 \[\]interface {} literal does not escape"
+	s := []interface{}{a, b, c} // ERROR "a escapes to heap" "b escapes to heap" "\[\]interface {} literal does not escape"
 	isink = FooL(s)
 }

test/fixedbugs/issue12588.go

@@ -26,7 +26,7 @@ func f(a A) int {
 	return 0
 }
 
-func g(a *A) int { // ERROR "g a does not escape"
+func g(a *A) int { // ERROR "a does not escape"
 	for i, x := range &a.b {
 		if x != 0 {
 			return 64*i + int(x)

test/fixedbugs/issue13799.go

@@ -20,7 +20,7 @@ func main() {
 	// (sometimes it takes 1 time, sometimes it takes ~4,000+).
 	for iter := 0; ; iter++ {
 		if iter%50 == 0 {
-			fmt.Println(iter) // ERROR "iter escapes to heap$" "main ... argument does not escape$"
+			fmt.Println(iter) // ERROR "iter escapes to heap$" "... argument does not escape$"
 		}
 		test1(iter)
 		test2(iter)
@@ -60,20 +60,20 @@ func test1(iter int) {
 	}
 
 	if len(m) != maxI {
-		panic(fmt.Sprintf("iter %d: maxI = %d, len(m) = %d", iter, maxI, len(m))) // ERROR "iter escapes to heap$" "len\(m\) escapes to heap$" "maxI escapes to heap$" "test1 ... argument does not escape$"
+		panic(fmt.Sprintf("iter %d: maxI = %d, len(m) = %d", iter, maxI, len(m))) // ERROR "iter escapes to heap$" "len\(m\) escapes to heap$" "maxI escapes to heap$" "... argument does not escape$"
 	}
 }
 
 func test2(iter int) {
 
 	const maxI = 500
-	m := make(map[int][]int) // ERROR "test2 make\(map\[int\]\[\]int\) does not escape$"
+	m := make(map[int][]int) // ERROR "make\(map\[int\]\[\]int\) does not escape$"
 
 	// var fn func()
 	for i := 0; i < maxI; i++ {
 		var fn func() // this makes it work, because fn stays off heap
 		j := 0
-		fn = func() { // ERROR "test2 func literal does not escape$"
+		fn = func() { // ERROR "func literal does not escape$"
 			m[i] = append(m[i], 0)
 			if j < 25 {
 				j++
@@ -84,7 +84,7 @@ func test2(iter int) {
 	}
 
 	if len(m) != maxI {
-		panic(fmt.Sprintf("iter %d: maxI = %d, len(m) = %d", iter, maxI, len(m))) // ERROR "iter escapes to heap$" "len\(m\) escapes to heap$" "maxI escapes to heap$" "test2 ... argument does not escape$"
+		panic(fmt.Sprintf("iter %d: maxI = %d, len(m) = %d", iter, maxI, len(m))) // ERROR "iter escapes to heap$" "len\(m\) escapes to heap$" "maxI escapes to heap$" "... argument does not escape$"
 	}
 }
 
@@ -110,7 +110,7 @@ func test3(iter int) {
 	}
 
 	if *m != maxI {
-		panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "test3 ... argument does not escape$"
+		panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "... argument does not escape$"
 	}
 }
 
@@ -124,7 +124,7 @@ func test4(iter int) {
 	for i := 0; i < maxI; i++ {
 		var fn func() // this makes it work, because fn stays off heap
 		j := 0
-		fn = func() { // ERROR "test4 func literal does not escape$"
+		fn = func() { // ERROR "func literal does not escape$"
 			if j < 100 {
 				j++
 				fn()
@@ -136,7 +136,7 @@ func test4(iter int) {
 	}
 
 	if *m != maxI {
-		panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "test4 ... argument does not escape$"
+		panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "... argument does not escape$"
 	}
 }
 
@@ -144,7 +144,7 @@ type str struct {
 	m *int
 }
 
-func recur1(j int, s *str) { // ERROR "recur1 s does not escape"
+func recur1(j int, s *str) { // ERROR "s does not escape"
 	if j < 100 {
 		j++
 		recur1(j, s)
@@ -167,7 +167,7 @@ func test5(iter int) {
 	}
 
 	if *m != maxI {
-		panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "test5 ... argument does not escape$"
+		panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "... argument does not escape$"
 	}
 }
 
@@ -185,6 +185,6 @@ func test6(iter int) {
 	}
 
 	if *m != maxI {
-		panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "test6 ... argument does not escape$"
+		panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "... argument does not escape$"
 	}
 }

test/fixedbugs/issue17318.go

@@ -22,12 +22,12 @@ type closure func(i, j int) ent
 type ent int
 
 func (e ent) String() string {
-	return fmt.Sprintf("%d", int(e)) // ERROR "ent.String ... argument does not escape$" "int\(e\) escapes to heap$"
+	return fmt.Sprintf("%d", int(e)) // ERROR "... argument does not escape$" "int\(e\) escapes to heap$"
 }
 
 //go:noinline
-func foo(ops closure, j int) (err fmt.Stringer) { // ERROR "foo ops does not escape"
-	enqueue := func(i int) fmt.Stringer { // ERROR "foo func literal does not escape"
+func foo(ops closure, j int) (err fmt.Stringer) { // ERROR "ops does not escape"
+	enqueue := func(i int) fmt.Stringer { // ERROR "func literal does not escape"
 		return ops(i, j) // ERROR "ops\(i, j\) escapes to heap$"
 	}
 	err = enqueue(4)
@@ -39,9 +39,9 @@ func foo(ops closure, j int) (err fmt.Stringer) { // ERROR "foo ops does not esc
 
 func main() {
 	// 3 identical functions, to get different escape behavior.
-	f := func(i, j int) ent { // ERROR "main func literal does not escape"
+	f := func(i, j int) ent { // ERROR "func literal does not escape"
 		return ent(i + j)
 	}
 	i := foo(f, 3).(ent)
-	fmt.Printf("foo(f,3)=%d\n", int(i)) // ERROR "int\(i\) escapes to heap$" "main ... argument does not escape$"
+	fmt.Printf("foo(f,3)=%d\n", int(i)) // ERROR "int\(i\) escapes to heap$" "... argument does not escape$"
 }

test/fixedbugs/issue21709.go

@@ -10,14 +10,14 @@ package p
 
 type S struct{}
 
-func (s *S) Inc() {} // ERROR "\(\*S\).Inc s does not escape"
+func (s *S) Inc() {} // ERROR "s does not escape"
 var N int
 
 func F1() {
 	var s S // ERROR "moved to heap: s"
 	for i := 0; i < N; i++ {
-		fs := []func(){ // ERROR "F1 \[\]func\(\) literal does not escape"
-			s.Inc, // ERROR "F1 s.Inc does not escape"
+		fs := []func(){ // ERROR "\[\]func\(\) literal does not escape"
+			s.Inc, // ERROR "s.Inc does not escape"
 		}
 		for _, f := range fs {
 			f()
@@ -28,8 +28,8 @@ func F1() {
 func F2() {
 	var s S // ERROR "moved to heap: s"
 	for i := 0; i < N; i++ {
-		for _, f := range []func(){ // ERROR "F2 \[\]func\(\) literal does not escape"
-			s.Inc, // ERROR "F2 s.Inc does not escape"
+		for _, f := range []func(){ // ERROR "\[\]func\(\) literal does not escape"
+			s.Inc, // ERROR "s.Inc does not escape"
 		} {
 			f()
 		}

test/fixedbugs/issue7921.go

@@ -18,20 +18,20 @@ func bufferNotEscape() string {
 	// can be stack-allocated.
 	var b bytes.Buffer
 	b.WriteString("123")
-	b.Write([]byte{'4'}) // ERROR "bufferNotEscape \[\]byte literal does not escape$"
+	b.Write([]byte{'4'}) // ERROR "\[\]byte literal does not escape$"
 	return b.String()    // ERROR "inlining call to bytes.\(\*Buffer\).String$" "string\(bytes.b.buf\[bytes.b.off:\]\) escapes to heap$"
 }
 
-func bufferNoEscape2(xs []string) int { // ERROR "bufferNoEscape2 xs does not escape$"
-	b := bytes.NewBuffer(make([]byte, 0, 64)) // ERROR "bufferNoEscape2 &bytes.Buffer literal does not escape$" "bufferNoEscape2 make\(\[\]byte, 0, 64\) does not escape$" "inlining call to bytes.NewBuffer$"
+func bufferNoEscape2(xs []string) int { // ERROR "xs does not escape$"
+	b := bytes.NewBuffer(make([]byte, 0, 64)) // ERROR "&bytes.Buffer literal does not escape$" "make\(\[\]byte, 0, 64\) does not escape$" "inlining call to bytes.NewBuffer$"
 	for _, x := range xs {
 		b.WriteString(x)
 	}
 	return b.Len() // ERROR "inlining call to bytes.\(\*Buffer\).Len$"
 }
 
-func bufferNoEscape3(xs []string) string { // ERROR "bufferNoEscape3 xs does not escape$"
-	b := bytes.NewBuffer(make([]byte, 0, 64)) // ERROR "bufferNoEscape3 &bytes.Buffer literal does not escape$" "bufferNoEscape3 make\(\[\]byte, 0, 64\) does not escape$" "inlining call to bytes.NewBuffer$"
+func bufferNoEscape3(xs []string) string { // ERROR "xs does not escape$"
+	b := bytes.NewBuffer(make([]byte, 0, 64)) // ERROR "&bytes.Buffer literal does not escape$" "make\(\[\]byte, 0, 64\) does not escape$" "inlining call to bytes.NewBuffer$"
 	for _, x := range xs {
 		b.WriteString(x)
 		b.WriteByte(',')
@@ -47,11 +47,11 @@ func bufferNoEscape4() []byte {
 }
 
 func bufferNoEscape5() { // ERROR "can inline bufferNoEscape5$"
-	b := bytes.NewBuffer(make([]byte, 0, 128)) // ERROR "bufferNoEscape5 &bytes.Buffer literal does not escape$" "bufferNoEscape5 make\(\[\]byte, 0, 128\) does not escape$" "inlining call to bytes.NewBuffer$"
+	b := bytes.NewBuffer(make([]byte, 0, 128)) // ERROR "&bytes.Buffer literal does not escape$" "make\(\[\]byte, 0, 128\) does not escape$" "inlining call to bytes.NewBuffer$"
 	useBuffer(b)
 }
 
 //go:noinline
-func useBuffer(b *bytes.Buffer) { // ERROR "useBuffer b does not escape$"
+func useBuffer(b *bytes.Buffer) { // ERROR "b does not escape$"
 	b.WriteString("1234")
 }

test/inline.go

@@ -95,15 +95,15 @@ func p() int {
 }
 
 func q(x int) int {
-	foo := func() int { return x * 2 } // ERROR "can inline q.func1" "q func literal does not escape"
+	foo := func() int { return x * 2 } // ERROR "can inline q.func1" "func literal does not escape"
 	return foo()                       // ERROR "inlining call to q.func1"
 }
 
 func r(z int) int {
-	foo := func(x int) int { // ERROR "can inline r.func1" "r func literal does not escape"
+	foo := func(x int) int { // ERROR "can inline r.func1" "func literal does not escape"
 		return x + z
 	}
-	bar := func(x int) int { // ERROR "r func literal does not escape"
+	bar := func(x int) int { // ERROR "func literal does not escape"
 		return x + func(y int) int { // ERROR "can inline r.func2.1"
 			return 2*y + x*z
 		}(x) // ERROR "inlining call to r.func2.1"
@@ -112,7 +112,7 @@ func r(z int) int {
 }
 
 func s0(x int) int {
-	foo := func() { // ERROR "can inline s0.func1" "s0 func literal does not escape"
+	foo := func() { // ERROR "can inline s0.func1" "func literal does not escape"
 		x = x + 1
 	}
 	foo() // ERROR "inlining call to s0.func1"
@@ -120,7 +120,7 @@ func s0(x int) int {
 }
 
 func s1(x int) int {
-	foo := func() int { // ERROR "can inline s1.func1" "s1 func literal does not escape"
+	foo := func() int { // ERROR "can inline s1.func1" "func literal does not escape"
 		return x
 	}
 	x = x + 1
@@ -145,7 +145,7 @@ func switchBreak(x, y int) int {
 }
 
 // can't currently inline functions with a type switch
-func switchType(x interface{}) int { // ERROR "switchType x does not escape"
+func switchType(x interface{}) int { // ERROR "x does not escape"
 	switch x.(type) {
 	case int:
 		return x.(int)

test/inline_big.go

@@ -9,18 +9,18 @@
 
 package foo
 
-func small(a []int) int { // ERROR "can inline small as:.*" "small a does not escape"
+func small(a []int) int { // ERROR "can inline small as:.*" "a does not escape"
 	// Cost 16 body (need cost < 20).
 	// See cmd/compile/internal/gc/inl.go:inlineBigFunction*
 	return a[0] + a[1] + a[2] + a[3]
 }
-func medium(a []int) int { // ERROR "can inline medium as:.*" "medium a does not escape"
+func medium(a []int) int { // ERROR "can inline medium as:.*" "a does not escape"
 	// Cost 32 body (need cost > 20 and cost < 80).
 	// See cmd/compile/internal/gc/inl.go:inlineBigFunction*
 	return a[0] + a[1] + a[2] + a[3] + a[4] + a[5] + a[6] + a[7]
 }
 
-func f(a []int) int { // ERROR "cannot inline f:.*" "f a does not escape"
+func f(a []int) int { // ERROR "cannot inline f:.*" "a does not escape"
 	// Add lots of nodes to f's body. We need >5000.
 	// See cmd/compile/internal/gc/inl.go:inlineBigFunction*
 	a[0] = 0

test/linkname.dir/linkname1.go

 package x
 
-func indexByte(xs []byte, b byte) int { // ERROR "indexByte xs does not escape"
+func indexByte(xs []byte, b byte) int { // ERROR "xs does not escape"
 	for i, x := range xs {
 		if x == b {
 			return i

test/live_syscall.go

@@ -15,7 +15,7 @@ import (
 	"unsafe"
 )
 
-func f(uintptr) // ERROR "f assuming arg#1 is unsafe uintptr"
+func f(uintptr) // ERROR "assuming arg#1 is unsafe uintptr"
 
 func g() { // ERROR "can inline g"
 	var t int