move austin/eval and austin/ogle to exp/eval and exp/ogle

R=r
OCL=35736
CL=35746

1 files changed, 0 insertions, 2007 deletions

diff --git a/usr/austin/eval/expr.go b/usr/austin/eval/expr.go
deleted file mode 100644
index ea4fc082b..000000000
--- a/usr/austin/eval/expr.go
+++ /dev/null
@@ -1,2007 +0,0 @@
-// 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 (
-	"bignum";
-	"go/ast";
-	"go/token";
-	"log";
-	"strconv";
-	"strings";
-	"os";
-)
-
-// 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.Position;
-}
-
-func (a *exprInfo) newExpr(t Type, desc string) *expr {
-	return &expr{exprInfo: a, t: t, desc: desc};
-}
-
-func (a *exprInfo) diag(format string, args ...) {
-	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.Crashf("attempted to convert from %v, expected ideal", a.t);
-	}
-
-	var rat *bignum.Rational;
-
-	// 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", ratToString(rat));
-			return nil;
-		}
-	case IdealIntType:
-		i := a.asIdealInt()();
-		rat = bignum.MakeRat(i, bignum.Nat(1));
-	default:
-		log.Crashf("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", ratToString(rat), t);
-			return nil;
-		}
-		if rat.Cmp(t.maxVal()) > 0 {
-			a.diag("constant %v overflows %v", ratToString(rat), t);
-			return nil;
-		}
-	}
-
-	// Convert rat to type t.
-	res := a.newExpr(t, a.desc);
-	switch t := t.lit().(type) {
-	case *uintType:
-		n, d := rat.Value();
-		f := n.Quo(bignum.MakeInt(false, d));
-		v := f.Abs().Value();
-		res.eval = func(*Thread) uint64 { return v };
-	case *intType:
-		n, d := rat.Value();
-		f := n.Quo(bignum.MakeInt(false, d));
-		v := f.Value();
-		res.eval = func(*Thread) int64 { return v };
-	case *idealIntType:
-		n, d := rat.Value();
-		f := n.Quo(bignum.MakeInt(false, d));
-		res.eval = func() *bignum.Integer { return f };
-	case *floatType:
-		n, d := rat.Value();
-		v := float64(n.Value())/float64(d.Value());
-		res.eval = func(*Thread) float64 { return v };
-	case *idealFloatType:
-		res.eval = func() *bignum.Rational { return rat };
-	default:
-		log.Crashf("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.IsNeg() {
-			a.diag("negative %s: %s", negErr, val);
-			return nil;
-		}
-		bound := max;
-		if negErr == "slice" {
-			bound++;
-		}
-		if max != -1 && val.Cmp(bignum.Int(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.Crashf("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.Position;
-	// 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.Position, 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 {
-			panicln("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.Crashf("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.Position, 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.Crashf("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, "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, "function call in constant context");
-			return nil;
-		}
-
-		if l.valType != nil {
-			a.diagAt(x, "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.Value);
-
-	case *ast.IndexExpr:
-		if x.End != nil {
-			arr := a.compile(x.X, false);
-			lo := a.compile(x.Index, false);
-			hi := a.compile(x.End, false);
-			if arr == nil || lo == nil || hi == nil {
-				return nil;
-			}
-			return ei.compileSliceExpr(arr, lo, hi);
-		}
-		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.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.Value);
-
-	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.StringList:
-		strings := make([]*expr, len(x.Strings));
-		bad := false;
-		for i, s := range x.Strings {
-			strings[i] = a.compile(s, false);
-			if strings[i] == nil {
-				bad = true;
-			}
-		}
-		if bad {
-			return nil;
-		}
-		return ei.compileStringList(strings);
-
-	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.Crashf("unexpected ast node type %T", x);
-	panic();
-
-typeexpr:
-	if !callCtx {
-		a.diagAt(x, "type used as expression");
-		return nil;
-	}
-	return ei.exprFromType(a.compileType(a.block, x));
-
-notimpl:
-	a.diagAt(x, "%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.Crashf("name %s has unknown type %T", name, def);
-	panic();
-}
-
-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 *bignum.Integer, desc string) *expr {
-	expr := a.newExpr(IdealIntType, desc);
-	expr.eval = func() *bignum.Integer { return i };
-	return expr;
-}
-
-func (a *exprInfo) compileIntLit(lit string) *expr {
-	i, _, _ := bignum.IntFromString(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:len(lit)], '\'');
-	if err != nil || tail != "'" {
-		// Caught by parser
-		a.silentErrors++;
-		return nil;
-	}
-	return a.compileIdealInt(bignum.Int(int64(v)), "character literal");
-}
-
-func (a *exprInfo) compileFloatLit(lit string) *expr {
-	f, _, n := bignum.RatFromString(lit, 0);
-	if n != len(lit) {
-		log.Crashf("malformed float literal %s at %v passed parser", lit, a.pos);
-	}
-	expr := a.newExpr(IdealFloatType, "float literal");
-	expr.eval = func() *bignum.Rational { 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.Crashf("Marked field at depth %d, but already found one at depth %d", depth, bestDepth);
-		}
-		amberr += "\n\t" + pathName[1:len(pathName)];
-	};
-
-	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 _, ok := visited[t]; ok {
-			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.Crash("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.Crashf("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.Crashf("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);
-	for i, t := range lt.In {
-		vts[i] = t;
-	}
-	for i, t := range lt.Out {
-		vts[i+nin] = t;
-	}
-
-	// 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 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, paniclnType, printType, printlnType:
-		evals := make([]func(*Thread)interface{}, len(as));
-		for i, x := range as {
-			evals[i] = x.asInterface();
-		}
-		spaces := ft == paniclnType || 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 || ft == paniclnType {
-			expr.exec = func(t *Thread) {
-				printer(t);
-				t.Abort(os.NewError("panic"));
-			}
-		}
-		return expr;
-	}
-
-	log.Crashf("unexpected built-in function '%s'", ft.builtin);
-	panic();
-}
-
-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.Crashf("Unary op %v not implemented", op);
-
-	default:
-		log.Crashf("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.Crashf("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.Crashf("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.Crash("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.Crashf("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()().IsZero()) ||
-				(r.t.isFloat() && r.asIdealFloat()().IsZero()) {
-				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(bignum.Int(maxShift)) > 0 {
-				a.diag("left shift by %v; exceeds implementation limit of %v", rv, maxShift);
-				expr.t = nil;
-				return nil;
-			}
-			val := lv.Shl(uint(rv.Value()));
-			expr.eval = func() *bignum.Integer { return val };
-		} else {
-			expr.genBinOpShl(l, r);
-		}
-
-	case token.SHR:
-		if l.t.isIdeal() {
-			lv := l.asIdealInt()();
-			rv := r.asIdealInt()();
-			val := lv.Shr(uint(rv.Value()));
-			expr.eval = func() *bignum.Integer { 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.Crashf("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, "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.Crashf("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.Crashf("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 = FloatType;
-		default:
-			log.Crashf("unexpected ideal type %v", tempType);
-		}
-	}
-	temp := b.DefineTemp(tempType);
-	tempIdx := temp.Index;
-
-	// Create "temp := rhs"
-	assign := ac.compile(b, tempType);
-	if assign == nil {
-		log.Crashf("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;
-}