more "declared and not used".

the last round omitted := range and only
checked 1 out of N vars in a multi-var :=

R=r
OCL=34624
CL=34638

6 files changed, 10 insertions, 12 deletions

diff --git a/src/pkg/gob/codec_test.go b/src/pkg/gob/codec_test.go
index 9564d8c344..8eff37e0a4 100644
--- a/src/pkg/gob/codec_test.go
+++ b/src/pkg/gob/codec_test.go
@@ -42,7 +42,7 @@ func TestUintCodec(t *testing.T) {
 	b := new(bytes.Buffer);
 	encState := new(encoderState);
 	encState.b = b;
-	for i, tt := range encodeT {
+	for _, tt := range encodeT {
 		b.Reset();
 		encodeUint(encState, tt.x);
 		if encState.err != nil {
diff --git a/src/pkg/gob/decode.go b/src/pkg/gob/decode.go
index 2c17aee40c..9f964a340a 100644
--- a/src/pkg/gob/decode.go
+++ b/src/pkg/gob/decode.go
@@ -45,7 +45,7 @@ func overflow(name string) os.ErrorString {
 // decodeUintReader reads an encoded unsigned integer from an io.Reader.
 // Used only by the Decoder to read the message length.
 func decodeUintReader(r io.Reader, buf []byte) (x uint64, err os.Error) {
-	n1, err := r.Read(buf[0:1]);
+	_, err = r.Read(buf[0:1]);
 	if err != nil {
 		return
 	}
diff --git a/src/pkg/gob/decoder.go b/src/pkg/gob/decoder.go
index 3442f80536..52a5015317 100644
--- a/src/pkg/gob/decoder.go
+++ b/src/pkg/gob/decoder.go
@@ -37,7 +37,7 @@ func NewDecoder(r io.Reader) *Decoder {
 
 func (dec *Decoder) recvType(id typeId) {
 	// Have we already seen this type?  That's an error
-	if wt_, alreadySeen := dec.seen[id]; alreadySeen {
+	if _, alreadySeen := dec.seen[id]; alreadySeen {
 		dec.state.err = os.ErrorString("gob: duplicate type received");
 		return
 	}
@@ -54,8 +54,6 @@ func (dec *Decoder) recvType(id typeId) {
 // The value underlying e must be the correct type for the next
 // data item received.
 func (dec *Decoder) Decode(e interface{}) os.Error {
-	rt, indir := indirect(reflect.Typeof(e));
-
 	// Make sure we're single-threaded through here.
 	dec.mutex.Lock();
 	defer dec.mutex.Unlock();
diff --git a/src/pkg/gob/encode.go b/src/pkg/gob/encode.go
index 34e58466d3..45247d5ecc 100644
--- a/src/pkg/gob/encode.go
+++ b/src/pkg/gob/encode.go
@@ -372,7 +372,7 @@ func encOpFor(rt reflect.Type) (encOp, int, os.Error) {
 			};
 		case *reflect.StructType:
 			// Generate a closure that calls out to the engine for the nested type.
-			engine, err := getEncEngine(typ);
+			_, err := getEncEngine(typ);
 			if err != nil {
 				return nil, 0, err
 			}
diff --git a/src/pkg/gob/encoder.go b/src/pkg/gob/encoder.go
index a3c968581f..bda4557643 100644
--- a/src/pkg/gob/encoder.go
+++ b/src/pkg/gob/encoder.go
@@ -237,7 +237,7 @@ func (enc *Encoder) send() {
 
 func (enc *Encoder) sendType(origt reflect.Type) {
 	// Drill down to the base type.
-	rt, indir_ := indirect(origt);
+	rt, _ := indirect(origt);
 
 	// We only send structs - everything else is basic or an error
 	switch rt.(type) {
@@ -259,7 +259,7 @@ func (enc *Encoder) sendType(origt reflect.Type) {
 	}
 
 	// Have we already sent this type?  This time we ask about the base type.
-	if id_, alreadySent := enc.sent[rt]; alreadySent {
+	if _, alreadySent := enc.sent[rt]; alreadySent {
 		return
 	}
 
@@ -296,7 +296,7 @@ func (enc *Encoder) Encode(e interface{}) os.Error {
 	if enc.state.b.Len() > 0 || enc.countState.b.Len() > 0 {
 		panicln("Encoder: buffer not empty")
 	}
-	rt, indir := indirect(reflect.Typeof(e));
+	rt, _ := indirect(reflect.Typeof(e));
 
 	// Make sure we're single-threaded through here.
 	enc.mutex.Lock();
@@ -304,7 +304,7 @@ func (enc *Encoder) Encode(e interface{}) os.Error {
 
 	// Make sure the type is known to the other side.
 	// First, have we already sent this type?
-	if id_, alreadySent := enc.sent[rt]; !alreadySent {
+	if _, alreadySent := enc.sent[rt]; !alreadySent {
 		// No, so send it.
 		enc.sendType(rt);
 		if enc.state.err != nil {
diff --git a/src/pkg/gob/type.go b/src/pkg/gob/type.go
index 8eb384ac7a..21da8771d9 100644
--- a/src/pkg/gob/type.go
+++ b/src/pkg/gob/type.go
@@ -292,7 +292,7 @@ func newTypeObject(name string, rt reflect.Type) (gobType, os.Error) {
 		field := make([]*fieldType, t.NumField());
 		for i := 0; i < t.NumField(); i++ {
 			f := t.Field(i);
-			typ, _indir := indirect(f.Type);
+			typ, _ := indirect(f.Type);
 			tname := typ.Name();
 			if tname == "" {
 				tname = f.Type.String();
@@ -384,7 +384,7 @@ var typeInfoMap = make(map[reflect.Type] *typeInfo)	// protected by typeLock
 // The reflection type must have all its indirections processed out.
 // typeLock must be held.
 func getTypeInfo(rt reflect.Type) (*typeInfo, os.Error) {
-	if pt, ok := rt.(*reflect.PtrType); ok {
+	if _, ok := rt.(*reflect.PtrType); ok {
 		panicln("pointer type in getTypeInfo:", rt.String())
 	}
 	info, ok := typeInfoMap[rt];