diff --git a/src/cmd/internal/gc/closure.go b/src/cmd/internal/gc/closure.go
index c9b6981..d6f657f 100644
--- a/src/cmd/internal/gc/closure.go
+++ b/src/cmd/internal/gc/closure.go
@@ -596,7 +596,6 @@
 	declare(xfunc.Nname, PFUNC)
 
 	// Declare and initialize variable holding receiver.
-	var body *NodeList
 
 	xfunc.Needctxt = true
 	cv := Nod(OCLOSUREVAR, nil, nil)
@@ -613,6 +612,7 @@
 	ptr.Used = 1
 	ptr.Curfn = xfunc
 	xfunc.Dcl = list(xfunc.Dcl, ptr)
+	var body *NodeList
 	if Isptr[rcvrtype.Etype] || Isinter(rcvrtype) {
 		ptr.Ntype = typenod(rcvrtype)
 		body = list(body, Nod(OAS, ptr, cv))
diff --git a/src/cmd/internal/gc/dcl.go b/src/cmd/internal/gc/dcl.go
index 8ea5d8d..a9454e6 100644
--- a/src/cmd/internal/gc/dcl.go
+++ b/src/cmd/internal/gc/dcl.go
@@ -313,7 +313,6 @@
  * new_name_list [[type] = expr_list]
  */
 func constiter(vl *NodeList, t *Node, cl *NodeList) *NodeList {
-	var vv *NodeList
 	if cl == nil {
 		if t != nil {
 			Yyerror("const declaration cannot have type without expression")
@@ -329,6 +328,7 @@
 
 	var v *Node
 	var c *Node
+	var vv *NodeList
 	for ; vl != nil; vl = vl.Next {
 		if cl == nil {
 			Yyerror("missing value in const declaration")
diff --git a/src/cmd/internal/gc/gsubr.go b/src/cmd/internal/gc/gsubr.go
index ad5e494..48a24a6 100644
--- a/src/cmd/internal/gc/gsubr.go
+++ b/src/cmd/internal/gc/gsubr.go
@@ -274,8 +274,7 @@
 	}
 }
 
-func Naddr(n *Node, a *obj.Addr, canemitcode int) {
-	*a = obj.Addr{}
+func Naddr(n *Node, canemitcode int) (a obj.Addr) {
 	if n == nil {
 		return
 	}
@@ -294,7 +293,8 @@
 
 	switch n.Op {
 	default:
-		Fatal("naddr: bad %v %v", Oconv(int(n.Op), 0), Ctxt.Dconv(a))
+		a := a // copy to let escape into Ctxt.Dconv
+		Fatal("naddr: bad %v %v", Oconv(int(n.Op), 0), Ctxt.Dconv(&a))
 
 	case OREGISTER:
 		a.Type = obj.TYPE_REG
@@ -338,7 +338,7 @@
 		a.Offset = n.Xoffset
 
 	case OCFUNC:
-		Naddr(n.Left, a, canemitcode)
+		a = Naddr(n.Left, canemitcode)
 		a.Sym = Linksym(n.Left.Sym)
 
 	case ONAME:
@@ -408,7 +408,7 @@
 			a.Offset = Mpgetfix(n.Val.U.Xval)
 
 		case CTSTR:
-			datagostring(n.Val.U.Sval, a)
+			datagostring(n.Val.U.Sval, &a)
 
 		case CTBOOL:
 			a.Sym = nil
@@ -422,19 +422,20 @@
 		}
 
 	case OADDR:
-		Naddr(n.Left, a, canemitcode)
+		a = Naddr(n.Left, canemitcode)
 		a.Etype = uint8(Tptr)
 		if Thearch.Thechar != '5' && Thearch.Thechar != '9' { // TODO(rsc): Do this even for arm, ppc64.
 			a.Width = int64(Widthptr)
 		}
 		if a.Type != obj.TYPE_MEM {
-			Fatal("naddr: OADDR %v (from %v)", Ctxt.Dconv(a), Oconv(int(n.Left.Op), 0))
+			a := a // copy to let escape into Ctxt.Dconv
+			Fatal("naddr: OADDR %v (from %v)", Ctxt.Dconv(&a), Oconv(int(n.Left.Op), 0))
 		}
 		a.Type = obj.TYPE_ADDR
 
 		// itable of interface value
 	case OITAB:
-		Naddr(n.Left, a, canemitcode)
+		a = Naddr(n.Left, canemitcode)
 
 		if a.Type == obj.TYPE_CONST && a.Offset == 0 {
 			break // itab(nil)
@@ -444,7 +445,7 @@
 
 		// pointer in a string or slice
 	case OSPTR:
-		Naddr(n.Left, a, canemitcode)
+		a = Naddr(n.Left, canemitcode)
 
 		if a.Type == obj.TYPE_CONST && a.Offset == 0 {
 			break // ptr(nil)
@@ -455,7 +456,7 @@
 
 		// len of string or slice
 	case OLEN:
-		Naddr(n.Left, a, canemitcode)
+		a = Naddr(n.Left, canemitcode)
 
 		if a.Type == obj.TYPE_CONST && a.Offset == 0 {
 			break // len(nil)
@@ -471,7 +472,7 @@
 
 		// cap of string or slice
 	case OCAP:
-		Naddr(n.Left, a, canemitcode)
+		a = Naddr(n.Left, canemitcode)
 
 		if a.Type == obj.TYPE_CONST && a.Offset == 0 {
 			break // cap(nil)
@@ -485,6 +486,7 @@
 			a.Width = int64(Widthint)
 		}
 	}
+	return
 }
 
 func newplist() *obj.Plist {
diff --git a/src/cmd/internal/gc/plive.go b/src/cmd/internal/gc/plive.go
index 5456435..ba13cdb 100644
--- a/src/cmd/internal/gc/plive.go
+++ b/src/cmd/internal/gc/plive.go
@@ -556,13 +556,11 @@
 // initialized, because any use of a variable must come after its
 // initialization.
 func progeffects(prog *obj.Prog, vars []*Node, uevar *Bvec, varkill *Bvec, avarinit *Bvec) {
-	var info ProgInfo
-
 	bvresetall(uevar)
 	bvresetall(varkill)
 	bvresetall(avarinit)
 
-	info = Thearch.Proginfo(prog)
+	info := Thearch.Proginfo(prog)
 	if prog.As == obj.ARET {
 		// Return instructions implicitly read all the arguments.  For
 		// the sake of correctness, out arguments must be read.  For the
@@ -1087,8 +1085,8 @@
 	Nodconst(&to, Types[TINT32], int64(index))
 	pcdata := unlinkedprog(obj.APCDATA)
 	pcdata.Lineno = prog.Lineno
-	Naddr(&from, &pcdata.From, 0)
-	Naddr(&to, &pcdata.To, 0)
+	pcdata.From = Naddr(&from, 0)
+	pcdata.To = Naddr(&to, 0)
 	return pcdata
 }
 
@@ -1296,7 +1294,6 @@
 	any := bvalloc(nvars)
 	all := bvalloc(nvars)
 	ambig := bvalloc(localswords() * obj.BitsPerPointer)
-	var msg []string
 	nmsg := int32(0)
 	startmsg := int32(0)
 
@@ -1392,6 +1389,7 @@
 	var fmt_ string
 	var next *obj.Prog
 	var numlive int32
+	var msg []string
 	for i := int32(0); i < int32(len(lv.cfg)); i++ {
 		bb = lv.cfg[i]
 
diff --git a/src/cmd/internal/gc/range.go b/src/cmd/internal/gc/range.go
index ed50bdf..3de70ba 100644
--- a/src/cmd/internal/gc/range.go
+++ b/src/cmd/internal/gc/range.go
@@ -136,7 +136,6 @@
 
 func walkrange(n *Node) {
 	t := n.Type
-	var init *NodeList
 
 	a := n.Right
 	lno := int(setlineno(a))
@@ -154,9 +153,8 @@
 	// to avoid erroneous processing by racewalk.
 	n.List = nil
 
-	var hv2 *Node
-
 	var body *NodeList
+	var init *NodeList
 	switch t.Etype {
 	default:
 		Fatal("walkrange")
@@ -366,6 +364,7 @@
 		init = list(init, Nod(OAS, hv1, nil))
 
 		var a *Node
+		var hv2 *Node
 		if v2 == nil {
 			a = Nod(OAS, hv1, mkcall("stringiter", Types[TINT], nil, ha, hv1))
 		} else {
diff --git a/src/cmd/internal/gc/typecheck.go b/src/cmd/internal/gc/typecheck.go
index 0ff8224..845aac6 100644
--- a/src/cmd/internal/gc/typecheck.go
+++ b/src/cmd/internal/gc/typecheck.go
@@ -276,44 +276,27 @@
 }
 
 func typecheck1(np **Node, top int) {
-	var et int
-	var aop int
-	var op int
-	var ptr int
-	var l *Node
-	var r *Node
-	var lo *Node
-	var mid *Node
-	var hi *Node
-	var ok int
-	var ntop int
-	var t *Type
-	var tp *Type
-	var missing *Type
-	var have *Type
-	var badtype *Type
-	var v Val
-	var why string
-	var x int64
-
 	n := *np
+	defer func() {
+		*np = n
+	}()
 
 	if n.Sym != nil {
 		if n.Op == ONAME && n.Etype != 0 && top&Ecall == 0 {
 			Yyerror("use of builtin %v not in function call", Sconv(n.Sym, 0))
-			goto error
+			n.Type = nil
+			return
 		}
 
 		typecheckdef(n)
 		if n.Op == ONONAME {
-			goto error
+			n.Type = nil
+			return
 		}
 	}
 
-	*np = n
-
-reswitch:
-	ok = 0
+	ok := 0
+OpSwitch:
 	switch n.Op {
 	// until typecheck is complete, do nothing.
 	default:
@@ -330,11 +313,11 @@
 		if n.Type == nil && n.Val.Ctype == CTSTR {
 			n.Type = idealstring
 		}
-		goto ret
+		break OpSwitch
 
 	case ONONAME:
 		ok |= Erv
-		goto ret
+		break OpSwitch
 
 	case ONAME:
 		if n.Decldepth == 0 {
@@ -342,14 +325,15 @@
 		}
 		if n.Etype != 0 {
 			ok |= Ecall
-			goto ret
+			break OpSwitch
 		}
 
 		if top&Easgn == 0 {
 			// not a write to the variable
 			if isblank(n) {
 				Yyerror("cannot use _ as value")
-				goto error
+				n.Type = nil
+				return
 			}
 
 			n.Used = 1
@@ -357,15 +341,17 @@
 
 		if top&Ecall == 0 && isunsafebuiltin(n) {
 			Yyerror("%v is not an expression, must be called", Nconv(n, 0))
-			goto error
+			n.Type = nil
+			return
 		}
 
 		ok |= Erv
-		goto ret
+		break OpSwitch
 
 	case OPACK:
 		Yyerror("use of package %v without selector", Sconv(n.Sym, 0))
-		goto error
+		n.Type = nil
+		return
 
 	case ODDD:
 		break
@@ -377,14 +363,15 @@
 		ok |= Etype
 
 		if n.Type == nil {
-			goto error
+			n.Type = nil
+			return
 		}
 
 	case OTARRAY:
 		ok |= Etype
-		t = typ(TARRAY)
-		l = n.Left
-		r = n.Right
+		t := typ(TARRAY)
+		l := n.Left
+		r := n.Right
 		if l == nil {
 			t.Bound = -1 // slice
 		} else if l.Op == ODDD {
@@ -395,7 +382,8 @@
 				Yyerror("use of [...] array outside of array literal")
 			}
 		} else {
-			l = typecheck(&n.Left, Erv)
+			l := typecheck(&n.Left, Erv)
+			var v Val
 			switch consttype(l) {
 			case CTINT,
 				CTRUNE:
@@ -410,22 +398,26 @@
 				} else {
 					Yyerror("invalid array bound %v", Nconv(l, 0))
 				}
-				goto error
+				n.Type = nil
+				return
 			}
 
 			t.Bound = Mpgetfix(v.U.Xval)
 			if doesoverflow(v, Types[TINT]) {
 				Yyerror("array bound is too large")
-				goto error
+				n.Type = nil
+				return
 			} else if t.Bound < 0 {
 				Yyerror("array bound must be non-negative")
-				goto error
+				n.Type = nil
+				return
 			}
 		}
 
 		typecheck(&r, Etype)
 		if r.Type == nil {
-			goto error
+			n.Type = nil
+			return
 		}
 		t.Type = r.Type
 		n.Op = OTYPE
@@ -438,10 +430,11 @@
 
 	case OTMAP:
 		ok |= Etype
-		l = typecheck(&n.Left, Etype)
-		r = typecheck(&n.Right, Etype)
+		l := typecheck(&n.Left, Etype)
+		r := typecheck(&n.Right, Etype)
 		if l.Type == nil || r.Type == nil {
-			goto error
+			n.Type = nil
+			return
 		}
 		n.Op = OTYPE
 		n.Type = maptype(l.Type, r.Type)
@@ -450,11 +443,12 @@
 
 	case OTCHAN:
 		ok |= Etype
-		l = typecheck(&n.Left, Etype)
+		l := typecheck(&n.Left, Etype)
 		if l.Type == nil {
-			goto error
+			n.Type = nil
+			return
 		}
-		t = typ(TCHAN)
+		t := typ(TCHAN)
 		t.Type = l.Type
 		t.Chan = n.Etype
 		n.Op = OTYPE
@@ -467,7 +461,8 @@
 		n.Op = OTYPE
 		n.Type = tostruct(n.List)
 		if n.Type == nil || n.Type.Broke != 0 {
-			goto error
+			n.Type = nil
+			return
 		}
 		n.List = nil
 
@@ -476,7 +471,8 @@
 		n.Op = OTYPE
 		n.Type = tointerface(n.List)
 		if n.Type == nil {
-			goto error
+			n.Type = nil
+			return
 		}
 
 	case OTFUNC:
@@ -484,61 +480,53 @@
 		n.Op = OTYPE
 		n.Type = functype(n.Left, n.List, n.Rlist)
 		if n.Type == nil {
-			goto error
+			n.Type = nil
+			return
 		}
 
 		/*
 		 * type or expr
 		 */
 	case OIND:
-		ntop = Erv | Etype
+		ntop := Erv | Etype
 
 		if top&Eaddr == 0 {
 			ntop |= Eindir
 		}
 		ntop |= top & Ecomplit
-		l = typecheck(&n.Left, ntop)
-		t = l.Type
+		l := typecheck(&n.Left, ntop)
+		t := l.Type
 		if t == nil {
-			goto error
+			n.Type = nil
+			return
 		}
 		if l.Op == OTYPE {
 			ok |= Etype
 			n.Op = OTYPE
 			n.Type = Ptrto(l.Type)
 			n.Left = nil
-			goto ret
+			break OpSwitch
 		}
 
 		if !Isptr[t.Etype] {
 			if top&(Erv|Etop) != 0 {
 				Yyerror("invalid indirect of %v", Nconv(n.Left, obj.FmtLong))
-				goto error
+				n.Type = nil
+				return
 			}
 
-			goto ret
+			break OpSwitch
 		}
 
 		ok |= Erv
 		n.Type = t.Type
-		goto ret
+		break OpSwitch
 
 		/*
 		 * arithmetic exprs
 		 */
-	case OASOP:
-		ok |= Etop
-
-		l = typecheck(&n.Left, Erv)
-		r = typecheck(&n.Right, Erv)
-		checkassign(n, n.Left)
-		if l.Type == nil || r.Type == nil {
-			goto error
-		}
-		op = int(n.Etype)
-		goto arith
-
-	case OADD,
+	case OASOP,
+		OADD,
 		OAND,
 		OANDAND,
 		OANDNOT,
@@ -557,32 +545,270 @@
 		OOROR,
 		OSUB,
 		OXOR:
-		ok |= Erv
-		l = typecheck(&n.Left, Erv|top&Eiota)
-		r = typecheck(&n.Right, Erv|top&Eiota)
-		if l.Type == nil || r.Type == nil {
-			goto error
+		var l *Node
+		var op int
+		var r *Node
+		if n.Op == OASOP {
+			ok |= Etop
+			l = typecheck(&n.Left, Erv)
+			r = typecheck(&n.Right, Erv)
+			checkassign(n, n.Left)
+			if l.Type == nil || r.Type == nil {
+				n.Type = nil
+				return
+			}
+			op = int(n.Etype)
+		} else {
+			ok |= Erv
+			l = typecheck(&n.Left, Erv|top&Eiota)
+			r = typecheck(&n.Right, Erv|top&Eiota)
+			if l.Type == nil || r.Type == nil {
+				n.Type = nil
+				return
+			}
+			op = int(n.Op)
 		}
-		op = int(n.Op)
-		goto arith
+		if op == OLSH || op == ORSH {
+			defaultlit(&r, Types[TUINT])
+			n.Right = r
+			t := r.Type
+			if !Isint[t.Etype] || Issigned[t.Etype] {
+				Yyerror("invalid operation: %v (shift count type %v, must be unsigned integer)", Nconv(n, 0), Tconv(r.Type, 0))
+				n.Type = nil
+				return
+			}
+
+			t = l.Type
+			if t != nil && t.Etype != TIDEAL && !Isint[t.Etype] {
+				Yyerror("invalid operation: %v (shift of type %v)", Nconv(n, 0), Tconv(t, 0))
+				n.Type = nil
+				return
+			}
+
+			// no defaultlit for left
+			// the outer context gives the type
+			n.Type = l.Type
+
+			break OpSwitch
+		}
+
+		// ideal mixed with non-ideal
+		defaultlit2(&l, &r, 0)
+
+		n.Left = l
+		n.Right = r
+		if l.Type == nil || r.Type == nil {
+			n.Type = nil
+			return
+		}
+		t := l.Type
+		if t.Etype == TIDEAL {
+			t = r.Type
+		}
+		et := int(t.Etype)
+		if et == TIDEAL {
+			et = TINT
+		}
+		aop := 0
+		if iscmp[n.Op] && t.Etype != TIDEAL && !Eqtype(l.Type, r.Type) {
+			// comparison is okay as long as one side is
+			// assignable to the other.  convert so they have
+			// the same type.
+			//
+			// the only conversion that isn't a no-op is concrete == interface.
+			// in that case, check comparability of the concrete type.
+			// The conversion allocates, so only do it if the concrete type is huge.
+			if r.Type.Etype != TBLANK {
+				aop = assignop(l.Type, r.Type, nil)
+				if aop != 0 {
+					if Isinter(r.Type) && !Isinter(l.Type) && algtype1(l.Type, nil) == ANOEQ {
+						Yyerror("invalid operation: %v (operator %v not defined on %s)", Nconv(n, 0), Oconv(int(op), 0), typekind(l.Type))
+						n.Type = nil
+						return
+					}
+
+					dowidth(l.Type)
+					if Isinter(r.Type) == Isinter(l.Type) || l.Type.Width >= 1<<16 {
+						l = Nod(aop, l, nil)
+						l.Type = r.Type
+						l.Typecheck = 1
+						n.Left = l
+					}
+
+					t = r.Type
+					goto converted
+				}
+			}
+
+			if l.Type.Etype != TBLANK {
+				aop = assignop(r.Type, l.Type, nil)
+				if aop != 0 {
+					if Isinter(l.Type) && !Isinter(r.Type) && algtype1(r.Type, nil) == ANOEQ {
+						Yyerror("invalid operation: %v (operator %v not defined on %s)", Nconv(n, 0), Oconv(int(op), 0), typekind(r.Type))
+						n.Type = nil
+						return
+					}
+
+					dowidth(r.Type)
+					if Isinter(r.Type) == Isinter(l.Type) || r.Type.Width >= 1<<16 {
+						r = Nod(aop, r, nil)
+						r.Type = l.Type
+						r.Typecheck = 1
+						n.Right = r
+					}
+
+					t = l.Type
+				}
+			}
+
+		converted:
+			et = int(t.Etype)
+		}
+
+		if t.Etype != TIDEAL && !Eqtype(l.Type, r.Type) {
+			defaultlit2(&l, &r, 1)
+			if n.Op == OASOP && n.Implicit != 0 {
+				Yyerror("invalid operation: %v (non-numeric type %v)", Nconv(n, 0), Tconv(l.Type, 0))
+				n.Type = nil
+				return
+			}
+
+			if Isinter(r.Type) == Isinter(l.Type) || aop == 0 {
+				Yyerror("invalid operation: %v (mismatched types %v and %v)", Nconv(n, 0), Tconv(l.Type, 0), Tconv(r.Type, 0))
+				n.Type = nil
+				return
+			}
+		}
+
+		if !okfor[op][et] {
+			Yyerror("invalid operation: %v (operator %v not defined on %s)", Nconv(n, 0), Oconv(int(op), 0), typekind(t))
+			n.Type = nil
+			return
+		}
+
+		// okfor allows any array == array, map == map, func == func.
+		// restrict to slice/map/func == nil and nil == slice/map/func.
+		if Isfixedarray(l.Type) && algtype1(l.Type, nil) == ANOEQ {
+			Yyerror("invalid operation: %v (%v cannot be compared)", Nconv(n, 0), Tconv(l.Type, 0))
+			n.Type = nil
+			return
+		}
+
+		if Isslice(l.Type) && !isnil(l) && !isnil(r) {
+			Yyerror("invalid operation: %v (slice can only be compared to nil)", Nconv(n, 0))
+			n.Type = nil
+			return
+		}
+
+		if l.Type.Etype == TMAP && !isnil(l) && !isnil(r) {
+			Yyerror("invalid operation: %v (map can only be compared to nil)", Nconv(n, 0))
+			n.Type = nil
+			return
+		}
+
+		if l.Type.Etype == TFUNC && !isnil(l) && !isnil(r) {
+			Yyerror("invalid operation: %v (func can only be compared to nil)", Nconv(n, 0))
+			n.Type = nil
+			return
+		}
+
+		var badtype *Type
+		if l.Type.Etype == TSTRUCT && algtype1(l.Type, &badtype) == ANOEQ {
+			Yyerror("invalid operation: %v (struct containing %v cannot be compared)", Nconv(n, 0), Tconv(badtype, 0))
+			n.Type = nil
+			return
+		}
+
+		t = l.Type
+		if iscmp[n.Op] {
+			evconst(n)
+			t = idealbool
+			if n.Op != OLITERAL {
+				defaultlit2(&l, &r, 1)
+				n.Left = l
+				n.Right = r
+			}
+		} else if n.Op == OANDAND || n.Op == OOROR {
+			if l.Type == r.Type {
+				t = l.Type
+			} else if l.Type == idealbool {
+				t = r.Type
+			} else if r.Type == idealbool {
+				t = l.Type
+			}
+		} else
+		// non-comparison operators on ideal bools should make them lose their ideal-ness
+		if t == idealbool {
+			t = Types[TBOOL]
+		}
+
+		if et == TSTRING {
+			if iscmp[n.Op] {
+				n.Etype = n.Op
+				n.Op = OCMPSTR
+			} else if n.Op == OADD {
+				// create OADDSTR node with list of strings in x + y + z + (w + v) + ...
+				n.Op = OADDSTR
+
+				if l.Op == OADDSTR {
+					n.List = l.List
+				} else {
+					n.List = list1(l)
+				}
+				if r.Op == OADDSTR {
+					n.List = concat(n.List, r.List)
+				} else {
+					n.List = list(n.List, r)
+				}
+				n.Left = nil
+				n.Right = nil
+			}
+		}
+
+		if et == TINTER {
+			if l.Op == OLITERAL && l.Val.Ctype == CTNIL {
+				// swap for back end
+				n.Left = r
+
+				n.Right = l
+			} else if r.Op == OLITERAL && r.Val.Ctype == CTNIL {
+			} else // leave alone for back end
+			if Isinter(r.Type) == Isinter(l.Type) {
+				n.Etype = n.Op
+				n.Op = OCMPIFACE
+			}
+		}
+
+		if (op == ODIV || op == OMOD) && Isconst(r, CTINT) {
+			if mpcmpfixc(r.Val.U.Xval, 0) == 0 {
+				Yyerror("division by zero")
+				n.Type = nil
+				return
+			}
+		}
+
+		n.Type = t
+		break OpSwitch
 
 	case OCOM,
 		OMINUS,
 		ONOT,
 		OPLUS:
 		ok |= Erv
-		l = typecheck(&n.Left, Erv|top&Eiota)
-		t = l.Type
+		l := typecheck(&n.Left, Erv|top&Eiota)
+		t := l.Type
 		if t == nil {
-			goto error
+			n.Type = nil
+			return
 		}
 		if !okfor[n.Op][t.Etype] {
 			Yyerror("invalid operation: %v %v", Oconv(int(n.Op), 0), Tconv(t, 0))
-			goto error
+			n.Type = nil
+			return
 		}
 
 		n.Type = t
-		goto ret
+		break OpSwitch
 
 		/*
 		 * exprs
@@ -592,10 +818,12 @@
 
 		typecheck(&n.Left, Erv|Eaddr)
 		if n.Left.Type == nil {
-			goto error
+			n.Type = nil
+			return
 		}
 		checklvalue(n.Left, "take the address of")
-		r = outervalue(n.Left)
+		r := outervalue(n.Left)
+		var l *Node
 		for l = n.Left; l != r; l = l.Left {
 			l.Addrtaken = 1
 			if l.Closure != nil {
@@ -612,46 +840,50 @@
 		}
 		defaultlit(&n.Left, nil)
 		l = n.Left
-		t = l.Type
+		t := l.Type
 		if t == nil {
-			goto error
+			n.Type = nil
+			return
 		}
 		n.Type = Ptrto(t)
-		goto ret
+		break OpSwitch
 
 	case OCOMPLIT:
 		ok |= Erv
 		typecheckcomplit(&n)
 		if n.Type == nil {
-			goto error
+			n.Type = nil
+			return
 		}
-		goto ret
+		break OpSwitch
 
-	case OXDOT:
-		n = adddot(n)
-		n.Op = ODOT
-		if n.Left == nil {
-			goto error
+	case OXDOT, ODOT:
+		if n.Op == OXDOT {
+			n = adddot(n)
+			n.Op = ODOT
+			if n.Left == nil {
+				n.Type = nil
+				return
+			}
 		}
-		fallthrough
 
-		// fall through
-	case ODOT:
 		typecheck(&n.Left, Erv|Etype)
 
 		defaultlit(&n.Left, nil)
 		if n.Right.Op != ONAME {
 			Yyerror("rhs of . must be a name") // impossible
-			goto error
+			n.Type = nil
+			return
 		}
 
-		t = n.Left.Type
+		t := n.Left.Type
 		if t == nil {
 			adderrorname(n)
-			goto error
+			n.Type = nil
+			return
 		}
 
-		r = n.Right
+		r := n.Right
 
 		if n.Left.Op == OTYPE {
 			if !looktypedot(n, t, 0) {
@@ -660,13 +892,15 @@
 				} else {
 					Yyerror("%v undefined (type %v has no method %v)", Nconv(n, 0), Tconv(t, 0), Sconv(n.Right.Sym, 0))
 				}
-				goto error
+				n.Type = nil
+				return
 			}
 
 			if n.Type.Etype != TFUNC || n.Type.Thistuple != 1 {
 				Yyerror("type %v has no method %v", Tconv(n.Left.Type, 0), Sconv(n.Right.Sym, obj.FmtShort))
 				n.Type = nil
-				goto error
+				n.Type = nil
+				return
 			}
 
 			n.Op = ONAME
@@ -675,13 +909,14 @@
 			n.Xoffset = 0
 			n.Class = PFUNC
 			ok = Erv
-			goto ret
+			break OpSwitch
 		}
 
 		if Isptr[t.Etype] && t.Type.Etype != TINTER {
 			t = t.Type
 			if t == nil {
-				goto error
+				n.Type = nil
+				return
 			}
 			n.Op = ODOTPTR
 			checkwidth(t)
@@ -689,7 +924,8 @@
 
 		if isblank(n.Right) {
 			Yyerror("cannot refer to blank field or method")
-			goto error
+			n.Type = nil
+			return
 		}
 
 		if !lookdot(n, t, 0) {
@@ -698,7 +934,8 @@
 			} else {
 				Yyerror("%v undefined (type %v has no field or method %v)", Nconv(n, 0), Tconv(n.Left.Type, 0), Sconv(n.Right.Sym, 0))
 			}
-			goto error
+			n.Type = nil
+			return
 		}
 
 		switch n.Op {
@@ -715,20 +952,22 @@
 			ok |= Erv
 		}
 
-		goto ret
+		break OpSwitch
 
 	case ODOTTYPE:
 		ok |= Erv
 		typecheck(&n.Left, Erv)
 		defaultlit(&n.Left, nil)
-		l = n.Left
-		t = l.Type
+		l := n.Left
+		t := l.Type
 		if t == nil {
-			goto error
+			n.Type = nil
+			return
 		}
 		if !Isinter(t) {
 			Yyerror("invalid type assertion: %v (non-interface type %v on left)", Nconv(n, 0), Tconv(t, 0))
-			goto error
+			n.Type = nil
+			return
 		}
 
 		if n.Right != nil {
@@ -736,11 +975,15 @@
 			n.Type = n.Right.Type
 			n.Right = nil
 			if n.Type == nil {
-				goto error
+				n.Type = nil
+				return
 			}
 		}
 
 		if n.Type != nil && n.Type.Etype != TINTER {
+			var have *Type
+			var missing *Type
+			var ptr int
 			if !implements(n.Type, t, &missing, &have, &ptr) {
 				if have != nil && have.Sym == missing.Sym {
 					Yyerror("impossible type assertion:\n\t%v does not implement %v (wrong type for %v method)\n"+"\t\thave %v%v\n\t\twant %v%v", Tconv(n.Type, 0), Tconv(t, 0), Sconv(missing.Sym, 0), Sconv(have.Sym, 0), Tconv(have.Type, obj.FmtShort|obj.FmtByte), Sconv(missing.Sym, 0), Tconv(missing.Type, obj.FmtShort|obj.FmtByte))
@@ -751,28 +994,31 @@
 				} else {
 					Yyerror("impossible type assertion:\n\t%v does not implement %v (missing %v method)", Tconv(n.Type, 0), Tconv(t, 0), Sconv(missing.Sym, 0))
 				}
-				goto error
+				n.Type = nil
+				return
 			}
 		}
 
-		goto ret
+		break OpSwitch
 
 	case OINDEX:
 		ok |= Erv
 		typecheck(&n.Left, Erv)
 		defaultlit(&n.Left, nil)
 		implicitstar(&n.Left)
-		l = n.Left
+		l := n.Left
 		typecheck(&n.Right, Erv)
-		r = n.Right
-		t = l.Type
+		r := n.Right
+		t := l.Type
 		if t == nil || r.Type == nil {
-			goto error
+			n.Type = nil
+			return
 		}
 		switch t.Etype {
 		default:
 			Yyerror("invalid operation: %v (type %v does not support indexing)", Nconv(n, 0), Tconv(t, 0))
-			goto error
+			n.Type = nil
+			return
 
 		case TSTRING,
 			TARRAY:
@@ -782,7 +1028,7 @@
 			} else {
 				n.Type = t.Type
 			}
-			why = "string"
+			why := "string"
 			if t.Etype == TARRAY {
 				if Isfixedarray(t) {
 					why = "array"
@@ -797,7 +1043,7 @@
 			}
 
 			if Isconst(n.Right, CTINT) {
-				x = Mpgetfix(n.Right.Val.U.Xval)
+				x := Mpgetfix(n.Right.Val.U.Xval)
 				if x < 0 {
 					Yyerror("invalid %s index %v (index must be non-negative)", why, Nconv(n.Right, 0))
 				} else if Isfixedarray(t) && t.Bound > 0 && x >= t.Bound {
@@ -819,54 +1065,61 @@
 			n.Op = OINDEXMAP
 		}
 
-		goto ret
+		break OpSwitch
 
 	case ORECV:
 		ok |= Etop | Erv
 		typecheck(&n.Left, Erv)
 		defaultlit(&n.Left, nil)
-		l = n.Left
-		t = l.Type
+		l := n.Left
+		t := l.Type
 		if t == nil {
-			goto error
+			n.Type = nil
+			return
 		}
 		if t.Etype != TCHAN {
 			Yyerror("invalid operation: %v (receive from non-chan type %v)", Nconv(n, 0), Tconv(t, 0))
-			goto error
+			n.Type = nil
+			return
 		}
 
 		if t.Chan&Crecv == 0 {
 			Yyerror("invalid operation: %v (receive from send-only type %v)", Nconv(n, 0), Tconv(t, 0))
-			goto error
+			n.Type = nil
+			return
 		}
 
 		n.Type = t.Type
-		goto ret
+		break OpSwitch
 
 	case OSEND:
 		ok |= Etop
-		l = typecheck(&n.Left, Erv)
+		l := typecheck(&n.Left, Erv)
 		typecheck(&n.Right, Erv)
 		defaultlit(&n.Left, nil)
 		l = n.Left
-		t = l.Type
+		t := l.Type
 		if t == nil {
-			goto error
+			n.Type = nil
+			return
 		}
 		if t.Etype != TCHAN {
 			Yyerror("invalid operation: %v (send to non-chan type %v)", Nconv(n, 0), Tconv(t, 0))
-			goto error
+			n.Type = nil
+			return
 		}
 
 		if t.Chan&Csend == 0 {
 			Yyerror("invalid operation: %v (send to receive-only type %v)", Nconv(n, 0), Tconv(t, 0))
-			goto error
+			n.Type = nil
+			return
 		}
 
 		defaultlit(&n.Right, t.Type)
-		r = n.Right
+		r := n.Right
 		if r.Type == nil {
-			goto error
+			n.Type = nil
+			return
 		}
 		n.Right = assignconv(r, l.Type.Type, "send")
 
@@ -874,7 +1127,7 @@
 		n.Etype = 0
 
 		n.Type = nil
-		goto ret
+		break OpSwitch
 
 	case OSLICE:
 		ok |= Erv
@@ -884,11 +1137,12 @@
 		defaultlit(&n.Left, nil)
 		indexlit(&n.Right.Left)
 		indexlit(&n.Right.Right)
-		l = n.Left
+		l := n.Left
 		if Isfixedarray(l.Type) {
 			if !islvalue(n.Left) {
 				Yyerror("invalid operation %v (slice of unaddressable value)", Nconv(n, 0))
-				goto error
+				n.Type = nil
+				return
 			}
 
 			n.Left = Nod(OADDR, n.Left, nil)
@@ -897,11 +1151,12 @@
 			l = n.Left
 		}
 
-		t = l.Type
+		t := l.Type
 		if t == nil {
-			goto error
+			n.Type = nil
+			return
 		}
-		tp = nil
+		var tp *Type
 		if Istype(t, TSTRING) {
 			n.Type = t
 			n.Op = OSLICESTR
@@ -916,21 +1171,25 @@
 			n.Type = t
 		} else {
 			Yyerror("cannot slice %v (type %v)", Nconv(l, 0), Tconv(t, 0))
-			goto error
+			n.Type = nil
+			return
 		}
 
-		lo = n.Right.Left
+		lo := n.Right.Left
 		if lo != nil && checksliceindex(l, lo, tp) < 0 {
-			goto error
+			n.Type = nil
+			return
 		}
-		hi = n.Right.Right
+		hi := n.Right.Right
 		if hi != nil && checksliceindex(l, hi, tp) < 0 {
-			goto error
+			n.Type = nil
+			return
 		}
 		if checksliceconst(lo, hi) < 0 {
-			goto error
+			n.Type = nil
+			return
 		}
-		goto ret
+		break OpSwitch
 
 	case OSLICE3:
 		ok |= Erv
@@ -942,11 +1201,12 @@
 		indexlit(&n.Right.Left)
 		indexlit(&n.Right.Right.Left)
 		indexlit(&n.Right.Right.Right)
-		l = n.Left
+		l := n.Left
 		if Isfixedarray(l.Type) {
 			if !islvalue(n.Left) {
 				Yyerror("invalid operation %v (slice of unaddressable value)", Nconv(n, 0))
-				goto error
+				n.Type = nil
+				return
 			}
 
 			n.Left = Nod(OADDR, n.Left, nil)
@@ -955,16 +1215,18 @@
 			l = n.Left
 		}
 
-		t = l.Type
+		t := l.Type
 		if t == nil {
-			goto error
+			n.Type = nil
+			return
 		}
-		tp = nil
 		if Istype(t, TSTRING) {
 			Yyerror("invalid operation %v (3-index slice of string)", Nconv(n, 0))
-			goto error
+			n.Type = nil
+			return
 		}
 
+		var tp *Type
 		if Isptr[t.Etype] && Isfixedarray(t.Type) {
 			tp = t.Type
 			n.Type = typ(TARRAY)
@@ -976,40 +1238,46 @@
 			n.Type = t
 		} else {
 			Yyerror("cannot slice %v (type %v)", Nconv(l, 0), Tconv(t, 0))
-			goto error
+			n.Type = nil
+			return
 		}
 
-		lo = n.Right.Left
+		lo := n.Right.Left
 		if lo != nil && checksliceindex(l, lo, tp) < 0 {
-			goto error
+			n.Type = nil
+			return
 		}
-		mid = n.Right.Right.Left
+		mid := n.Right.Right.Left
 		if mid != nil && checksliceindex(l, mid, tp) < 0 {
-			goto error
+			n.Type = nil
+			return
 		}
-		hi = n.Right.Right.Right
+		hi := n.Right.Right.Right
 		if hi != nil && checksliceindex(l, hi, tp) < 0 {
-			goto error
+			n.Type = nil
+			return
 		}
 		if checksliceconst(lo, hi) < 0 || checksliceconst(lo, mid) < 0 || checksliceconst(mid, hi) < 0 {
-			goto error
+			n.Type = nil
+			return
 		}
-		goto ret
+		break OpSwitch
 
 		/*
 		 * call and call like
 		 */
 	case OCALL:
-		l = n.Left
+		l := n.Left
 
 		if l.Op == ONAME {
-			r = unsafenmagic(n)
+			r := unsafenmagic(n)
 			if r != nil {
 				if n.Isddd != 0 {
 					Yyerror("invalid use of ... with builtin %v", Nconv(l, 0))
 				}
 				n = r
-				goto reswitch
+				typecheck1(&n, top)
+				return
 			}
 		}
 
@@ -1026,11 +1294,12 @@
 
 			n.Left = n.Right
 			n.Right = nil
-			goto reswitch
+			typecheck1(&n, top)
+			return
 		}
 
 		defaultlit(&n.Left, nil)
-		l := n.Left
+		l = n.Left
 		if l.Op == OTYPE {
 			if n.Isddd != 0 || l.Type.Bound == -100 {
 				if l.Type.Broke == 0 {
@@ -1048,9 +1317,11 @@
 			n.Op = OCONV
 			n.Type = l.Type
 			if onearg(n, "conversion to %v", Tconv(l.Type, 0)) < 0 {
-				goto error
+				n.Type = nil
+				return
 			}
-			goto doconv
+			typecheck1(&n, top)
+			return
 		}
 
 		if count(n.List) == 1 && n.Isddd == 0 {
@@ -1060,7 +1331,8 @@
 		}
 		t := l.Type
 		if t == nil {
-			goto error
+			n.Type = nil
+			return
 		}
 		checkwidth(t)
 
@@ -1085,7 +1357,8 @@
 			n.Op = OCALLFUNC
 			if t.Etype != TFUNC {
 				Yyerror("cannot call non-function %v (type %v)", Nconv(l, 0), Tconv(t, 0))
-				goto error
+				n.Type = nil
+				return
 			}
 		}
 
@@ -1094,29 +1367,30 @@
 		typecheckaste(OCALL, n.Left, int(n.Isddd), getinargx(t), n.List, desc)
 		ok |= Etop
 		if t.Outtuple == 0 {
-			goto ret
+			break OpSwitch
 		}
 		ok |= Erv
 		if t.Outtuple == 1 {
 			t := getoutargx(l.Type).Type
 			if t == nil {
-				goto error
+				n.Type = nil
+				return
 			}
 			if t.Etype == TFIELD {
 				t = t.Type
 			}
 			n.Type = t
-			goto ret
+			break OpSwitch
 		}
 
 		// multiple return
 		if top&(Efnstruct|Etop) == 0 {
 			Yyerror("multiple-value %v() in single-value context", Nconv(l, 0))
-			goto ret
+			break OpSwitch
 		}
 
 		n.Type = getoutargx(l.Type)
-		goto ret
+		break OpSwitch
 
 	case OCAP,
 		OLEN,
@@ -1124,7 +1398,8 @@
 		OIMAG:
 		ok |= Erv
 		if onearg(n, "%v", Oconv(int(n.Op), 0)) < 0 {
-			goto error
+			n.Type = nil
+			return
 		}
 		typecheck(&n.Left, Erv)
 		defaultlit(&n.Left, nil)
@@ -1132,7 +1407,8 @@
 		l := n.Left
 		t := l.Type
 		if t == nil {
-			goto error
+			n.Type = nil
+			return
 		}
 		switch n.Op {
 		case OCAP:
@@ -1161,7 +1437,7 @@
 			}
 
 			n.Type = Types[cplxsubtype(int(t.Etype))]
-			goto ret
+			break OpSwitch
 		}
 
 		// might be constant
@@ -1188,7 +1464,12 @@
 		}
 
 		n.Type = Types[TINT]
-		goto ret
+		break OpSwitch
+
+	badcall1:
+		Yyerror("invalid argument %v for %v", Nconv(n.Left, obj.FmtLong), Oconv(int(n.Op), 0))
+		n.Type = nil
+		return
 
 	case OCOMPLEX:
 		ok |= Erv
@@ -1198,13 +1479,15 @@
 			typechecklist(n.List, Efnstruct)
 			if n.List.N.Op != OCALLFUNC && n.List.N.Op != OCALLMETH {
 				Yyerror("invalid operation: complex expects two arguments")
-				goto error
+				n.Type = nil
+				return
 			}
 
 			t := n.List.N.Left.Type
 			if t.Outtuple != 2 {
 				Yyerror("invalid operation: complex expects two arguments, %v returns %d results", Nconv(n.List.N, 0), t.Outtuple)
-				goto error
+				n.Type = nil
+				return
 			}
 
 			t = n.List.N.Type.Type
@@ -1212,16 +1495,19 @@
 			r = t.Down.Nname
 		} else {
 			if twoarg(n) < 0 {
-				goto error
+				n.Type = nil
+				return
 			}
 			l = typecheck(&n.Left, Erv|top&Eiota)
 			r = typecheck(&n.Right, Erv|top&Eiota)
 			if l.Type == nil || r.Type == nil {
-				goto error
+				n.Type = nil
+				return
 			}
 			defaultlit2(&l, &r, 0)
 			if l.Type == nil || r.Type == nil {
-				goto error
+				n.Type = nil
+				return
 			}
 			n.Left = l
 			n.Right = r
@@ -1229,14 +1515,16 @@
 
 		if !Eqtype(l.Type, r.Type) {
 			Yyerror("invalid operation: %v (mismatched types %v and %v)", Nconv(n, 0), Tconv(l.Type, 0), Tconv(r.Type, 0))
-			goto error
+			n.Type = nil
+			return
 		}
 
 		var t *Type
 		switch l.Type.Etype {
 		default:
 			Yyerror("invalid operation: %v (arguments have type %v, expected floating-point)", Nconv(n, 0), Tconv(l.Type, 0), r.Type)
-			goto error
+			n.Type = nil
+			return
 
 		case TIDEAL:
 			t = Types[TIDEAL]
@@ -1257,47 +1545,54 @@
 		}
 
 		n.Type = t
-		goto ret
+		break OpSwitch
 
 	case OCLOSE:
 		if onearg(n, "%v", Oconv(int(n.Op), 0)) < 0 {
-			goto error
+			n.Type = nil
+			return
 		}
 		typecheck(&n.Left, Erv)
 		defaultlit(&n.Left, nil)
 		l := n.Left
 		t := l.Type
 		if t == nil {
-			goto error
+			n.Type = nil
+			return
 		}
 		if t.Etype != TCHAN {
 			Yyerror("invalid operation: %v (non-chan type %v)", Nconv(n, 0), Tconv(t, 0))
-			goto error
+			n.Type = nil
+			return
 		}
 
 		if t.Chan&Csend == 0 {
 			Yyerror("invalid operation: %v (cannot close receive-only channel)", Nconv(n, 0))
-			goto error
+			n.Type = nil
+			return
 		}
 
 		ok |= Etop
-		goto ret
+		break OpSwitch
 
 	case ODELETE:
 		args := n.List
 		if args == nil {
 			Yyerror("missing arguments to delete")
-			goto error
+			n.Type = nil
+			return
 		}
 
 		if args.Next == nil {
 			Yyerror("missing second (key) argument to delete")
-			goto error
+			n.Type = nil
+			return
 		}
 
 		if args.Next.Next != nil {
 			Yyerror("too many arguments to delete")
-			goto error
+			n.Type = nil
+			return
 		}
 
 		ok |= Etop
@@ -1306,18 +1601,20 @@
 		r := args.Next.N
 		if l.Type != nil && l.Type.Etype != TMAP {
 			Yyerror("first argument to delete must be map; have %v", Tconv(l.Type, obj.FmtLong))
-			goto error
+			n.Type = nil
+			return
 		}
 
 		args.Next.N = assignconv(r, l.Type.Down, "delete")
-		goto ret
+		break OpSwitch
 
 	case OAPPEND:
 		ok |= Erv
 		args := n.List
 		if args == nil {
 			Yyerror("missing arguments to append")
-			goto error
+			n.Type = nil
+			return
 		}
 
 		if count(args) == 1 && n.Isddd == 0 {
@@ -1328,7 +1625,8 @@
 
 		t := args.N.Type
 		if t == nil {
-			goto error
+			n.Type = nil
+			return
 		}
 
 		// Unpack multiple-return result before type-checking.
@@ -1343,31 +1641,35 @@
 		if !Isslice(t) {
 			if Isconst(args.N, CTNIL) {
 				Yyerror("first argument to append must be typed slice; have untyped nil", t)
-				goto error
+				n.Type = nil
+				return
 			}
 
 			Yyerror("first argument to append must be slice; have %v", Tconv(t, obj.FmtLong))
-			goto error
+			n.Type = nil
+			return
 		}
 
 		if n.Isddd != 0 {
 			if args.Next == nil {
 				Yyerror("cannot use ... on first argument to append")
-				goto error
+				n.Type = nil
+				return
 			}
 
 			if args.Next.Next != nil {
 				Yyerror("too many arguments to append")
-				goto error
+				n.Type = nil
+				return
 			}
 
 			if Istype(t.Type, TUINT8) && Istype(args.Next.N.Type, TSTRING) {
 				defaultlit(&args.Next.N, Types[TSTRING])
-				goto ret
+				break OpSwitch
 			}
 
 			args.Next.N = assignconv(args.Next.N, t.Orig, "append")
-			goto ret
+			break OpSwitch
 		}
 
 		for args = args.Next; args != nil; args = args.Next {
@@ -1377,19 +1679,21 @@
 			args.N = assignconv(args.N, t.Type, "append")
 		}
 
-		goto ret
+		break OpSwitch
 
 	case OCOPY:
 		ok |= Etop | Erv
 		args := n.List
 		if args == nil || args.Next == nil {
 			Yyerror("missing arguments to copy")
-			goto error
+			n.Type = nil
+			return
 		}
 
 		if args.Next.Next != nil {
 			Yyerror("too many arguments to copy")
-			goto error
+			n.Type = nil
+			return
 		}
 
 		n.Left = args.N
@@ -1399,21 +1703,24 @@
 		typecheck(&n.Left, Erv)
 		typecheck(&n.Right, Erv)
 		if n.Left.Type == nil || n.Right.Type == nil {
-			goto error
+			n.Type = nil
+			return
 		}
 		defaultlit(&n.Left, nil)
 		defaultlit(&n.Right, nil)
 		if n.Left.Type == nil || n.Right.Type == nil {
-			goto error
+			n.Type = nil
+			return
 		}
 
 		// copy([]byte, string)
 		if Isslice(n.Left.Type) && n.Right.Type.Etype == TSTRING {
 			if Eqtype(n.Left.Type.Type, bytetype) {
-				goto ret
+				break OpSwitch
 			}
 			Yyerror("arguments to copy have different element types: %v and string", Tconv(n.Left.Type, obj.FmtLong))
-			goto error
+			n.Type = nil
+			return
 		}
 
 		if !Isslice(n.Left.Type) || !Isslice(n.Right.Type) {
@@ -1424,25 +1731,73 @@
 			} else {
 				Yyerror("second argument to copy should be slice or string; have %v", Tconv(n.Right.Type, obj.FmtLong))
 			}
-			goto error
+			n.Type = nil
+			return
 		}
 
 		if !Eqtype(n.Left.Type.Type, n.Right.Type.Type) {
 			Yyerror("arguments to copy have different element types: %v and %v", Tconv(n.Left.Type, obj.FmtLong), Tconv(n.Right.Type, obj.FmtLong))
-			goto error
+			n.Type = nil
+			return
 		}
 
-		goto ret
+		break OpSwitch
 
 	case OCONV:
-		goto doconv
+		{
+			ok |= Erv
+			saveorignode(n)
+			typecheck(&n.Left, Erv|top&(Eindir|Eiota))
+			convlit1(&n.Left, n.Type, true)
+			t := n.Left.Type
+			if t == nil || n.Type == nil {
+				n.Type = nil
+				return
+			}
+			var why string
+			n.Op = uint8(convertop(t, n.Type, &why))
+			if (n.Op) == 0 {
+				if n.Diag == 0 && n.Type.Broke == 0 {
+					Yyerror("cannot convert %v to type %v%s", Nconv(n.Left, obj.FmtLong), Tconv(n.Type, 0), why)
+					n.Diag = 1
+				}
+
+				n.Op = OCONV
+			}
+
+			switch n.Op {
+			case OCONVNOP:
+				if n.Left.Op == OLITERAL && n.Type != Types[TBOOL] {
+					r := Nod(OXXX, nil, nil)
+					n.Op = OCONV
+					n.Orig = r
+					*r = *n
+					n.Op = OLITERAL
+					n.Val = n.Left.Val
+				}
+
+				// do not use stringtoarraylit.
+			// generated code and compiler memory footprint is better without it.
+			case OSTRARRAYBYTE:
+				break
+
+			case OSTRARRAYRUNE:
+				if n.Left.Op == OLITERAL {
+					stringtoarraylit(&n)
+				}
+			}
+
+			break OpSwitch
+		}
+		break OpSwitch
 
 	case OMAKE:
 		ok |= Erv
 		args := n.List
 		if args == nil {
 			Yyerror("missing argument to make")
-			goto error
+			n.Type = nil
+			return
 		}
 
 		n.List = nil
@@ -1451,23 +1806,27 @@
 		typecheck(&l, Etype)
 		t := l.Type
 		if t == nil {
-			goto error
+			n.Type = nil
+			return
 		}
 
 		switch t.Etype {
 		default:
 			Yyerror("cannot make type %v", Tconv(t, 0))
-			goto error
+			n.Type = nil
+			return
 
 		case TARRAY:
 			if !Isslice(t) {
 				Yyerror("cannot make type %v", Tconv(t, 0))
-				goto error
+				n.Type = nil
+				return
 			}
 
 			if args == nil {
 				Yyerror("missing len argument to make(%v)", Tconv(t, 0))
-				goto error
+				n.Type = nil
+				return
 			}
 
 			l = args.N
@@ -1481,16 +1840,19 @@
 			}
 
 			if l.Type == nil || (r != nil && r.Type == nil) {
-				goto error
+				n.Type = nil
+				return
 			}
 			et := bool2int(checkmake(t, "len", l) < 0)
 			et |= bool2int(r != nil && checkmake(t, "cap", r) < 0)
 			if et != 0 {
-				goto error
+				n.Type = nil
+				return
 			}
 			if Isconst(l, CTINT) && r != nil && Isconst(r, CTINT) && Mpcmpfixfix(l.Val.U.Xval, r.Val.U.Xval) > 0 {
 				Yyerror("len larger than cap in make(%v)", Tconv(t, 0))
-				goto error
+				n.Type = nil
+				return
 			}
 
 			n.Left = l
@@ -1504,10 +1866,12 @@
 				typecheck(&l, Erv)
 				defaultlit(&l, Types[TINT])
 				if l.Type == nil {
-					goto error
+					n.Type = nil
+					return
 				}
 				if checkmake(t, "size", l) < 0 {
-					goto error
+					n.Type = nil
+					return
 				}
 				n.Left = l
 			} else {
@@ -1523,10 +1887,12 @@
 				typecheck(&l, Erv)
 				defaultlit(&l, Types[TINT])
 				if l.Type == nil {
-					goto error
+					n.Type = nil
+					return
 				}
 				if checkmake(t, "buffer", l) < 0 {
-					goto error
+					n.Type = nil
+					return
 				}
 				n.Left = l
 			} else {
@@ -1538,34 +1904,38 @@
 		if args != nil {
 			Yyerror("too many arguments to make(%v)", Tconv(t, 0))
 			n.Op = OMAKE
-			goto error
+			n.Type = nil
+			return
 		}
 
 		n.Type = t
-		goto ret
+		break OpSwitch
 
 	case ONEW:
 		ok |= Erv
 		args := n.List
 		if args == nil {
 			Yyerror("missing argument to new")
-			goto error
+			n.Type = nil
+			return
 		}
 
 		l := args.N
 		typecheck(&l, Etype)
 		t := l.Type
 		if t == nil {
-			goto error
+			n.Type = nil
+			return
 		}
 		if args.Next != nil {
 			Yyerror("too many arguments to new(%v)", Tconv(t, 0))
-			goto error
+			n.Type = nil
+			return
 		}
 
 		n.Left = l
 		n.Type = Ptrto(t)
-		goto ret
+		break OpSwitch
 
 	case OPRINT,
 		OPRINTN:
@@ -1580,57 +1950,63 @@
 			}
 		}
 
-		goto ret
+		break OpSwitch
 
 	case OPANIC:
 		ok |= Etop
 		if onearg(n, "panic") < 0 {
-			goto error
+			n.Type = nil
+			return
 		}
 		typecheck(&n.Left, Erv)
 		defaultlit(&n.Left, Types[TINTER])
 		if n.Left.Type == nil {
-			goto error
+			n.Type = nil
+			return
 		}
-		goto ret
+		break OpSwitch
 
 	case ORECOVER:
 		ok |= Erv | Etop
 		if n.List != nil {
 			Yyerror("too many arguments to recover")
-			goto error
+			n.Type = nil
+			return
 		}
 
 		n.Type = Types[TINTER]
-		goto ret
+		break OpSwitch
 
 	case OCLOSURE:
 		ok |= Erv
 		typecheckclosure(n, top)
 		if n.Type == nil {
-			goto error
+			n.Type = nil
+			return
 		}
-		goto ret
+		break OpSwitch
 
 	case OITAB:
 		ok |= Erv
 		typecheck(&n.Left, Erv)
 		t := n.Left.Type
 		if t == nil {
-			goto error
+			n.Type = nil
+			return
 		}
 		if t.Etype != TINTER {
 			Fatal("OITAB of %v", Tconv(t, 0))
 		}
 		n.Type = Ptrto(Types[TUINTPTR])
-		goto ret
+		break OpSwitch
 
 	case OSPTR:
 		ok |= Erv
 		typecheck(&n.Left, Erv)
 		t := n.Left.Type
 		if t == nil {
-			goto error
+			n.Type = nil
+			return
 		}
 		if !Isslice(t) && t.Etype != TSTRING {
 			Fatal("OSPTR of %v", Tconv(t, 0))
@@ -1640,22 +2016,22 @@
 		} else {
 			n.Type = Ptrto(t.Type)
 		}
-		goto ret
+		break OpSwitch
 
 	case OCLOSUREVAR:
 		ok |= Erv
-		goto ret
+		break OpSwitch
 
 	case OCFUNC:
 		ok |= Erv
 		typecheck(&n.Left, Erv)
 		n.Type = Types[TUINTPTR]
-		goto ret
+		break OpSwitch
 
 	case OCONVNOP:
 		ok |= Erv
 		typecheck(&n.Left, Erv)
-		goto ret
+		break OpSwitch
 
 		/*
 		 * statements
@@ -1669,12 +2045,12 @@
 		if n.Left.Op == ONAME && strings.HasPrefix(n.Left.Sym.Name, "autotmp_") {
 			n.Left.Defn = n
 		}
-		goto ret
+		break OpSwitch
 
 	case OAS2:
 		ok |= Etop
 		typecheckas2(n)
-		goto ret
+		break OpSwitch
 
 	case OBREAK,
 		OCONTINUE,
@@ -1684,12 +2060,12 @@
 		OXFALL,
 		OVARKILL:
 		ok |= Etop
-		goto ret
+		break OpSwitch
 
 	case OLABEL:
 		ok |= Etop
 		decldepth++
-		goto ret
+		break OpSwitch
 
 	case ODEFER:
 		ok |= Etop
@@ -1697,13 +2073,13 @@
 		if n.Left.Diag == 0 {
 			checkdefergo(n)
 		}
-		goto ret
+		break OpSwitch
 
 	case OPROC:
 		ok |= Etop
 		typecheck(&n.Left, Etop|Eproc|Erv)
 		checkdefergo(n)
-		goto ret
+		break OpSwitch
 
 	case OFOR:
 		ok |= Etop
@@ -1719,7 +2095,7 @@
 		typecheck(&n.Nincr, Etop)
 		typechecklist(n.Nbody, Etop)
 		decldepth--
-		goto ret
+		break OpSwitch
 
 	case OIF:
 		ok |= Etop
@@ -1733,7 +2109,7 @@
 		}
 		typechecklist(n.Nbody, Etop)
 		typechecklist(n.Nelse, Etop)
-		goto ret
+		break OpSwitch
 
 	case ORETURN:
 		ok |= Etop
@@ -1744,53 +2120,55 @@
 		}
 		if Curfn == nil {
 			Yyerror("return outside function")
-			goto error
+			n.Type = nil
+			return
 		}
 
 		if Curfn.Type.Outnamed != 0 && n.List == nil {
-			goto ret
+			break OpSwitch
 		}
 		typecheckaste(ORETURN, nil, 0, getoutargx(Curfn.Type), n.List, "return argument")
-		goto ret
+		break OpSwitch
 
 	case ORETJMP:
 		ok |= Etop
-		goto ret
+		break OpSwitch
 
 	case OSELECT:
 		ok |= Etop
 		typecheckselect(n)
-		goto ret
+		break OpSwitch
 
 	case OSWITCH:
 		ok |= Etop
 		typecheckswitch(n)
-		goto ret
+		break OpSwitch
 
 	case ORANGE:
 		ok |= Etop
 		typecheckrange(n)
-		goto ret
+		break OpSwitch
 
 	case OTYPESW:
 		Yyerror("use of .(type) outside type switch")
-		goto error
+		n.Type = nil
+		return
 
 	case OXCASE:
 		ok |= Etop
 		typechecklist(n.List, Erv)
 		typechecklist(n.Nbody, Etop)
-		goto ret
+		break OpSwitch
 
 	case ODCLFUNC:
 		ok |= Etop
 		typecheckfunc(n)
-		goto ret
+		break OpSwitch
 
 	case ODCLCONST:
 		ok |= Etop
 		typecheck(&n.Left, Erv)
-		goto ret
+		break OpSwitch
 
 	case ODCLTYPE:
 		ok |= Etop
@@ -1798,264 +2176,10 @@
 		if incannedimport == 0 {
 			checkwidth(n.Left.Type)
 		}
-		goto ret
+		break OpSwitch
 	}
 
-	goto ret
-
-arith:
-	if op == OLSH || op == ORSH {
-		defaultlit(&r, Types[TUINT])
-		n.Right = r
-		t := r.Type
-		if !Isint[t.Etype] || Issigned[t.Etype] {
-			Yyerror("invalid operation: %v (shift count type %v, must be unsigned integer)", Nconv(n, 0), Tconv(r.Type, 0))
-			goto error
-		}
-
-		t = l.Type
-		if t != nil && t.Etype != TIDEAL && !Isint[t.Etype] {
-			Yyerror("invalid operation: %v (shift of type %v)", Nconv(n, 0), Tconv(t, 0))
-			goto error
-		}
-
-		// no defaultlit for left
-		// the outer context gives the type
-		n.Type = l.Type
-
-		goto ret
-	}
-
-	// ideal mixed with non-ideal
-	defaultlit2(&l, &r, 0)
-
-	n.Left = l
-	n.Right = r
-	if l.Type == nil || r.Type == nil {
-		goto error
-	}
-	t = l.Type
-	if t.Etype == TIDEAL {
-		t = r.Type
-	}
-	et = int(t.Etype)
-	if et == TIDEAL {
-		et = TINT
-	}
-	aop = 0
-	if iscmp[n.Op] && t.Etype != TIDEAL && !Eqtype(l.Type, r.Type) {
-		// comparison is okay as long as one side is
-		// assignable to the other.  convert so they have
-		// the same type.
-		//
-		// the only conversion that isn't a no-op is concrete == interface.
-		// in that case, check comparability of the concrete type.
-		// The conversion allocates, so only do it if the concrete type is huge.
-		if r.Type.Etype != TBLANK {
-			aop = assignop(l.Type, r.Type, nil)
-			if aop != 0 {
-				if Isinter(r.Type) && !Isinter(l.Type) && algtype1(l.Type, nil) == ANOEQ {
-					Yyerror("invalid operation: %v (operator %v not defined on %s)", Nconv(n, 0), Oconv(int(op), 0), typekind(l.Type))
-					goto error
-				}
-
-				dowidth(l.Type)
-				if Isinter(r.Type) == Isinter(l.Type) || l.Type.Width >= 1<<16 {
-					l = Nod(aop, l, nil)
-					l.Type = r.Type
-					l.Typecheck = 1
-					n.Left = l
-				}
-
-				t = r.Type
-				goto converted
-			}
-		}
-
-		if l.Type.Etype != TBLANK {
-			aop = assignop(r.Type, l.Type, nil)
-			if aop != 0 {
-				if Isinter(l.Type) && !Isinter(r.Type) && algtype1(r.Type, nil) == ANOEQ {
-					Yyerror("invalid operation: %v (operator %v not defined on %s)", Nconv(n, 0), Oconv(int(op), 0), typekind(r.Type))
-					goto error
-				}
-
-				dowidth(r.Type)
-				if Isinter(r.Type) == Isinter(l.Type) || r.Type.Width >= 1<<16 {
-					r = Nod(aop, r, nil)
-					r.Type = l.Type
-					r.Typecheck = 1
-					n.Right = r
-				}
-
-				t = l.Type
-			}
-		}
-
-	converted:
-		et = int(t.Etype)
-	}
-
-	if t.Etype != TIDEAL && !Eqtype(l.Type, r.Type) {
-		defaultlit2(&l, &r, 1)
-		if n.Op == OASOP && n.Implicit != 0 {
-			Yyerror("invalid operation: %v (non-numeric type %v)", Nconv(n, 0), Tconv(l.Type, 0))
-			goto error
-		}
-
-		if Isinter(r.Type) == Isinter(l.Type) || aop == 0 {
-			Yyerror("invalid operation: %v (mismatched types %v and %v)", Nconv(n, 0), Tconv(l.Type, 0), Tconv(r.Type, 0))
-			goto error
-		}
-	}
-
-	if !okfor[op][et] {
-		Yyerror("invalid operation: %v (operator %v not defined on %s)", Nconv(n, 0), Oconv(int(op), 0), typekind(t))
-		goto error
-	}
-
-	// okfor allows any array == array, map == map, func == func.
-	// restrict to slice/map/func == nil and nil == slice/map/func.
-	if Isfixedarray(l.Type) && algtype1(l.Type, nil) == ANOEQ {
-		Yyerror("invalid operation: %v (%v cannot be compared)", Nconv(n, 0), Tconv(l.Type, 0))
-		goto error
-	}
-
-	if Isslice(l.Type) && !isnil(l) && !isnil(r) {
-		Yyerror("invalid operation: %v (slice can only be compared to nil)", Nconv(n, 0))
-		goto error
-	}
-
-	if l.Type.Etype == TMAP && !isnil(l) && !isnil(r) {
-		Yyerror("invalid operation: %v (map can only be compared to nil)", Nconv(n, 0))
-		goto error
-	}
-
-	if l.Type.Etype == TFUNC && !isnil(l) && !isnil(r) {
-		Yyerror("invalid operation: %v (func can only be compared to nil)", Nconv(n, 0))
-		goto error
-	}
-
-	if l.Type.Etype == TSTRUCT && algtype1(l.Type, &badtype) == ANOEQ {
-		Yyerror("invalid operation: %v (struct containing %v cannot be compared)", Nconv(n, 0), Tconv(badtype, 0))
-		goto error
-	}
-
-	t = l.Type
-	if iscmp[n.Op] {
-		evconst(n)
-		t = idealbool
-		if n.Op != OLITERAL {
-			defaultlit2(&l, &r, 1)
-			n.Left = l
-			n.Right = r
-		}
-	} else if n.Op == OANDAND || n.Op == OOROR {
-		if l.Type == r.Type {
-			t = l.Type
-		} else if l.Type == idealbool {
-			t = r.Type
-		} else if r.Type == idealbool {
-			t = l.Type
-		}
-	} else
-	// non-comparison operators on ideal bools should make them lose their ideal-ness
-	if t == idealbool {
-		t = Types[TBOOL]
-	}
-
-	if et == TSTRING {
-		if iscmp[n.Op] {
-			n.Etype = n.Op
-			n.Op = OCMPSTR
-		} else if n.Op == OADD {
-			// create OADDSTR node with list of strings in x + y + z + (w + v) + ...
-			n.Op = OADDSTR
-
-			if l.Op == OADDSTR {
-				n.List = l.List
-			} else {
-				n.List = list1(l)
-			}
-			if r.Op == OADDSTR {
-				n.List = concat(n.List, r.List)
-			} else {
-				n.List = list(n.List, r)
-			}
-			n.Left = nil
-			n.Right = nil
-		}
-	}
-
-	if et == TINTER {
-		if l.Op == OLITERAL && l.Val.Ctype == CTNIL {
-			// swap for back end
-			n.Left = r
-
-			n.Right = l
-		} else if r.Op == OLITERAL && r.Val.Ctype == CTNIL {
-		} else // leave alone for back end
-		if Isinter(r.Type) == Isinter(l.Type) {
-			n.Etype = n.Op
-			n.Op = OCMPIFACE
-		}
-	}
-
-	if (op == ODIV || op == OMOD) && Isconst(r, CTINT) {
-		if mpcmpfixc(r.Val.U.Xval, 0) == 0 {
-			Yyerror("division by zero")
-			goto error
-		}
-	}
-
-	n.Type = t
-	goto ret
-
-doconv:
-	ok |= Erv
-	saveorignode(n)
-	typecheck(&n.Left, Erv|top&(Eindir|Eiota))
-	convlit1(&n.Left, n.Type, true)
-	t = n.Left.Type
-	if t == nil || n.Type == nil {
-		goto error
-	}
-	n.Op = uint8(convertop(t, n.Type, &why))
-	if (n.Op) == 0 {
-		if n.Diag == 0 && n.Type.Broke == 0 {
-			Yyerror("cannot convert %v to type %v%s", Nconv(n.Left, obj.FmtLong), Tconv(n.Type, 0), why)
-			n.Diag = 1
-		}
-
-		n.Op = OCONV
-	}
-
-	switch n.Op {
-	case OCONVNOP:
-		if n.Left.Op == OLITERAL && n.Type != Types[TBOOL] {
-			r := Nod(OXXX, nil, nil)
-			n.Op = OCONV
-			n.Orig = r
-			*r = *n
-			n.Op = OLITERAL
-			n.Val = n.Left.Val
-		}
-
-		// do not use stringtoarraylit.
-	// generated code and compiler memory footprint is better without it.
-	case OSTRARRAYBYTE:
-		break
-
-	case OSTRARRAYRUNE:
-		if n.Left.Op == OLITERAL {
-			stringtoarraylit(&n)
-		}
-	}
-
-	goto ret
-
-ret:
-	t = n.Type
+	t := n.Type
 	if t != nil && t.Funarg == 0 && n.Op != OTYPE {
 		switch t.Etype {
 		case TFUNC, // might have TANY; wait until its called
@@ -2078,18 +2202,21 @@
 	evconst(n)
 	if n.Op == OTYPE && top&Etype == 0 {
 		Yyerror("type %v is not an expression", Tconv(n.Type, 0))
-		goto error
+		n.Type = nil
+		return
 	}
 
 	if top&(Erv|Etype) == Etype && n.Op != OTYPE {
 		Yyerror("%v is not a type", Nconv(n, 0))
-		goto error
+		n.Type = nil
+		return
 	}
 
 	// TODO(rsc): simplify
 	if (top&(Ecall|Erv|Etype) != 0) && top&Etop == 0 && ok&(Erv|Etype|Ecall) == 0 {
 		Yyerror("%v used as value", Nconv(n, 0))
-		goto error
+		n.Type = nil
+		return
 	}
 
 	if (top&Etop != 0) && top&(Ecall|Erv|Etype) == 0 && ok&Etop == 0 {
@@ -2098,24 +2225,14 @@
 			n.Diag = 1
 		}
 
-		goto error
+		n.Type = nil
+		return
 	}
 
 	/* TODO
 	if(n->type == T)
 		fatal("typecheck nil type");
 	*/
-	goto out
-
-badcall1:
-	Yyerror("invalid argument %v for %v", Nconv(n.Left, obj.FmtLong), Oconv(int(n.Op), 0))
-	goto error
-
-error:
-	n.Type = nil
-
-out:
-	*np = n
 }
 
 func checksliceindex(l *Node, r *Node, tp *Type) int {
@@ -2840,35 +2957,35 @@
 }
 
 func typecheckcomplit(np **Node) {
-	var nerr int
-	var l *Node
-	var norig *Node
-	var r *Node
-	var t *Type
-
 	n := *np
 	lno := lineno
+	defer func() {
+		lineno = lno
+		*np = n
+	}()
 
 	if n.Right == nil {
 		if n.List != nil {
 			setlineno(n.List.N)
 		}
 		Yyerror("missing type in composite literal")
-		goto error
+		n.Type = nil
+		return
 	}
 
 	// Save original node (including n->right)
-	norig = Nod(int(n.Op), nil, nil)
+	norig := Nod(int(n.Op), nil, nil)
 
 	*norig = *n
 
 	setlineno(n.Right)
-	l = typecheck(&n.Right, Etype|Ecomplit) /* sic */
-	t = l.Type
+	l := typecheck(&n.Right, Etype|Ecomplit) /* sic */
+	t := l.Type
 	if t == nil {
-		goto error
+		n.Type = nil
+		return
 	}
-	nerr = nerrors
+	nerr := nerrors
 	n.Type = t
 
 	if Isptr[t.Etype] {
@@ -2876,18 +2993,21 @@
 		// except when using the &T syntax, which sets implicit on the OIND.
 		if n.Right.Implicit == 0 {
 			Yyerror("invalid pointer type %v for composite literal (use &%v instead)", Tconv(t, 0), Tconv(t.Type, 0))
-			goto error
+			n.Type = nil
+			return
 		}
 
 		// Also, the underlying type must be a struct, map, slice, or array.
 		if !iscomptype(t) {
 			Yyerror("invalid pointer type %v for composite literal", Tconv(t, 0))
-			goto error
+			n.Type = nil
+			return
 		}
 
 		t = t.Type
 	}
 
+	var r *Node
 	switch t.Etype {
 	default:
 		Yyerror("invalid type for composite literal: %v", Tconv(t, 0))
@@ -3075,7 +3195,8 @@
 	}
 
 	if nerr != nerrors {
-		goto error
+		n.Type = nil
+		return
 	}
 
 	n.Orig = norig
@@ -3088,14 +3209,7 @@
 	}
 
 	n.Orig = norig
-	*np = n
-	lineno = lno
 	return
-
-error:
-	n.Type = nil
-	*np = n
-	lineno = lno
 }
 
 /*
diff --git a/src/cmd/internal/gc/walk.go b/src/cmd/internal/gc/walk.go
index ed46809..0992c18 100644
--- a/src/cmd/internal/gc/walk.go
+++ b/src/cmd/internal/gc/walk.go
@@ -3235,9 +3235,6 @@
 
 	// Checking src[lb:hb:cb] or src[lb:hb].
 	// if chk0 || chk1 || chk2 { panicslice() }
-	var chk0 *Node // cap(src) < cb
-	var chk1 *Node // cb < hb for src[lb:hb:cb]; cap(src) < hb for src[lb:hb]
-	var chk2 *Node // hb < lb
 
 	// All comparisons are unsigned to avoid testing < 0.
 	bt := Types[Simtype[TUINT]]
@@ -3254,6 +3251,7 @@
 
 	bound = cheapexpr(conv(bound, bt), init)
 
+	var chk0 *Node // cap(src) < cb
 	if cb != nil {
 		cb = cheapexpr(conv(cb, bt), init)
 		if bounded == 0 {
@@ -3264,6 +3262,7 @@
 		Fatal("slice3 with cb == N") // rejected by parser
 	}
 
+	var chk1 *Node // cb < hb for src[lb:hb:cb]; cap(src) < hb for src[lb:hb]
 	if hb != nil {
 		hb = cheapexpr(conv(hb, bt), init)
 		if bounded == 0 {
@@ -3285,6 +3284,7 @@
 		hb = cheapexpr(conv(hb, bt), init)
 	}
 
+	var chk2 *Node // hb < lb
 	if lb != nil {
 		lb = cheapexpr(conv(lb, bt), init)
 		if bounded == 0 {
@@ -3432,14 +3432,6 @@
 		r = n.Left
 	}
 
-	var call *Node
-	var a *Node
-	var cmpl *Node
-	var cmpr *Node
-	var andor int
-	var expr *Node
-	var needsize int
-	var t *Type
 	if l != nil {
 		x := temp(r.Type)
 		ok := temp(Types[TBOOL])
@@ -3464,12 +3456,13 @@
 			r = Nod(OOROR, Nod(ONOT, ok, nil), Nod(ONE, x, r))
 		}
 		*init = list(*init, expr)
-		goto ret
+		finishcompare(np, n, r, init)
+		return
 	}
 
 	// Must be comparison of array or struct.
 	// Otherwise back end handles it.
-	t = n.Left.Type
+	t := n.Left.Type
 
 	switch t.Etype {
 	default:
@@ -3484,11 +3477,11 @@
 		break
 	}
 
-	cmpl = n.Left
+	cmpl := n.Left
 	for cmpl != nil && cmpl.Op == OCONVNOP {
 		cmpl = cmpl.Left
 	}
-	cmpr = n.Right
+	cmpr := n.Right
 	for cmpr != nil && cmpr.Op == OCONVNOP {
 		cmpr = cmpr.Left
 	}
@@ -3498,7 +3491,7 @@
 	}
 
 	l = temp(Ptrto(t))
-	a = Nod(OAS, l, Nod(OADDR, cmpl, nil))
+	a := Nod(OAS, l, Nod(OADDR, cmpl, nil))
 	a.Right.Etype = 1 // addr does not escape
 	typecheck(&a, Etop)
 	*init = list(*init, a)
@@ -3509,12 +3502,12 @@
 	typecheck(&a, Etop)
 	*init = list(*init, a)
 
-	expr = nil
-	andor = OANDAND
+	andor := OANDAND
 	if n.Op == ONE {
 		andor = OOROR
 	}
 
+	var expr *Node
 	if t.Etype == TARRAY && t.Bound <= 4 && issimple[t.Type.Etype] {
 		// Four or fewer elements of a basic type.
 		// Unroll comparisons.
@@ -3534,8 +3527,8 @@
 		if expr == nil {
 			expr = Nodbool(n.Op == OEQ)
 		}
-		r = expr
-		goto ret
+		finishcompare(np, n, expr, init)
+		return
 	}
 
 	if t.Etype == TSTRUCT && countfield(t) <= 4 {
@@ -3560,12 +3553,13 @@
 		if expr == nil {
 			expr = Nodbool(n.Op == OEQ)
 		}
-		r = expr
-		goto ret
+		finishcompare(np, n, expr, init)
+		return
 	}
 
 	// Chose not to inline.  Call equality function directly.
-	call = Nod(OCALL, eqfor(t, &needsize), nil)
+	var needsize int
+	call := Nod(OCALL, eqfor(t, &needsize), nil)
 
 	call.List = list(call.List, l)
 	call.List = list(call.List, r)
@@ -3576,19 +3570,23 @@
 	if n.Op != OEQ {
 		r = Nod(ONOT, r, nil)
 	}
-	goto ret
 
-ret:
-	typecheck(&r, Erv)
-	walkexpr(&r, init)
+	finishcompare(np, n, r, init)
+	return
+}
+
+func finishcompare(np **Node, n, r *Node, init **NodeList) {
+	// Using np here to avoid passing &r to typecheck.
+	*np = r
+	typecheck(np, Erv)
+	walkexpr(np, init)
+	r = *np
 	if r.Type != n.Type {
 		r = Nod(OCONVNOP, r, nil)
 		r.Type = n.Type
 		r.Typecheck = 1
+		*np = r
 	}
-
-	*np = r
-	return
 }
 
 func samecheap(a *Node, b *Node) bool {