client/flagpb: fix repeated bool without value

client/flagpb/unmarshal.go

 // Copyright 2016 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 flagpb
 
 import (
         "encoding/hex"
         "fmt"
         "strconv"
@@ skipping 57 matching lines @@
                 return nil, fmt.Errorf("a flag was expected")
         }
         flagName := strings.TrimPrefix(firstArg, "-") // -foo
         flagName = strings.TrimPrefix(flagName, "-")  // --foo
         if strings.HasPrefix(flagName, "-") {
                 // Triple dash is too much.
                 return nil, fmt.Errorf("bad flag syntax")
         }
 
         // Split key-value pair x=y.
-        flagName, value, hasValue := p.splitKeyValuePair(flagName)
+        flagName, valueStr, hasValueStr := p.splitKeyValuePair(flagName)
         if flagName == "" {
                 return nil, fmt.Errorf("bad flag syntax")
         }
 
         // Split field path "a.b.c" and resolve field names.
         fieldPath := strings.Split(flagName, ".")
         pathMsgs, err := p.subMessages(root, fieldPath[:len(fieldPath)-1])
         if err != nil {
                 return nil, err
         }
 
-        // Where to assign a value?
+        // Where to assign the value?
         target := &root
         if len(pathMsgs) > 0 {
                 lastMsg := pathMsgs[len(pathMsgs)-1]
                 target = &lastMsg.message
         }
 
         // Resolve last field name.
         name := fieldPath[len(fieldPath)-1]
         fi := target.desc.FindField(name)
         if fi == -1 {
                 return nil, fmt.Errorf("field %s not found in message %s", name, target.desc.GetName())
         }
         field := target.desc.Field[fi]
 
-        if !hasValue {
+        var value interface{}
+        hasValue := false
+
+        if !hasValueStr {
                 switch {
                 // Boolean and repeated message fields may have no value and ignore
                 // next argument.
                 case field.GetType() == descriptor.FieldDescriptorProto_TYPE_BOOL:
-                        target.data[name] = true
-                        return flags, nil
+                        value = true
+                        hasValue = true
                 case field.GetType() == descriptor.FieldDescriptorProto_TYPE_MESSAGE && field.Repeated():
-                        target.data[name] = append(asSlice(target.data[name]), map[string]interface{}{})
-                        return flags, nil
+                        value = map[string]interface{}{}
+                        hasValue = true
 
-                // Read next argument as a value.
                 default:
+                        // Read next argument as a value.
                         if len(flags) == 0 {
                                 return nil, fmt.Errorf("value was expected")
                         }
-                        value, flags = flags[0], flags[1:]
+                        valueStr, flags = flags[0], flags[1:]
                 }
         }
 
         // Check if the value is already set.
         if target.data[name] != nil && !field.Repeated() {
                 repeatedFields := make([]string, 0, len(pathMsgs))
                 for _, m := range pathMsgs {
                         if m.repeated {
                                 repeatedFields = append(repeatedFields, "-"+strings.Join(m.path, "."))
                         }
                 }
                 if len(repeatedFields) == 0 {
                         return nil, fmt.Errorf("value is already set to %v", target.data[name])
                 }
                 return nil, fmt.Errorf(
                         "value is already set to %v. Did you forgot to insert %s in between to declare a new repeated message?",
                         target.data[name], strings.Join(repeatedFields, " or "))
         }
 
-        // Parse the value and set/append it.
-        parsedValue, err := p.parseFieldValue(value, target.desc.GetName(), field)
-        if err != nil {
-                return nil, err
+        if !hasValue {
+                value, err = p.parseFieldValue(valueStr, target.desc.GetName(), field)
+                if err != nil {
+                        return nil, err
+                }
         }
 
         if !field.Repeated() {
-                target.data[name] = parsedValue
+                target.data[name] = value
         } else {
-                target.data[name] = append(asSlice(target.data[name]), parsedValue)
+                target.data[name] = append(asSlice(target.data[name]), value)
         }
+
         return flags, nil
 }
 
 type subMsg struct {
         message
         path     []string
         repeated bool
 }
 
 // subMessages returns message field values at each component of the path.
@@ skipping 161 matching lines @@
         }
         return enum.Value[i].GetNumber(), nil
 }
 
 func asSlice(x interface{}) []interface{} {
         if x == nil {
                 return nil
         }
         return x.([]interface{})
 }