  	case constant:
  		typ = x.typ
  		val = x.val
+@@ -905,7 +913,9 @@
+ 
+ 	switch e := e.(type) {
+ 	case *ast.BadExpr:
+-		goto Error // error was reported before
++		x.mode = invalid
++		x.expr = e
++		return statement // error was reported before
+ 
+ 	case *ast.Ident:
+ 		check.ident(x, e, nil, false)
+@@ -914,13 +924,17 @@
+ 		// ellipses are handled explicitly where they are legal
+ 		// (array composite literals and parameter lists)
+ 		check.errorf(e.Pos(), "invalid use of '...'")
+-		goto Error
++		x.mode = invalid
++		x.expr = e
++		return statement
+ 
+ 	case *ast.BasicLit:
+ 		x.setConst(e.Kind, e.Value)
+ 		if x.mode == invalid {
+ 			check.invalidAST(e.Pos(), "invalid literal %v", e.Value)
+-			goto Error
++			x.mode = invalid
++			x.expr = e
++			return statement
+ 		}
+ 
+ 	case *ast.FuncLit:
+@@ -930,7 +944,9 @@
+ 			check.later(nil, sig, e.Body)
+ 		} else {
+ 			check.invalidAST(e.Pos(), "invalid function literal %s", e)
+-			goto Error
++			x.mode = invalid
++			x.expr = e
++			return statement
+ 		}
+ 
+ 	case *ast.CompositeLit:
+@@ -955,7 +971,9 @@
+ 		}
+ 		if typ == nil {
+ 			check.errorf(e.Pos(), "missing type in composite literal")
+-			goto Error
++			x.mode = invalid
++			x.expr = e
++			return statement
+ 		}
+ 
+ 		switch typ, _ := deref(typ); utyp := typ.Underlying().(type) {
+@@ -1070,7 +1088,9 @@
+ 
+ 		default:
+ 			check.errorf(e.Pos(), "invalid composite literal type %s", typ)
+-			goto Error
++			x.mode = invalid
++			x.expr = e
++			return statement
+ 		}
+ 
+ 		x.mode = value
+@@ -1087,7 +1107,9 @@
+ 	case *ast.IndexExpr:
+ 		check.expr(x, e.X)
+ 		if x.mode == invalid {
+-			goto Error
++			x.mode = invalid
++			x.expr = e
++			return statement
+ 		}
+ 
+ 		valid := false
+@@ -1134,7 +1156,9 @@
+ 				if key.mode != invalid {
+ 					check.invalidOp(key.pos(), "cannot use %s as map index of type %s", &key, typ.key)
+ 				}
+-				goto Error
++				x.mode = invalid
++				x.expr = e
++				return statement
+ 			}
+ 			x.mode = valueok
+ 			x.typ = typ.elt
+@@ -1144,12 +1168,16 @@
+ 
+ 		if !valid {
+ 			check.invalidOp(x.pos(), "cannot index %s", x)
+-			goto Error
++			x.mode = invalid
++			x.expr = e
++			return statement
+ 		}
+ 
+ 		if e.Index == nil {
+ 			check.invalidAST(e.Pos(), "missing index for %s", x)
+-			goto Error
++			x.mode = invalid
++			x.expr = e
++			return statement
+ 		}
+ 
+ 		check.index(e.Index, length)
+@@ -1158,7 +1186,9 @@
+ 	case *ast.SliceExpr:
+ 		check.expr(x, e.X)
+ 		if x.mode == invalid {
+-			goto Error
++			x.mode = invalid
++			x.expr = e
++			return statement
+ 		}
+ 
+ 		valid := false
+@@ -1168,7 +1198,9 @@
+ 			if isString(typ) {
+ 				if slice3(e) {
+ 					check.invalidOp(x.pos(), "3-index slice of string")
+-					goto Error
++					x.mode = invalid
++					x.expr = e
++					return statement
+ 				}
+ 				valid = true
+ 				if x.mode == constant {
+@@ -1187,7 +1219,9 @@
+ 			length = typ.len
+ 			if x.mode != variable {
+ 				check.invalidOp(x.pos(), "cannot slice %s (value not addressable)", x)
+-				goto Error
++				x.mode = invalid
++				x.expr = e
++				return statement
+ 			}
+ 			x.typ = &Slice{elt: typ.elt}
+ 
+@@ -1207,13 +1241,17 @@
+ 
+ 		if !valid {
+ 			check.invalidOp(x.pos(), "cannot slice %s", x)
+-			goto Error
++			x.mode = invalid
++			x.expr = e
++			return statement
+ 		}
+ 
+ 		// spec: "Only the first index may be omitted; it defaults to 0."
+ 		if slice3(e) && (e.High == nil || sliceMax(e) == nil) {
+ 			check.errorf(e.Rbrack, "2nd and 3rd index required in 3-index slice")
+-			goto Error
++			x.mode = invalid
++			x.expr = e
++			return statement
+ 		}
+ 
+ 		// check indices
+@@ -1259,21 +1297,29 @@
+ 	case *ast.TypeAssertExpr:
+ 		check.expr(x, e.X)
+ 		if x.mode == invalid {
+-			goto Error
++			x.mode = invalid
++			x.expr = e
++			return statement
+ 		}
+ 		xtyp, _ := x.typ.Underlying().(*Interface)
+ 		if xtyp == nil {
+ 			check.invalidOp(x.pos(), "%s is not an interface", x)
+-			goto Error
++			x.mode = invalid
++			x.expr = e
++			return statement
+ 		}
+ 		// x.(type) expressions are handled explicitly in type switches
+ 		if e.Type == nil {
+ 			check.invalidAST(e.Pos(), "use of .(type) outside type switch")
+-			goto Error
++			x.mode = invalid
++			x.expr = e
++			return statement
+ 		}
+ 		T := check.typ(e.Type, nil, false)
+ 		if T == Typ[Invalid] {
+-			goto Error
++			x.mode = invalid
++			x.expr = e
++			return statement
+ 		}
+ 		check.typeAssertion(x.pos(), x, xtyp, T)
+ 		x.mode = valueok
+@@ -1286,7 +1332,9 @@
+ 		check.exprOrType(x, e.X)
+ 		switch x.mode {
+ 		case invalid:
+-			goto Error
++			x.mode = invalid
++			x.expr = e
++			return statement
+ 		case typexpr:
+ 			x.typ = &Pointer{base: x.typ}
+ 		default:
+@@ -1295,18 +1343,24 @@
+ 				x.typ = typ.base
+ 			} else {
+ 				check.invalidOp(x.pos(), "cannot indirect %s", x)
+-				goto Error
++				x.mode = invalid
++				x.expr = e
++				return statement
+ 			}
+ 		}
+ 
+ 	case *ast.UnaryExpr:
+ 		check.expr(x, e.X)
+ 		if x.mode == invalid {
+-			goto Error
++			x.mode = invalid
++			x.expr = e
++			return statement
+ 		}
+ 		check.unary(x, e.Op)
+ 		if x.mode == invalid {
+-			goto Error
++			x.mode = invalid
++			x.expr = e
++			return statement
+ 		}
+ 		if e.Op == token.ARROW {
+ 			x.expr = e
+@@ -1316,13 +1370,17 @@
+ 	case *ast.BinaryExpr:
+ 		check.binary(x, e.X, e.Y, e.Op)
+ 		if x.mode == invalid {
+-			goto Error
++			x.mode = invalid
++			x.expr = e
++			return statement
+ 		}
+ 
+ 	case *ast.KeyValueExpr:
+ 		// key:value expressions are handled in composite literals
+ 		check.invalidAST(e.Pos(), "no key:value expected")
+-		goto Error
++		x.mode = invalid
++		x.expr = e
++		return statement
+ 
+ 	case *ast.ArrayType, *ast.StructType, *ast.FuncType,
+ 		*ast.InterfaceType, *ast.MapType, *ast.ChanType:
+@@ -1344,11 +1402,6 @@
+ 	// everything went well
+ 	x.expr = e
+ 	return expression
+-
+-Error:
+-	x.mode = invalid
+-	x.expr = e
+-	return statement // avoid follow-up errors
+ }
+ 
+ // typeAssertion checks that x.(T) is legal; xtyp must be the type of x.
 diff -r 1d462abd2860 go/types/gcimporter.go
 --- a/go/types/gcimporter.go	Wed Oct 09 16:35:59 2013 -0400
-+++ b/go/types/gcimporter.go	Wed Oct 09 22:56:42 2013 +0200
++++ b/go/types/gcimporter.go	Wed Oct 09 23:04:18 2013 +0200
 @@ -723,7 +723,8 @@
  func (p *gcParser) parseImportDecl() {
  	p.expectKeyword("import")

 // Iterate calls function f on each entry in the map in unspecified order.
diff -r 1d462abd2860 go/types/types.go
--- a/go/types/types.go	Wed Oct 09 16:35:59 2013 -0400
+++ b/go/types/types.go	Wed Oct 09 22:56:42 2013 +0200
@@ -174,18 +174,12 @@
 
 // NewTuple returns a new tuple for the given variables.

 // int_lit = [ "+" | "-" ] { "0" ... "9" } .
diff -r 1d462abd2860 go/types/methodset.go
--- a/go/types/methodset.go	Wed Oct 09 16:35:59 2013 -0400
+++ b/go/types/methodset.go	Wed Oct 09 23:04:18 2013 +0200
@@ -121,8 +121,8 @@
 		var next []embeddedType // embedded types found at current depth
 
