Fix error message from KeyForObj when passing an invalid struct.

service/datastore/properties.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 (
         "encoding/base64"
         "errors"
         "fmt"
@@ skipping 631 matching lines @@
         //   val, err := helper.GetPLS(&MyStruct{10}).GetMeta("id")
         //   // val == 10
         //   // err == nil
         //
         //   type MyStruct struct {
         //     TFlag Toggle `gae:"$flag1,true"`  // defaults to true
         //     FFlag Toggle `gae:"$flag2,false"` // defaults to false
         //     // BadFlag  Toggle `gae:"$flag3"` // ILLEGAL
         //   }
         GetMeta(key string) (interface{}, error)
-
-        // GetMetaDefault is GetMeta, but with a default.
-        //
-        // If the metadata key is not available, or its type doesn't equal the
-        // homogenized type of dflt, then dflt will be returned.
-        //
-        // Type homogenization:
-        //   signed integer types -> int64
-        //   bool                 -> Toggle fields (bool)
-        //
-        // Example:
-        //   pls.GetMetaDefault("foo", 100).(int64)
-        GetMetaDefault(key string, dflt interface{}) interface{}
 }
 
 // PropertyLoadSaver may be implemented by a user type, and Interface will
 // use this interface to serialize the type instead of trying to automatically
 // create a serialization codec for it with helper.GetPLS.
 type PropertyLoadSaver interface {
         // Load takes the values from the given map and attempts to save them into
         // the underlying object (usually a struct or a PropertyMap). If a fatal
         // error occurs, it's returned via error. If non-fatal conversion errors
         // occur, error will be a MultiError containing one or more ErrFieldMismatch
         // objects.
         Load(PropertyMap) error
 
         // Save returns the current property as a PropertyMap. if withMeta is true,
         // then the PropertyMap contains all the metadata (e.g. '$meta' fields)
         // which was held by this PropertyLoadSaver.
         Save(withMeta bool) (PropertyMap, error)
-
-        // Problem indicates that this PLS has a fatal problem. Usually this is
-        // set when the underlying struct has recursion, invalid field types, nested
-        // slices, etc.
-        Problem() error
 }
 
 // MetaGetterSetter is the subset of PropertyLoadSaver which pertains to
 // getting and saving metadata.
 //
 // A *struct may implement this interface to provide metadata which is
 // supplimental to the variety described by GetPLS. For example, this could be
 // used to implement a parsed-out $kind or $id.
 type MetaGetterSetter interface {
         MetaGetter
@@ skipping 83 matching lines @@
         for k, v := range pm {
                 if isMetaKey(k) {
                         newV := make([]Property, len(v))
                         copy(newV, v)
                         ret[k] = newV
                 }
         }
         return ret
 }
 
-// GetMetaDefault is the implementation of PropertyLoadSaver.GetMetaDefault.
-func (pm PropertyMap) GetMetaDefault(key string, dflt interface{}) interface{} {
-        return GetMetaDefaultImpl(pm.GetMeta, key, dflt)
-}
-
 // SetMeta implements PropertyLoadSaver.SetMeta. It will only return an error
 // if `val` has an invalid type (e.g. not one supported by Property).
 func (pm PropertyMap) SetMeta(key string, val interface{}) error {
         prop := Property{}
         if err := prop.SetValue(val, NoIndex); err != nil {
                 return err
         }
         pm["$"+key] = []Property{prop}
         return nil
 }
@@ skipping 21 matching lines @@
         }
         return ret
 }
 
 func isMetaKey(k string) bool {
         // empty counts as a metakey since it's not a valid data key, but it's
         // not really a valid metakey either.
         return k == "" || k[0] == '$'
 }
 
-// GetMetaDefaultImpl is the implementation of PropertyLoadSaver.GetMetaDefault.
+// GetMetaDefault is a helper for GetMeta, allowing a default value.
 //
-// It takes the normal GetMeta function, the key and the default, and returns
-// the value according to PropertyLoadSaver.GetMetaDefault.
-func GetMetaDefaultImpl(gm func(string) (interface{}, error), key string, dflt interface{}) interface{} {
+// If the metadata key is not available, or its type doesn't equal the
+// homogenized type of dflt, then dflt will be returned.
+//
+// Type homogenization:
+//   signed integer types -> int64
+//   bool                 -> Toggle fields (bool)
+//
+// Example:
+//   pls.GetMetaDefault("foo", 100).(int64)
+func GetMetaDefault(getter MetaGetter, key string, dflt interface{}) (interface{}, error) {
         dflt = UpconvertUnderlyingType(dflt)
-        cur, err := gm(key)
+        cur, err := getter.GetMeta(key)
         if err != nil {
-                return dflt
+                if err == ErrMetaFieldUnset {
+                        return dflt, nil
+                }
+                return nil, err
         }
         if dflt != nil && reflect.TypeOf(cur) != reflect.TypeOf(dflt) {
-                return dflt
+                return dflt, nil
         }
-        return cur
+        return cur, nil
 }