remove semis after statements in one-statement statement lists

R=rsc, r
http://go/go-review/1025029

7 files changed, 122 insertions, 122 deletions

diff --git a/src/pkg/debug/dwarf/buf.go b/src/pkg/debug/dwarf/buf.go
index 87576e65ce..2838c098fd 100644
--- a/src/pkg/debug/dwarf/buf.go
+++ b/src/pkg/debug/dwarf/buf.go
@@ -24,7 +24,7 @@ type buf struct {
 }
 
 func makeBuf(d *Data, name string, off Offset, data []byte, addrsize int) buf {
-	return buf{d, d.order, name, off, data, addrsize, nil};
+	return buf{d, d.order, name, off, data, addrsize, nil}
 }
 
 func (b *buf) uint8() uint8 {
@@ -67,7 +67,7 @@ func (b *buf) string() string {
 func (b *buf) uint16() uint16 {
 	a := b.bytes(2);
 	if a == nil {
-		return 0;
+		return 0
 	}
 	return b.order.Uint16(a);
 }
@@ -75,7 +75,7 @@ func (b *buf) uint16() uint16 {
 func (b *buf) uint32() uint32 {
 	a := b.bytes(4);
 	if a == nil {
-		return 0;
+		return 0
 	}
 	return b.order.Uint32(a);
 }
@@ -83,7 +83,7 @@ func (b *buf) uint32() uint32 {
 func (b *buf) uint64() uint64 {
 	a := b.bytes(8);
 	if a == nil {
-		return 0;
+		return 0
 	}
 	return b.order.Uint64(a);
 }
@@ -115,7 +115,7 @@ func (b *buf) int() int64 {
 	ux, bits := b.varint();
 	x := int64(ux);
 	if x&(1<<(bits-1)) != 0 {
-		x |= -1 << bits;
+		x |= -1 << bits
 	}
 	return x;
 }
@@ -124,13 +124,13 @@ func (b *buf) int() int64 {
 func (b *buf) addr() uint64 {
 	switch b.addrsize {
 	case 1:
-		return uint64(b.uint8());
+		return uint64(b.uint8())
 	case 2:
-		return uint64(b.uint16());
+		return uint64(b.uint16())
 	case 4:
-		return uint64(b.uint32());
+		return uint64(b.uint32())
 	case 8:
-		return uint64(b.uint64());
+		return uint64(b.uint64())
 	}
 	b.error("unknown address size");
 	return 0;
@@ -150,5 +150,5 @@ type DecodeError struct {
 }
 
 func (e DecodeError) String() string {
-	return "decoding dwarf section " + e.Name + " at offset 0x" + strconv.Itob64(int64(e.Offset), 16) + ": " + e.Error;
+	return "decoding dwarf section " + e.Name + " at offset 0x" + strconv.Itob64(int64(e.Offset), 16) + ": " + e.Error
 }
diff --git a/src/pkg/debug/dwarf/const.go b/src/pkg/debug/dwarf/const.go
index 0b626c4b56..808a80c8a4 100644
--- a/src/pkg/debug/dwarf/const.go
+++ b/src/pkg/debug/dwarf/const.go
@@ -165,7 +165,7 @@ func (a Attr) String() string {
 	if int(a) < len(attrNames) {
 		s := attrNames[a];
 		if s != "" {
-			return s;
+			return s
 		}
 	}
 	return strconv.Itoa(int(a));
@@ -175,7 +175,7 @@ func (a Attr) GoString() string {
 	if int(a) < len(attrNames) {
 		s := attrNames[a];
 		if s != "" {
-			return "dwarf.Attr" + s;
+			return "dwarf.Attr" + s
 		}
 	}
 	return "dwarf.Attr(" + strconv.Itoa64(int64(a)) + ")";
@@ -334,7 +334,7 @@ func (t Tag) String() string {
 	if int(t) < len(tagNames) {
 		s := tagNames[t];
 		if s != "" {
-			return s;
+			return s
 		}
 	}
 	return strconv.Itoa(int(t));
@@ -344,7 +344,7 @@ func (t Tag) GoString() string {
 	if int(t) < len(tagNames) {
 		s := tagNames[t];
 		if s != "" {
-			return "dwarf.Tag" + s;
+			return "dwarf.Tag" + s
 		}
 	}
 	return "dwarf.Tag(" + strconv.Itoa64(int64(t)) + ")";
diff --git a/src/pkg/debug/dwarf/entry.go b/src/pkg/debug/dwarf/entry.go
index 97e58af402..9b2727b26d 100644
--- a/src/pkg/debug/dwarf/entry.go
+++ b/src/pkg/debug/dwarf/entry.go
@@ -31,14 +31,14 @@ type abbrevTable map[uint32]abbrev
 // in the .debug_abbrev section.
 func (d *Data) parseAbbrev(off uint32) (abbrevTable, os.Error) {
 	if m, ok := d.abbrevCache[off]; ok {
-		return m, nil;
+		return m, nil
 	}
 
 	data := d.abbrev;
 	if off > uint32(len(data)) {
-		data = nil;
+		data = nil
 	} else {
-		data = data[off:len(data)];
+		data = data[off:len(data)]
 	}
 	b := makeBuf(d, "abbrev", 0, data, 0);
 
@@ -49,7 +49,7 @@ func (d *Data) parseAbbrev(off uint32) (abbrevTable, os.Error) {
 		// Table ends with id == 0.
 		id := uint32(b.uint());
 		if id == 0 {
-			break;
+			break
 		}
 
 		// Walk over attributes, counting.
@@ -61,12 +61,12 @@ func (d *Data) parseAbbrev(off uint32) (abbrevTable, os.Error) {
 			tag := b1.uint();
 			fmt := b1.uint();
 			if tag == 0 && fmt == 0 {
-				break;
+				break
 			}
 			n++;
 		}
 		if b1.err != nil {
-			return nil, b1.err;
+			return nil, b1.err
 		}
 
 		// Walk over attributes again, this time writing them down.
@@ -84,7 +84,7 @@ func (d *Data) parseAbbrev(off uint32) (abbrevTable, os.Error) {
 		m[id] = a;
 	}
 	if b.err != nil {
-		return nil, b.err;
+		return nil, b.err
 	}
 	d.abbrevCache[off] = m;
 	return m, nil;
@@ -114,7 +114,7 @@ type Field struct {
 func (e *Entry) Val(a Attr) interface{} {
 	for _, f := range e.Field {
 		if f.Attr == a {
-			return f.Val;
+			return f.Val
 		}
 	}
 	return nil;
@@ -130,7 +130,7 @@ func (b *buf) entry(atab abbrevTable, ubase Offset) *Entry {
 	off := b.off;
 	id := uint32(b.uint());
 	if id == 0 {
-		return &Entry{};
+		return &Entry{}
 	}
 	a, ok := atab[id];
 	if !ok {
@@ -147,66 +147,66 @@ func (b *buf) entry(atab abbrevTable, ubase Offset) *Entry {
 		e.Field[i].Attr = a.field[i].attr;
 		fmt := a.field[i].fmt;
 		if fmt == formIndirect {
-			fmt = format(b.uint());
+			fmt = format(b.uint())
 		}
 		var val interface{}
 		switch fmt {
 		default:
-			b.error("unknown entry attr format");
+			b.error("unknown entry attr format")
 
 		// address
 		case formAddr:
-			val = b.addr();
+			val = b.addr()
 
 		// block
 		case formDwarfBlock1:
-			val = b.bytes(int(b.uint8()));
+			val = b.bytes(int(b.uint8()))
 		case formDwarfBlock2:
-			val = b.bytes(int(b.uint16()));
+			val = b.bytes(int(b.uint16()))
 		case formDwarfBlock4:
-			val = b.bytes(int(b.uint32()));
+			val = b.bytes(int(b.uint32()))
 		case formDwarfBlock:
-			val = b.bytes(int(b.uint()));
+			val = b.bytes(int(b.uint()))
 
 		// constant
 		case formData1:
-			val = int64(b.uint8());
+			val = int64(b.uint8())
 		case formData2:
-			val = int64(b.uint16());
+			val = int64(b.uint16())
 		case formData4:
-			val = int64(b.uint32());
+			val = int64(b.uint32())
 		case formData8:
-			val = int64(b.uint64());
+			val = int64(b.uint64())
 		case formSdata:
-			val = int64(b.int());
+			val = int64(b.int())
 		case formUdata:
-			val = int64(b.uint());
+			val = int64(b.uint())
 
 		// flag
 		case formFlag:
-			val = b.uint8() == 1;
+			val = b.uint8() == 1
 
 		// reference to other entry
 		case formRefAddr:
-			val = Offset(b.addr());
+			val = Offset(b.addr())
 		case formRef1:
-			val = Offset(b.uint8())+ubase;
+			val = Offset(b.uint8())+ubase
 		case formRef2:
-			val = Offset(b.uint16())+ubase;
+			val = Offset(b.uint16())+ubase
 		case formRef4:
-			val = Offset(b.uint32())+ubase;
+			val = Offset(b.uint32())+ubase
 		case formRef8:
-			val = Offset(b.uint64())+ubase;
+			val = Offset(b.uint64())+ubase
 		case formRefUdata:
-			val = Offset(b.uint())+ubase;
+			val = Offset(b.uint())+ubase
 
 		// string
 		case formString:
-			val = b.string();
+			val = b.string()
 		case formStrp:
 			off := b.uint32();	// offset into .debug_str
 			if b.err != nil {
-				return nil;
+				return nil
 			}
 			b1 := makeBuf(b.dwarf, "str", 0, b.dwarf.str, 0);
 			b1.skip(int(off));
@@ -219,7 +219,7 @@ func (b *buf) entry(atab abbrevTable, ubase Offset) *Entry {
 		e.Field[i].Val = val;
 	}
 	if b.err != nil {
-		return nil;
+		return nil
 	}
 	return e;
 }
@@ -254,7 +254,7 @@ func (r *Reader) Seek(off Offset) {
 	r.lastChildren = false;
 	if off == 0 {
 		if len(d.unit) == 0 {
-			return;
+			return
 		}
 		u := &d.unit[0];
 		r.unit = 0;
@@ -291,11 +291,11 @@ func (r *Reader) maybeNextUnit() {
 // offset cannot be decoded as a valid Entry.
 func (r *Reader) Next() (*Entry, os.Error) {
 	if r.err != nil {
-		return nil, r.err;
+		return nil, r.err
 	}
 	r.maybeNextUnit();
 	if len(r.b.data) == 0 {
-		return nil, nil;
+		return nil, nil
 	}
 	u := &r.d.unit[r.unit];
 	e := r.b.entry(u.atable, u.base);
@@ -306,10 +306,10 @@ func (r *Reader) Next() (*Entry, os.Error) {
 	if e != nil {
 		r.lastChildren = e.Children;
 		if r.lastChildren {
-			r.lastSibling, _ = e.Val(AttrSibling).(Offset);
+			r.lastSibling, _ = e.Val(AttrSibling).(Offset)
 		}
 	} else {
-		r.lastChildren = false;
+		r.lastChildren = false
 	}
 	return e, nil;
 }
@@ -319,7 +319,7 @@ func (r *Reader) Next() (*Entry, os.Error) {
 // children or Next has not been called, SkipChildren is a no-op.
 func (r *Reader) SkipChildren() {
 	if r.err != nil || !r.lastChildren {
-		return;
+		return
 	}
 
 	// If the last entry had a sibling attribute,
@@ -334,10 +334,10 @@ func (r *Reader) SkipChildren() {
 	for {
 		e, err := r.Next();
 		if err != nil || e == nil || e.Tag == 0 {
-			break;
+			break
 		}
 		if e.Children {
-			r.SkipChildren();
+			r.SkipChildren()
 		}
 	}
 }
diff --git a/src/pkg/debug/dwarf/open.go b/src/pkg/debug/dwarf/open.go
index 1b50beaa4d..a5cb1a1034 100644
--- a/src/pkg/debug/dwarf/open.go
+++ b/src/pkg/debug/dwarf/open.go
@@ -57,23 +57,23 @@ func New(abbrev, aranges, frame, info, line, pubnames, ranges, str []byte) (*Dat
 	// Sniff .debug_info to figure out byte order.
 	// bytes 4:6 are the version, a tiny 16-bit number (1, 2, 3).
 	if len(d.info) < 6 {
-		return nil, DecodeError{"info", Offset(len(d.info)), "too short"};
+		return nil, DecodeError{"info", Offset(len(d.info)), "too short"}
 	}
 	x, y := d.info[4], d.info[5];
 	switch {
 	case x == 0 && y == 0:
-		return nil, DecodeError{"info", 4, "unsupported version 0"};
+		return nil, DecodeError{"info", 4, "unsupported version 0"}
 	case x == 0:
-		d.order = binary.BigEndian;
+		d.order = binary.BigEndian
 	case y == 0:
-		d.order = binary.LittleEndian;
+		d.order = binary.LittleEndian
 	default:
-		return nil, DecodeError{"info", 4, "cannot determine byte order"};
+		return nil, DecodeError{"info", 4, "cannot determine byte order"}
 	}
 
 	u, err := d.parseUnits();
 	if err != nil {
-		return nil, err;
+		return nil, err
 	}
 	d.unit = u;
 	return d, nil;
diff --git a/src/pkg/debug/dwarf/type.go b/src/pkg/debug/dwarf/type.go
index 77d24f5d27..2cac2e4fb3 100644
--- a/src/pkg/debug/dwarf/type.go
+++ b/src/pkg/debug/dwarf/type.go
@@ -46,7 +46,7 @@ func (b *BasicType) Basic() *BasicType	{ return b }
 
 func (t *BasicType) String() string {
 	if t.Name != "" {
-		return t.Name;
+		return t.Name
 	}
 	return "?";
 }
@@ -113,7 +113,7 @@ type ArrayType struct {
 }
 
 func (t *ArrayType) String() string {
-	return "[" + strconv.Itoa64(t.Count) + "]" + t.Type.String();
+	return "[" + strconv.Itoa64(t.Count) + "]" + t.Type.String()
 }
 
 func (t *ArrayType) Size() int64	{ return t.Count * t.Type.Size() }
@@ -154,7 +154,7 @@ type StructField struct {
 
 func (t *StructType) String() string {
 	if t.StructName != "" {
-		return t.Kind + " " + t.StructName;
+		return t.Kind + " " + t.StructName
 	}
 	return t.Defn();
 }
@@ -162,7 +162,7 @@ func (t *StructType) String() string {
 func (t *StructType) Defn() string {
 	s := t.Kind;
 	if t.StructName != "" {
-		s += " " + t.StructName;
+		s += " " + t.StructName
 	}
 	if t.Incomplete {
 		s += " /*incomplete*/";
@@ -171,7 +171,7 @@ func (t *StructType) Defn() string {
 	s += " {";
 	for i, f := range t.Field {
 		if i > 0 {
-			s += "; ";
+			s += "; "
 		}
 		s += f.Name + " " + f.Type.String();
 		s += "@" + strconv.Itoa64(f.ByteOffset);
@@ -202,12 +202,12 @@ type EnumValue struct {
 func (t *EnumType) String() string {
 	s := "enum";
 	if t.EnumName != "" {
-		s += " " + t.EnumName;
+		s += " " + t.EnumName
 	}
 	s += " {";
 	for i, v := range t.Val {
 		if i > 0 {
-			s += "; ";
+			s += "; "
 		}
 		s += v.Name + "=" + strconv.Itoa64(v.Val);
 	}
@@ -226,13 +226,13 @@ func (t *FuncType) String() string {
 	s := "func(";
 	for i, t := range t.ParamType {
 		if i > 0 {
-			s += ", ";
+			s += ", "
 		}
 		s += t.String();
 	}
 	s += ")";
 	if t.ReturnType != nil {
-		s += " " + t.ReturnType.String();
+		s += " " + t.ReturnType.String()
 	}
 	return s;
 }
@@ -256,17 +256,17 @@ func (t *TypedefType) Size() int64	{ return t.Type.Size() }
 
 func (d *Data) Type(off Offset) (Type, os.Error) {
 	if t, ok := d.typeCache[off]; ok {
-		return t, nil;
+		return t, nil
 	}
 
 	r := d.Reader();
 	r.Seek(off);
 	e, err := r.Next();
 	if err != nil {
-		return nil, err;
+		return nil, err
 	}
 	if e == nil || e.Offset != off {
-		return nil, DecodeError{"info", off, "no type at offset"};
+		return nil, DecodeError{"info", off, "no type at offset"}
 	}
 
 	// Parse type from Entry.
@@ -277,7 +277,7 @@ func (d *Data) Type(off Offset) (Type, os.Error) {
 	// Get next child; set err if error happens.
 	next := func() *Entry {
 		if !e.Children {
-			return nil;
+			return nil
 		}
 		kid, err1 := r.Next();
 		if err1 != nil {
@@ -289,7 +289,7 @@ func (d *Data) Type(off Offset) (Type, os.Error) {
 			return nil;
 		}
 		if kid.Tag == 0 {
-			return nil;
+			return nil
 		}
 		return kid;
 	};
@@ -300,11 +300,11 @@ func (d *Data) Type(off Offset) (Type, os.Error) {
 		toff, ok := e.Val(AttrType).(Offset);
 		if !ok {
 			// It appears that no Type means "void".
-			return new(VoidType);
+			return new(VoidType)
 		}
 		var t Type;
 		if t, err = d.Type(toff); err != nil {
-			return nil;
+			return nil
 		}
 		return t;
 	};
@@ -323,7 +323,7 @@ func (d *Data) Type(off Offset) (Type, os.Error) {
 		typ = t;
 		d.typeCache[off] = t;
 		if t.Type = typeOf(e); err != nil {
-			goto Error;
+			goto Error
 		}
 		t.StrideBitSize, _ = e.Val(AttrStrideSize).(int64);
 
@@ -336,14 +336,14 @@ func (d *Data) Type(off Offset) (Type, os.Error) {
 			case TagSubrangeType:
 				max, ok := kid.Val(AttrUpperBound).(int64);
 				if !ok {
-					max = -2;	// Count == -1, as in x[].
+					max = -2	// Count == -1, as in x[].
 				}
 				if ndim == 0 {
-					t.Count = max+1;
+					t.Count = max+1
 				} else {
 					// Multidimensional array.
 					// Create new array type underneath this one.
-					t.Type = &ArrayType{Type: t.Type, Count: max+1};
+					t.Type = &ArrayType{Type: t.Type, Count: max+1}
 				}
 				ndim++;
 			case TagEnumerationType:
@@ -376,21 +376,21 @@ func (d *Data) Type(off Offset) (Type, os.Error) {
 			goto Error;
 
 		case encAddress:
-			typ = new(AddrType);
+			typ = new(AddrType)
 		case encBoolean:
-			typ = new(BoolType);
+			typ = new(BoolType)
 		case encComplexFloat:
-			typ = new(ComplexType);
+			typ = new(ComplexType)
 		case encFloat:
-			typ = new(FloatType);
+			typ = new(FloatType)
 		case encSigned:
-			typ = new(IntType);
+			typ = new(IntType)
 		case encUnsigned:
-			typ = new(UintType);
+			typ = new(UintType)
 		case encSignedChar:
-			typ = new(CharType);
+			typ = new(CharType)
 		case encUnsignedChar:
-			typ = new(UcharType);
+			typ = new(UcharType)
 		}
 		d.typeCache[off] = typ;
 		t := typ.(interface {
@@ -420,11 +420,11 @@ func (d *Data) Type(off Offset) (Type, os.Error) {
 		d.typeCache[off] = t;
 		switch e.Tag {
 		case TagClassType:
-			t.Kind = "class";
+			t.Kind = "class"
 		case TagStructType:
-			t.Kind = "struct";
+			t.Kind = "struct"
 		case TagUnionType:
-			t.Kind = "union";
+			t.Kind = "union"
 		}
 		t.StructName, _ = e.Val(AttrName).(string);
 		t.Incomplete = e.Val(AttrDeclaration) != nil;
@@ -433,7 +433,7 @@ func (d *Data) Type(off Offset) (Type, os.Error) {
 			if kid.Tag == TagMember {
 				f := new(StructField);
 				if f.Type = typeOf(kid); err != nil {
-					goto Error;
+					goto Error
 				}
 				if loc, ok := kid.Val(AttrDataMemberLoc).([]byte); ok {
 					b := makeBuf(d, "location", 0, loc, d.addrsize);
@@ -455,7 +455,7 @@ func (d *Data) Type(off Offset) (Type, os.Error) {
 				if n >= cap(t.Field) {
 					fld := make([]*StructField, n, n*2);
 					for i, f := range t.Field {
-						fld[i] = f;
+						fld[i] = f
 					}
 					t.Field = fld;
 				}
@@ -472,15 +472,15 @@ func (d *Data) Type(off Offset) (Type, os.Error) {
 		typ = t;
 		d.typeCache[off] = t;
 		if t.Type = typeOf(e); err != nil {
-			goto Error;
+			goto Error
 		}
 		switch e.Tag {
 		case TagConstType:
-			t.Qual = "const";
+			t.Qual = "const"
 		case TagRestrictType:
-			t.Qual = "restrict";
+			t.Qual = "restrict"
 		case TagVolatileType:
-			t.Qual = "volatile";
+			t.Qual = "volatile"
 		}
 
 	case TagEnumerationType:
@@ -506,7 +506,7 @@ func (d *Data) Type(off Offset) (Type, os.Error) {
 				if n >= cap(t.Val) {
 					val := make([]*EnumValue, n, n*2);
 					for i, f := range t.Val {
-						val[i] = f;
+						val[i] = f
 					}
 					t.Val = val;
 				}
@@ -543,26 +543,26 @@ func (d *Data) Type(off Offset) (Type, os.Error) {
 		typ = t;
 		d.typeCache[off] = t;
 		if t.ReturnType = typeOf(e); err != nil {
-			goto Error;
+			goto Error
 		}
 		t.ParamType = make([]Type, 0, 8);
 		for kid := next(); kid != nil; kid = next() {
 			var tkid Type;
 			switch kid.Tag {
 			default:
-				continue;
+				continue
 			case TagFormalParameter:
 				if tkid = typeOf(kid); err != nil {
-					goto Error;
+					goto Error
 				}
 			case TagUnspecifiedParameters:
-				tkid = &DotDotDotType{};
+				tkid = &DotDotDotType{}
 			}
 			n := len(t.ParamType);
 			if n >= cap(t.ParamType) {
 				param := make([]Type, n, n*2);
 				for i, t := range t.ParamType {
-					param[i] = t;
+					param[i] = t
 				}
 				t.ParamType = param;
 			}
@@ -583,12 +583,12 @@ func (d *Data) Type(off Offset) (Type, os.Error) {
 	}
 
 	if err != nil {
-		goto Error;
+		goto Error
 	}
 
 	b, ok := e.Val(AttrByteSize).(int64);
 	if !ok {
-		b = -1;
+		b = -1
 	}
 	typ.Common().ByteSize = b;
 
diff --git a/src/pkg/debug/dwarf/type_test.go b/src/pkg/debug/dwarf/type_test.go
index dcecbe2c3e..629f0fb166 100644
--- a/src/pkg/debug/dwarf/type_test.go
+++ b/src/pkg/debug/dwarf/type_test.go
@@ -32,12 +32,12 @@ var typedefTests = map[string]string{
 func elfData(t *testing.T, name string) *Data {
 	f, err := elf.Open(name);
 	if err != nil {
-		t.Fatal(err);
+		t.Fatal(err)
 	}
 
 	d, err := f.DWARF();
 	if err != nil {
-		t.Fatal(err);
+		t.Fatal(err)
 	}
 	return d;
 }
@@ -45,12 +45,12 @@ func elfData(t *testing.T, name string) *Data {
 func machoData(t *testing.T, name string) *Data {
 	f, err := macho.Open(name);
 	if err != nil {
-		t.Fatal(err);
+		t.Fatal(err)
 	}
 
 	d, err := f.DWARF();
 	if err != nil {
-		t.Fatal(err);
+		t.Fatal(err)
 	}
 	return d;
 }
@@ -59,7 +59,7 @@ func machoData(t *testing.T, name string) *Data {
 func TestTypedefsELF(t *testing.T)	{ testTypedefs(t, elfData(t, "testdata/typedef.elf")) }
 
 func TestTypedefsMachO(t *testing.T) {
-	testTypedefs(t, machoData(t, "testdata/typedef.macho"));
+	testTypedefs(t, machoData(t, "testdata/typedef.macho"))
 }
 
 func testTypedefs(t *testing.T, d *Data) {
@@ -68,42 +68,42 @@ func testTypedefs(t *testing.T, d *Data) {
 	for {
 		e, err := r.Next();
 		if err != nil {
-			t.Fatal("r.Next:", err);
+			t.Fatal("r.Next:", err)
 		}
 		if e == nil {
-			break;
+			break
 		}
 		if e.Tag == TagTypedef {
 			typ, err := d.Type(e.Offset);
 			if err != nil {
-				t.Fatal("d.Type:", err);
+				t.Fatal("d.Type:", err)
 			}
 			t1 := typ.(*TypedefType);
 			var typstr string;
 			if ts, ok := t1.Type.(*StructType); ok {
-				typstr = ts.Defn();
+				typstr = ts.Defn()
 			} else {
-				typstr = t1.Type.String();
+				typstr = t1.Type.String()
 			}
 
 			if want, ok := typedefTests[t1.Name]; ok {
 				if _, ok := seen[t1.Name]; ok {
-					t.Errorf("multiple definitions for %s", t1.Name);
+					t.Errorf("multiple definitions for %s", t1.Name)
 				}
 				seen[t1.Name] = true;
 				if typstr != want {
-					t.Errorf("%s:\n\thave %s\n\twant %s", t1.Name, typstr, want);
+					t.Errorf("%s:\n\thave %s\n\twant %s", t1.Name, typstr, want)
 				}
 			}
 		}
 		if e.Tag != TagCompileUnit {
-			r.SkipChildren();
+			r.SkipChildren()
 		}
 	}
 
 	for k := range typedefTests {
 		if _, ok := seen[k]; !ok {
-			t.Errorf("missing %s", k);
+			t.Errorf("missing %s", k)
 		}
 	}
 }
diff --git a/src/pkg/debug/dwarf/unit.go b/src/pkg/debug/dwarf/unit.go
index d4bcf5889d..582fd0cf27 100644
--- a/src/pkg/debug/dwarf/unit.go
+++ b/src/pkg/debug/dwarf/unit.go
@@ -29,7 +29,7 @@ func (d *Data) parseUnits() ([]unit, os.Error) {
 		nunit++;
 	}
 	if b.err != nil {
-		return nil, b.err;
+		return nil, b.err
 	}
 
 	// Again, this time writing them down.
@@ -46,7 +46,7 @@ func (d *Data) parseUnits() ([]unit, os.Error) {
 		atable, err := d.parseAbbrev(b.uint32());
 		if err != nil {
 			if b.err == nil {
-				b.err = err;
+				b.err = err
 			}
 			break;
 		}
@@ -56,7 +56,7 @@ func (d *Data) parseUnits() ([]unit, os.Error) {
 		u.data = b.bytes(int(n-(2+4+1)));
 	}
 	if b.err != nil {
-		return nil, b.err;
+		return nil, b.err
 	}
 	return units, nil;
 }