proptools/unpack.go - platform/build/blueprint - Git at Google

 // Copyright 2014 Google Inc. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 package proptools

 import (
 	"fmt"
 	"reflect"
 	"sort"
 	"strconv"
 	"strings"
 	"text/scanner"

 	"github.com/google/blueprint/parser"
 )

 const maxUnpackErrors = 10

 type UnpackError struct {
 	Err error
 	Pos scanner.Position
 }

 func (e *UnpackError) Error() string {
 	return fmt.Sprintf("%s: %s", e.Pos, e.Err)
 }

 // packedProperty helps to track properties usage (`used` will be true)
 type packedProperty struct {
 	property *parser.Property
 	used     bool
 }

 // unpackContext keeps compound names and their values in a map. It is initialized from
 // parsed properties.
 type unpackContext struct {
 	propertyMap map[string]*packedProperty
 	errs        []error
 }

 // UnpackProperties populates the list of runtime values ("property structs") from the parsed properties.
 // If a property a.b.c has a value, a field with the matching name in each runtime value is initialized
 // from it. See PropertyNameForField for field and property name matching.
 // For instance, if the input contains
 //   { foo: "abc", bar: {x: 1},}
 // and a runtime value being has been declared as
 //   var v struct { Foo string; Bar int }
 // then v.Foo will be set to "abc" and v.Bar will be set to 1
 // (cf. unpack_test.go for further examples)
 //
 // The type of a receiving field has to match the property type, i.e., a bool/int/string field
 // can be set from a property with bool/int/string value, a struct can be set from a map (only the
 // matching fields are set), and an slice can be set from a list.
 // If a field of a runtime value has been already set prior to the UnpackProperties, the new value
 // is appended to it (see somewhat inappropriately named ExtendBasicType).
 // The same property can initialize fields in multiple runtime values. It is an error if any property
 // value was not used to initialize at least one field.
 func UnpackProperties(properties []*parser.Property, objects ...interface{}) (map[string]*parser.Property, []error) {
 	var unpackContext unpackContext
 	unpackContext.propertyMap = make(map[string]*packedProperty)
 	if !unpackContext.buildPropertyMap("", properties) {
 		return nil, unpackContext.errs
 	}

 	for _, obj := range objects {
 		valueObject := reflect.ValueOf(obj)
 		if !isStructPtr(valueObject.Type()) {
 			panic(fmt.Errorf("properties must be *struct, got %s",
 				valueObject.Type()))
 		}
 		unpackContext.unpackToStruct("", valueObject.Elem())
 		if len(unpackContext.errs) >= maxUnpackErrors {
 			return nil, unpackContext.errs
 		}
 	}

 	// Gather property map, and collect any unused properties.
 	// Avoid reporting subproperties of unused properties.
 	result := make(map[string]*parser.Property)
 	var unusedNames []string
 	for name, v := range unpackContext.propertyMap {
 		if v.used {
 			result[name] = v.property
 		} else {
 			unusedNames = append(unusedNames, name)
 		}
 	}
 	if len(unusedNames) == 0 && len(unpackContext.errs) == 0 {
 		return result, nil
 	}
 	return nil, unpackContext.reportUnusedNames(unusedNames)
 }

 func (ctx *unpackContext) reportUnusedNames(unusedNames []string) []error {
 	sort.Strings(unusedNames)
 	var lastReported string
 	for _, name := range unusedNames {
 		// if 'foo' has been reported, ignore 'foo\..*' and 'foo\[.*'
 		if lastReported != "" {
 			trimmed := strings.TrimPrefix(name, lastReported)
 			if trimmed != name && (trimmed[0] == '.' || trimmed[0] == '[') {
 				continue
 			}
 		}
 		ctx.errs = append(ctx.errs, &UnpackError{
 			fmt.Errorf("unrecognized property %q", name),
 			ctx.propertyMap[name].property.ColonPos})
 		lastReported = name
 	}
 	return ctx.errs
 }

 func (ctx *unpackContext) buildPropertyMap(prefix string, properties []*parser.Property) bool {
 	nOldErrors := len(ctx.errs)
 	for _, property := range properties {
 		name := fieldPath(prefix, property.Name)
 		if first, present := ctx.propertyMap[name]; present {
 			ctx.addError(
 				&UnpackError{fmt.Errorf("property %q already defined", name), property.ColonPos})
 			if ctx.addError(
 				&UnpackError{fmt.Errorf("<-- previous definition here"), first.property.ColonPos}) {
 				return false
 			}
 			continue
 		}

 		ctx.propertyMap[name] = &packedProperty{property, false}
 		switch propValue := property.Value.Eval().(type) {
 		case *parser.Map:
 			ctx.buildPropertyMap(name, propValue.Properties)
 		case *parser.List:
 			// If it is a list, unroll it unless its elements are of primitive type
 			// (no further mapping will be needed in that case, so we avoid cluttering
 			// the map).
 			if len(propValue.Values) == 0 {
 				continue
 			}
 			if t := propValue.Values[0].Type(); t == parser.StringType || t == parser.Int64Type || t == parser.BoolType {
 				continue
 			}

 			itemProperties := make([]*parser.Property, len(propValue.Values), len(propValue.Values))
 			for i, expr := range propValue.Values {
 				itemProperties[i] = &parser.Property{
 					Name:     property.Name + "[" + strconv.Itoa(i) + "]",
 					NamePos:  property.NamePos,
 					ColonPos: property.ColonPos,
 					Value:    expr,
 				}
 			}
 			if !ctx.buildPropertyMap(prefix, itemProperties) {
 				return false
 			}
 		}
 	}

 	return len(ctx.errs) == nOldErrors
 }

 func fieldPath(prefix, fieldName string) string {
 	if prefix == "" {
 		return fieldName
 	}
 	return prefix + "." + fieldName
 }

 func (ctx *unpackContext) addError(e error) bool {
 	ctx.errs = append(ctx.errs, e)
 	return len(ctx.errs) < maxUnpackErrors
 }

 func (ctx *unpackContext) unpackToStruct(namePrefix string, structValue reflect.Value) {
 	structType := structValue.Type()

 	for i := 0; i < structValue.NumField(); i++ {
 		fieldValue := structValue.Field(i)
 		field := structType.Field(i)

 		// In Go 1.7, runtime-created structs are unexported, so it's not
 		// possible to create an exported anonymous field with a generated
 		// type. So workaround this by special-casing "BlueprintEmbed" to
 		// behave like an anonymous field for structure unpacking.
 		if field.Name == "BlueprintEmbed" {
 			field.Name = ""
 			field.Anonymous = true
 		}

 		if field.PkgPath != "" {
 			// This is an unexported field, so just skip it.
 			continue
 		}

 		propertyName := fieldPath(namePrefix, PropertyNameForField(field.Name))

 		if !fieldValue.CanSet() {
 			panic(fmt.Errorf("field %s is not settable", propertyName))
 		}

 		// Get the property value if it was specified.
 		packedProperty, propertyIsSet := ctx.propertyMap[propertyName]

 		origFieldValue := fieldValue

 		// To make testing easier we validate the struct field's type regardless
 		// of whether or not the property was specified in the parsed string.
 		// TODO(ccross): we don't validate types inside nil struct pointers
 		// Move type validation to a function that runs on each factory once
 		switch kind := fieldValue.Kind(); kind {
 		case reflect.Bool, reflect.String, reflect.Struct, reflect.Slice:
 			// Do nothing
 		case reflect.Interface:
 			if fieldValue.IsNil() {
 				panic(fmt.Errorf("field %s contains a nil interface", propertyName))
 			}
 			fieldValue = fieldValue.Elem()
 			elemType := fieldValue.Type()
 			if elemType.Kind() != reflect.Ptr {
 				panic(fmt.Errorf("field %s contains a non-pointer interface", propertyName))
 			}
 			fallthrough
 		case reflect.Ptr:
 			switch ptrKind := fieldValue.Type().Elem().Kind(); ptrKind {
 			case reflect.Struct:
 				if fieldValue.IsNil() && (propertyIsSet || field.Anonymous) {
 					// Instantiate nil struct pointers
 					// Set into origFieldValue in case it was an interface, in which case
 					// fieldValue points to the unsettable pointer inside the interface
 					fieldValue = reflect.New(fieldValue.Type().Elem())
 					origFieldValue.Set(fieldValue)
 				}
 				fieldValue = fieldValue.Elem()
 			case reflect.Bool, reflect.Int64, reflect.String:
 				// Nothing
 			default:
 				panic(fmt.Errorf("field %s contains a pointer to %s", propertyName, ptrKind))
 			}

 		case reflect.Int, reflect.Uint:
 			if !HasTag(field, "blueprint", "mutated") {
 				panic(fmt.Errorf(`int field %s must be tagged blueprint:"mutated"`, propertyName))
 			}

 		default:
 			panic(fmt.Errorf("unsupported kind for field %s: %s", propertyName, kind))
 		}

 		if field.Anonymous && isStruct(fieldValue.Type()) {
 			ctx.unpackToStruct(namePrefix, fieldValue)
 			continue
 		}

 		if !propertyIsSet {
 			// This property wasn't specified.
 			continue
 		}

 		packedProperty.used = true
 		property := packedProperty.property

 		if HasTag(field, "blueprint", "mutated") {
 			if !ctx.addError(
 				&UnpackError{
 					fmt.Errorf("mutated field %s cannot be set in a Blueprint file", propertyName),
 					property.ColonPos,
 				}) {
 				return
 			}
 			continue
 		}

 		if isStruct(fieldValue.Type()) {
 			if property.Value.Eval().Type() != parser.MapType {
 				ctx.addError(&UnpackError{
 					fmt.Errorf("can't assign %s value to map property %q",
 						property.Value.Type(), property.Name),
 					property.Value.Pos(),
 				})
 				continue
 			}
 			ctx.unpackToStruct(propertyName, fieldValue)
 			if len(ctx.errs) >= maxUnpackErrors {
 				return
 			}
 		} else if isSlice(fieldValue.Type()) {
 			if unpackedValue, ok := ctx.unpackToSlice(propertyName, property, fieldValue.Type()); ok {
 				ExtendBasicType(fieldValue, unpackedValue, Append)
 			}
 			if len(ctx.errs) >= maxUnpackErrors {
 				return
 			}

 		} else {
 			unpackedValue, err := propertyToValue(fieldValue.Type(), property)
 			if err != nil && !ctx.addError(err) {
 				return
 			}
 			ExtendBasicType(fieldValue, unpackedValue, Append)
 		}
 	}
 }

 // unpackSlice creates a value of a given slice type from the property which should be a list
 func (ctx *unpackContext) unpackToSlice(
 	sliceName string, property *parser.Property, sliceType reflect.Type) (reflect.Value, bool) {
 	propValueAsList, ok := property.Value.Eval().(*parser.List)
 	if !ok {
 		ctx.addError(&UnpackError{
 			fmt.Errorf("can't assign %s value to list property %q",
 				property.Value.Type(), property.Name),
 			property.Value.Pos(),
 		})
 		return reflect.MakeSlice(sliceType, 0, 0), false
 	}
 	exprs := propValueAsList.Values
 	value := reflect.MakeSlice(sliceType, 0, len(exprs))
 	if len(exprs) == 0 {
 		return value, true
 	}

 	// The function to construct an item value depends on the type of list elements.
 	var getItemFunc func(*parser.Property, reflect.Type) (reflect.Value, bool)
 	switch exprs[0].Type() {
 	case parser.BoolType, parser.StringType, parser.Int64Type:
 		getItemFunc = func(property *parser.Property, t reflect.Type) (reflect.Value, bool) {
 			value, err := propertyToValue(t, property)
 			if err != nil {
 				ctx.addError(err)
 				return value, false
 			}
 			return value, true
 		}
 	case parser.ListType:
 		getItemFunc = func(property *parser.Property, t reflect.Type) (reflect.Value, bool) {
 			return ctx.unpackToSlice(property.Name, property, t)
 		}
 	case parser.MapType:
 		getItemFunc = func(property *parser.Property, t reflect.Type) (reflect.Value, bool) {
 			itemValue := reflect.New(t).Elem()
 			ctx.unpackToStruct(property.Name, itemValue)
 			return itemValue, true
 		}
 	case parser.NotEvaluatedType:
 		getItemFunc = func(property *parser.Property, t reflect.Type) (reflect.Value, bool) {
 			return reflect.New(t), false
 		}
 	default:
 		panic(fmt.Errorf("bizarre property expression type: %v", exprs[0].Type()))
 	}

 	itemProperty := &parser.Property{NamePos: property.NamePos, ColonPos: property.ColonPos}
 	elemType := sliceType.Elem()
 	isPtr := elemType.Kind() == reflect.Ptr

 	for i, expr := range exprs {
 		itemProperty.Name = sliceName + "[" + strconv.Itoa(i) + "]"
 		itemProperty.Value = expr
 		if packedProperty, ok := ctx.propertyMap[itemProperty.Name]; ok {
 			packedProperty.used = true
 		}
 		if isPtr {
 			if itemValue, ok := getItemFunc(itemProperty, elemType.Elem()); ok {
 				ptrValue := reflect.New(itemValue.Type())
 				ptrValue.Elem().Set(itemValue)
 				value = reflect.Append(value, ptrValue)
 			}
 		} else {
 			if itemValue, ok := getItemFunc(itemProperty, elemType); ok {
 				value = reflect.Append(value, itemValue)
 			}
 		}
 	}
 	return value, true
 }

 // propertyToValue creates a value of a given value type from the property.
 func propertyToValue(typ reflect.Type, property *parser.Property) (reflect.Value, error) {
 	var value reflect.Value
 	var baseType reflect.Type
 	isPtr := typ.Kind() == reflect.Ptr
 	if isPtr {
 		baseType = typ.Elem()
 	} else {
 		baseType = typ
 	}

 	switch kind := baseType.Kind(); kind {
 	case reflect.Bool:
 		b, ok := property.Value.Eval().(*parser.Bool)
 		if !ok {
 			return value, &UnpackError{
 				fmt.Errorf("can't assign %s value to bool property %q",
 					property.Value.Type(), property.Name),
 				property.Value.Pos(),
 			}
 		}
 		value = reflect.ValueOf(b.Value)

 	case reflect.Int64:
 		b, ok := property.Value.Eval().(*parser.Int64)
 		if !ok {
 			return value, &UnpackError{
 				fmt.Errorf("can't assign %s value to int64 property %q",
 					property.Value.Type(), property.Name),
 				property.Value.Pos(),
 			}
 		}
 		value = reflect.ValueOf(b.Value)

 	case reflect.String:
 		s, ok := property.Value.Eval().(*parser.String)
 		if !ok {
 			return value, &UnpackError{
 				fmt.Errorf("can't assign %s value to string property %q",
 					property.Value.Type(), property.Name),
 				property.Value.Pos(),
 			}
 		}
 		value = reflect.ValueOf(s.Value)

 	default:
 		return value, &UnpackError{
 			fmt.Errorf("cannot assign %s value %s to %s property %s", property.Value.Type(), property.Value, kind, typ),
 			property.NamePos}
 	}

 	if isPtr {
 		ptrValue := reflect.New(value.Type())
 		ptrValue.Elem().Set(value)
 		return ptrValue, nil
 	}
 	return value, nil
 }
	// Copyright 2014 Google Inc. All rights reserved.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	package proptools

	import (
	"fmt"
	"reflect"
	"sort"
	"strconv"
	"strings"
	"text/scanner"

	"github.com/google/blueprint/parser"
	)

	const maxUnpackErrors = 10

	type UnpackError struct {
	Err error
	Pos scanner.Position
	}

	func (e *UnpackError) Error() string {
	return fmt.Sprintf("%s: %s", e.Pos, e.Err)
	}

	// packedProperty helps to track properties usage (`used` will be true)
	type packedProperty struct {
	property *parser.Property
	used bool
	}

	// unpackContext keeps compound names and their values in a map. It is initialized from
	// parsed properties.
	type unpackContext struct {
	propertyMap map[string]*packedProperty
	errs []error
	}

	// UnpackProperties populates the list of runtime values ("property structs") from the parsed properties.
	// If a property a.b.c has a value, a field with the matching name in each runtime value is initialized
	// from it. See PropertyNameForField for field and property name matching.
	// For instance, if the input contains
	// { foo: "abc", bar: {x: 1},}
	// and a runtime value being has been declared as
	// var v struct { Foo string; Bar int }
	// then v.Foo will be set to "abc" and v.Bar will be set to 1
	// (cf. unpack_test.go for further examples)
	//
	// The type of a receiving field has to match the property type, i.e., a bool/int/string field
	// can be set from a property with bool/int/string value, a struct can be set from a map (only the
	// matching fields are set), and an slice can be set from a list.
	// If a field of a runtime value has been already set prior to the UnpackProperties, the new value
	// is appended to it (see somewhat inappropriately named ExtendBasicType).
	// The same property can initialize fields in multiple runtime values. It is an error if any property
	// value was not used to initialize at least one field.
	func UnpackProperties(properties []parser.Property, objects ...interface{}) (map[string]parser.Property, []error) {
	var unpackContext unpackContext
	unpackContext.propertyMap = make(map[string]*packedProperty)
	if !unpackContext.buildPropertyMap("", properties) {
	return nil, unpackContext.errs
	}

	for _, obj := range objects {
	valueObject := reflect.ValueOf(obj)
	if !isStructPtr(valueObject.Type()) {
	panic(fmt.Errorf("properties must be *struct, got %s",
	valueObject.Type()))
	}
	unpackContext.unpackToStruct("", valueObject.Elem())
	if len(unpackContext.errs) >= maxUnpackErrors {
	return nil, unpackContext.errs
	}
	}

	// Gather property map, and collect any unused properties.
	// Avoid reporting subproperties of unused properties.
	result := make(map[string]*parser.Property)
	var unusedNames []string
	for name, v := range unpackContext.propertyMap {
	if v.used {
	result[name] = v.property
	} else {
	unusedNames = append(unusedNames, name)
	}
	}
	if len(unusedNames) == 0 && len(unpackContext.errs) == 0 {
	return result, nil
	}
	return nil, unpackContext.reportUnusedNames(unusedNames)
	}

	func (ctx *unpackContext) reportUnusedNames(unusedNames []string) []error {
	sort.Strings(unusedNames)
	var lastReported string
	for _, name := range unusedNames {
	// if 'foo' has been reported, ignore 'foo\..' and 'foo\[.'
	if lastReported != "" {
	trimmed := strings.TrimPrefix(name, lastReported)
	if trimmed != name && (trimmed[0] == '.' \|\| trimmed[0] == '[') {
	continue
	}
	}
	ctx.errs = append(ctx.errs, &UnpackError{
	fmt.Errorf("unrecognized property %q", name),
	ctx.propertyMap[name].property.ColonPos})
	lastReported = name
	}
	return ctx.errs
	}

	func (ctx unpackContext) buildPropertyMap(prefix string, properties []parser.Property) bool {
	nOldErrors := len(ctx.errs)
	for _, property := range properties {
	name := fieldPath(prefix, property.Name)
	if first, present := ctx.propertyMap[name]; present {
	ctx.addError(
	&UnpackError{fmt.Errorf("property %q already defined", name), property.ColonPos})
	if ctx.addError(
	&UnpackError{fmt.Errorf("<-- previous definition here"), first.property.ColonPos}) {
	return false
	}
	continue
	}

	ctx.propertyMap[name] = &packedProperty{property, false}
	switch propValue := property.Value.Eval().(type) {
	case *parser.Map:
	ctx.buildPropertyMap(name, propValue.Properties)
	case *parser.List:
	// If it is a list, unroll it unless its elements are of primitive type
	// (no further mapping will be needed in that case, so we avoid cluttering
	// the map).
	if len(propValue.Values) == 0 {
	continue
	}
	if t := propValue.Values[0].Type(); t == parser.StringType \|\| t == parser.Int64Type \|\| t == parser.BoolType {
	continue
	}

	itemProperties := make([]*parser.Property, len(propValue.Values), len(propValue.Values))
	for i, expr := range propValue.Values {
	itemProperties[i] = &parser.Property{
	Name: property.Name + "[" + strconv.Itoa(i) + "]",
	NamePos: property.NamePos,
	ColonPos: property.ColonPos,
	Value: expr,
	}
	}
	if !ctx.buildPropertyMap(prefix, itemProperties) {
	return false
	}
	}
	}

	return len(ctx.errs) == nOldErrors
	}

	func fieldPath(prefix, fieldName string) string {
	if prefix == "" {
	return fieldName
	}
	return prefix + "." + fieldName
	}

	func (ctx *unpackContext) addError(e error) bool {
	ctx.errs = append(ctx.errs, e)
	return len(ctx.errs) < maxUnpackErrors
	}

	func (ctx *unpackContext) unpackToStruct(namePrefix string, structValue reflect.Value) {
	structType := structValue.Type()

	for i := 0; i < structValue.NumField(); i++ {
	fieldValue := structValue.Field(i)
	field := structType.Field(i)

	// In Go 1.7, runtime-created structs are unexported, so it's not
	// possible to create an exported anonymous field with a generated
	// type. So workaround this by special-casing "BlueprintEmbed" to
	// behave like an anonymous field for structure unpacking.
	if field.Name == "BlueprintEmbed" {
	field.Name = ""
	field.Anonymous = true
	}

	if field.PkgPath != "" {
	// This is an unexported field, so just skip it.
	continue
	}

	propertyName := fieldPath(namePrefix, PropertyNameForField(field.Name))

	if !fieldValue.CanSet() {
	panic(fmt.Errorf("field %s is not settable", propertyName))
	}

	// Get the property value if it was specified.
	packedProperty, propertyIsSet := ctx.propertyMap[propertyName]

	origFieldValue := fieldValue

	// To make testing easier we validate the struct field's type regardless
	// of whether or not the property was specified in the parsed string.
	// TODO(ccross): we don't validate types inside nil struct pointers
	// Move type validation to a function that runs on each factory once
	switch kind := fieldValue.Kind(); kind {
	case reflect.Bool, reflect.String, reflect.Struct, reflect.Slice:
	// Do nothing
	case reflect.Interface:
	if fieldValue.IsNil() {
	panic(fmt.Errorf("field %s contains a nil interface", propertyName))
	}
	fieldValue = fieldValue.Elem()
	elemType := fieldValue.Type()
	if elemType.Kind() != reflect.Ptr {
	panic(fmt.Errorf("field %s contains a non-pointer interface", propertyName))
	}
	fallthrough
	case reflect.Ptr:
	switch ptrKind := fieldValue.Type().Elem().Kind(); ptrKind {
	case reflect.Struct:
	if fieldValue.IsNil() && (propertyIsSet \|\| field.Anonymous) {
	// Instantiate nil struct pointers
	// Set into origFieldValue in case it was an interface, in which case
	// fieldValue points to the unsettable pointer inside the interface
	fieldValue = reflect.New(fieldValue.Type().Elem())
	origFieldValue.Set(fieldValue)
	}
	fieldValue = fieldValue.Elem()
	case reflect.Bool, reflect.Int64, reflect.String:
	// Nothing
	default:
	panic(fmt.Errorf("field %s contains a pointer to %s", propertyName, ptrKind))
	}

	case reflect.Int, reflect.Uint:
	if !HasTag(field, "blueprint", "mutated") {
	panic(fmt.Errorf(`int field %s must be tagged blueprint:"mutated"`, propertyName))
	}

	default:
	panic(fmt.Errorf("unsupported kind for field %s: %s", propertyName, kind))
	}

	if field.Anonymous && isStruct(fieldValue.Type()) {
	ctx.unpackToStruct(namePrefix, fieldValue)
	continue
	}

	if !propertyIsSet {
	// This property wasn't specified.
	continue
	}

	packedProperty.used = true
	property := packedProperty.property

	if HasTag(field, "blueprint", "mutated") {
	if !ctx.addError(
	&UnpackError{
	fmt.Errorf("mutated field %s cannot be set in a Blueprint file", propertyName),
	property.ColonPos,
	}) {
	return
	}
	continue
	}

	if isStruct(fieldValue.Type()) {
	if property.Value.Eval().Type() != parser.MapType {
	ctx.addError(&UnpackError{
	fmt.Errorf("can't assign %s value to map property %q",
	property.Value.Type(), property.Name),
	property.Value.Pos(),
	})
	continue
	}
	ctx.unpackToStruct(propertyName, fieldValue)
	if len(ctx.errs) >= maxUnpackErrors {
	return
	}
	} else if isSlice(fieldValue.Type()) {
	if unpackedValue, ok := ctx.unpackToSlice(propertyName, property, fieldValue.Type()); ok {
	ExtendBasicType(fieldValue, unpackedValue, Append)
	}
	if len(ctx.errs) >= maxUnpackErrors {
	return
	}

	} else {
	unpackedValue, err := propertyToValue(fieldValue.Type(), property)
	if err != nil && !ctx.addError(err) {
	return
	}
	ExtendBasicType(fieldValue, unpackedValue, Append)
	}
	}
	}

	// unpackSlice creates a value of a given slice type from the property which should be a list
	func (ctx *unpackContext) unpackToSlice(
	sliceName string, property *parser.Property, sliceType reflect.Type) (reflect.Value, bool) {
	propValueAsList, ok := property.Value.Eval().(*parser.List)
	if !ok {
	ctx.addError(&UnpackError{
	fmt.Errorf("can't assign %s value to list property %q",
	property.Value.Type(), property.Name),
	property.Value.Pos(),
	})
	return reflect.MakeSlice(sliceType, 0, 0), false
	}
	exprs := propValueAsList.Values
	value := reflect.MakeSlice(sliceType, 0, len(exprs))
	if len(exprs) == 0 {
	return value, true
	}

	// The function to construct an item value depends on the type of list elements.
	var getItemFunc func(*parser.Property, reflect.Type) (reflect.Value, bool)
	switch exprs[0].Type() {
	case parser.BoolType, parser.StringType, parser.Int64Type:
	getItemFunc = func(property *parser.Property, t reflect.Type) (reflect.Value, bool) {
	value, err := propertyToValue(t, property)
	if err != nil {
	ctx.addError(err)
	return value, false
	}
	return value, true
	}
	case parser.ListType:
	getItemFunc = func(property *parser.Property, t reflect.Type) (reflect.Value, bool) {
	return ctx.unpackToSlice(property.Name, property, t)
	}
	case parser.MapType:
	getItemFunc = func(property *parser.Property, t reflect.Type) (reflect.Value, bool) {
	itemValue := reflect.New(t).Elem()
	ctx.unpackToStruct(property.Name, itemValue)
	return itemValue, true
	}
	case parser.NotEvaluatedType:
	getItemFunc = func(property *parser.Property, t reflect.Type) (reflect.Value, bool) {
	return reflect.New(t), false
	}
	default:
	panic(fmt.Errorf("bizarre property expression type: %v", exprs[0].Type()))
	}

	itemProperty := &parser.Property{NamePos: property.NamePos, ColonPos: property.ColonPos}
	elemType := sliceType.Elem()
	isPtr := elemType.Kind() == reflect.Ptr

	for i, expr := range exprs {
	itemProperty.Name = sliceName + "[" + strconv.Itoa(i) + "]"
	itemProperty.Value = expr
	if packedProperty, ok := ctx.propertyMap[itemProperty.Name]; ok {
	packedProperty.used = true
	}
	if isPtr {
	if itemValue, ok := getItemFunc(itemProperty, elemType.Elem()); ok {
	ptrValue := reflect.New(itemValue.Type())
	ptrValue.Elem().Set(itemValue)
	value = reflect.Append(value, ptrValue)
	}
	} else {
	if itemValue, ok := getItemFunc(itemProperty, elemType); ok {
	value = reflect.Append(value, itemValue)
	}
	}
	}
	return value, true
	}

	// propertyToValue creates a value of a given value type from the property.
	func propertyToValue(typ reflect.Type, property *parser.Property) (reflect.Value, error) {
	var value reflect.Value
	var baseType reflect.Type
	isPtr := typ.Kind() == reflect.Ptr
	if isPtr {
	baseType = typ.Elem()
	} else {
	baseType = typ
	}

	switch kind := baseType.Kind(); kind {
	case reflect.Bool:
	b, ok := property.Value.Eval().(*parser.Bool)
	if !ok {
	return value, &UnpackError{
	fmt.Errorf("can't assign %s value to bool property %q",
	property.Value.Type(), property.Name),
	property.Value.Pos(),
	}
	}
	value = reflect.ValueOf(b.Value)

	case reflect.Int64:
	b, ok := property.Value.Eval().(*parser.Int64)
	if !ok {
	return value, &UnpackError{
	fmt.Errorf("can't assign %s value to int64 property %q",
	property.Value.Type(), property.Name),
	property.Value.Pos(),
	}
	}
	value = reflect.ValueOf(b.Value)

	case reflect.String:
	s, ok := property.Value.Eval().(*parser.String)
	if !ok {
	return value, &UnpackError{
	fmt.Errorf("can't assign %s value to string property %q",
	property.Value.Type(), property.Name),
	property.Value.Pos(),
	}
	}
	value = reflect.ValueOf(s.Value)

	default:
	return value, &UnpackError{
	fmt.Errorf("cannot assign %s value %s to %s property %s", property.Value.Type(), property.Value, kind, typ),
	property.NamePos}
	}

	if isPtr {
	ptrValue := reflect.New(value.Type())
	ptrValue.Elem().Set(value)
	return ptrValue, nil
	}
	return value, nil
	}