code review 2763041: use copy

src/pkg/debug/dwarf/type.go

 // 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.
 
 // DWARF type information structures.
 // The format is heavily biased toward C, but for simplicity
 // the String methods use a pseudo-Go syntax.
 
 package dwarf
 
@@ skipping 436 matching lines @@
                                                 goto Error
                                         }
                                 }
                                 f.Name, _ = kid.Val(AttrName).(string)
                                 f.ByteSize, _ = kid.Val(AttrByteSize).(int64)
                                 f.BitOffset, _ = kid.Val(AttrBitOffset).(int64)
                                 f.BitSize, _ = kid.Val(AttrBitSize).(int64)
                                 n := len(t.Field)
                                 if n >= cap(t.Field) {
                                         fld := make([]*StructField, n, n*2)
-                                        for i, f := range t.Field {
-                                                fld[i] = f
-                                        }
+                                        copy(fld, t.Field)
                                         t.Field = fld
                                 }
                                 t.Field = t.Field[0 : n+1]
                                 t.Field[n] = f
                         }
                 }
 
         case TagConstType, TagVolatileType, TagRestrictType:
                 // Type modifier (DWARF v2 §5.2)
                 // Attributes:
@@ skipping 28 matching lines @@
                 t.EnumName, _ = e.Val(AttrName).(string)
                 t.Val = make([]*EnumValue, 0, 8)
                 for kid := next(); kid != nil; kid = next() {
                         if kid.Tag == TagEnumerator {
                                 f := new(EnumValue)
                                 f.Name, _ = kid.Val(AttrName).(string)
                                 f.Val, _ = kid.Val(AttrConstValue).(int64)
                                 n := len(t.Val)
                                 if n >= cap(t.Val) {
                                         val := make([]*EnumValue, n, n*2)
-                                        for i, f := range t.Val {
-                                                val[i] = f
-                                        }
+                                        copy(val, t.Val)
                                         t.Val = val
                                 }
                                 t.Val = t.Val[0 : n+1]
                                 t.Val[n] = f
                         }
                 }
 
         case TagPointerType:
                 // Type modifier (DWARF v2 §5.2)
                 // Attributes:
@@ skipping 33 matching lines @@
                         case TagFormalParameter:
                                 if tkid = typeOf(kid); err != nil {
                                         goto Error
                                 }
                         case TagUnspecifiedParameters:
                                 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
-                                }
+                                copy(param, t.ParamType)
                                 t.ParamType = param
                         }
                         t.ParamType = t.ParamType[0 : n+1]
                         t.ParamType[n] = tkid
                 }
 
         case TagTypedef:
                 // Typedef (DWARF v2 §5.3)
                 // Attributes:
                 //      AttrName: name [required]
@@ skipping 17 matching lines @@
 
         return typ, nil
 
 Error:
         // If the parse fails, take the type out of the cache
         // so that the next call with this offset doesn't hit
         // the cache and return success.
         d.typeCache[off] = nil, false
         return nil, err
 }