Panic when non-runtime-handleable type errors occur

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 147 matching lines @@
         fq, err := q.Finalize()
         if err != nil {
                 return 0, err
         }
         return d.RawInterface.Count(fq)
 }
 
 func (d *datastoreImpl) GetAll(q *Query, dst interface{}) error {
         v := reflect.ValueOf(dst)
         if v.Kind() != reflect.Ptr {
-                return fmt.Errorf("invalid GetAll dst: must have a ptr-to-slice: %T", dst)
+                panic(fmt.Errorf("invalid GetAll dst: must have a ptr-to-slice: %T", dst))
         }
         if !v.IsValid() || v.IsNil() {
-                return errors.New("invalid GetAll dst: <nil>")
+                panic(errors.New("invalid GetAll dst: <nil>"))
         }
 
         if keys, ok := dst.(*[]*Key); ok {
                 fq, err := q.KeysOnly(true).Finalize()
                 if err != nil {
                         return err
                 }
 
                 return d.RawInterface.Run(fq, func(k *Key, _ PropertyMap, _ CursorCB) error {
                         *keys = append(*keys, k)
                         return nil
                 })
         }
         fq, err := q.Finalize()
         if err != nil {
                 return err
         }
 
         slice := v.Elem()
         mat := parseMultiArg(slice.Type())
         if mat.newElem == nil {
-                return fmt.Errorf("invalid GetAll input type: %T", dst)
+                panic(fmt.Errorf("invalid GetAll dst (non-concrete element type): %T", dst))
         }
 
         errs := map[int]error{}
         i := 0
         err = d.RawInterface.Run(fq, func(k *Key, pm PropertyMap, _ CursorCB) error {
                 slice.Set(reflect.Append(slice, mat.newElem()))
                 itm := slice.Index(i)
                 mat.setKey(itm, k)
                 err := mat.setPM(itm, pm)
                 if err != nil {
                         errs[i] = err
                 }
                 i++
                 return nil
         })
         if err == nil {
                 if len(errs) > 0 {
                         me := make(errors.MultiError, slice.Len())
                         for i, e := range errs {
                                 me[i] = e
                         }
                         err = me
                 }
         }
         return err
 }
 
-func isOkType(v reflect.Type) bool {
-        if v == typeOfKey {
-                return false
+func isOkType(t reflect.Type) error {
+        if t == nil {
+                return errors.New("no type information")
         }
-        if v.Implements(typeOfPropertyLoadSaver) {
-                return true
+        if t.Implements(typeOfPropertyLoadSaver) {
+                return nil
         }
-        if v.Kind() == reflect.Ptr && v.Elem().Kind() == reflect.Struct {
-                return true
+        if t == typeOfKey {
+                return errors.New("not user datatype")
         }
-        return false
+        if t.Kind() != reflect.Ptr {
+                return errors.New("not a pointer")
+        }
+        if t.Elem().Kind() != reflect.Struct {
+                return errors.New("does not point to a struct")
+        }
+        return nil
 }
 
 func (d *datastoreImpl) ExistsMulti(keys []*Key) ([]bool, error) {
         lme := errors.NewLazyMultiError(len(keys))
         ret := make([]bool, len(keys))
         i := 0
         err := d.RawInterface.GetMulti(keys, nil, func(_ PropertyMap, err error) error {
                 if err == nil {
                         ret[i] = true
                 } else if err != ErrNoSuchEntity {
                         lme.Assign(i, err)
                 }
                 i++
                 return nil
         })
         if err != nil {
                 return ret, err
         }
         return ret, lme.Get()
 }
 
 func (d *datastoreImpl) Exists(k *Key) (bool, error) {
         ret, err := d.ExistsMulti([]*Key{k})
         return ret[0], errors.SingleError(err)
 }
 
 func (d *datastoreImpl) Get(dst interface{}) (err error) {
-        if !isOkType(reflect.TypeOf(dst)) {
-                return fmt.Errorf("invalid Get input type: %T", dst)
+        if err := isOkType(reflect.TypeOf(dst)); err != nil {
+                panic(fmt.Errorf("invalid Get input type (%T): %s", dst, err))
         }
         return errors.SingleError(d.GetMulti([]interface{}{dst}))
 }
 
 func (d *datastoreImpl) Put(src interface{}) (err error) {
-        if !isOkType(reflect.TypeOf(src)) {
-                return fmt.Errorf("invalid Put input type: %T", src)
+        if err := isOkType(reflect.TypeOf(src)); err != nil {
+                panic(fmt.Errorf("invalid Put input type (%T): %s", src, err))
         }
         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)
@@ skipping 57 matching lines @@
         err = lme.Get()
         if err == nil {
                 err = extErr
         }
         return
 }
 
 func (d *datastoreImpl) Raw() RawInterface {
         return d.RawInterface
 }