Re-add metadata passthrough on Get operations

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"
 
         "github.com/luci/luci-go/common/errors"
 )
 
 type multiArgType struct {
         valid bool
 
         getKey  func(nk newKeyFunc, slot reflect.Value) (Key, error)
         getPM   func(slot reflect.Value) (PropertyMap, error)
         setPM   func(slot reflect.Value, pm PropertyMap) error
         setKey  func(slot reflect.Value, k Key)
         newElem func() reflect.Value
 }
 
-func (mat *multiArgType) GetKeys(nk newKeyFunc, slice reflect.Value) ([]Key, error) {
-        ret := make([]Key, slice.Len())
-        lme := errors.LazyMultiError{Size: len(ret)}
-        for i := range ret {
+func (mat *multiArgType) GetKeysPMs(nk newKeyFunc, slice reflect.Value) ([]Key, []PropertyMap, error) {
+        retKey := make([]Key, slice.Len())
+        retPM := make([]PropertyMap, slice.Len())
+        lme := errors.LazyMultiError{Size: len(retKey)}
+        for i := range retKey {
                 key, err := mat.getKey(nk, slice.Index(i))
-                lme.Assign(i, err)
-                ret[i] = key
+                if !lme.Assign(i, err) {
+                        retKey[i] = key
+                        pm, err := mat.getPM(slice.Index(i))
+                        if !lme.Assign(i, err) {
+                                retPM[i] = pm
+                        }
+                }
         }
-        return ret, lme.Get()
-}
-
-func (mat *multiArgType) GetPMs(slice reflect.Value) ([]PropertyMap, error) {
-        ret := make([]PropertyMap, slice.Len())
-        lme := errors.LazyMultiError{Size: len(ret)}
-        for i := range ret {
-                key, err := mat.getPM(slice.Index(i))
-                lme.Assign(i, err)
-                ret[i] = key
-        }
-        return ret, lme.Get()
+        return retKey, retPM, lme.Get()
 }
 
 // parseMultiArg checks that v has type []S, []*S, []I, []P or []*P, for some
 // struct type S, for some interface type I, or some non-interface non-pointer
 // type P such that P or *P implements PropertyLoadSaver.
 func parseMultiArg(e reflect.Type) multiArgType {
         if e.Kind() != reflect.Slice {
                 return multiArgTypeInvalid()
         }
         return parseArg(e.Elem())
@@ skipping 241 matching lines @@
                 return dflt
         }
         return ret
 }
 
 func getMetaKey(pls PropertyLoadSaver, key string) Key {
         mkey, _ := pls.GetMeta(key)
         ret, _ := mkey.(Key)
         return ret
 }