flag: add BoolFunc; FlagSet.BoolFunc

Fixes golang#53747

Based on [CL 416514](https://go.dev/cl/416514)

src/flag/example_func_test.go

@@ -39,3 +39,19 @@ func ExampleFunc() {
 	//     	IP address to parse
 	// {ip: <nil>, loopback: false}
 }
+
+func ExampleBoolFunc() {
+	fs := flag.NewFlagSet("ExampleBoolFunc", flag.ContinueOnError)
+	fs.SetOutput(os.Stdout)
+
+	fs.BoolFunc("log", "logs a dummy message", func(s string) error {
+		fmt.Println("dummy message:", s)
+		return nil
+	})
+	fs.Parse([]string{"-log"})
+	fs.Parse([]string{"-log=0"})
+
+	// Output:
+	// dummy message: true
+	// dummy message: 0
+}

src/flag/flag.go

@@ -337,6 +337,15 @@ func (f funcValue) Set(s string) error { return f(s) }
 
 func (f funcValue) String() string { return "" }
 
+// -- boolFunc Value
+type boolFuncValue func(string) error
+
+func (f boolFuncValue) Set(s string) error { return f(s) }
+
+func (f boolFuncValue) String() string { return "" }
+
+func (f boolFuncValue) IsBoolFlag() bool { return true }
+
 // Value is the interface to the dynamic value stored in a flag.
 // (The default value is represented as a string.)
 //
@@ -955,6 +964,20 @@ func Func(name, usage string, fn func(string) error) {
 	CommandLine.Func(name, usage, fn)
 }
 
+// BoolFunc defines a flag with the specified name and usage string without requiring values.
+// Each time the flag is seen, fn is called with the value of the flag.
+// If fn returns a non-nil error, it will be treated as a flag value parsing error.
+func (f *FlagSet) BoolFunc(name, usage string, fn func(string) error) {
+	f.Var(boolFuncValue(fn), name, usage)
+}
+
+// BoolFunc defines a flag with the specified name and usage string without requiring values.
+// Each time the flag is seen, fn is called with the value of the flag.
+// If fn returns a non-nil error, it will be treated as a flag value parsing error.
+func BoolFunc(name, usage string, fn func(string) error) {
+	CommandLine.BoolFunc(name, usage, fn)
+}
+
 // Var defines a flag with the specified name and usage string. The type and
 // value of the flag are represented by the first argument, of type Value, which
 // typically holds a user-defined implementation of Value. For instance, the

src/flag/flag_test.go

@@ -38,6 +38,7 @@ func TestEverything(t *testing.T) {
 	Float64("test_float64", 0, "float64 value")
 	Duration("test_duration", 0, "time.Duration value")
 	Func("test_func", "func value", func(string) error { return nil })
+	BoolFunc("test_boolfunc", "func", func(string) error { return nil })
 
 	m := make(map[string]*Flag)
 	desired := "0"
@@ -54,14 +55,16 @@ func TestEverything(t *testing.T) {
 				ok = true
 			case f.Name == "test_func" && f.Value.String() == "":
 				ok = true
+			case f.Name == "test_boolfunc" && f.Value.String() == "":
+				ok = true
 			}
 			if !ok {
 				t.Error("Visit: bad value", f.Value.String(), "for", f.Name)
 			}
 		}
 	}
 	VisitAll(visitor)
-	if len(m) != 9 {
+	if len(m) != 10 {
 		t.Error("VisitAll misses some flags")
 		for k, v := range m {
 			t.Log(k, *v)
@@ -85,9 +88,10 @@ func TestEverything(t *testing.T) {
 	Set("test_float64", "1")
 	Set("test_duration", "1s")
 	Set("test_func", "1")
+	Set("test_boolfunc", "")
 	desired = "1"
 	Visit(visitor)
-	if len(m) != 9 {
+	if len(m) != 10 {
 		t.Error("Visit fails after set")
 		for k, v := range m {
 			t.Log(k, *v)
@@ -797,3 +801,46 @@ func TestRedefinedFlags(t *testing.T) {
 		}
 	}
 }
+
+func TestUserDefinedBoolFunc(t *testing.T) {
+	flags := NewFlagSet("test", ContinueOnError)
+	flags.SetOutput(io.Discard)
+	var ss []string
+	flags.BoolFunc("v", "usage", func(s string) error {
+		ss = append(ss, s)
+		return nil
+	})
+	if err := flags.Parse([]string{"-v", "", "-v", "1", "-v=2"}); err != nil {
+		t.Error(err)
+	}
+	if len(ss) != 1 {
+		t.Fatal("expected 1 args; got ", len(ss))
+	}
+	expect := "[true]"
+	if got := fmt.Sprint(ss); got != expect {
+		t.Errorf("expected value %q got %q", expect, got)
+	}
+	// test usage
+	var buf strings.Builder
+	flags.SetOutput(&buf)
+	flags.Parse([]string{"-h"})
+	if usage := buf.String(); !strings.Contains(usage, "usage") {
+		t.Errorf("usage string not included: %q", usage)
+	}
+	// test BoolFunc error
+	flags = NewFlagSet("test", ContinueOnError)
+	flags.SetOutput(io.Discard)
+	flags.BoolFunc("v", "usage", func(s string) error {
+		return fmt.Errorf("test error")
+	})
+	// flag not set, so no error
+	if err := flags.Parse(nil); err != nil {
+		t.Error(err)
+	}
+	// flag set, expect error
+	if err := flags.Parse([]string{"-v", ""}); err == nil {
+		t.Error("expected error; got none")
+	} else if errMsg := err.Error(); !strings.Contains(errMsg, "test error") {
+		t.Errorf(`error should contain "test error"; got %q`, errMsg)
+	}
+}