obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

1 files changed, 2015 insertions, 0 deletions

diff --git a/libgo/go/exp/eval/expr.go b/libgo/go/exp/eval/expr.go
new file mode 100644
index 000000000..e65f47617
--- /dev/null
+++ b/libgo/go/exp/eval/expr.go
@@ -0,0 +1,2015 @@
+// Copyright 2009 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package eval
+
+import (
+	"big"
+	"fmt"
+	"go/ast"
+	"go/token"
+	"log"
+	"strconv"
+	"strings"
+	"os"
+)
+
+var (
+	idealZero = big.NewInt(0)
+	idealOne  = big.NewInt(1)
+)
+
+// An expr is the result of compiling an expression.  It stores the
+// type of the expression and its evaluator function.
+type expr struct {
+	*exprInfo
+	t Type
+
+	// Evaluate this node as the given type.
+	eval interface{}
+
+	// Map index expressions permit special forms of assignment,
+	// for which we need to know the Map and key.
+	evalMapValue func(t *Thread) (Map, interface{})
+
+	// Evaluate to the "address of" this value; that is, the
+	// settable Value object.  nil for expressions whose address
+	// cannot be taken.
+	evalAddr func(t *Thread) Value
+
+	// Execute this expression as a statement.  Only expressions
+	// that are valid expression statements should set this.
+	exec func(t *Thread)
+
+	// If this expression is a type, this is its compiled type.
+	// This is only permitted in the function position of a call
+	// expression.  In this case, t should be nil.
+	valType Type
+
+	// A short string describing this expression for error
+	// messages.
+	desc string
+}
+
+// exprInfo stores information needed to compile any expression node.
+// Each expr also stores its exprInfo so further expressions can be
+// compiled from it.
+type exprInfo struct {
+	*compiler
+	pos token.Pos
+}
+
+func (a *exprInfo) newExpr(t Type, desc string) *expr {
+	return &expr{exprInfo: a, t: t, desc: desc}
+}
+
+func (a *exprInfo) diag(format string, args ...interface{}) {
+	a.diagAt(a.pos, format, args...)
+}
+
+func (a *exprInfo) diagOpType(op token.Token, vt Type) {
+	a.diag("illegal operand type for '%v' operator\n\t%v", op, vt)
+}
+
+func (a *exprInfo) diagOpTypes(op token.Token, lt Type, rt Type) {
+	a.diag("illegal operand types for '%v' operator\n\t%v\n\t%v", op, lt, rt)
+}
+
+/*
+ * Common expression manipulations
+ */
+
+// a.convertTo(t) converts the value of the analyzed expression a,
+// which must be a constant, ideal number, to a new analyzed
+// expression with a constant value of type t.
+//
+// TODO(austin) Rename to resolveIdeal or something?
+func (a *expr) convertTo(t Type) *expr {
+	if !a.t.isIdeal() {
+		log.Panicf("attempted to convert from %v, expected ideal", a.t)
+	}
+
+	var rat *big.Rat
+
+	// XXX(Spec)  The spec says "It is erroneous".
+	//
+	// It is an error to assign a value with a non-zero fractional
+	// part to an integer, or if the assignment would overflow or
+	// underflow, or in general if the value cannot be represented
+	// by the type of the variable.
+	switch a.t {
+	case IdealFloatType:
+		rat = a.asIdealFloat()()
+		if t.isInteger() && !rat.IsInt() {
+			a.diag("constant %v truncated to integer", rat.FloatString(6))
+			return nil
+		}
+	case IdealIntType:
+		i := a.asIdealInt()()
+		rat = new(big.Rat).SetInt(i)
+	default:
+		log.Panicf("unexpected ideal type %v", a.t)
+	}
+
+	// Check bounds
+	if t, ok := t.lit().(BoundedType); ok {
+		if rat.Cmp(t.minVal()) < 0 {
+			a.diag("constant %v underflows %v", rat.FloatString(6), t)
+			return nil
+		}
+		if rat.Cmp(t.maxVal()) > 0 {
+			a.diag("constant %v overflows %v", rat.FloatString(6), t)
+			return nil
+		}
+	}
+
+	// Convert rat to type t.
+	res := a.newExpr(t, a.desc)
+	switch t := t.lit().(type) {
+	case *uintType:
+		n, d := rat.Num(), rat.Denom()
+		f := new(big.Int).Quo(n, d)
+		f = f.Abs(f)
+		v := uint64(f.Int64())
+		res.eval = func(*Thread) uint64 { return v }
+	case *intType:
+		n, d := rat.Num(), rat.Denom()
+		f := new(big.Int).Quo(n, d)
+		v := f.Int64()
+		res.eval = func(*Thread) int64 { return v }
+	case *idealIntType:
+		n, d := rat.Num(), rat.Denom()
+		f := new(big.Int).Quo(n, d)
+		res.eval = func() *big.Int { return f }
+	case *floatType:
+		n, d := rat.Num(), rat.Denom()
+		v := float64(n.Int64()) / float64(d.Int64())
+		res.eval = func(*Thread) float64 { return v }
+	case *idealFloatType:
+		res.eval = func() *big.Rat { return rat }
+	default:
+		log.Panicf("cannot convert to type %T", t)
+	}
+
+	return res
+}
+
+// convertToInt converts this expression to an integer, if possible,
+// or produces an error if not.  This accepts ideal ints, uints, and
+// ints.  If max is not -1, produces an error if possible if the value
+// exceeds max.  If negErr is not "", produces an error if possible if
+// the value is negative.
+func (a *expr) convertToInt(max int64, negErr string, errOp string) *expr {
+	switch a.t.lit().(type) {
+	case *idealIntType:
+		val := a.asIdealInt()()
+		if negErr != "" && val.Sign() < 0 {
+			a.diag("negative %s: %s", negErr, val)
+			return nil
+		}
+		bound := max
+		if negErr == "slice" {
+			bound++
+		}
+		if max != -1 && val.Cmp(big.NewInt(bound)) >= 0 {
+			a.diag("index %s exceeds length %d", val, max)
+			return nil
+		}
+		return a.convertTo(IntType)
+
+	case *uintType:
+		// Convert to int
+		na := a.newExpr(IntType, a.desc)
+		af := a.asUint()
+		na.eval = func(t *Thread) int64 { return int64(af(t)) }
+		return na
+
+	case *intType:
+		// Good as is
+		return a
+	}
+
+	a.diag("illegal operand type for %s\n\t%v", errOp, a.t)
+	return nil
+}
+
+// derefArray returns an expression of array type if the given
+// expression is a *array type.  Otherwise, returns the given
+// expression.
+func (a *expr) derefArray() *expr {
+	if pt, ok := a.t.lit().(*PtrType); ok {
+		if _, ok := pt.Elem.lit().(*ArrayType); ok {
+			deref := a.compileStarExpr(a)
+			if deref == nil {
+				log.Panicf("failed to dereference *array")
+			}
+			return deref
+		}
+	}
+	return a
+}
+
+/*
+ * Assignments
+ */
+
+// An assignCompiler compiles assignment operations.  Anything other
+// than short declarations should use the compileAssign wrapper.
+//
+// There are three valid types of assignment:
+// 1) T = T
+//    Assigning a single expression with single-valued type to a
+//    single-valued type.
+// 2) MT = T, T, ...
+//    Assigning multiple expressions with single-valued types to a
+//    multi-valued type.
+// 3) MT = MT
+//    Assigning a single expression with multi-valued type to a
+//    multi-valued type.
+type assignCompiler struct {
+	*compiler
+	pos token.Pos
+	// The RHS expressions.  This may include nil's for
+	// expressions that failed to compile.
+	rs []*expr
+	// The (possibly unary) MultiType of the RHS.
+	rmt *MultiType
+	// Whether this is an unpack assignment (case 3).
+	isUnpack bool
+	// Whether map special assignment forms are allowed.
+	allowMap bool
+	// Whether this is a "r, ok = a[x]" assignment.
+	isMapUnpack bool
+	// The operation name to use in error messages, such as
+	// "assignment" or "function call".
+	errOp string
+	// The name to use for positions in error messages, such as
+	// "argument".
+	errPosName string
+}
+
+// Type check the RHS of an assignment, returning a new assignCompiler
+// and indicating if the type check succeeded.  This always returns an
+// assignCompiler with rmt set, but if type checking fails, slots in
+// the MultiType may be nil.  If rs contains nil's, type checking will
+// fail and these expressions given a nil type.
+func (a *compiler) checkAssign(pos token.Pos, rs []*expr, errOp, errPosName string) (*assignCompiler, bool) {
+	c := &assignCompiler{
+		compiler:   a,
+		pos:        pos,
+		rs:         rs,
+		errOp:      errOp,
+		errPosName: errPosName,
+	}
+
+	// Is this an unpack?
+	if len(rs) == 1 && rs[0] != nil {
+		if rmt, isUnpack := rs[0].t.(*MultiType); isUnpack {
+			c.rmt = rmt
+			c.isUnpack = true
+			return c, true
+		}
+	}
+
+	// Create MultiType for RHS and check that all RHS expressions
+	// are single-valued.
+	rts := make([]Type, len(rs))
+	ok := true
+	for i, r := range rs {
+		if r == nil {
+			ok = false
+			continue
+		}
+
+		if _, isMT := r.t.(*MultiType); isMT {
+			r.diag("multi-valued expression not allowed in %s", errOp)
+			ok = false
+			continue
+		}
+
+		rts[i] = r.t
+	}
+
+	c.rmt = NewMultiType(rts)
+	return c, ok
+}
+
+func (a *assignCompiler) allowMapForms(nls int) {
+	a.allowMap = true
+
+	// Update unpacking info if this is r, ok = a[x]
+	if nls == 2 && len(a.rs) == 1 && a.rs[0] != nil && a.rs[0].evalMapValue != nil {
+		a.isUnpack = true
+		a.rmt = NewMultiType([]Type{a.rs[0].t, BoolType})
+		a.isMapUnpack = true
+	}
+}
+
+// compile type checks and compiles an assignment operation, returning
+// a function that expects an l-value and the frame in which to
+// evaluate the RHS expressions.  The l-value must have exactly the
+// type given by lt.  Returns nil if type checking fails.
+func (a *assignCompiler) compile(b *block, lt Type) func(Value, *Thread) {
+	lmt, isMT := lt.(*MultiType)
+	rmt, isUnpack := a.rmt, a.isUnpack
+
+	// Create unary MultiType for single LHS
+	if !isMT {
+		lmt = NewMultiType([]Type{lt})
+	}
+
+	// Check that the assignment count matches
+	lcount := len(lmt.Elems)
+	rcount := len(rmt.Elems)
+	if lcount != rcount {
+		msg := "not enough"
+		pos := a.pos
+		if rcount > lcount {
+			msg = "too many"
+			if lcount > 0 {
+				pos = a.rs[lcount-1].pos
+			}
+		}
+		a.diagAt(pos, "%s %ss for %s\n\t%s\n\t%s", msg, a.errPosName, a.errOp, lt, rmt)
+		return nil
+	}
+
+	bad := false
+
+	// If this is an unpack, create a temporary to store the
+	// multi-value and replace the RHS with expressions to pull
+	// out values from the temporary.  Technically, this is only
+	// necessary when we need to perform assignment conversions.
+	var effect func(*Thread)
+	if isUnpack {
+		// This leaks a slot, but is definitely safe.
+		temp := b.DefineTemp(a.rmt)
+		tempIdx := temp.Index
+		if tempIdx < 0 {
+			panic(fmt.Sprintln("tempidx", tempIdx))
+		}
+		if a.isMapUnpack {
+			rf := a.rs[0].evalMapValue
+			vt := a.rmt.Elems[0]
+			effect = func(t *Thread) {
+				m, k := rf(t)
+				v := m.Elem(t, k)
+				found := boolV(true)
+				if v == nil {
+					found = boolV(false)
+					v = vt.Zero()
+				}
+				t.f.Vars[tempIdx] = multiV([]Value{v, &found})
+			}
+		} else {
+			rf := a.rs[0].asMulti()
+			effect = func(t *Thread) { t.f.Vars[tempIdx] = multiV(rf(t)) }
+		}
+		orig := a.rs[0]
+		a.rs = make([]*expr, len(a.rmt.Elems))
+		for i, t := range a.rmt.Elems {
+			if t.isIdeal() {
+				log.Panicf("Right side of unpack contains ideal: %s", rmt)
+			}
+			a.rs[i] = orig.newExpr(t, orig.desc)
+			index := i
+			a.rs[i].genValue(func(t *Thread) Value { return t.f.Vars[tempIdx].(multiV)[index] })
+		}
+	}
+	// Now len(a.rs) == len(a.rmt) and we've reduced any unpacking
+	// to multi-assignment.
+
+	// TODO(austin) Deal with assignment special cases.
+
+	// Values of any type may always be assigned to variables of
+	// compatible static type.
+	for i, lt := range lmt.Elems {
+		rt := rmt.Elems[i]
+
+		// When [an ideal is] (used in an expression) assigned
+		// to a variable or typed constant, the destination
+		// must be able to represent the assigned value.
+		if rt.isIdeal() {
+			a.rs[i] = a.rs[i].convertTo(lmt.Elems[i])
+			if a.rs[i] == nil {
+				bad = true
+				continue
+			}
+			rt = a.rs[i].t
+		}
+
+		// A pointer p to an array can be assigned to a slice
+		// variable v with compatible element type if the type
+		// of p or v is unnamed.
+		if rpt, ok := rt.lit().(*PtrType); ok {
+			if at, ok := rpt.Elem.lit().(*ArrayType); ok {
+				if lst, ok := lt.lit().(*SliceType); ok {
+					if lst.Elem.compat(at.Elem, false) && (rt.lit() == Type(rt) || lt.lit() == Type(lt)) {
+						rf := a.rs[i].asPtr()
+						a.rs[i] = a.rs[i].newExpr(lt, a.rs[i].desc)
+						len := at.Len
+						a.rs[i].eval = func(t *Thread) Slice { return Slice{rf(t).(ArrayValue), len, len} }
+						rt = a.rs[i].t
+					}
+				}
+			}
+		}
+
+		if !lt.compat(rt, false) {
+			if len(a.rs) == 1 {
+				a.rs[0].diag("illegal operand types for %s\n\t%v\n\t%v", a.errOp, lt, rt)
+			} else {
+				a.rs[i].diag("illegal operand types in %s %d of %s\n\t%v\n\t%v", a.errPosName, i+1, a.errOp, lt, rt)
+			}
+			bad = true
+		}
+	}
+	if bad {
+		return nil
+	}
+
+	// Compile
+	if !isMT {
+		// Case 1
+		return genAssign(lt, a.rs[0])
+	}
+	// Case 2 or 3
+	as := make([]func(lv Value, t *Thread), len(a.rs))
+	for i, r := range a.rs {
+		as[i] = genAssign(lmt.Elems[i], r)
+	}
+	return func(lv Value, t *Thread) {
+		if effect != nil {
+			effect(t)
+		}
+		lmv := lv.(multiV)
+		for i, a := range as {
+			a(lmv[i], t)
+		}
+	}
+}
+
+// compileAssign compiles an assignment operation without the full
+// generality of an assignCompiler.  See assignCompiler for a
+// description of the arguments.
+func (a *compiler) compileAssign(pos token.Pos, b *block, lt Type, rs []*expr, errOp, errPosName string) func(Value, *Thread) {
+	ac, ok := a.checkAssign(pos, rs, errOp, errPosName)
+	if !ok {
+		return nil
+	}
+	return ac.compile(b, lt)
+}
+
+/*
+ * Expression compiler
+ */
+
+// An exprCompiler stores information used throughout the compilation
+// of a single expression.  It does not embed funcCompiler because
+// expressions can appear at top level.
+type exprCompiler struct {
+	*compiler
+	// The block this expression is being compiled in.
+	block *block
+	// Whether this expression is used in a constant context.
+	constant bool
+}
+
+// compile compiles an expression AST.  callCtx should be true if this
+// AST is in the function position of a function call node; it allows
+// the returned expression to be a type or a built-in function (which
+// otherwise result in errors).
+func (a *exprCompiler) compile(x ast.Expr, callCtx bool) *expr {
+	ei := &exprInfo{a.compiler, x.Pos()}
+
+	switch x := x.(type) {
+	// Literals
+	case *ast.BasicLit:
+		switch x.Kind {
+		case token.INT:
+			return ei.compileIntLit(string(x.Value))
+		case token.FLOAT:
+			return ei.compileFloatLit(string(x.Value))
+		case token.CHAR:
+			return ei.compileCharLit(string(x.Value))
+		case token.STRING:
+			return ei.compileStringLit(string(x.Value))
+		default:
+			log.Panicf("unexpected basic literal type %v", x.Kind)
+		}
+
+	case *ast.CompositeLit:
+		goto notimpl
+
+	case *ast.FuncLit:
+		decl := ei.compileFuncType(a.block, x.Type)
+		if decl == nil {
+			// TODO(austin) Try compiling the body,
+			// perhaps with dummy argument definitions
+			return nil
+		}
+		fn := ei.compileFunc(a.block, decl, x.Body)
+		if fn == nil {
+			return nil
+		}
+		if a.constant {
+			a.diagAt(x.Pos(), "function literal used in constant expression")
+			return nil
+		}
+		return ei.compileFuncLit(decl, fn)
+
+	// Types
+	case *ast.ArrayType:
+		// TODO(austin) Use a multi-type case
+		goto typeexpr
+
+	case *ast.ChanType:
+		goto typeexpr
+
+	case *ast.Ellipsis:
+		goto typeexpr
+
+	case *ast.FuncType:
+		goto typeexpr
+
+	case *ast.InterfaceType:
+		goto typeexpr
+
+	case *ast.MapType:
+		goto typeexpr
+
+	// Remaining expressions
+	case *ast.BadExpr:
+		// Error already reported by parser
+		a.silentErrors++
+		return nil
+
+	case *ast.BinaryExpr:
+		l, r := a.compile(x.X, false), a.compile(x.Y, false)
+		if l == nil || r == nil {
+			return nil
+		}
+		return ei.compileBinaryExpr(x.Op, l, r)
+
+	case *ast.CallExpr:
+		l := a.compile(x.Fun, true)
+		args := make([]*expr, len(x.Args))
+		bad := false
+		for i, arg := range x.Args {
+			if i == 0 && l != nil && (l.t == Type(makeType) || l.t == Type(newType)) {
+				argei := &exprInfo{a.compiler, arg.Pos()}
+				args[i] = argei.exprFromType(a.compileType(a.block, arg))
+			} else {
+				args[i] = a.compile(arg, false)
+			}
+			if args[i] == nil {
+				bad = true
+			}
+		}
+		if bad || l == nil {
+			return nil
+		}
+		if a.constant {
+			a.diagAt(x.Pos(), "function call in constant context")
+			return nil
+		}
+
+		if l.valType != nil {
+			a.diagAt(x.Pos(), "type conversions not implemented")
+			return nil
+		} else if ft, ok := l.t.(*FuncType); ok && ft.builtin != "" {
+			return ei.compileBuiltinCallExpr(a.block, ft, args)
+		} else {
+			return ei.compileCallExpr(a.block, l, args)
+		}
+
+	case *ast.Ident:
+		return ei.compileIdent(a.block, a.constant, callCtx, x.Name)
+
+	case *ast.IndexExpr:
+		l, r := a.compile(x.X, false), a.compile(x.Index, false)
+		if l == nil || r == nil {
+			return nil
+		}
+		return ei.compileIndexExpr(l, r)
+
+	case *ast.SliceExpr:
+		var lo, hi *expr
+		arr := a.compile(x.X, false)
+		if x.Low == nil {
+			// beginning was omitted, so we need to provide it
+			ei := &exprInfo{a.compiler, x.Pos()}
+			lo = ei.compileIntLit("0")
+		} else {
+			lo = a.compile(x.Low, false)
+		}
+		if x.High == nil {
+			// End was omitted, so we need to compute len(x.X)
+			ei := &exprInfo{a.compiler, x.Pos()}
+			hi = ei.compileBuiltinCallExpr(a.block, lenType, []*expr{arr})
+		} else {
+			hi = a.compile(x.High, false)
+		}
+		if arr == nil || lo == nil || hi == nil {
+			return nil
+		}
+		return ei.compileSliceExpr(arr, lo, hi)
+
+	case *ast.KeyValueExpr:
+		goto notimpl
+
+	case *ast.ParenExpr:
+		return a.compile(x.X, callCtx)
+
+	case *ast.SelectorExpr:
+		v := a.compile(x.X, false)
+		if v == nil {
+			return nil
+		}
+		return ei.compileSelectorExpr(v, x.Sel.Name)
+
+	case *ast.StarExpr:
+		// We pass down our call context because this could be
+		// a pointer type (and thus a type conversion)
+		v := a.compile(x.X, callCtx)
+		if v == nil {
+			return nil
+		}
+		if v.valType != nil {
+			// Turns out this was a pointer type, not a dereference
+			return ei.exprFromType(NewPtrType(v.valType))
+		}
+		return ei.compileStarExpr(v)
+
+	case *ast.StructType:
+		goto notimpl
+
+	case *ast.TypeAssertExpr:
+		goto notimpl
+
+	case *ast.UnaryExpr:
+		v := a.compile(x.X, false)
+		if v == nil {
+			return nil
+		}
+		return ei.compileUnaryExpr(x.Op, v)
+	}
+	log.Panicf("unexpected ast node type %T", x)
+	panic("unreachable")
+
+typeexpr:
+	if !callCtx {
+		a.diagAt(x.Pos(), "type used as expression")
+		return nil
+	}
+	return ei.exprFromType(a.compileType(a.block, x))
+
+notimpl:
+	a.diagAt(x.Pos(), "%T expression node not implemented", x)
+	return nil
+}
+
+func (a *exprInfo) exprFromType(t Type) *expr {
+	if t == nil {
+		return nil
+	}
+	expr := a.newExpr(nil, "type")
+	expr.valType = t
+	return expr
+}
+
+func (a *exprInfo) compileIdent(b *block, constant bool, callCtx bool, name string) *expr {
+	bl, level, def := b.Lookup(name)
+	if def == nil {
+		a.diag("%s: undefined", name)
+		return nil
+	}
+	switch def := def.(type) {
+	case *Constant:
+		expr := a.newExpr(def.Type, "constant")
+		if ft, ok := def.Type.(*FuncType); ok && ft.builtin != "" {
+			// XXX(Spec) I don't think anything says that
+			// built-in functions can't be used as values.
+			if !callCtx {
+				a.diag("built-in function %s cannot be used as a value", ft.builtin)
+				return nil
+			}
+			// Otherwise, we leave the evaluators empty
+			// because this is handled specially
+		} else {
+			expr.genConstant(def.Value)
+		}
+		return expr
+	case *Variable:
+		if constant {
+			a.diag("variable %s used in constant expression", name)
+			return nil
+		}
+		if bl.global {
+			return a.compileGlobalVariable(def)
+		}
+		return a.compileVariable(level, def)
+	case Type:
+		if callCtx {
+			return a.exprFromType(def)
+		}
+		a.diag("type %v used as expression", name)
+		return nil
+	}
+	log.Panicf("name %s has unknown type %T", name, def)
+	panic("unreachable")
+}
+
+func (a *exprInfo) compileVariable(level int, v *Variable) *expr {
+	if v.Type == nil {
+		// Placeholder definition from an earlier error
+		a.silentErrors++
+		return nil
+	}
+	expr := a.newExpr(v.Type, "variable")
+	expr.genIdentOp(level, v.Index)
+	return expr
+}
+
+func (a *exprInfo) compileGlobalVariable(v *Variable) *expr {
+	if v.Type == nil {
+		// Placeholder definition from an earlier error
+		a.silentErrors++
+		return nil
+	}
+	if v.Init == nil {
+		v.Init = v.Type.Zero()
+	}
+	expr := a.newExpr(v.Type, "variable")
+	val := v.Init
+	expr.genValue(func(t *Thread) Value { return val })
+	return expr
+}
+
+func (a *exprInfo) compileIdealInt(i *big.Int, desc string) *expr {
+	expr := a.newExpr(IdealIntType, desc)
+	expr.eval = func() *big.Int { return i }
+	return expr
+}
+
+func (a *exprInfo) compileIntLit(lit string) *expr {
+	i, _ := new(big.Int).SetString(lit, 0)
+	return a.compileIdealInt(i, "integer literal")
+}
+
+func (a *exprInfo) compileCharLit(lit string) *expr {
+	if lit[0] != '\'' {
+		// Caught by parser
+		a.silentErrors++
+		return nil
+	}
+	v, _, tail, err := strconv.UnquoteChar(lit[1:], '\'')
+	if err != nil || tail != "'" {
+		// Caught by parser
+		a.silentErrors++
+		return nil
+	}
+	return a.compileIdealInt(big.NewInt(int64(v)), "character literal")
+}
+
+func (a *exprInfo) compileFloatLit(lit string) *expr {
+	f, ok := new(big.Rat).SetString(lit)
+	if !ok {
+		log.Panicf("malformed float literal %s at %v passed parser", lit, a.pos)
+	}
+	expr := a.newExpr(IdealFloatType, "float literal")
+	expr.eval = func() *big.Rat { return f }
+	return expr
+}
+
+func (a *exprInfo) compileString(s string) *expr {
+	// Ideal strings don't have a named type but they are
+	// compatible with type string.
+
+	// TODO(austin) Use unnamed string type.
+	expr := a.newExpr(StringType, "string literal")
+	expr.eval = func(*Thread) string { return s }
+	return expr
+}
+
+func (a *exprInfo) compileStringLit(lit string) *expr {
+	s, err := strconv.Unquote(lit)
+	if err != nil {
+		a.diag("illegal string literal, %v", err)
+		return nil
+	}
+	return a.compileString(s)
+}
+
+func (a *exprInfo) compileStringList(list []*expr) *expr {
+	ss := make([]string, len(list))
+	for i, s := range list {
+		ss[i] = s.asString()(nil)
+	}
+	return a.compileString(strings.Join(ss, ""))
+}
+
+func (a *exprInfo) compileFuncLit(decl *FuncDecl, fn func(*Thread) Func) *expr {
+	expr := a.newExpr(decl.Type, "function literal")
+	expr.eval = fn
+	return expr
+}
+
+func (a *exprInfo) compileSelectorExpr(v *expr, name string) *expr {
+	// mark marks a field that matches the selector name.  It
+	// tracks the best depth found so far and whether more than
+	// one field has been found at that depth.
+	bestDepth := -1
+	ambig := false
+	amberr := ""
+	mark := func(depth int, pathName string) {
+		switch {
+		case bestDepth == -1 || depth < bestDepth:
+			bestDepth = depth
+			ambig = false
+			amberr = ""
+
+		case depth == bestDepth:
+			ambig = true
+
+		default:
+			log.Panicf("Marked field at depth %d, but already found one at depth %d", depth, bestDepth)
+		}
+		amberr += "\n\t" + pathName[1:]
+	}
+
+	visited := make(map[Type]bool)
+
+	// find recursively searches for the named field, starting at
+	// type t.  If it finds the named field, it returns a function
+	// which takes an expr that represents a value of type 't' and
+	// returns an expr that retrieves the named field.  We delay
+	// expr construction to avoid producing lots of useless expr's
+	// as we search.
+	//
+	// TODO(austin) Now that the expression compiler works on
+	// semantic values instead of AST's, there should be a much
+	// better way of doing this.
+	var find func(Type, int, string) func(*expr) *expr
+	find = func(t Type, depth int, pathName string) func(*expr) *expr {
+		// Don't bother looking if we've found something shallower
+		if bestDepth != -1 && bestDepth < depth {
+			return nil
+		}
+
+		// Don't check the same type twice and avoid loops
+		if visited[t] {
+			return nil
+		}
+		visited[t] = true
+
+		// Implicit dereference
+		deref := false
+		if ti, ok := t.(*PtrType); ok {
+			deref = true
+			t = ti.Elem
+		}
+
+		// If it's a named type, look for methods
+		if ti, ok := t.(*NamedType); ok {
+			_, ok := ti.methods[name]
+			if ok {
+				mark(depth, pathName+"."+name)
+				log.Panic("Methods not implemented")
+			}
+			t = ti.Def
+		}
+
+		// If it's a struct type, check fields and embedded types
+		var builder func(*expr) *expr
+		if t, ok := t.(*StructType); ok {
+			for i, f := range t.Elems {
+				var sub func(*expr) *expr
+				switch {
+				case f.Name == name:
+					mark(depth, pathName+"."+name)
+					sub = func(e *expr) *expr { return e }
+
+				case f.Anonymous:
+					sub = find(f.Type, depth+1, pathName+"."+f.Name)
+					if sub == nil {
+						continue
+					}
+
+				default:
+					continue
+				}
+
+				// We found something.  Create a
+				// builder for accessing this field.
+				ft := f.Type
+				index := i
+				builder = func(parent *expr) *expr {
+					if deref {
+						parent = a.compileStarExpr(parent)
+					}
+					expr := a.newExpr(ft, "selector expression")
+					pf := parent.asStruct()
+					evalAddr := func(t *Thread) Value { return pf(t).Field(t, index) }
+					expr.genValue(evalAddr)
+					return sub(expr)
+				}
+			}
+		}
+
+		return builder
+	}
+
+	builder := find(v.t, 0, "")
+	if builder == nil {
+		a.diag("type %v has no field or method %s", v.t, name)
+		return nil
+	}
+	if ambig {
+		a.diag("field %s is ambiguous in type %v%s", name, v.t, amberr)
+		return nil
+	}
+
+	return builder(v)
+}
+
+func (a *exprInfo) compileSliceExpr(arr, lo, hi *expr) *expr {
+	// Type check object
+	arr = arr.derefArray()
+
+	var at Type
+	var maxIndex int64 = -1
+
+	switch lt := arr.t.lit().(type) {
+	case *ArrayType:
+		at = NewSliceType(lt.Elem)
+		maxIndex = lt.Len
+
+	case *SliceType:
+		at = lt
+
+	case *stringType:
+		at = lt
+
+	default:
+		a.diag("cannot slice %v", arr.t)
+		return nil
+	}
+
+	// Type check index and convert to int
+	// XXX(Spec) It's unclear if ideal floats with no
+	// fractional part are allowed here.  6g allows it.  I
+	// believe that's wrong.
+	lo = lo.convertToInt(maxIndex, "slice", "slice")
+	hi = hi.convertToInt(maxIndex, "slice", "slice")
+	if lo == nil || hi == nil {
+		return nil
+	}
+
+	expr := a.newExpr(at, "slice expression")
+
+	// Compile
+	lof := lo.asInt()
+	hif := hi.asInt()
+	switch lt := arr.t.lit().(type) {
+	case *ArrayType:
+		arrf := arr.asArray()
+		bound := lt.Len
+		expr.eval = func(t *Thread) Slice {
+			arr, lo, hi := arrf(t), lof(t), hif(t)
+			if lo > hi || hi > bound || lo < 0 {
+				t.Abort(SliceError{lo, hi, bound})
+			}
+			return Slice{arr.Sub(lo, bound-lo), hi - lo, bound - lo}
+		}
+
+	case *SliceType:
+		arrf := arr.asSlice()
+		expr.eval = func(t *Thread) Slice {
+			arr, lo, hi := arrf(t), lof(t), hif(t)
+			if lo > hi || hi > arr.Cap || lo < 0 {
+				t.Abort(SliceError{lo, hi, arr.Cap})
+			}
+			return Slice{arr.Base.Sub(lo, arr.Cap-lo), hi - lo, arr.Cap - lo}
+		}
+
+	case *stringType:
+		arrf := arr.asString()
+		// TODO(austin) This pulls over the whole string in a
+		// remote setting, instead of creating a substring backed
+		// by remote memory.
+		expr.eval = func(t *Thread) string {
+			arr, lo, hi := arrf(t), lof(t), hif(t)
+			if lo > hi || hi > int64(len(arr)) || lo < 0 {
+				t.Abort(SliceError{lo, hi, int64(len(arr))})
+			}
+			return arr[lo:hi]
+		}
+
+	default:
+		log.Panicf("unexpected left operand type %T", arr.t.lit())
+	}
+
+	return expr
+}
+
+func (a *exprInfo) compileIndexExpr(l, r *expr) *expr {
+	// Type check object
+	l = l.derefArray()
+
+	var at Type
+	intIndex := false
+	var maxIndex int64 = -1
+
+	switch lt := l.t.lit().(type) {
+	case *ArrayType:
+		at = lt.Elem
+		intIndex = true
+		maxIndex = lt.Len
+
+	case *SliceType:
+		at = lt.Elem
+		intIndex = true
+
+	case *stringType:
+		at = Uint8Type
+		intIndex = true
+
+	case *MapType:
+		at = lt.Elem
+		if r.t.isIdeal() {
+			r = r.convertTo(lt.Key)
+			if r == nil {
+				return nil
+			}
+		}
+		if !lt.Key.compat(r.t, false) {
+			a.diag("cannot use %s as index into %s", r.t, lt)
+			return nil
+		}
+
+	default:
+		a.diag("cannot index into %v", l.t)
+		return nil
+	}
+
+	// Type check index and convert to int if necessary
+	if intIndex {
+		// XXX(Spec) It's unclear if ideal floats with no
+		// fractional part are allowed here.  6g allows it.  I
+		// believe that's wrong.
+		r = r.convertToInt(maxIndex, "index", "index")
+		if r == nil {
+			return nil
+		}
+	}
+
+	expr := a.newExpr(at, "index expression")
+
+	// Compile
+	switch lt := l.t.lit().(type) {
+	case *ArrayType:
+		lf := l.asArray()
+		rf := r.asInt()
+		bound := lt.Len
+		expr.genValue(func(t *Thread) Value {
+			l, r := lf(t), rf(t)
+			if r < 0 || r >= bound {
+				t.Abort(IndexError{r, bound})
+			}
+			return l.Elem(t, r)
+		})
+
+	case *SliceType:
+		lf := l.asSlice()
+		rf := r.asInt()
+		expr.genValue(func(t *Thread) Value {
+			l, r := lf(t), rf(t)
+			if l.Base == nil {
+				t.Abort(NilPointerError{})
+			}
+			if r < 0 || r >= l.Len {
+				t.Abort(IndexError{r, l.Len})
+			}
+			return l.Base.Elem(t, r)
+		})
+
+	case *stringType:
+		lf := l.asString()
+		rf := r.asInt()
+		// TODO(austin) This pulls over the whole string in a
+		// remote setting, instead of just the one character.
+		expr.eval = func(t *Thread) uint64 {
+			l, r := lf(t), rf(t)
+			if r < 0 || r >= int64(len(l)) {
+				t.Abort(IndexError{r, int64(len(l))})
+			}
+			return uint64(l[r])
+		}
+
+	case *MapType:
+		lf := l.asMap()
+		rf := r.asInterface()
+		expr.genValue(func(t *Thread) Value {
+			m := lf(t)
+			k := rf(t)
+			if m == nil {
+				t.Abort(NilPointerError{})
+			}
+			e := m.Elem(t, k)
+			if e == nil {
+				t.Abort(KeyError{k})
+			}
+			return e
+		})
+		// genValue makes things addressable, but map values
+		// aren't addressable.
+		expr.evalAddr = nil
+		expr.evalMapValue = func(t *Thread) (Map, interface{}) {
+			// TODO(austin) Key check?  nil check?
+			return lf(t), rf(t)
+		}
+
+	default:
+		log.Panicf("unexpected left operand type %T", l.t.lit())
+	}
+
+	return expr
+}
+
+func (a *exprInfo) compileCallExpr(b *block, l *expr, as []*expr) *expr {
+	// TODO(austin) Variadic functions.
+
+	// Type check
+
+	// XXX(Spec) Calling a named function type is okay.  I really
+	// think there needs to be a general discussion of named
+	// types.  A named type creates a new, distinct type, but the
+	// type of that type is still whatever it's defined to.  Thus,
+	// in "type Foo int", Foo is still an integer type and in
+	// "type Foo func()", Foo is a function type.
+	lt, ok := l.t.lit().(*FuncType)
+	if !ok {
+		a.diag("cannot call non-function type %v", l.t)
+		return nil
+	}
+
+	// The arguments must be single-valued expressions assignment
+	// compatible with the parameters of F.
+	//
+	// XXX(Spec) The spec is wrong.  It can also be a single
+	// multi-valued expression.
+	nin := len(lt.In)
+	assign := a.compileAssign(a.pos, b, NewMultiType(lt.In), as, "function call", "argument")
+	if assign == nil {
+		return nil
+	}
+
+	var t Type
+	nout := len(lt.Out)
+	switch nout {
+	case 0:
+		t = EmptyType
+	case 1:
+		t = lt.Out[0]
+	default:
+		t = NewMultiType(lt.Out)
+	}
+	expr := a.newExpr(t, "function call")
+
+	// Gather argument and out types to initialize frame variables
+	vts := make([]Type, nin+nout)
+	copy(vts, lt.In)
+	copy(vts[nin:], lt.Out)
+
+	// Compile
+	lf := l.asFunc()
+	call := func(t *Thread) []Value {
+		fun := lf(t)
+		fr := fun.NewFrame()
+		for i, t := range vts {
+			fr.Vars[i] = t.Zero()
+		}
+		assign(multiV(fr.Vars[0:nin]), t)
+		oldf := t.f
+		t.f = fr
+		fun.Call(t)
+		t.f = oldf
+		return fr.Vars[nin : nin+nout]
+	}
+	expr.genFuncCall(call)
+
+	return expr
+}
+
+func (a *exprInfo) compileBuiltinCallExpr(b *block, ft *FuncType, as []*expr) *expr {
+	checkCount := func(min, max int) bool {
+		if len(as) < min {
+			a.diag("not enough arguments to %s", ft.builtin)
+			return false
+		} else if len(as) > max {
+			a.diag("too many arguments to %s", ft.builtin)
+			return false
+		}
+		return true
+	}
+
+	switch ft {
+	case capType:
+		if !checkCount(1, 1) {
+			return nil
+		}
+		arg := as[0].derefArray()
+		expr := a.newExpr(IntType, "function call")
+		switch t := arg.t.lit().(type) {
+		case *ArrayType:
+			// TODO(austin) It would be nice if this could
+			// be a constant int.
+			v := t.Len
+			expr.eval = func(t *Thread) int64 { return v }
+
+		case *SliceType:
+			vf := arg.asSlice()
+			expr.eval = func(t *Thread) int64 { return vf(t).Cap }
+
+		//case *ChanType:
+
+		default:
+			a.diag("illegal argument type for cap function\n\t%v", arg.t)
+			return nil
+		}
+		return expr
+
+	case copyType:
+		if !checkCount(2, 2) {
+			return nil
+		}
+		src := as[1]
+		dst := as[0]
+		if src.t != dst.t {
+			a.diag("arguments to built-in function 'copy' must have same type\nsrc: %s\ndst: %s\n", src.t, dst.t)
+			return nil
+		}
+		if _, ok := src.t.lit().(*SliceType); !ok {
+			a.diag("src argument to 'copy' must be a slice (got: %s)", src.t)
+			return nil
+		}
+		if _, ok := dst.t.lit().(*SliceType); !ok {
+			a.diag("dst argument to 'copy' must be a slice (got: %s)", dst.t)
+			return nil
+		}
+		expr := a.newExpr(IntType, "function call")
+		srcf := src.asSlice()
+		dstf := dst.asSlice()
+		expr.eval = func(t *Thread) int64 {
+			src, dst := srcf(t), dstf(t)
+			nelems := src.Len
+			if nelems > dst.Len {
+				nelems = dst.Len
+			}
+			dst.Base.Sub(0, nelems).Assign(t, src.Base.Sub(0, nelems))
+			return nelems
+		}
+		return expr
+
+	case lenType:
+		if !checkCount(1, 1) {
+			return nil
+		}
+		arg := as[0].derefArray()
+		expr := a.newExpr(IntType, "function call")
+		switch t := arg.t.lit().(type) {
+		case *stringType:
+			vf := arg.asString()
+			expr.eval = func(t *Thread) int64 { return int64(len(vf(t))) }
+
+		case *ArrayType:
+			// TODO(austin) It would be nice if this could
+			// be a constant int.
+			v := t.Len
+			expr.eval = func(t *Thread) int64 { return v }
+
+		case *SliceType:
+			vf := arg.asSlice()
+			expr.eval = func(t *Thread) int64 { return vf(t).Len }
+
+		case *MapType:
+			vf := arg.asMap()
+			expr.eval = func(t *Thread) int64 {
+				// XXX(Spec) What's the len of an
+				// uninitialized map?
+				m := vf(t)
+				if m == nil {
+					return 0
+				}
+				return m.Len(t)
+			}
+
+		//case *ChanType:
+
+		default:
+			a.diag("illegal argument type for len function\n\t%v", arg.t)
+			return nil
+		}
+		return expr
+
+	case makeType:
+		if !checkCount(1, 3) {
+			return nil
+		}
+		// XXX(Spec) What are the types of the
+		// arguments?  Do they have to be ints?  6g
+		// accepts any integral type.
+		var lenexpr, capexpr *expr
+		var lenf, capf func(*Thread) int64
+		if len(as) > 1 {
+			lenexpr = as[1].convertToInt(-1, "length", "make function")
+			if lenexpr == nil {
+				return nil
+			}
+			lenf = lenexpr.asInt()
+		}
+		if len(as) > 2 {
+			capexpr = as[2].convertToInt(-1, "capacity", "make function")
+			if capexpr == nil {
+				return nil
+			}
+			capf = capexpr.asInt()
+		}
+
+		switch t := as[0].valType.lit().(type) {
+		case *SliceType:
+			// A new, initialized slice value for a given
+			// element type T is made using the built-in
+			// function make, which takes a slice type and
+			// parameters specifying the length and
+			// optionally the capacity.
+			if !checkCount(2, 3) {
+				return nil
+			}
+			et := t.Elem
+			expr := a.newExpr(t, "function call")
+			expr.eval = func(t *Thread) Slice {
+				l := lenf(t)
+				// XXX(Spec) What if len or cap is
+				// negative?  The runtime panics.
+				if l < 0 {
+					t.Abort(NegativeLengthError{l})
+				}
+				c := l
+				if capf != nil {
+					c = capf(t)
+					if c < 0 {
+						t.Abort(NegativeCapacityError{c})
+					}
+					// XXX(Spec) What happens if
+					// len > cap?  The runtime
+					// sets cap to len.
+					if l > c {
+						c = l
+					}
+				}
+				base := arrayV(make([]Value, c))
+				for i := int64(0); i < c; i++ {
+					base[i] = et.Zero()
+				}
+				return Slice{&base, l, c}
+			}
+			return expr
+
+		case *MapType:
+			// A new, empty map value is made using the
+			// built-in function make, which takes the map
+			// type and an optional capacity hint as
+			// arguments.
+			if !checkCount(1, 2) {
+				return nil
+			}
+			expr := a.newExpr(t, "function call")
+			expr.eval = func(t *Thread) Map {
+				if lenf == nil {
+					return make(evalMap)
+				}
+				l := lenf(t)
+				return make(evalMap, l)
+			}
+			return expr
+
+		//case *ChanType:
+
+		default:
+			a.diag("illegal argument type for make function\n\t%v", as[0].valType)
+			return nil
+		}
+
+	case closeType, closedType:
+		a.diag("built-in function %s not implemented", ft.builtin)
+		return nil
+
+	case newType:
+		if !checkCount(1, 1) {
+			return nil
+		}
+
+		t := as[0].valType
+		expr := a.newExpr(NewPtrType(t), "new")
+		expr.eval = func(*Thread) Value { return t.Zero() }
+		return expr
+
+	case panicType, printType, printlnType:
+		evals := make([]func(*Thread) interface{}, len(as))
+		for i, x := range as {
+			evals[i] = x.asInterface()
+		}
+		spaces := ft == printlnType
+		newline := ft != printType
+		printer := func(t *Thread) {
+			for i, eval := range evals {
+				if i > 0 && spaces {
+					print(" ")
+				}
+				v := eval(t)
+				type stringer interface {
+					String() string
+				}
+				switch v1 := v.(type) {
+				case bool:
+					print(v1)
+				case uint64:
+					print(v1)
+				case int64:
+					print(v1)
+				case float64:
+					print(v1)
+				case string:
+					print(v1)
+				case stringer:
+					print(v1.String())
+				default:
+					print("???")
+				}
+			}
+			if newline {
+				print("\n")
+			}
+		}
+		expr := a.newExpr(EmptyType, "print")
+		expr.exec = printer
+		if ft == panicType {
+			expr.exec = func(t *Thread) {
+				printer(t)
+				t.Abort(os.NewError("panic"))
+			}
+		}
+		return expr
+	}
+
+	log.Panicf("unexpected built-in function '%s'", ft.builtin)
+	panic("unreachable")
+}
+
+func (a *exprInfo) compileStarExpr(v *expr) *expr {
+	switch vt := v.t.lit().(type) {
+	case *PtrType:
+		expr := a.newExpr(vt.Elem, "indirect expression")
+		vf := v.asPtr()
+		expr.genValue(func(t *Thread) Value {
+			v := vf(t)
+			if v == nil {
+				t.Abort(NilPointerError{})
+			}
+			return v
+		})
+		return expr
+	}
+
+	a.diagOpType(token.MUL, v.t)
+	return nil
+}
+
+var unaryOpDescs = make(map[token.Token]string)
+
+func (a *exprInfo) compileUnaryExpr(op token.Token, v *expr) *expr {
+	// Type check
+	var t Type
+	switch op {
+	case token.ADD, token.SUB:
+		if !v.t.isInteger() && !v.t.isFloat() {
+			a.diagOpType(op, v.t)
+			return nil
+		}
+		t = v.t
+
+	case token.NOT:
+		if !v.t.isBoolean() {
+			a.diagOpType(op, v.t)
+			return nil
+		}
+		t = BoolType
+
+	case token.XOR:
+		if !v.t.isInteger() {
+			a.diagOpType(op, v.t)
+			return nil
+		}
+		t = v.t
+
+	case token.AND:
+		// The unary prefix address-of operator & generates
+		// the address of its operand, which must be a
+		// variable, pointer indirection, field selector, or
+		// array or slice indexing operation.
+		if v.evalAddr == nil {
+			a.diag("cannot take the address of %s", v.desc)
+			return nil
+		}
+
+		// TODO(austin) Implement "It is illegal to take the
+		// address of a function result variable" once I have
+		// function result variables.
+
+		t = NewPtrType(v.t)
+
+	case token.ARROW:
+		log.Panicf("Unary op %v not implemented", op)
+
+	default:
+		log.Panicf("unknown unary operator %v", op)
+	}
+
+	desc, ok := unaryOpDescs[op]
+	if !ok {
+		desc = "unary " + op.String() + " expression"
+		unaryOpDescs[op] = desc
+	}
+
+	// Compile
+	expr := a.newExpr(t, desc)
+	switch op {
+	case token.ADD:
+		// Just compile it out
+		expr = v
+		expr.desc = desc
+
+	case token.SUB:
+		expr.genUnaryOpNeg(v)
+
+	case token.NOT:
+		expr.genUnaryOpNot(v)
+
+	case token.XOR:
+		expr.genUnaryOpXor(v)
+
+	case token.AND:
+		vf := v.evalAddr
+		expr.eval = func(t *Thread) Value { return vf(t) }
+
+	default:
+		log.Panicf("Compilation of unary op %v not implemented", op)
+	}
+
+	return expr
+}
+
+var binOpDescs = make(map[token.Token]string)
+
+func (a *exprInfo) compileBinaryExpr(op token.Token, l, r *expr) *expr {
+	// Save the original types of l.t and r.t for error messages.
+	origlt := l.t
+	origrt := r.t
+
+	// XXX(Spec) What is the exact definition of a "named type"?
+
+	// XXX(Spec) Arithmetic operators: "Integer types" apparently
+	// means all types compatible with basic integer types, though
+	// this is never explained.  Likewise for float types, etc.
+	// This relates to the missing explanation of named types.
+
+	// XXX(Spec) Operators: "If both operands are ideal numbers,
+	// the conversion is to ideal floats if one of the operands is
+	// an ideal float (relevant for / and %)."  How is that
+	// relevant only for / and %?  If I add an ideal int and an
+	// ideal float, I get an ideal float.
+
+	if op != token.SHL && op != token.SHR {
+		// Except in shift expressions, if one operand has
+		// numeric type and the other operand is an ideal
+		// number, the ideal number is converted to match the
+		// type of the other operand.
+		if (l.t.isInteger() || l.t.isFloat()) && !l.t.isIdeal() && r.t.isIdeal() {
+			r = r.convertTo(l.t)
+		} else if (r.t.isInteger() || r.t.isFloat()) && !r.t.isIdeal() && l.t.isIdeal() {
+			l = l.convertTo(r.t)
+		}
+		if l == nil || r == nil {
+			return nil
+		}
+
+		// Except in shift expressions, if both operands are
+		// ideal numbers and one is an ideal float, the other
+		// is converted to ideal float.
+		if l.t.isIdeal() && r.t.isIdeal() {
+			if l.t.isInteger() && r.t.isFloat() {
+				l = l.convertTo(r.t)
+			} else if l.t.isFloat() && r.t.isInteger() {
+				r = r.convertTo(l.t)
+			}
+			if l == nil || r == nil {
+				return nil
+			}
+		}
+	}
+
+	// Useful type predicates
+	// TODO(austin) CL 33668 mandates identical types except for comparisons.
+	compat := func() bool { return l.t.compat(r.t, false) }
+	integers := func() bool { return l.t.isInteger() && r.t.isInteger() }
+	floats := func() bool { return l.t.isFloat() && r.t.isFloat() }
+	strings := func() bool {
+		// TODO(austin) Deal with named types
+		return l.t == StringType && r.t == StringType
+	}
+	booleans := func() bool { return l.t.isBoolean() && r.t.isBoolean() }
+
+	// Type check
+	var t Type
+	switch op {
+	case token.ADD:
+		if !compat() || (!integers() && !floats() && !strings()) {
+			a.diagOpTypes(op, origlt, origrt)
+			return nil
+		}
+		t = l.t
+
+	case token.SUB, token.MUL, token.QUO:
+		if !compat() || (!integers() && !floats()) {
+			a.diagOpTypes(op, origlt, origrt)
+			return nil
+		}
+		t = l.t
+
+	case token.REM, token.AND, token.OR, token.XOR, token.AND_NOT:
+		if !compat() || !integers() {
+			a.diagOpTypes(op, origlt, origrt)
+			return nil
+		}
+		t = l.t
+
+	case token.SHL, token.SHR:
+		// XXX(Spec) Is it okay for the right operand to be an
+		// ideal float with no fractional part?  "The right
+		// operand in a shift operation must be always be of
+		// unsigned integer type or an ideal number that can
+		// be safely converted into an unsigned integer type
+		// (§Arithmetic operators)" suggests so and 6g agrees.
+
+		if !l.t.isInteger() || !(r.t.isInteger() || r.t.isIdeal()) {
+			a.diagOpTypes(op, origlt, origrt)
+			return nil
+		}
+
+		// The right operand in a shift operation must be
+		// always be of unsigned integer type or an ideal
+		// number that can be safely converted into an
+		// unsigned integer type.
+		if r.t.isIdeal() {
+			r2 := r.convertTo(UintType)
+			if r2 == nil {
+				return nil
+			}
+
+			// If the left operand is not ideal, convert
+			// the right to not ideal.
+			if !l.t.isIdeal() {
+				r = r2
+			}
+
+			// If both are ideal, but the right side isn't
+			// an ideal int, convert it to simplify things.
+			if l.t.isIdeal() && !r.t.isInteger() {
+				r = r.convertTo(IdealIntType)
+				if r == nil {
+					log.Panicf("conversion to uintType succeeded, but conversion to idealIntType failed")
+				}
+			}
+		} else if _, ok := r.t.lit().(*uintType); !ok {
+			a.diag("right operand of shift must be unsigned")
+			return nil
+		}
+
+		if l.t.isIdeal() && !r.t.isIdeal() {
+			// XXX(Spec) What is the meaning of "ideal >>
+			// non-ideal"?  Russ says the ideal should be
+			// converted to an int.  6g propagates the
+			// type down from assignments as a hint.
+
+			l = l.convertTo(IntType)
+			if l == nil {
+				return nil
+			}
+		}
+
+		// At this point, we should have one of three cases:
+		// 1) uint SHIFT uint
+		// 2) int SHIFT uint
+		// 3) ideal int SHIFT ideal int
+
+		t = l.t
+
+	case token.LOR, token.LAND:
+		if !booleans() {
+			return nil
+		}
+		// XXX(Spec) There's no mention of *which* boolean
+		// type the logical operators return.  From poking at
+		// 6g, it appears to be the named boolean type, NOT
+		// the type of the left operand, and NOT an unnamed
+		// boolean type.
+
+		t = BoolType
+
+	case token.ARROW:
+		// The operands in channel sends differ in type: one
+		// is always a channel and the other is a variable or
+		// value of the channel's element type.
+		log.Panic("Binary op <- not implemented")
+		t = BoolType
+
+	case token.LSS, token.GTR, token.LEQ, token.GEQ:
+		// XXX(Spec) It's really unclear what types which
+		// comparison operators apply to.  I feel like the
+		// text is trying to paint a Venn diagram for me,
+		// which it's really pretty simple: <, <=, >, >= apply
+		// only to numeric types and strings.  == and != apply
+		// to everything except arrays and structs, and there
+		// are some restrictions on when it applies to slices.
+
+		if !compat() || (!integers() && !floats() && !strings()) {
+			a.diagOpTypes(op, origlt, origrt)
+			return nil
+		}
+		t = BoolType
+
+	case token.EQL, token.NEQ:
+		// XXX(Spec) The rules for type checking comparison
+		// operators are spread across three places that all
+		// partially overlap with each other: the Comparison
+		// Compatibility section, the Operators section, and
+		// the Comparison Operators section.  The Operators
+		// section should just say that operators require
+		// identical types (as it does currently) except that
+		// there a few special cases for comparison, which are
+		// described in section X.  Currently it includes just
+		// one of the four special cases.  The Comparison
+		// Compatibility section and the Comparison Operators
+		// section should either be merged, or at least the
+		// Comparison Compatibility section should be
+		// exclusively about type checking and the Comparison
+		// Operators section should be exclusively about
+		// semantics.
+
+		// XXX(Spec) Comparison operators: "All comparison
+		// operators apply to basic types except bools."  This
+		// is very difficult to parse.  It's explained much
+		// better in the Comparison Compatibility section.
+
+		// XXX(Spec) Comparison compatibility: "Function
+		// values are equal if they refer to the same
+		// function." is rather vague.  It should probably be
+		// similar to the way the rule for map values is
+		// written: Function values are equal if they were
+		// created by the same execution of a function literal
+		// or refer to the same function declaration.  This is
+		// *almost* but not quite waht 6g implements.  If a
+		// function literals does not capture any variables,
+		// then multiple executions of it will result in the
+		// same closure.  Russ says he'll change that.
+
+		// TODO(austin) Deal with remaining special cases
+
+		if !compat() {
+			a.diagOpTypes(op, origlt, origrt)
+			return nil
+		}
+		// Arrays and structs may not be compared to anything.
+		switch l.t.(type) {
+		case *ArrayType, *StructType:
+			a.diagOpTypes(op, origlt, origrt)
+			return nil
+		}
+		t = BoolType
+
+	default:
+		log.Panicf("unknown binary operator %v", op)
+	}
+
+	desc, ok := binOpDescs[op]
+	if !ok {
+		desc = op.String() + " expression"
+		binOpDescs[op] = desc
+	}
+
+	// Check for ideal divide by zero
+	switch op {
+	case token.QUO, token.REM:
+		if r.t.isIdeal() {
+			if (r.t.isInteger() && r.asIdealInt()().Sign() == 0) ||
+				(r.t.isFloat() && r.asIdealFloat()().Sign() == 0) {
+				a.diag("divide by zero")
+				return nil
+			}
+		}
+	}
+
+	// Compile
+	expr := a.newExpr(t, desc)
+	switch op {
+	case token.ADD:
+		expr.genBinOpAdd(l, r)
+
+	case token.SUB:
+		expr.genBinOpSub(l, r)
+
+	case token.MUL:
+		expr.genBinOpMul(l, r)
+
+	case token.QUO:
+		expr.genBinOpQuo(l, r)
+
+	case token.REM:
+		expr.genBinOpRem(l, r)
+
+	case token.AND:
+		expr.genBinOpAnd(l, r)
+
+	case token.OR:
+		expr.genBinOpOr(l, r)
+
+	case token.XOR:
+		expr.genBinOpXor(l, r)
+
+	case token.AND_NOT:
+		expr.genBinOpAndNot(l, r)
+
+	case token.SHL:
+		if l.t.isIdeal() {
+			lv := l.asIdealInt()()
+			rv := r.asIdealInt()()
+			const maxShift = 99999
+			if rv.Cmp(big.NewInt(maxShift)) > 0 {
+				a.diag("left shift by %v; exceeds implementation limit of %v", rv, maxShift)
+				expr.t = nil
+				return nil
+			}
+			val := new(big.Int).Lsh(lv, uint(rv.Int64()))
+			expr.eval = func() *big.Int { return val }
+		} else {
+			expr.genBinOpShl(l, r)
+		}
+
+	case token.SHR:
+		if l.t.isIdeal() {
+			lv := l.asIdealInt()()
+			rv := r.asIdealInt()()
+			val := new(big.Int).Rsh(lv, uint(rv.Int64()))
+			expr.eval = func() *big.Int { return val }
+		} else {
+			expr.genBinOpShr(l, r)
+		}
+
+	case token.LSS:
+		expr.genBinOpLss(l, r)
+
+	case token.GTR:
+		expr.genBinOpGtr(l, r)
+
+	case token.LEQ:
+		expr.genBinOpLeq(l, r)
+
+	case token.GEQ:
+		expr.genBinOpGeq(l, r)
+
+	case token.EQL:
+		expr.genBinOpEql(l, r)
+
+	case token.NEQ:
+		expr.genBinOpNeq(l, r)
+
+	case token.LAND:
+		expr.genBinOpLogAnd(l, r)
+
+	case token.LOR:
+		expr.genBinOpLogOr(l, r)
+
+	default:
+		log.Panicf("Compilation of binary op %v not implemented", op)
+	}
+
+	return expr
+}
+
+// TODO(austin) This is a hack to eliminate a circular dependency
+// between type.go and expr.go
+func (a *compiler) compileArrayLen(b *block, expr ast.Expr) (int64, bool) {
+	lenExpr := a.compileExpr(b, true, expr)
+	if lenExpr == nil {
+		return 0, false
+	}
+
+	// XXX(Spec) Are ideal floats with no fractional part okay?
+	if lenExpr.t.isIdeal() {
+		lenExpr = lenExpr.convertTo(IntType)
+		if lenExpr == nil {
+			return 0, false
+		}
+	}
+
+	if !lenExpr.t.isInteger() {
+		a.diagAt(expr.Pos(), "array size must be an integer")
+		return 0, false
+	}
+
+	switch lenExpr.t.lit().(type) {
+	case *intType:
+		return lenExpr.asInt()(nil), true
+	case *uintType:
+		return int64(lenExpr.asUint()(nil)), true
+	}
+	log.Panicf("unexpected integer type %T", lenExpr.t)
+	return 0, false
+}
+
+func (a *compiler) compileExpr(b *block, constant bool, expr ast.Expr) *expr {
+	ec := &exprCompiler{a, b, constant}
+	nerr := a.numError()
+	e := ec.compile(expr, false)
+	if e == nil && nerr == a.numError() {
+		log.Panicf("expression compilation failed without reporting errors")
+	}
+	return e
+}
+
+// extractEffect separates out any effects that the expression may
+// have, returning a function that will perform those effects and a
+// new exprCompiler that is guaranteed to be side-effect free.  These
+// are the moral equivalents of "temp := expr" and "temp" (or "temp :=
+// &expr" and "*temp" for addressable exprs).  Because this creates a
+// temporary variable, the caller should create a temporary block for
+// the compilation of this expression and the evaluation of the
+// results.
+func (a *expr) extractEffect(b *block, errOp string) (func(*Thread), *expr) {
+	// Create "&a" if a is addressable
+	rhs := a
+	if a.evalAddr != nil {
+		rhs = a.compileUnaryExpr(token.AND, rhs)
+	}
+
+	// Create temp
+	ac, ok := a.checkAssign(a.pos, []*expr{rhs}, errOp, "")
+	if !ok {
+		return nil, nil
+	}
+	if len(ac.rmt.Elems) != 1 {
+		a.diag("multi-valued expression not allowed in %s", errOp)
+		return nil, nil
+	}
+	tempType := ac.rmt.Elems[0]
+	if tempType.isIdeal() {
+		// It's too bad we have to duplicate this rule.
+		switch {
+		case tempType.isInteger():
+			tempType = IntType
+		case tempType.isFloat():
+			tempType = Float64Type
+		default:
+			log.Panicf("unexpected ideal type %v", tempType)
+		}
+	}
+	temp := b.DefineTemp(tempType)
+	tempIdx := temp.Index
+
+	// Create "temp := rhs"
+	assign := ac.compile(b, tempType)
+	if assign == nil {
+		log.Panicf("compileAssign type check failed")
+	}
+
+	effect := func(t *Thread) {
+		tempVal := tempType.Zero()
+		t.f.Vars[tempIdx] = tempVal
+		assign(tempVal, t)
+	}
+
+	// Generate "temp" or "*temp"
+	getTemp := a.compileVariable(0, temp)
+	if a.evalAddr == nil {
+		return effect, getTemp
+	}
+
+	deref := a.compileStarExpr(getTemp)
+	if deref == nil {
+		return nil, nil
+	}
+	return effect, deref
+}