add support for "wrapped" types using some unsafe shenanigans

Author: Matthew Jaffee

com.go

@@ -271,27 +271,27 @@ func setFlags(flags *flagTracker, main interface{}, prefix string) error {
 		// now check basic kinds
 		switch ft.Type.Kind() {
 		case reflect.String:
-			p := f.Addr().Interface().(*string)
+			p := (*string)(f.Addr().UnsafePointer())
 			flags.string(p, flagName, shorthand, f.String(), flagHelp(ft))
 		case reflect.Bool:
-			p := f.Addr().Interface().(*bool)
+			p := (*bool)(f.Addr().UnsafePointer())
 			flags.bool(p, flagName, shorthand, f.Bool(), flagHelp(ft))
 		case reflect.Int:
-			p := f.Addr().Interface().(*int)
+			p := (*int)(f.Addr().UnsafePointer())
 			val := int(f.Int())
 			flags.int(p, flagName, shorthand, val, flagHelp(ft))
 		case reflect.Int64:
-			p := f.Addr().Interface().(*int64)
+			p := (*int64)(f.Addr().UnsafePointer())
 			flags.int64(p, flagName, shorthand, f.Int(), flagHelp(ft))
 		case reflect.Float64:
-			p := f.Addr().Interface().(*float64)
+			p := (*float64)(f.Addr().UnsafePointer())
 			flags.float64(p, flagName, shorthand, f.Float(), flagHelp(ft))
 		case reflect.Uint:
-			p := f.Addr().Interface().(*uint)
+			p := (*uint)(f.Addr().UnsafePointer())
 			val := uint(f.Uint())
 			flags.uint(p, flagName, shorthand, val, flagHelp(ft))
 		case reflect.Uint64:
-			p := f.Addr().Interface().(*uint64)
+			p := (*uint64)(f.Addr().UnsafePointer())
 			flags.uint64(p, flagName, shorthand, f.Uint(), flagHelp(ft))
 		case reflect.Slice:
 			if !flags.pflag {
@@ -317,43 +317,43 @@ func setFlags(flags *flagTracker, main interface{}, prefix string) error {
 			if !flags.pflag {
 				return fmt.Errorf("cannot support float32 field at '%v' with stdlib flag pkg.", flagName)
 			}
-			p := f.Addr().Interface().(*float32)
+			p := (*float32)(f.Addr().UnsafePointer())
 			flags.float32(p, flagName, shorthand, *p, flagHelp(ft))
 		case reflect.Int16:
 			if !flags.pflag {
 				return fmt.Errorf("cannot support int16 field at '%v' with stdlib flag pkg.", flagName)
 			}
-			p := f.Addr().Interface().(*int16)
+			p := (*int16)(f.Addr().UnsafePointer())
 			flags.int16(p, flagName, shorthand, *p, flagHelp(ft))
 		case reflect.Int32:
 			if !flags.pflag {
 				return fmt.Errorf("cannot support int32 field at '%v' with stdlib flag pkg.", flagName)
 			}
-			p := f.Addr().Interface().(*int32)
+			p := (*int32)(f.Addr().UnsafePointer())
 			flags.int32(p, flagName, shorthand, *p, flagHelp(ft))
 		case reflect.Uint16:
 			if !flags.pflag {
 				return fmt.Errorf("cannot support uint16 field at '%v' with stdlib flag pkg.", flagName)
 			}
-			p := f.Addr().Interface().(*uint16)
+			p := (*uint16)(f.Addr().UnsafePointer())
 			flags.uint16(p, flagName, shorthand, *p, flagHelp(ft))
 		case reflect.Uint32:
 			if !flags.pflag {
 				return fmt.Errorf("cannot support uint32 field at '%v' with stdlib flag pkg.", flagName)
 			}
-			p := f.Addr().Interface().(*uint32)
+			p := (*uint32)(f.Addr().UnsafePointer())
 			flags.uint32(p, flagName, shorthand, *p, flagHelp(ft))
 		case reflect.Uint8:
 			if !flags.pflag {
 				return fmt.Errorf("cannot support uint8 field at '%v' with stdlib flag pkg.", flagName)
 			}
-			p := f.Addr().Interface().(*uint8)
+			p := (*uint8)(f.Addr().UnsafePointer())
 			flags.uint8(p, flagName, shorthand, *p, flagHelp(ft))
 		case reflect.Int8:
 			if !flags.pflag {
 				return fmt.Errorf("cannot support int8 field at '%v' with stdlib flag pkg.", flagName)
 			}
-			p := f.Addr().Interface().(*int8)
+			p := (*int8)(f.Addr().UnsafePointer())
 			flags.int8(p, flagName, shorthand, *p, flagHelp(ft))
 		case reflect.Struct:
 			var newprefix string

com_test.go

@@ -18,14 +18,15 @@ func TestLoadEnv(t *testing.T) {
 
 	// create initial instance with defaults
 	mm := &test.SimpleMain{
-		One:   "one",
-		Two:   2,
-		Three: 3,
-		Four:  true,
-		Five:  5,
-		Six:   6,
-		Seven: 7.0,
-		Eight: time.Millisecond * 8,
+		One:    "one",
+		Two:    2,
+		Three:  3,
+		Four:   true,
+		Five:   5,
+		Six:    6,
+		Seven:  7.0,
+		Eight:  time.Millisecond * 8,
+		Twelve: "blah",
 	}
 
 	// create flags with defaults by walking instance
@@ -53,7 +54,7 @@ func TestLoadEnv(t *testing.T) {
 	}
 
 	// change values on instance by parsing command line
-	err = fs.Parse([]string{"-two", "99"})
+	err = fs.Parse([]string{"-two", "99", "-twelve", "haha"})
 	if err != nil {
 		t.Fatalf("parsing command line: %v", err)
 	}
@@ -65,6 +66,9 @@ func TestLoadEnv(t *testing.T) {
 	if mm.One != "z" {
 		t.Errorf("unexpected value for One after command line parsing: %s", mm.One)
 	}
+	if mm.Twelve != "haha" {
+		t.Errorf("unexpected value for Twelve after cmd line parsing: %s", mm.Twelve)
+	}
 
 	// simulate parsing a config file and setting values directly from it
 	mm.Three = 33
@@ -562,4 +566,14 @@ func TestRunSimpleMain(t *testing.T) {
 	} else {
 		t.Fatalf("couldn't look up 'ten'")
 	}
+	if f := flags.Lookup("eleven"); f != nil {
+		if f.DefValue != "11s" {
+			t.Fatalf("wrong default value for 'eleven': %v", f.DefValue)
+		}
+	}
+	if f := flags.Lookup("twelve"); f != nil {
+		if f.DefValue != "twelve" {
+			t.Fatalf("wrong default value for 'tweleve': %v", f.DefValue)
+		}
+	}
 }

test/test.go

@@ -94,6 +94,8 @@ func (m *MyMain) Run() error {
 	return fmt.Errorf("mymain error")
 }
 
+type WrappedString string
+
 type SimpleMain struct {
 	One    string
 	Two    int
@@ -106,6 +108,7 @@ type SimpleMain struct {
 	Nine   []string
 	Ten    time.Time
 	Eleven MyDuration
+	Twelve WrappedString
 }
 
 func NewSimpleMain() *SimpleMain {
@@ -121,6 +124,7 @@ func NewSimpleMain() *SimpleMain {
 		Nine:   []string{"9", "nine"},
 		Ten:    time.Unix(0, 0).UTC(),
 		Eleven: MyDuration(time.Second * 11),
+		Twelve: "twelve",
 	}
 }