Fix error message from KeyForObj when passing an invalid struct.

service/datastore/datastore.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package datastore
 
 import (
         "fmt"
         "reflect"
 
@@ skipping 44 matching lines @@
 
         badSig := false
         mat := multiArgType{}
         isKey := false
 
         if cbTyp.Kind() == reflect.Func && cbTyp.NumIn() == 2 && cbTyp.NumOut() == 1 {
                 firstArg := cbTyp.In(0)
                 if firstArg == typeOfKey {
                         isKey = true
                 } else {
-                        mat = parseArg(firstArg)
-                        badSig = !mat.valid || mat.newElem == nil
+                        mat = parseArg(firstArg, false)
+                        badSig = mat.newElem == nil
                 }
         } else {
                 badSig = true
         }
 
         if badSig || cbTyp.Out(0) != typeOfBool || cbTyp.In(1) != typeOfCursorCB {
                 panic(fmt.Errorf(
                         "cb does not match the required callback signature: `%T` != `func(TYPE, CursorCB) bool`",
                         cbIface))
         }
@@ skipping 59 matching lines @@
                         return true
                 })
         }
         fq, err := q.Finalize()
         if err != nil {
                 return err
         }
 
         slice := v.Elem()
         mat := parseMultiArg(slice.Type())
-        if !mat.valid || mat.newElem == nil {
+        if mat.newElem == nil {
                 return fmt.Errorf("invalid GetAll input type: %T", dst)
         }
 
         errs := map[int]error{}
         i := 0
         err = d.RawInterface.Run(fq, func(k *Key, pm PropertyMap, _ CursorCB) bool {
                 slice.Set(reflect.Append(slice, mat.newElem()))
                 itm := slice.Index(i)
                 mat.setKey(itm, k)
                 err := mat.setPM(itm, pm)
@@ skipping 62 matching lines @@
         return errors.SingleError(d.PutMulti([]interface{}{src}))
 }
 
 func (d *datastoreImpl) Delete(key *Key) (err error) {
         return errors.SingleError(d.DeleteMulti([]*Key{key}))
 }
 
 func (d *datastoreImpl) GetMulti(dst interface{}) error {
         slice := reflect.ValueOf(dst)
         mat := parseMultiArg(slice.Type())
-        if !mat.valid {
-                return fmt.Errorf("invalid GetMulti input type: %T", dst)
-        }
 
         keys, pms, err := mat.GetKeysPMs(d.aid, d.ns, slice, true)
         if err != nil {
                 return err
         }
 
         lme := errors.NewLazyMultiError(len(keys))
         i := 0
         meta := NewMultiMetaGetter(pms)
         err = d.RawInterface.GetMulti(keys, meta, func(pm PropertyMap, err error) {
                 if !lme.Assign(i, err) {
                         lme.Assign(i, mat.setPM(slice.Index(i), pm))
                 }
                 i++
         })
 
         if err == nil {
                 err = lme.Get()
         }
         return err
 }
 
 func (d *datastoreImpl) PutMulti(src interface{}) error {
         slice := reflect.ValueOf(src)
         mat := parseMultiArg(slice.Type())
-        if !mat.valid {
-                return fmt.Errorf("invalid PutMulti input type: %T", src)
-        }
 
         keys, vals, err := mat.GetKeysPMs(d.aid, d.ns, slice, false)
         if err != nil {
                 return err
         }
 
         lme := errors.NewLazyMultiError(len(keys))
         i := 0
         err = d.RawInterface.PutMulti(keys, vals, func(key *Key, err error) {
                 if key != keys[i] {
@@ skipping 19 matching lines @@
         err = lme.Get()
         if err == nil {
                 err = extErr
         }
         return
 }
 
 func (d *datastoreImpl) Raw() RawInterface {
         return d.RawInterface
 }