Differentiate between single- and multi- props.

service/datastore/dumper/dumper.go

 // Copyright 2016 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 dumper implements a very VERY dumb datastore-dumping debugging aid.
 // You shouldn't plan on having this work with the production datastore with any
 // appreciable amount of data.
 //
 // This will take an arbitrary query (or even a query for every entity in the
 // entire datastore), and print every entity to some output stream.
@@ skipping 68 matching lines @@
                 return prop.String()
         }
 
         prnt := func(format string, args ...interface{}) (err error) {
                 var amt int
                 amt, err = fmt.Fprintf(out, format, args...)
                 n += amt
                 return
         }
 
-        prop := func(kind, name string, vals []datastore.Property) (err error) {
-                if len(vals) <= 1 {
-                        return prnt("  %q: [%s]\n", name, fmtVal(kind, name, vals[0]))
-                }
-                if err = prnt("  %q: [\n    %s", name, fmtVal(kind, name, vals[0])); err != nil {
-                        return
-                }
-                for _, v := range vals[1:] {
-                        if err = prnt(",\n    %s", fmtVal(kind, name, v)); err != nil {
+        prop := func(kind, name string, pdata datastore.PropertyData) (err error) {
+                switch t := pdata.(type) {
+                case datastore.Property:
+                        return prnt("  %q: %s\n", name, fmtVal(kind, name, t))
+
+                case datastore.PropertySlice:
+                        if len(t) <= 1 {
+                                return prnt("  %q: [%s]\n", name, fmtVal(kind, name, t[0]))
+                        }
+                        if err = prnt("  %q: [\n    %s", name, fmtVal(kind, name, t[0])); err != nil {
                                 return
                         }
+                        for _, v := range t[1:] {
+                                if err = prnt(",\n    %s", fmtVal(kind, name, v)); err != nil {
+                                        return
+                                }
+                        }
+
+                default:
+                        return fmt.Errorf("unknown PropertyData %T", t)
                 }
                 return prnt("\n  ]\n")
         }
 
         err = ds.Run(q, func(pm datastore.PropertyMap) error {
                 key := datastore.GetMetaDefault(pm, "key", nil).(*datastore.Key)
                 if !cfg.WithSpecial && strings.HasPrefix(key.Kind(), "__") && strings.HasSuffix(key.Kind(), "__") {
                         return nil
                 }
                 if err := prnt("\n%s:\n", key); err != nil {
@@ skipping 32 matching lines @@
 // default rendering.
 func Query(c context.Context, q *datastore.Query) {
         Config{}.Query(c, q)
 }
 
 // All dumps all entities to stdout without special entities and with default
 // rendering.
 func All(c context.Context) {
         Config{}.Query(c, nil)
 }