Differentiate between single- and multi- props.

impl/prod/raw_datastore_type_converter.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package prod
 
 import (
         "fmt"
         "reflect"
         "time"
@@ skipping 144 matching lines @@
         return ret, err
 }
 
 func (tf *typeFilter) Load(props []datastore.Property) error {
         tf.pm = make(ds.PropertyMap, len(props))
         for _, p := range props {
                 prop, err := dsR2FProp(p)
                 if err != nil {
                         return err
                 }
-                tf.pm[p.Name] = append(tf.pm[p.Name], prop)
+
+                pdata := tf.pm[p.Name]
+                if p.Multiple {
+                        var pslice ds.PropertySlice
+                        if pdata != nil {
+                                var ok bool
+                                if pslice, ok = pdata.(ds.PropertySlice); !ok {
+                                        return fmt.Errorf("mixed Multiple/non-Multiple properties for %q", p.Name)

[iannucci, 2016/09/16 07:11:03]

I don't think this is possible?

[dnj, 2016/09/16 19:07:22]

It shouldn't be, but since we're sitting at an interface boundary and have to
type assert anyway, it seems reasonable to check.

+                                }
+                        }
+                        tf.pm[p.Name] = append(pslice, prop)
+                } else {
+                        if pdata != nil {
+                                return fmt.Errorf("multiple properties for non-Multiple %q", p.Name)
+                        }
+                        tf.pm[p.Name] = prop
+                }
         }
         return nil
 }
 
 func (tf *typeFilter) Save() ([]datastore.Property, error) {
         props := []datastore.Property{}
-        for name, propList := range tf.pm {
+        for name, pdata := range tf.pm {
                 if len(name) != 0 && name[0] == '$' {
                         continue
                 }
-                multiple := len(propList) > 1
-                for _, prop := range propList {
+
+                var (
+                        pslice   ds.PropertySlice
+                        multiple bool
+                )
+                switch t := pdata.(type) {
+                case ds.Property:
+                        pslice = ds.PropertySlice{t}
+                case ds.PropertySlice:
+                        pslice, multiple = t, true
+                default:
+                        return nil, fmt.Errorf("unknown PropertyData type %T", t)
+                }
+
+                for _, prop := range pslice {
                         toAdd, err := dsF2RProp(tf.ctx, prop)
                         if err != nil {
                                 return nil, err
                         }
                         toAdd.Name = name
                         toAdd.Multiple = multiple
                         props = append(props, toAdd)
                 }
         }
         return props, nil
 }