code review 7129046: go/types: correct result type for append (bug fix)

src/pkg/go/types/builtins.go

 // Copyright 2012 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.
 
 // This file implements typechecking of builtin function calls.
 
 package types
 
 import (
         "go/ast"
         "go/token"
 )
 
 // builtin typechecks a built-in call. The built-in type is bin, and iota is the current
 // value of iota or -1 if iota doesn't have a value in the current context. The result
 // of the call is returned via x. If the call has type errors, the returned x is marked
 // as invalid (x.mode == invalid).
 //
 func (check *checker) builtin(x *operand, call *ast.CallExpr, bin *builtin, iota int) {
         args := call.Args
         id := bin.id
 
         // declare before goto's
         var arg0 ast.Expr // first argument, if present
-        var utyp0 Type    // underlying type of first argument (nil for _Make, _New, _Trace)
 
         // check argument count
         n := len(args)
         msg := ""
         if n < bin.nargs {
                 msg = "not enough"
         } else if !bin.isVariadic && n > bin.nargs {
                 msg = "too many"
         }
         if msg != "" {
                 check.invalidOp(call.Pos(), msg+" arguments for %s (expected %d, found %d)", call, bin.nargs, n)
                 goto Error
         }
 
         // common case: evaluate first argument if present;
         // if it is an expression, x has the expression value
         if n > 0 {
                 arg0 = args[0]
                 switch id {
                 case _Make, _New, _Trace:
                         // respective cases below do the work
                 default:
                         // argument must be an expression
                         check.expr(x, arg0, nil, iota)
                         if x.mode == invalid {
                                 goto Error
                         }
-                        utyp0 = underlying(x.typ)
                 }
         }
 
         switch id {
         case _Append:
-                if _, ok := utyp0.(*Slice); !ok {
+                if _, ok := underlying(x.typ).(*Slice); !ok {
                         check.invalidArg(x.pos(), "%s is not a typed slice", x)
                         goto Error
                 }
                 resultTyp := x.typ
                 for _, arg := range args[1:] {
                         check.expr(x, arg, nil, iota)
                         if x.mode == invalid {
                                 goto Error
                         }
                         // TODO(gri) check assignability
                 }
                 x.mode = value
                 x.typ = resultTyp
 
         case _Cap, _Len:
                 mode := invalid
                 var val interface{}
-                switch typ := implicitDeref(utyp0).(type) {
+                switch typ := implicitDeref(underlying(x.typ)).(type) {
                 case *Basic:
                         if isString(typ) && id == _Len {
                                 if x.mode == constant {
                                         mode = constant
                                         val = int64(len(x.val.(string)))
                                 } else {
                                         mode = value
                                 }
                         }
 
@@ skipping 15 matching lines @@
 
                 if mode == invalid {
                         check.invalidArg(x.pos(), "%s for %s", x, bin.name)
                         goto Error
                 }
                 x.mode = mode
                 x.typ = Typ[Int]
                 x.val = val
 
         case _Close:
-                ch, ok := utyp0.(*Chan)
+                ch, ok := underlying(x.typ).(*Chan)
                 if !ok {
                         check.invalidArg(x.pos(), "%s is not a channel", x)
                         goto Error
                 }
                 if ch.Dir&ast.SEND == 0 {
                         check.invalidArg(x.pos(), "%s must not be a receive-only channel", x)
                         goto Error
                 }
                 x.mode = novalue
 
@@ skipping 45 matching lines @@
                 }
 
         case _Copy:
                 var y operand
                 check.expr(&y, args[1], nil, iota)
                 if y.mode == invalid {
                         goto Error
                 }
 
                 var dst, src Type
-                if t, ok := utyp0.(*Slice); ok {
+                if t, ok := underlying(x.typ).(*Slice); ok {
                         dst = t.Elt
                 }
                 switch t := underlying(y.typ).(type) {
                 case *Basic:
                         if isString(y.typ) {
                                 src = Typ[Byte]
                         }
                 case *Slice:
                         src = t.Elt
                 }
 
                 if dst == nil || src == nil {
                         check.invalidArg(x.pos(), "copy expects slice arguments; found %s and %s", x, &y)
                         goto Error
                 }
 
                 if !isIdentical(dst, src) {
                         check.invalidArg(x.pos(), "arguments to copy %s and %s have different element types %s and %s", x, &y, dst, src)
                         goto Error
                 }
 
                 x.mode = value
                 x.typ = Typ[Int]
 
         case _Delete:
-                m, ok := utyp0.(*Map)
+                m, ok := underlying(x.typ).(*Map)
                 if !ok {
                         check.invalidArg(x.pos(), "%s is not a map", x)
                         goto Error
                 }
                 check.expr(x, args[1], nil, iota)
                 if x.mode == invalid {
                         goto Error
                 }
                 if !x.isAssignable(m.Key) {
                         check.invalidArg(x.pos(), "%s is not assignable to %s", x, m.Key)
                         goto Error
                 }
                 x.mode = novalue
 
         case _Imag, _Real:
-                if !isComplex(utyp0) {
+                if !isComplex(x.typ) {
                         check.invalidArg(x.pos(), "%s must be a complex number", x)
                         goto Error
                 }
                 if x.mode == constant {
                         // nothing to do for x.val == 0
                         if !isZeroConst(x.val) {
                                 c := x.val.(Complex)
                                 if id == _Real {
                                         x.val = c.Re
                                 } else {
                                         x.val = c.Im
                                 }
                         }
                 } else {
                         x.mode = value
                 }
                 k := Invalid
-                switch utyp0.(*Basic).Kind {
+                switch underlying(x.typ).(*Basic).Kind {
                 case Complex64:
                         k = Float32
                 case Complex128:
                         k = Float64
                 case UntypedComplex:
                         k = UntypedFloat
                 default:
                         unreachable()
                 }
                 x.typ = Typ[k]
@@ skipping 81 matching lines @@
 
         case _Sizeof:
                 x.mode = constant
                 x.val = sizeof(check.ctxt, x.typ)
                 x.typ = Typ[Uintptr]
 
         case _Assert:
                 // assert(pred) causes a typechecker error if pred is false.
                 // The result of assert is the value of pred if there is no error.
                 // Note: assert is only available in self-test mode.
-                if x.mode != constant || !isBoolean(utyp0) {
+                if x.mode != constant || !isBoolean(x.typ) {
                         check.invalidArg(x.pos(), "%s is not a boolean constant", x)
                         goto Error
                 }
                 pred, ok := x.val.(bool)
                 if !ok {
                         check.errorf(x.pos(), "internal error: value of %s should be a boolean constant", x)
                         goto Error
                 }
                 if !pred {
                         check.errorf(call.Pos(), "%s failed", call)
@@ skipping 98 matching lines @@
                 return sizeof(ctxt, typ.Elt) * typ.Len
         case *Struct:
                 var size int64
                 for _, f := range typ.Fields {
                         size += sizeof(ctxt, f.Type)
                 }
                 return size
         }
         return ctxt.PtrSize // good enough
 }