}
 
                // Unpack multiple-return result before type-checking.
+               var funarg *Type
                if Istype(t, TSTRUCT) && t.Funarg != 0 {
-                       t = t.Type
-                       if Istype(t, TFIELD) {
-                               t = t.Type
-                       }
+                       funarg = t
+                       t = t.Type.Type
                }
 
                n.Type = t
                        break OpSwitch
                }
 
-               for args = args.Next; args != nil; args = args.Next {
-                       if args.N.Type == nil {
-                               continue
+               if funarg != nil {
+                       for t := funarg.Type.Down; t != nil; t = t.Down {
+                               if assignop(t.Type, n.Type.Type, nil) == 0 {
+                                       Yyerror("cannot append %v value to []%v", t.Type, n.Type.Type)
+                               }
+                       }
+               } else {
+                       for args = args.Next; args != nil; args = args.Next {
+                               if args.N.Type == nil {
+                                       continue
+                               }
+                               args.N = assignconv(args.N, t.Type, "append")
                        }
-                       args.N = assignconv(args.N, t.Type, "append")
                }
 
                break OpSwitch
 
 
 package main
 
-func f() (_, _ []int) { return }
+func f() (_, _ []int)         { return }
+func g() (x []int, y float64) { return }
 
 func main() {
-       _ = append(f()) // ERROR "cannot use _"
+       _ = append(f()) // ERROR "cannot append \[\]int value to \[\]int"
+       _ = append(g()) // ERROR "cannot append float64 value to \[\]int"
 }