Support twiddling field names in anonymous markers

This supports changing field names in anonymous markers, meaning you can
have a marker like

```
//+default=<any>
```

map to a struct

```
type Default struct {
        Value interface{}
}
```

by changing the definition up a bit.

This supports when you need to make an any-type definition and also
implement methods on it, like for defaulting.

Author: DirectXMan12

pkg/markers/parse.go

@@ -768,9 +768,21 @@ func (d *Definition) Parse(rawMarker string) (interface{}, error) {
 	// TODO(directxman12): strict parsing where we error out if certain fields aren't optional
 	seen := make(map[string]struct{}, len(d.Fields))
 	if d.AnonymousField() && scanner.Peek() != sc.EOF {
+		// might still be a struct that something fiddled with, so double check
+		structFieldName := d.FieldNames[""]
+		outTarget := out
+		if structFieldName != "" {
+			// it's a struct field mapped to an anonymous marker
+			outTarget = out.FieldByName(structFieldName)
+			if !outTarget.CanSet() {
+				scanner.Error(scanner, fmt.Sprintf("cannot set field %q (might not exist)", structFieldName))
+				return out.Interface(), loader.MaybeErrList(errs)
+			}
+		}
+
 		// no need for trying to parse field names if we're not a struct
 		field := d.Fields[""]
-		field.Parse(scanner, fields, out)
+		field.Parse(scanner, fields, outTarget)
 		seen[""] = struct{}{} // mark as seen for strict definitions
 	} else if !d.Empty() && scanner.Peek() != sc.EOF {
 		// if we expect *and* actually have arguments passed

pkg/markers/parse_test.go

@@ -51,6 +51,10 @@ type allOptionalStruct struct {
 	OptInt *int
 }
 
+type CustomType struct {
+	Value interface{}
+}
+
 var _ = Describe("Parsing", func() {
 	var reg *Registry
 
@@ -71,8 +75,17 @@ var _ = Describe("Parsing", func() {
 			mustDefine(reg, "testing:tripleDefined", DescribesPackage, 0)
 			mustDefine(reg, "testing:tripleDefined", DescribesField, "")
 			mustDefine(reg, "testing:tripleDefined", DescribesType, false)
+
+			defn, err := MakeDefinition("testing:custom", DescribesPackage, CustomType{})
+			Expect(err).NotTo(HaveOccurred())
+			defn.FieldNames = map[string]string{"": "Value"}
+			defn.Fields = map[string]Argument{"": defn.Fields["value"]}
+
+			Expect(reg.Register(defn)).To(Succeed())
 		})
 
+		It("should work with fiddled field names", parseTestCase{reg: &reg, raw: "+testing:custom={hi}", output: CustomType{Value: []string{"hi"}}}.Run)
+
 		It("should parse name-only markers", parseTestCase{reg: &reg, raw: "+testing:empty", output: struct{}{}}.Run)
 
 		Context("when parsing anonymous markers", func() {