GAE Datastore - Fix derived types not being reflected properly

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 306 matching lines @@
                         if err != nil {
                                 return nil, false
                         }
                         return prop.value, true
                 }
 
                 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
+                        } else {
+                                val = UpconvertUnderlyingType(val)
                         }
                 }
         }
         return val, true
 }
 
 func (p *structPLS) GetAllMeta() PropertyMap {
         needKind := true
         ret := make(PropertyMap, len(p.c.byMeta)+1)
         for k, idx := range p.c.byMeta {
@@ skipping 39 matching lines @@
                 if b {
                         val = On
                 } else {
                         val = Off
                 }
         }
         f := p.o.Field(idx)
         if val == nil {
                 f.Set(reflect.Zero(f.Type()))
         } else {
-                f.Set(reflect.ValueOf(val))
+                value := reflect.ValueOf(val)
+                f.Set(value.Convert(f.Type()))
         }
         return nil
 }
 
 func (p *structPLS) Problem() error { return p.c.problem }
 
 var (
         // The RWMutex is chosen intentionally, as the majority of access to the
         // structCodecs map will be in parallel and will be to read an existing codec.
         // There's no reason to serialize goroutines on every
@@ skipping 180 matching lines @@
                         st.idxSetting = NoIndex
                 }
         }
         if c.problem == errRecursiveStruct {
                 c.problem = nil
         }
         return
 }
 
 func convertMeta(val string, t reflect.Type) (interface{}, error) {
+        switch t.Kind() {
+        case reflect.String:
+                return val, nil
+        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+                if val == "" {
+                        return int64(0), nil
+                }
+                return strconv.ParseInt(val, 10, 64)
+        }
         switch t {
-        case typeOfString:
-                return val, nil
         case typeOfKey:
                 if val != "" {
                         return nil, fmt.Errorf("key field is not allowed to have a default: %q", val)
                 }
                 return nil, nil
-        case typeOfInt64:
-                if val == "" {
-                        return int64(0), nil
-                }
-                return strconv.ParseInt(val, 10, 64)
         case typeOfToggle:
                 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)
 }