Refactor parsing of embedded structs to types table conversion

Author: antonmedv

parser.go

@@ -64,7 +64,7 @@ type parser struct {
 	position int
 	current  token
 	strict   bool
-	types    map[string]Type
+	types    typesTable
 }
 
 // OptionFn for configuring parser.
@@ -81,7 +81,7 @@ func Parse(input string, ops ...OptionFn) (Node, error) {
 		input:   input,
 		tokens:  tokens,
 		current: tokens[0],
-		types:   make(map[string]Type),
+		types:   make(typesTable),
 	}
 
 	for _, op := range ops {
@@ -116,60 +116,69 @@ func Define(name string, t interface{}) OptionFn {
 }
 
 // With sets variables for type checks during parsing.
-// If struct is passed, all fields will be treated as variables.
+// If struct is passed, all fields will be treated as variables,
+// as well as all fields of embedded structs.
+//
 // If map is passed, all items will be treated as variables
 // (key as name, value as type).
 func With(i interface{}) OptionFn {
 	return func(p *parser) {
 		p.strict = true
-		v := reflect.ValueOf(i)
-		t := reflect.TypeOf(i)
-		t = dereference(t)
-		if t == nil {
-			return
+		for k, v := range p.createTypesTable(i) {
+			p.types[k] = v
 		}
+	}
+}
 
-		switch t.Kind() {
-		case reflect.Struct:
-			for i := 0; i < t.NumField(); i++ {
-				f := t.Field(i)
-				p.types[f.Name] = f.Type
+func (p *parser) createTypesTable(i interface{}) typesTable {
+	types := make(typesTable)
+	v := reflect.ValueOf(i)
+	t := reflect.TypeOf(i)
 
-				for name, typ := range p.findEmbeddedFieldNames(f.Type) {
-					p.types[name] = typ
-				}
-			}
-		case reflect.Map:
-			for _, key := range v.MapKeys() {
-				value := v.MapIndex(key)
-				if key.Kind() == reflect.String && value.IsValid() && value.CanInterface() {
-					p.types[key.String()] = reflect.TypeOf(value.Interface())
-				}
+	t = dereference(t)
+	if t == nil {
+		return types
+	}
+
+	switch t.Kind() {
+	case reflect.Struct:
+		types = p.fromStruct(t)
+
+	case reflect.Map:
+		for _, key := range v.MapKeys() {
+			value := v.MapIndex(key)
+			if key.Kind() == reflect.String && value.IsValid() && value.CanInterface() {
+				types[key.String()] = reflect.TypeOf(value.Interface())
 			}
 		}
 	}
+
+	return types
 }
 
-func (p *parser) findEmbeddedFieldNames(t reflect.Type) map[string]Type {
+func (p *parser) fromStruct(t reflect.Type) typesTable {
+	types := make(typesTable)
 	t = dereference(t)
+	if t == nil {
+		return types
+	}
 
-	res := make(map[string]Type)
-	if t.Kind() == reflect.Struct {
+	switch t.Kind() {
+	case reflect.Struct:
 		for i := 0; i < t.NumField(); i++ {
 			f := t.Field(i)
 
-			fType := dereference(f.Type)
-			if fType.Kind() == reflect.Struct && f.Anonymous && fType.Name() == f.Name {
-				for name, typ := range p.findEmbeddedFieldNames(fType) {
-					res[name] = typ
+			if f.Anonymous {
+				for name, typ := range p.fromStruct(f.Type) {
+					types[name] = typ
 				}
+			} else {
+				types[f.Name] = f.Type
 			}
-
-			res[f.Name] = fType
 		}
 	}
 
-	return res
+	return types
 }
 
 func (p *parser) errorf(format string, args ...interface{}) *syntaxError {

parser_test.go

@@ -208,7 +208,9 @@ func TestParse_error(t *testing.T) {
 	}
 }
 
-func TestParser_findEmbeddedFieldNames(t *testing.T) {
+func TestParser_createTypesTable(t *testing.T) {
+	var intType = reflect.TypeOf(0)
+
 	type (
 		D struct {
 			F2 int
@@ -228,12 +230,16 @@ func TestParser_findEmbeddedFieldNames(t *testing.T) {
 		}
 	)
 
-	res := new(parser).findEmbeddedFieldNames(reflect.TypeOf(A{}))
-	if res["F"] != reflect.TypeOf(1) {
+	p := parser{}
+	types := p.createTypesTable(A{})
+
+	if len(types) != 2 {
+		t.Error("unexpected number of fields")
+	}
+	if types["F"] != intType {
 		t.Error("expected embedded struct field 'F'")
 	}
-
-	if res["F2"] != reflect.TypeOf(1) {
+	if types["F2"] != intType {
 		t.Error("expected embedded struct field 'F2'")
 	}
 }