binder/tools/pkg/codegen/enum_gen.go at v0.0.9 · AndroidGoLab/binder

597 lines (565 loc) · 16.3 KB
package codegen
	"github.com/AndroidGoLab/binder/tools/pkg/parser"
	"github.com/AndroidGoLab/binder/tools/pkg/resolver"
// GenerateEnum generates Go source for an AIDL enum declaration.
// The output includes:
// - A Go type alias for the backing type
// - Typed constants for each enumerator
func GenerateEnum(
	decl *parser.EnumDecl,
	pkg string,
	options ...GenOption,
) ([]byte, error) {
	opts := applyGenOptions(options)
	f := NewGoFile(pkg)
	goName := AIDLToGoName(decl.EnumName)
	backingGoType := enumBackingGoType(decl)
	f.P("// Code generated by aidlgen. DO NOT EDIT.")
	// Type declaration.
	f.P("type %s %s", goName, backingGoType)
	// Enumerator constants.
	if len(decl.Enumerators) > 0 {
		f.P("const (")
		counter := int64(0)
		for _, e := range decl.Enumerators {
			constName := goName + AIDLToGoName(e.Name)
			if e.Value != nil {
				valStr, err := enumConstExprToGo(e.Value, backingGoType, goName, opts.Registry)
				if err != nil {
					return nil, fmt.Errorf("evaluating enumerator %s: %w", e.Name, err)
				f.P("\t%s %s = %s", constName, goName, valStr)
				// Try to parse the explicit value so subsequent implicit
				// enumerators continue from the right number.
				if parsed, parseErr := strconv.ParseInt(valStr, 0, 64); parseErr == nil {
					counter = parsed + 1
				} else {
					// Cannot determine the numeric value (e.g. expression);
					// subsequent implicit enumerators will be wrong, but
					// this is the best we can do without a const evaluator.
					counter++
			} else {
				f.P("\t%s %s = %d", constName, goName, counter)
				counter++
	return f.Bytes()
// enumBackingGoType returns the Go type for an enum's backing type.
// Defaults to int32 if no backing type is specified.
func enumBackingGoType(decl *parser.EnumDecl) string {
	if decl.BackingType != nil {
		goType := AIDLTypeToGo(decl.BackingType)
		if goType != "" {
			return goType
	return "int32"
// enumConstExprToGo converts a ConstExpr to a Go source string in the context
// of an enum with the given backing Go type (e.g., "int32", "int64", "byte").
// It handles:
// - Integer literals that overflow the backing type (two's complement conversion)
// - Cross-type identifier references (casting to the backing type)
// The optional registry parameter enables resolution of cross-enum references
// for overflow detection in complex expressions.
func enumConstExprToGo(
	expr parser.ConstExpr,
	backingGoType string,
	enumGoName string,
	registry ...*resolver.TypeRegistry,
) (string, error) {
	var reg *resolver.TypeRegistry
	if len(registry) > 0 {
		reg = registry[0]
	switch e := expr.(type) {
	case *parser.IntegerLiteral:
		return enumIntLiteralToGo(e.Value, backingGoType)
	case *parser.IdentExpr:
		goName := aidlDottedNameToGo(e.Name)
		// Determine the cast target type: use the enum type if available,
		// otherwise fall back to the backing Go type.
		castType := enumGoName
		if castType == "" {
			castType = backingGoType
		// If the AIDL name contains a dot, it's a qualified reference to
		// another type's constant (e.g. "SourceClass.BUTTON") and always
		// needs casting so Go allows the typed expression.
		if strings.Contains(e.Name, ".") {
			return castType + "(" + goName + ")", nil
		if enumGoName == "" {
			// No enum context (e.g. standalone constant): cast all idents.
			return castType + "(" + goName + ")", nil
		// Unqualified reference: this is a self-reference to another
		// enumerator in the same enum (e.g., STYLUS referencing itself).
		// Prefix with the enum name to match the generated constant name.
		return enumGoName + goName, nil
	case *parser.UnaryExpr:
		// Handle negative integer literals that overflow unsigned backing types.
		if e.Op == parser.TokenMinus {
			if intLit, ok := e.Operand.(*parser.IntegerLiteral); ok {
				stripped := stripAIDLIntSuffix(intLit.Value)
				if parsed, parseErr := strconv.ParseUint(stripped, 0, 64); parseErr == nil {
					negVal := -int64(parsed)
					return enumSignedToBackingType(negVal, backingGoType), nil
		operand, err := enumConstExprToGo(e.Operand, backingGoType, enumGoName, reg)
		if err != nil {
			return "", err
		return tokenToGoOp(e.Op) + operand, nil
	case *parser.BinaryExpr:
		// Try to evaluate the full expression numerically (including
		// cross-enum references via the registry). If it overflows
		// the backing type, emit the folded signed value directly.
		if val, ok := tryEvalConstExprWithRegistry(expr, reg); ok {
			folded := foldUnsignedToSigned(val, backingGoType)
			original := fmt.Sprintf("%d", val)
			if folded != original {
				return folded, nil
		left, err := enumConstExprToGo(e.Left, backingGoType, enumGoName, reg)
		if err != nil {
			return "", err
		right, err := enumConstExprToGo(e.Right, backingGoType, enumGoName, reg)
		if err != nil {
			return "", err
		return fmt.Sprintf("(%s %s %s)", left, tokenToGoOp(e.Op), right), nil
		// For other expression types, fall back to the generic converter.
		return constExprToGo(expr)
// enumIntLiteralToGo converts an AIDL integer literal to a Go source string,
// handling overflow for the given backing type by emitting two's complement.
func enumIntLiteralToGo(
	value string,
	backingGoType string,
) (string, error) {
	stripped := stripAIDLIntSuffix(value)
	// Try to parse as unsigned to detect overflow.
	parsed, err := strconv.ParseUint(stripped, 0, 64)
	if err != nil {
		// Not a simple integer; return as-is (may be negative or valid).
		return stripped, nil
	return foldUnsignedToSigned(parsed, backingGoType), nil
// foldUnsignedToSigned converts an unsigned value to its signed representation
// if it overflows the range of the given Go backing type.
func foldUnsignedToSigned(
	val uint64,
	backingGoType string,
	switch backingGoType {
	case "byte":
		if val > math.MaxUint8 {
			// byte is uint8 in Go, so truncate to uint8 (not int8, which
			// would produce negative numbers for values > 127).
			return fmt.Sprintf("%d", byte(val))
	case "int32":
		if val > math.MaxInt32 {
			return fmt.Sprintf("%d", int32(val))
	case "int64":
		if val > math.MaxInt64 {
			return fmt.Sprintf("%d", int64(val))
	return fmt.Sprintf("%d", val)
// tryEvalConstExpr attempts to evaluate a const expression to a uint64 value.
// Returns the value and true if evaluation succeeds, or 0 and false otherwise.
func tryEvalConstExpr(expr parser.ConstExpr) (uint64, bool) {
	switch e := expr.(type) {
	case *parser.IntegerLiteral:
		stripped := stripAIDLIntSuffix(e.Value)
		val, err := strconv.ParseUint(stripped, 0, 64)
		if err != nil {
			// Try signed parse for negative literals.
			sval, err2 := strconv.ParseInt(stripped, 0, 64)
			if err2 != nil {
				return 0, false
			return uint64(sval), true
		return val, true
	case *parser.UnaryExpr:
		operand, ok := tryEvalConstExpr(e.Operand)
			return 0, false
		switch e.Op {
		case parser.TokenMinus:
			return uint64(-int64(operand)), true
		case parser.TokenTilde:
			return ^operand, true
		case parser.TokenBang:
			if operand == 0 {
				return 1, true
			return 0, true
			return 0, false
	case *parser.BinaryExpr:
		left, ok := tryEvalConstExpr(e.Left)
			return 0, false
		right, ok := tryEvalConstExpr(e.Right)
			return 0, false
		// Note: arithmetic on uint64 wraps on overflow, matching Java/C unsigned semantics.
		switch e.Op {
		case parser.TokenPlus:
			return left + right, true
		case parser.TokenMinus:
			return left - right, true
		case parser.TokenStar:
			return left * right, true
		case parser.TokenSlash:
			if right == 0 {
				return 0, false
			return left / right, true
		case parser.TokenPercent:
			if right == 0 {
				return 0, false
			return left % right, true
		case parser.TokenAmp:
			return left & right, true
		case parser.TokenPipe:
			return left | right, true
		case parser.TokenCaret:
			return left ^ right, true
		case parser.TokenLShift:
			return left << right, true
		case parser.TokenRShift:
			return left >> right, true
			return 0, false
		return 0, false
// tryEvalConstExprWithRegistry attempts to evaluate a const expression to a
// uint64 value, using the type registry to resolve cross-enum ident references
// (e.g., "CameraMetadataSection.VENDOR_SECTION").
func tryEvalConstExprWithRegistry(
	expr parser.ConstExpr,
	registry *resolver.TypeRegistry,
) (uint64, bool) {
	// First try without registry (handles pure numeric expressions).
	if val, ok := tryEvalConstExpr(expr); ok {
		return val, true
	if registry == nil {
		return 0, false
	switch e := expr.(type) {
	case *parser.IdentExpr:
		return resolveEnumIdentValue(e.Name, registry)
	case *parser.UnaryExpr:
		operand, ok := tryEvalConstExprWithRegistry(e.Operand, registry)
			return 0, false
		switch e.Op {
		case parser.TokenMinus:
			return uint64(-int64(operand)), true
		case parser.TokenTilde:
			return ^operand, true
			return 0, false
	case *parser.BinaryExpr:
		left, ok := tryEvalConstExprWithRegistry(e.Left, registry)
			return 0, false
		right, ok := tryEvalConstExprWithRegistry(e.Right, registry)
			return 0, false
		// Note: arithmetic on uint64 wraps on overflow, matching Java/C unsigned semantics.
		switch e.Op {
		case parser.TokenPlus:
			return left + right, true
		case parser.TokenMinus:
			return left - right, true
		case parser.TokenStar:
			return left * right, true
		case parser.TokenSlash:
			if right == 0 {
				return 0, false
			return left / right, true
		case parser.TokenPercent:
			if right == 0 {
				return 0, false
			return left % right, true
		case parser.TokenAmp:
			return left & right, true
		case parser.TokenPipe:
			return left | right, true
		case parser.TokenCaret:
			return left ^ right, true
		case parser.TokenLShift:
			return left << right, true
		case parser.TokenRShift:
			return left >> right, true
			return 0, false
		return 0, false
// resolveEnumIdentValue resolves an AIDL enum constant reference (e.g.,
// "CameraMetadataSection.VENDOR_SECTION") to its numeric value using the
// type registry.
func resolveEnumIdentValue(
	name string,
	registry *resolver.TypeRegistry,
) (uint64, bool) {
	dotIdx := strings.LastIndex(name, ".")
	if dotIdx < 0 {
		return 0, false
	enumName := name[:dotIdx]
	constName := name[dotIdx+1:]
	// Look up the enum definition by short name.
	qualifiedName, def, ok := registry.LookupQualifiedByShortName(enumName)
		// Try fully qualified.
		def, ok = registry.Lookup(enumName)
			return 0, false
		qualifiedName = enumName
	_ = qualifiedName
	enumDecl, ok := def.(*parser.EnumDecl)
		return 0, false
	// Find the enumerator by name and evaluate its value.
	counter := int64(0)
	for _, e := range enumDecl.Enumerators {
		if e.Value != nil {
			if val, evalOK := tryEvalConstExpr(e.Value); evalOK {
				counter = int64(val)
		if e.Name == constName {
			return uint64(counter), true
		counter++
	return 0, false
// enumSignedToBackingType converts a signed integer value to a valid Go
// representation for the given backing type. For unsigned types like byte,
// negative values are converted to their unsigned equivalent.
func enumSignedToBackingType(
	val int64,
	backingGoType string,
	if val >= 0 {
		return fmt.Sprintf("%d", val)
	switch backingGoType {
	case "byte":
		return fmt.Sprintf("%d", byte(val))
		return fmt.Sprintf("%d", val)
// typedConstExprToGo converts a ConstExpr to a Go source string, handling
// integer overflow for the given Go type. For non-integer types or empty
// goType, it falls back to constExprToGo. The optional prefix is used to
// qualify self-referencing identifiers in constant expressions (e.g.,
// constants declared inside a struct/union/interface).
func typedConstExprToGo(
	expr parser.ConstExpr,
	goType string,
	prefix ...string,
) (string, error) {
	if len(prefix) > 0 {
		p = prefix[0]
	switch goType {
	case "int32", "int64", "byte":
		if p != "" {
			// For non-enum container constants (parcelable, union,
			// interface), use the prefix only for self-reference
			// qualification. The cast type must be the backing Go type,
			// not the container name (which might be an interface type).
			return prefixedIntConstExprToGo(expr, goType, p)
		return enumConstExprToGo(expr, goType, "")
		if p != "" {
			return prefixedConstExprToGo(expr, p)
		return constExprToGo(expr)
// prefixedIntConstExprToGo converts integer constant expressions with
// a container prefix for self-references, using the backing Go type
// (not the container name) for cross-type casts.
func prefixedIntConstExprToGo(
	expr parser.ConstExpr,
	backingGoType string,
	prefix string,
) (string, error) {
	switch e := expr.(type) {
	case *parser.IntegerLiteral:
		return enumIntLiteralToGo(e.Value, backingGoType)
	case *parser.IdentExpr:
		goName := aidlDottedNameToGo(e.Name)
		if strings.Contains(e.Name, ".") {
			// Cross-type reference: cast to backing type.
			return backingGoType + "(" + goName + ")", nil
		// Self-reference: prefix with the container name.
		return prefix + goName, nil
	case *parser.UnaryExpr:
		if e.Op == parser.TokenMinus {
			if intLit, ok := e.Operand.(*parser.IntegerLiteral); ok {
				stripped := stripAIDLIntSuffix(intLit.Value)
				if parsed, parseErr := strconv.ParseUint(stripped, 0, 64); parseErr == nil {
					negVal := -int64(parsed)
					return enumSignedToBackingType(negVal, backingGoType), nil
		operand, err := prefixedIntConstExprToGo(e.Operand, backingGoType, prefix)
		if err != nil {
			return "", err
		return tokenToGoOp(e.Op) + operand, nil
	case *parser.BinaryExpr:
		if val, ok := tryEvalConstExpr(expr); ok {
			folded := foldUnsignedToSigned(val, backingGoType)
			original := fmt.Sprintf("%d", val)
			if folded != original {
				return folded, nil
		left, err := prefixedIntConstExprToGo(e.Left, backingGoType, prefix)
		if err != nil {
			return "", err
		right, err := prefixedIntConstExprToGo(e.Right, backingGoType, prefix)
		if err != nil {
			return "", err
		return fmt.Sprintf("(%s %s %s)", left, tokenToGoOp(e.Op), right), nil
		return constExprToGo(expr)
// prefixedConstExprToGo converts a ConstExpr to a Go source string,
// prefixing unqualified identifier references with the given prefix.
// This handles constants declared inside types (parcelable, union) that
// reference other constants in the same type.
func prefixedConstExprToGo(
	expr parser.ConstExpr,
	prefix string,
) (string, error) {
	switch e := expr.(type) {
	case *parser.IdentExpr:
		goName := aidlDottedNameToGo(e.Name)
		if strings.Contains(e.Name, ".") {
			return goName, nil
		return prefix + goName, nil
	case *parser.UnaryExpr:
		operand, err := prefixedConstExprToGo(e.Operand, prefix)
		if err != nil {
			return "", err
		return tokenToGoOp(e.Op) + operand, nil
	case *parser.BinaryExpr:
		left, err := prefixedConstExprToGo(e.Left, prefix)
		if err != nil {
			return "", err
		right, err := prefixedConstExprToGo(e.Right, prefix)
		if err != nil {
			return "", err
		return fmt.Sprintf("(%s %s %s)", left, tokenToGoOp(e.Op), right), nil
		return constExprToGo(expr)
// constExprToGo converts a ConstExpr to a Go source string.
func constExprToGo(expr parser.ConstExpr) (string, error) {
	switch e := expr.(type) {
	case *parser.IntegerLiteral:
		return stripAIDLIntSuffix(e.Value), nil
	case *parser.FloatLiteral:
		return stripAIDLFloatSuffix(e.Value), nil
	case *parser.StringLiteralExpr:
		return fmt.Sprintf("%q", e.Value), nil
	case *parser.BoolLiteral:
		if e.Value {
			return "true", nil
		return "false", nil
	case *parser.CharLiteralExpr:
		return fmt.Sprintf("'%s'", e.Value), nil
	case *parser.NullLiteral:
		return "nil", nil
	case *parser.IdentExpr:
		return aidlDottedNameToGo(e.Name), nil
	case *parser.UnaryExpr:
		operand, err := constExprToGo(e.Operand)
		if err != nil {
			return "", err
		return tokenToGoOp(e.Op) + operand, nil
	case *parser.BinaryExpr:
		left, err := constExprToGo(e.Left)
		if err != nil {
			return "", err
		right, err := constExprToGo(e.Right)
		if err != nil {
			return "", err
		return fmt.Sprintf("(%s %s %s)", left, tokenToGoOp(e.Op), right), nil
		return "", fmt.Errorf("unsupported constant expression type %T", expr)
Provide feedback

Saved searches

Use saved searches to filter your results more quickly

FilesExpand file tree

enum_gen.go

Latest commit

History

enum_gen.go

File metadata and controls
