Re-add metadata passthrough on Get operations

service/datastore/pls_impl.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.
 
 // HEAVILY adapted from github.com/golang/appengine/datastore
 
 package datastore
 
 import (
         "fmt"
@@ skipping 322 matching lines @@
                 if !reflect.DeepEqual(reflect.Zero(f.Type()).Interface(), f.Interface()) {
                         val = f.Interface()
                         if bf, ok := val.(Toggle); ok {
                                 val = bf == On // true if On, otherwise false
                         }
                 }
         }
         return val, nil
 }
 
+func (p *structPLS) GetMetaDefault(key string, def interface{}) interface{} {
+        return GetMetaDefaultImpl(p.GetMeta, key, def)
+}
+
 func (p *structPLS) SetMeta(key string, val interface{}) (err error) {
         if err = p.Problem(); err != nil {
                 return
         }
         idx, ok := p.c.byMeta[key]
         if !ok {
                 return ErrMetaFieldUnset
         }
         if !p.c.byIndex[idx].canSet {
                 return fmt.Errorf("gae/helper: cannot set meta %q: unexported field", key)
@@ skipping 179 matching lines @@
                                         return
                                 }
                                 c.byName[absName] = i
                         }
                 } else {
                         if !st.convert { // check the underlying static type of the field
                                 t := ft
                                 if st.isSlice {
                                         t = t.Elem()
                                 }
-                                v := reflect.New(t).Elem().Interface()
-                                v, _ = UpconvertUnderlyingType(v, t)
+                                v := UpconvertUnderlyingType(reflect.New(t).Elem().Interface())
                                 if _, err := PropertyTypeOf(v, false); err != nil {
                                         c.problem = me("field %q has invalid type: %s", name, ft)
                                         return
                                 }
                         }
 
                         if _, ok := c.byName[name]; ok {
                                 c.problem = me("struct tag has repeated property name: %q", name)
                                 return
                         }
@@ skipping 28 matching lines @@
                 switch val {
                 case "on", "On", "true":
                         return true, nil
                 case "off", "Off", "false":
                         return false, nil
                 }
                 return nil, fmt.Errorf("Toggle field has bad/missing default, got %q", val)
         }
         return nil, fmt.Errorf("helper: meta field with bad type/value %s/%q", t, val)
 }