tools/fidl/gidl/llcpp/lib/equality_builder.go - fuchsia - Git at Google

 // Copyright 2021 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 package lib

 import (
 	"fmt"
 	"strings"

 	gidlir "go.fuchsia.dev/fuchsia/tools/fidl/gidl/ir"
 	gidlmixer "go.fuchsia.dev/fuchsia/tools/fidl/gidl/mixer"
 	"go.fuchsia.dev/fuchsia/tools/fidl/lib/fidlgen"
 )

 // EqualityCheck contains the necessary information to render an equality check.
 // See BuildEqualityCheck.
 type EqualityCheck = struct {
 	// InputVar is the name of the wire domain object to be checked.
 	InputVar string

 	// HelperStatements is a series of statements binding particular fields
 	// in a wire domain object to named references. It should precede the
 	// EqualityExpr when rendered.
 	HelperStatements string

 	// Expr is an expression checking the named references from
 	// HelperStatements against their expected value.
 	Expr string
 }

 // BuildEqualityCheck builds an ad-hoc equality test verifying that a wire domain object
 // matches the expected value.
 //
 // In particular, an actual handle having the same KOID, type, and rights as the expected
 // handle is considered equal to the expected, despite possibly having different handle
 // numbers, to accommodate handle replacement.
 func BuildEqualityCheck(actualVar string, expectedValue gidlir.Value, decl gidlmixer.Declaration, handleKoidVectorName string) EqualityCheck {
 	builder := equalityCheckBuilder{
 		handleKoidVectorName: handleKoidVectorName,
 	}
 	resultValue := builder.visit(fidlExpr(actualVar), expectedValue, decl)
 	resultBuild := builder.String()
 	return EqualityCheck{
 		InputVar:         actualVar,
 		HelperStatements: resultBuild,
 		Expr:             string(resultValue),
 	}
 }

 // A boolean expression in C++ (i.e. the output of the check).
 type boolExpr string

 // A fidl expression in C++ (i.e. one of the input FIDL objects or subobjects).
 type fidlExpr string

 // Create a fidl expression from a formatted string.
 func fidlSprintf(format string, vals ...interface{}) fidlExpr {
 	return fidlExpr(fmt.Sprintf(format, vals...))
 }

 // Create a boolean expression from a formatted string.
 func boolSprintf(format string, vals ...interface{}) boolExpr {
 	return boolExpr(fmt.Sprintf(format, vals...))
 }

 // Join a list of boolean expressions into a new expression that is true iff all of the inputs are true.
 func boolJoin(exprs []boolExpr) boolExpr {
 	if len(exprs) == 0 {
 		return "true"
 	}

 	var strs []string
 	for _, expr := range exprs {
 		strs = append(strs, string(expr))
 	}
 	return boolExpr(fmt.Sprintf("(%s)", strings.Join(strs, " && ")))
 }

 // Generator of new variable names from a sequence.
 type varSeq int

 func (v *varSeq) next() int {
 	*v++
 	return int(*v)
 }

 func (v *varSeq) nextBoolVar() boolExpr {
 	return boolExpr(fmt.Sprintf("b%d", v.next()))
 }
 func (v *varSeq) nextFidlVar() fidlExpr {
 	return fidlExpr(fmt.Sprintf("f%d", v.next()))
 }

 type equalityCheckBuilder struct {
 	strings.Builder
 	varSeq varSeq
 	// Name of a C++ variable containing an vector of zx_koid_t of handle values
 	// This is read-only and is used for checking handle koid equality.
 	handleKoidVectorName string
 }

 func (b *equalityCheckBuilder) write(format string, vals ...interface{}) {
 	b.WriteString(fmt.Sprintf(format, vals...))
 }

 func (b *equalityCheckBuilder) createAndAssignVar(val fidlExpr) fidlExpr {
 	varName := b.varSeq.nextFidlVar()
 	b.write("[[maybe_unused]] auto& %s = %s;\n", varName, val)
 	return varName
 }

 func (b *equalityCheckBuilder) construct(typename string, fmtStr string, args ...interface{}) fidlExpr {
 	val := fmt.Sprintf(fmtStr, args...)
 	return fidlSprintf("%s(%s)", typename, val)
 }

 func (b *equalityCheckBuilder) equals(actual, expected fidlExpr) boolExpr {
 	return boolSprintf("(%s == %s)", actual, expected)
 }

 func (b *equalityCheckBuilder) visit(actualExpr fidlExpr, expectedValue gidlir.Value, decl gidlmixer.Declaration) boolExpr {
 	switch expectedValue := expectedValue.(type) {
 	case bool:
 		return b.equals(actualExpr, b.construct(typeName(decl), "%t", expectedValue))
 	case int64, uint64, float64:
 		switch decl := decl.(type) {
 		case gidlmixer.PrimitiveDeclaration, *gidlmixer.EnumDecl:
 			return b.equals(actualExpr, b.construct(typeName(decl), formatPrimitive(expectedValue)))
 		case *gidlmixer.BitsDecl:
 			return b.equals(actualExpr, fidlSprintf("static_cast<%s>(%s)", declName(decl), formatPrimitive(expectedValue)))
 		}
 	case gidlir.RawFloat:
 		switch decl.(*gidlmixer.FloatDecl).Subtype() {
 		case fidlgen.Float32:
 			return b.equals(actualExpr, fidlSprintf("([] { uint32_t u = %#b; float f; memcpy(&f, &u, sizeof(float)); return f; })()", expectedValue))
 		case fidlgen.Float64:
 			return b.equals(actualExpr, fidlSprintf("([] { uint64_t u = %#b; double d; memcpy(&d, &u, sizeof(double)); return d; })()", expectedValue))
 		}
 	case string:
 		return boolSprintf("(%[1]s.size() == %[3]d && memcmp(%[1]s.data(), %[2]q, %[3]d) == 0)", actualExpr, expectedValue, len(expectedValue))
 	case gidlir.HandleWithRights:
 		return b.visitHandle(actualExpr, expectedValue, decl.(*gidlmixer.HandleDecl))
 	case gidlir.Record:
 		switch decl := decl.(type) {
 		case *gidlmixer.StructDecl:
 			return b.visitStruct(actualExpr, expectedValue, decl)
 		case *gidlmixer.TableDecl:
 			return b.visitTable(actualExpr, expectedValue, decl)
 		case *gidlmixer.UnionDecl:
 			return b.visitUnion(actualExpr, expectedValue, decl)
 		}
 	case []gidlir.Value:
 		return b.visitList(actualExpr, expectedValue, decl.(gidlmixer.ListDeclaration))
 	case nil:
 		switch decl.(type) {
 		case *gidlmixer.VectorDecl:
 			return boolSprintf("(%s.data() == nullptr)", actualExpr)
 		case *gidlmixer.StringDecl:
 			return boolSprintf("%s.is_null()", actualExpr)
 		case *gidlmixer.HandleDecl:
 			return boolSprintf("!%s.is_valid()", actualExpr)
 		case *gidlmixer.UnionDecl:
 			return boolSprintf("%s.has_invalid_tag()", actualExpr)
 		case *gidlmixer.StructDecl:
 			return boolSprintf("(%s == nullptr)", actualExpr)
 		}
 	}
 	panic(fmt.Sprintf("not implemented: %T (decl: %T)", expectedValue, decl))
 }

 func (b *equalityCheckBuilder) visitHandle(actualExpr fidlExpr, expectedValue gidlir.HandleWithRights, decl *gidlmixer.HandleDecl) boolExpr {
 	actualVar := b.createAndAssignVar(actualExpr)
 	resultVar := b.varSeq.nextBoolVar()
 	// Check:
 	// - Original handle's koid matches final handle (it could be replaced so can't check handle value).
 	// - Type matches expectation.
 	// - Rights matches expectation.
 	b.write(`
 	zx_info_handle_basic_t %[1]s_info;
 	ZX_ASSERT(ZX_OK == zx_object_get_info(%[2]s.get(), ZX_INFO_HANDLE_BASIC, &%[1]s_info, sizeof(%[1]s_info), nullptr, nullptr));
 	bool %[1]s = %[1]s_info.koid == %[3]s[%[4]d] &&
 		(%[1]s_info.type == %[5]d || %[5]d == ZX_OBJ_TYPE_NONE) &&
 		(%[1]s_info.rights == %[6]d || %[6]d == ZX_RIGHT_SAME_RIGHTS);
 	`, resultVar, actualVar, b.handleKoidVectorName, expectedValue.Handle, expectedValue.Type, expectedValue.Rights)
 	return resultVar
 }

 func (b *equalityCheckBuilder) visitStruct(actualExpr fidlExpr, expectedValue gidlir.Record, decl *gidlmixer.StructDecl) boolExpr {
 	op := "."
 	if decl.IsNullable() {
 		op = "->"
 	}
 	actualVar := b.createAndAssignVar(actualExpr)
 	var fieldEquality []boolExpr
 	for _, field := range expectedValue.Fields {
 		fieldDecl, ok := decl.Field(field.Key.Name)
 		if !ok {
 			panic(fmt.Sprintf("field %s not found", field.Key.Name))
 		}
 		actualFieldExpr := fidlSprintf("%s%s%s", actualVar, op, field.Key.Name)
 		fieldEquality = append(fieldEquality, b.visit(actualFieldExpr, field.Value, fieldDecl))
 	}
 	return boolJoin(fieldEquality)
 }

 func (b *equalityCheckBuilder) visitTable(actualExpr fidlExpr, expectedValue gidlir.Record, decl *gidlmixer.TableDecl) boolExpr {
 	actualVar := b.createAndAssignVar(actualExpr)
 	var fieldEquality []boolExpr
 	expectedFieldValues := map[string]gidlir.Value{}
 	for _, field := range expectedValue.Fields {
 		if field.Key.IsUnknown() {
 			panic("LLCPP does not support constructing unknown fields")
 		}
 		expectedFieldValues[field.Key.Name] = field.Value
 	}
 	for _, fieldName := range decl.FieldNames() {
 		fieldDecl, ok := decl.Field(fieldName)
 		if !ok {
 			panic(fmt.Sprintf("field decl %s not found", fieldName))
 		}
 		if expectedFieldValue, ok := expectedFieldValues[fieldName]; ok {
 			fieldEquality = append(fieldEquality, boolSprintf("%s.has_%s()", actualVar, fieldName))
 			actualFieldExpr := fidlSprintf("%s.%s()", actualVar, fieldName)
 			fieldEquality = append(fieldEquality, b.visit(actualFieldExpr, expectedFieldValue, fieldDecl))
 		} else {
 			fieldEquality = append(fieldEquality, boolSprintf("!%s.has_%s()", actualVar, fieldName))
 		}
 	}
 	if len(fieldEquality) == 0 {
 		return "true"
 	}
 	return boolJoin(fieldEquality)
 }

 func (b *equalityCheckBuilder) visitUnion(actualExpr fidlExpr, expectedValue gidlir.Record, decl *gidlmixer.UnionDecl) boolExpr {
 	actualVar := b.createAndAssignVar(actualExpr)
 	if len(expectedValue.Fields) != 1 {
 		panic("shouldn't happen")
 	}
 	field := expectedValue.Fields[0]
 	if field.Key.IsUnknown() {
 		panic("LLCPP does not support constructing unknown fields")
 	}
 	fieldDecl, ok := decl.Field(field.Key.Name)
 	if !ok {
 		panic(fmt.Sprintf("field %s not found", field.Key.Name))
 	}
 	actualFieldExpr := fidlSprintf("%s.%s()", actualVar, fidlgen.ToSnakeCase(field.Key.Name))
 	fieldEquality := b.visit(actualFieldExpr, field.Value, fieldDecl)
 	return boolSprintf("(%s.which() == %s::Tag::%s && %s)",
 		actualVar, declName(decl), fidlgen.ConstNameToKCamelCase(field.Key.Name), fieldEquality)
 }

 func (b *equalityCheckBuilder) visitList(actualExpr fidlExpr, expectedValue []gidlir.Value, decl gidlmixer.ListDeclaration) boolExpr {
 	actualVar := b.createAndAssignVar(actualExpr)
 	var equalityChecks []boolExpr
 	if _, ok := decl.(*gidlmixer.VectorDecl); ok {
 		equalityChecks = append(equalityChecks, boolSprintf("%s.count() == %d", actualVar, len(expectedValue)))
 	}
 	for i, item := range expectedValue {
 		equalityChecks = append(equalityChecks, b.visit(fidlSprintf("%s[%d]", actualVar, i), item, decl.Elem()))
 	}
 	if len(equalityChecks) == 0 {
 		return "true"
 	}
 	return boolJoin(equalityChecks)
 }
	// Copyright 2021 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	package lib

	import (
	"fmt"
	"strings"

	gidlir "go.fuchsia.dev/fuchsia/tools/fidl/gidl/ir"
	gidlmixer "go.fuchsia.dev/fuchsia/tools/fidl/gidl/mixer"
	"go.fuchsia.dev/fuchsia/tools/fidl/lib/fidlgen"
	)

	// EqualityCheck contains the necessary information to render an equality check.
	// See BuildEqualityCheck.
	type EqualityCheck = struct {
	// InputVar is the name of the wire domain object to be checked.
	InputVar string

	// HelperStatements is a series of statements binding particular fields
	// in a wire domain object to named references. It should precede the
	// EqualityExpr when rendered.
	HelperStatements string

	// Expr is an expression checking the named references from
	// HelperStatements against their expected value.
	Expr string
	}

	// BuildEqualityCheck builds an ad-hoc equality test verifying that a wire domain object
	// matches the expected value.
	//
	// In particular, an actual handle having the same KOID, type, and rights as the expected
	// handle is considered equal to the expected, despite possibly having different handle
	// numbers, to accommodate handle replacement.
	func BuildEqualityCheck(actualVar string, expectedValue gidlir.Value, decl gidlmixer.Declaration, handleKoidVectorName string) EqualityCheck {
	builder := equalityCheckBuilder{
	handleKoidVectorName: handleKoidVectorName,
	}
	resultValue := builder.visit(fidlExpr(actualVar), expectedValue, decl)
	resultBuild := builder.String()
	return EqualityCheck{
	InputVar: actualVar,
	HelperStatements: resultBuild,
	Expr: string(resultValue),
	}
	}

	// A boolean expression in C++ (i.e. the output of the check).
	type boolExpr string

	// A fidl expression in C++ (i.e. one of the input FIDL objects or subobjects).
	type fidlExpr string

	// Create a fidl expression from a formatted string.
	func fidlSprintf(format string, vals ...interface{}) fidlExpr {
	return fidlExpr(fmt.Sprintf(format, vals...))
	}

	// Create a boolean expression from a formatted string.
	func boolSprintf(format string, vals ...interface{}) boolExpr {
	return boolExpr(fmt.Sprintf(format, vals...))
	}

	// Join a list of boolean expressions into a new expression that is true iff all of the inputs are true.
	func boolJoin(exprs []boolExpr) boolExpr {
	if len(exprs) == 0 {
	return "true"
	}

	var strs []string
	for _, expr := range exprs {
	strs = append(strs, string(expr))
	}
	return boolExpr(fmt.Sprintf("(%s)", strings.Join(strs, " && ")))
	}

	// Generator of new variable names from a sequence.
	type varSeq int

	func (v *varSeq) next() int {
	*v++
	return int(*v)
	}

	func (v *varSeq) nextBoolVar() boolExpr {
	return boolExpr(fmt.Sprintf("b%d", v.next()))
	}
	func (v *varSeq) nextFidlVar() fidlExpr {
	return fidlExpr(fmt.Sprintf("f%d", v.next()))
	}

	type equalityCheckBuilder struct {
	strings.Builder
	varSeq varSeq
	// Name of a C++ variable containing an vector of zx_koid_t of handle values
	// This is read-only and is used for checking handle koid equality.
	handleKoidVectorName string
	}

	func (b *equalityCheckBuilder) write(format string, vals ...interface{}) {
	b.WriteString(fmt.Sprintf(format, vals...))
	}

	func (b *equalityCheckBuilder) createAndAssignVar(val fidlExpr) fidlExpr {
	varName := b.varSeq.nextFidlVar()
	b.write("[[maybe_unused]] auto& %s = %s;\n", varName, val)
	return varName
	}

	func (b *equalityCheckBuilder) construct(typename string, fmtStr string, args ...interface{}) fidlExpr {
	val := fmt.Sprintf(fmtStr, args...)
	return fidlSprintf("%s(%s)", typename, val)
	}

	func (b *equalityCheckBuilder) equals(actual, expected fidlExpr) boolExpr {
	return boolSprintf("(%s == %s)", actual, expected)
	}

	func (b *equalityCheckBuilder) visit(actualExpr fidlExpr, expectedValue gidlir.Value, decl gidlmixer.Declaration) boolExpr {
	switch expectedValue := expectedValue.(type) {
	case bool:
	return b.equals(actualExpr, b.construct(typeName(decl), "%t", expectedValue))
	case int64, uint64, float64:
	switch decl := decl.(type) {
	case gidlmixer.PrimitiveDeclaration, *gidlmixer.EnumDecl:
	return b.equals(actualExpr, b.construct(typeName(decl), formatPrimitive(expectedValue)))
	case *gidlmixer.BitsDecl:
	return b.equals(actualExpr, fidlSprintf("static_cast<%s>(%s)", declName(decl), formatPrimitive(expectedValue)))
	}
	case gidlir.RawFloat:
	switch decl.(*gidlmixer.FloatDecl).Subtype() {
	case fidlgen.Float32:
	return b.equals(actualExpr, fidlSprintf("([] { uint32_t u = %#b; float f; memcpy(&f, &u, sizeof(float)); return f; })()", expectedValue))
	case fidlgen.Float64:
	return b.equals(actualExpr, fidlSprintf("([] { uint64_t u = %#b; double d; memcpy(&d, &u, sizeof(double)); return d; })()", expectedValue))
	}
	case string:
	return boolSprintf("(%[1]s.size() == %[3]d && memcmp(%[1]s.data(), %[2]q, %[3]d) == 0)", actualExpr, expectedValue, len(expectedValue))
	case gidlir.HandleWithRights:
	return b.visitHandle(actualExpr, expectedValue, decl.(*gidlmixer.HandleDecl))
	case gidlir.Record:
	switch decl := decl.(type) {
	case *gidlmixer.StructDecl:
	return b.visitStruct(actualExpr, expectedValue, decl)
	case *gidlmixer.TableDecl:
	return b.visitTable(actualExpr, expectedValue, decl)
	case *gidlmixer.UnionDecl:
	return b.visitUnion(actualExpr, expectedValue, decl)
	}
	case []gidlir.Value:
	return b.visitList(actualExpr, expectedValue, decl.(gidlmixer.ListDeclaration))
	case nil:
	switch decl.(type) {
	case *gidlmixer.VectorDecl:
	return boolSprintf("(%s.data() == nullptr)", actualExpr)
	case *gidlmixer.StringDecl:
	return boolSprintf("%s.is_null()", actualExpr)
	case *gidlmixer.HandleDecl:
	return boolSprintf("!%s.is_valid()", actualExpr)
	case *gidlmixer.UnionDecl:
	return boolSprintf("%s.has_invalid_tag()", actualExpr)
	case *gidlmixer.StructDecl:
	return boolSprintf("(%s == nullptr)", actualExpr)
	}
	}
	panic(fmt.Sprintf("not implemented: %T (decl: %T)", expectedValue, decl))
	}

	func (b equalityCheckBuilder) visitHandle(actualExpr fidlExpr, expectedValue gidlir.HandleWithRights, decl gidlmixer.HandleDecl) boolExpr {
	actualVar := b.createAndAssignVar(actualExpr)
	resultVar := b.varSeq.nextBoolVar()
	// Check:
	// - Original handle's koid matches final handle (it could be replaced so can't check handle value).
	// - Type matches expectation.
	// - Rights matches expectation.
	b.write(`
	zx_info_handle_basic_t %[1]s_info;
	ZX_ASSERT(ZX_OK == zx_object_get_info(%[2]s.get(), ZX_INFO_HANDLE_BASIC, &%[1]s_info, sizeof(%[1]s_info), nullptr, nullptr));
	bool %[1]s = %[1]s_info.koid == %[3]s[%[4]d] &&
	(%[1]s_info.type == %[5]d \|\| %[5]d == ZX_OBJ_TYPE_NONE) &&
	(%[1]s_info.rights == %[6]d \|\| %[6]d == ZX_RIGHT_SAME_RIGHTS);
	`, resultVar, actualVar, b.handleKoidVectorName, expectedValue.Handle, expectedValue.Type, expectedValue.Rights)
	return resultVar
	}

	func (b equalityCheckBuilder) visitStruct(actualExpr fidlExpr, expectedValue gidlir.Record, decl gidlmixer.StructDecl) boolExpr {
	op := "."
	if decl.IsNullable() {
	op = "->"
	}
	actualVar := b.createAndAssignVar(actualExpr)
	var fieldEquality []boolExpr
	for _, field := range expectedValue.Fields {
	fieldDecl, ok := decl.Field(field.Key.Name)
	if !ok {
	panic(fmt.Sprintf("field %s not found", field.Key.Name))
	}
	actualFieldExpr := fidlSprintf("%s%s%s", actualVar, op, field.Key.Name)
	fieldEquality = append(fieldEquality, b.visit(actualFieldExpr, field.Value, fieldDecl))
	}
	return boolJoin(fieldEquality)
	}

	func (b equalityCheckBuilder) visitTable(actualExpr fidlExpr, expectedValue gidlir.Record, decl gidlmixer.TableDecl) boolExpr {
	actualVar := b.createAndAssignVar(actualExpr)
	var fieldEquality []boolExpr
	expectedFieldValues := map[string]gidlir.Value{}
	for _, field := range expectedValue.Fields {
	if field.Key.IsUnknown() {
	panic("LLCPP does not support constructing unknown fields")
	}
	expectedFieldValues[field.Key.Name] = field.Value
	}
	for _, fieldName := range decl.FieldNames() {
	fieldDecl, ok := decl.Field(fieldName)
	if !ok {
	panic(fmt.Sprintf("field decl %s not found", fieldName))
	}
	if expectedFieldValue, ok := expectedFieldValues[fieldName]; ok {
	fieldEquality = append(fieldEquality, boolSprintf("%s.has_%s()", actualVar, fieldName))
	actualFieldExpr := fidlSprintf("%s.%s()", actualVar, fieldName)
	fieldEquality = append(fieldEquality, b.visit(actualFieldExpr, expectedFieldValue, fieldDecl))
	} else {
	fieldEquality = append(fieldEquality, boolSprintf("!%s.has_%s()", actualVar, fieldName))
	}
	}
	if len(fieldEquality) == 0 {
	return "true"
	}
	return boolJoin(fieldEquality)
	}

	func (b equalityCheckBuilder) visitUnion(actualExpr fidlExpr, expectedValue gidlir.Record, decl gidlmixer.UnionDecl) boolExpr {
	actualVar := b.createAndAssignVar(actualExpr)
	if len(expectedValue.Fields) != 1 {
	panic("shouldn't happen")
	}
	field := expectedValue.Fields[0]
	if field.Key.IsUnknown() {
	panic("LLCPP does not support constructing unknown fields")
	}
	fieldDecl, ok := decl.Field(field.Key.Name)
	if !ok {
	panic(fmt.Sprintf("field %s not found", field.Key.Name))
	}
	actualFieldExpr := fidlSprintf("%s.%s()", actualVar, fidlgen.ToSnakeCase(field.Key.Name))
	fieldEquality := b.visit(actualFieldExpr, field.Value, fieldDecl)
	return boolSprintf("(%s.which() == %s::Tag::%s && %s)",
	actualVar, declName(decl), fidlgen.ConstNameToKCamelCase(field.Key.Name), fieldEquality)
	}

	func (b *equalityCheckBuilder) visitList(actualExpr fidlExpr, expectedValue []gidlir.Value, decl gidlmixer.ListDeclaration) boolExpr {
	actualVar := b.createAndAssignVar(actualExpr)
	var equalityChecks []boolExpr
	if _, ok := decl.(*gidlmixer.VectorDecl); ok {
	equalityChecks = append(equalityChecks, boolSprintf("%s.count() == %d", actualVar, len(expectedValue)))
	}
	for i, item := range expectedValue {
	equalityChecks = append(equalityChecks, b.visit(fidlSprintf("%s[%d]", actualVar, i), item, decl.Elem()))
	}
	if len(equalityChecks) == 0 {
	return "true"
	}
	return boolJoin(equalityChecks)
	}