Fix miscellaneous prod bugs.

service/datastore/multiarg.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 196 matching lines @@
 
 // multiArgTypeInterface == []I
 func multiArgTypeInterface() multiArgType {
         return multiArgType{
                 valid: true,
 
                 getKey: func(nk newKeyFunc, slot reflect.Value) (Key, error) {
                         return newKeyObjErr(nk, slot.Elem().Interface())
                 },
                 getPM: func(slot reflect.Value) (PropertyMap, error) {
-                        pls, _ := mkPLSName(slot.Elem().Interface())
+                        pls := mkPLS(slot.Elem().Interface())
                         return pls.Save(true)
                 },
                 setPM: func(slot reflect.Value, pm PropertyMap) error {
-                        pls, _ := mkPLSName(slot.Elem().Interface())
+                        pls := mkPLS(slot.Elem().Interface())
                         return pls.Load(pm)
                 },
                 setKey: func(slot reflect.Value, k Key) {
                         setKey(slot.Elem().Interface(), k)
                 },
         }
 }
 
 func newKeyObjErr(nk newKeyFunc, src interface{}) (Key, error) {
-        pls, name := mkPLSName(src)
+        pls := mkPLS(src)
         if key, _ := pls.GetMetaDefault("key", nil).(Key); key != nil {
                 return key, nil
         }
 
         // get kind
-        kind := pls.GetMetaDefault("kind", name).(string)
-        if kind == "" {
-                return nil, fmt.Errorf("unable to extract $kind from %v", src)
+        kindIface, err := pls.GetMeta("kind")

[iannucci, 2015/08/15 21:50:54]

I think you could GetMetaDefault("kind", "").(string), and just return the first
error if it == ""

[dnj (Google), 2015/08/16 06:11:06]

Done.

+        if err != nil {
+                return nil, fmt.Errorf("unable to extract $kind from %v: %s", src, err)
+        }
+        kind, ok := kindIface.(string)
+        if !ok {
+                return nil, fmt.Errorf("$kind is not a string: %T", kind)
         }
 
         // get id - allow both to be default for default keys
         sid := pls.GetMetaDefault("id", "").(string)
         iid := pls.GetMetaDefault("id", 0).(int64)
 
         // get parent
         par, _ := pls.GetMetaDefault("parent", nil).(Key)
 
         return nk(kind, sid, iid, par), nil
 }
 
 func setKey(src interface{}, key Key) {
-        pls, _ := mkPLSName(src)
+        pls := mkPLS(src)
         if pls.SetMeta("key", key) == ErrMetaFieldUnset {
                 if key.StringID() != "" {
                         pls.SetMeta("id", key.StringID())
                 } else {
                         pls.SetMeta("id", key.IntID())
                 }
                 pls.SetMeta("kind", key.Kind())
                 pls.SetMeta("parent", key.Parent())
         }
 }
 
-func mkPLSName(o interface{}) (PropertyLoadSaver, string) {
-        if pls, ok := o.(*structPLS); ok {
-                return pls, pls.o.Type().Name()
+func mkPLS(o interface{}) PropertyLoadSaver {
+        if pls, ok := o.(PropertyLoadSaver); ok {
+                return pls
         }
-        if pls, ok := o.(PropertyLoadSaver); ok {
-                return pls, ""
-        }
-        pls := GetPLS(o)
-        name := pls.(*structPLS).o.Type().Name()
-        return pls, name
+        return GetPLS(o)
 }