tools/fidl/lib/fidlgen_cpp/name_transforms.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 fidlgen_cpp

 import (
 	"fmt"

 	"go.fuchsia.dev/fuchsia/tools/fidl/lib/fidlgen"
 )

 func changeIfReserved(name string, ctx fidlgen.NameContext) string {
 	if ctx.IsReserved(name) {
 		return name + "_"
 	}
 	return name
 }

 type nameTransform func(string) string

 func (fn nameTransform) apply(s string) string {
 	if fn == nil {
 		return s
 	}
 	return fn(s)
 }

 type declarationTransform func(fidlgen.CompoundIdentifier, fidlgen.NameContext) name

 func simpleDeclarationTransform(
 	nsFn func(fidlgen.LibraryIdentifier) namespace,
 	nFn nameTransform) declarationTransform {
 	return func(id fidlgen.CompoundIdentifier, ctx fidlgen.NameContext) name {
 		return nsFn(id.Library).member(changeIfReserved(nFn.apply(string(id.Name)), ctx))
 	}
 }

 type declarationTransforms struct {
 	natural declarationTransform
 	unified declarationTransform
 	wire    declarationTransform
 }
 type declarationContext struct {
 	fidlgen.NameContext
 	transforms declarationTransforms
 }

 func (ctx declarationContext) transform(id fidlgen.CompoundIdentifier) nameVariants {
 	return nameVariants{
 		Natural: ctx.transforms.natural(id, ctx.NameContext),
 		Unified: ctx.transforms.unified(id, ctx.NameContext),
 		Wire:    ctx.transforms.wire(id, ctx.NameContext),
 	}
 }

 type memberTransform func(fidlgen.Identifier) name
 type memberTransforms struct {
 	natural nameTransform
 	unified nameTransform
 	wire    nameTransform
 }
 type memberContext struct {
 	fidlgen.NameContext
 	transforms memberTransforms
 }

 // wireMemberContext returns a memberContext that just applies a transform to
 // the wire name, leaving the others alone.
 func wireMemberContext(wireTransform nameTransform) memberContext {
 	return memberContext{
 		fidlgen.NewNameContext(), memberTransforms{wire: wireTransform},
 	}
 }

 // helper function used by transform
 func (ctx memberContext) makeName(n string) name {
 	return simpleName(changeIfReserved(n, ctx.NameContext))
 }

 func (ctx memberContext) transform(id fidlgen.Identifier) nameVariants {
 	n := string(id)
 	return nameVariants{
 		Natural: ctx.makeName(ctx.transforms.natural.apply(n)),
 		Unified: ctx.makeName(ctx.transforms.unified.apply(n)),
 		Wire:    ctx.makeName(ctx.transforms.wire.apply(n)),
 	}

 }

 // All data members are in lower_snake_case:
 // https://google.github.io/styleguide/cppguide.html#Variable_Names
 func newDataMemberContext() memberContext {
 	return memberContext{
 		fidlgen.NewNameContext(), memberTransforms{wire: fidlgen.ToSnakeCase},
 	}
 }

 // All constants members are in kCamelCase:
 // https://google.github.io/styleguide/cppguide.html#Enumerator_Names
 func newConstantMemberContext() memberContext {
 	return memberContext{
 		fidlgen.NewNameContext(), memberTransforms{wire: fidlgen.ConstNameToKCamelCase},
 	}
 }

 var (
 	// Name of a bits member
 	bitsMemberContext = newConstantMemberContext()
 	// Name of an enum member
 	enumMemberContext = newConstantMemberContext()
 	// Name of a struct member
 	structMemberContext = newDataMemberContext()
 	// Name of a table member
 	tableMemberContext = newDataMemberContext()
 	// Name of a union member
 	unionMemberContext = newDataMemberContext()
 	// Name of a union member tag
 	unionMemberTagContext = memberContext{
 		NameContext: fidlgen.NewNameContext(),
 		transforms: memberTransforms{
 			natural: fidlgen.ConstNameToKCamelCase,
 			unified: fidlgen.ConstNameToKCamelCase,
 			wire:    fidlgen.ConstNameToKCamelCase,
 		},
 	}
 	// Name of a method
 	// https://google.github.io/styleguide/cppguide.html#Function_Names
 	methodNameContext = wireMemberContext(fidlgen.ToUpperCamelCase)
 	// Name of a service member
 	// https://google.github.io/styleguide/cppguide.html#Type_Names
 	serviceMemberContext = wireMemberContext(fidlgen.ToSnakeCase)
 	// Name of a constant
 	// https://google.github.io/styleguide/cppguide.html#Constant_Names
 	constantContext = declarationContext{
 		NameContext: fidlgen.NewNameContext(),
 		transforms: declarationTransforms{
 			natural: simpleDeclarationTransform(naturalNamespace, nil),
 			unified: simpleDeclarationTransform(unifiedNamespace, nil),
 			wire:    simpleDeclarationTransform(wireNamespace, fidlgen.ConstNameToKCamelCase),
 		},
 	}
 	// Name of a data-type declaration
 	// https://google.github.io/styleguide/cppguide.html#Type_Names
 	typeContext = declarationContext{
 		NameContext: fidlgen.NewNameContext(),
 		transforms: declarationTransforms{
 			natural: simpleDeclarationTransform(naturalNamespace, nil),
 			unified: simpleDeclarationTransform(unifiedNamespace, nil),
 			wire:    simpleDeclarationTransform(wireNamespace, fidlgen.ToUpperCamelCase),
 		},
 	}
 	// Name of a service declaration
 	// https://google.github.io/styleguide/cppguide.html#Type_Names
 	// TODO(yifeit): Protocols and services should not have DeclName.
 	// Not all bindings generate these types.
 	serviceContext = declarationContext{
 		NameContext: fidlgen.NewNameContext(),
 		transforms: declarationTransforms{
 			natural: simpleDeclarationTransform(naturalNamespace, nil),
 			// Intentionally using the natural namespace, since we would like
 			// the unified bindings to transparently accept natural types, which
 			// may certainly contain protocol endpoints.
 			// TODO(fxbug.dev/72980): Switch to ClientEnd/ServerEnd and
 			// underscore namespace when corresponding endpoint types can easily
 			// convert into each other.
 			unified: simpleDeclarationTransform(naturalNamespace, nil),
 			wire:    simpleDeclarationTransform(unifiedNamespace, fidlgen.ToUpperCamelCase),
 		},
 	}
 	// Name of a protocol declaration
 	// https://google.github.io/styleguide/cppguide.html#Type_Names
 	// TODO(yifeit): Protocols and services should not have DeclName.
 	// Not all bindings generate these types.
 	protocolContext = declarationContext{
 		NameContext: fidlgen.NewNameContext(),
 		transforms: declarationTransforms{
 			natural: simpleDeclarationTransform(naturalNamespace, nil),
 			// Intentionally using the natural namespace, since we would like
 			// the unified bindings to transparently accept natural types, which
 			// may certainly contain protocol endpoints.
 			// TODO(fxbug.dev/72980): Switch to ClientEnd/ServerEnd and
 			// underscore namespace when corresponding endpoint types can easily
 			// convert into each other.
 			unified: simpleDeclarationTransform(naturalNamespace, nil),
 			wire:    simpleDeclarationTransform(unifiedNamespace, fidlgen.ToUpperCamelCase),
 		},
 	}

 	// Namespace components
 	// https://google.github.io/styleguide/cppguide.html#Namespace_Names
 	nsComponentContext = fidlgen.NewNameContext()
 )

 func declContext(declType fidlgen.DeclType) declarationContext {
 	switch declType {
 	case fidlgen.ConstDeclType:
 		return constantContext
 	case fidlgen.BitsDeclType, fidlgen.EnumDeclType, fidlgen.StructDeclType,
 		fidlgen.TableDeclType, fidlgen.UnionDeclType:
 		return typeContext
 	case fidlgen.ProtocolDeclType:
 		return protocolContext
 	case fidlgen.ServiceDeclType:
 		return serviceContext
 	default:
 		panic(fmt.Sprintf("Unknown decl type: %#v", declType))
 	}
 }

 func memberNameContext(declType fidlgen.DeclType) memberContext {
 	switch declType {
 	case fidlgen.BitsDeclType:
 		return bitsMemberContext
 	case fidlgen.EnumDeclType:
 		return enumMemberContext
 	case fidlgen.StructDeclType:
 		return structMemberContext
 	case fidlgen.TableDeclType:
 		return tableMemberContext
 	case fidlgen.UnionDeclType:
 		return unionMemberContext
 	case fidlgen.ProtocolDeclType:
 		return methodNameContext
 	case fidlgen.ServiceDeclType:
 		return serviceMemberContext
 	default:
 		panic(fmt.Sprintf("Decl type %#v shouldn't have members", declType))
 	}
 }

 func init() {
 	// C++ keywords from: https://en.cppreference.com/w/cpp/keyword
 	cppKeywords := []string{
 		"alignas", "alignof", "and_eq", "and", "asm", "atomic_cancel",
 		"atomic_commit", "atomic_noexcept", "auto", "bitand", "bitor",
 		"bool", "break", "case", "catch", "char", "char16_t", "char32_t",
 		"class", "co_await", "co_return", "co_yield", "compl", "concept",
 		"const_cast", "const", "consteval", "constexpr", "constinit",
 		"continue", "decltype", "default", "delete", "do", "double",
 		"dynamic_cast", "else", "enum", "explicit", "export", "extern",
 		"false", "float", "for", "friend", "goto", "if", "inline", "int",
 		"long", "module", "mutable", "namespace", "new", "noexcept",
 		"not_eq", "not", "nullptr", "operator", "or_eq", "or", "private",
 		"protected", "public", "reflexexpr", "register",
 		"reinterpret_cast", "requires", "return", "short", "signed",
 		"sizeof", "static_assert", "static_cast", "static", "struct",
 		"switch", "synchronized", "template", "this", "thread_local",
 		"throw", "true", "try", "typedef", "typeid", "typename", "union",
 		"unsigned", "using", "virtual", "void", "volatile", "wchar_t",
 		"while", "xor_eq", "xor"}

 	// All names from errno definitions.
 	errnos := []string{"EPERM", "ENOENT", "ESRCH", "EINTR", "EIO",
 		"ENXIO", "E2BIG", "ENOEXEC", "EBADF", "ECHILD", "EAGAIN", "ENOMEM",
 		"EACCES", "EFAULT", "ENOTBLK", "EBUSY", "EEXIST", "EXDEV", "ENODEV",
 		"ENOTDIR", "EISDIR", "EINVAL", "ENFILE", "EMFILE", "ENOTTY",
 		"ETXTBSY", "EFBIG", "ENOSPC", "ESPIPE", "EROFS", "EMLINK", "EPIPE",
 		"EDOM", "ERANGE", "EDEADLK", "ENAMETOOLONG", "ENOLCK", "ENOSYS",
 		"ENOTEMPTY", "ELOOP", "EWOULDBLOCK", "ENOMSG", "EIDRM", "ECHRNG",
 		"EL2NSYNC", "EL3HLT", "EL3RST", "ELNRNG", "EUNATCH", "ENOCSI",
 		"EL2HLT", "EBADE", "EBADR", "EXFULL", "ENOANO", "EBADRQC",
 		"EBADSLT", "EDEADLOCK", "EBFONT", "ENOSTR", "ENODATA", "ETIME",
 		"ENOSR", "ENONET", "ENOPKG", "EREMOTE", "ENOLINK", "EADV", "ESRMNT",
 		"ECOMM", "EPROTO", "EMULTIHOP", "EDOTDOT", "EBADMSG", "EOVERFLOW",
 		"ENOTUNIQ", "EBADFD", "EREMCHG", "ELIBACC", "ELIBBAD", "ELIBSCN",
 		"ELIBMAX", "ELIBEXEC", "EILSEQ", "ERESTART", "ESTRPIPE", "EUSERS",
 		"ENOTSOCK", "EDESTADDRREQ", "EMSGSIZE", "EPROTOTYPE", "ENOPROTOOPT",
 		"EPROTONOSUPPORT", "ESOCKTNOSUPPORT", "EOPNOTSUPP", "ENOTSUP",
 		"EPFNOSUPPORT", "EAFNOSUPPORT", "EADDRINUSE", "EADDRNOTAVAIL",
 		"ENETDOWN", "ENETUNREACH", "ENETRESET", "ECONNABORTED",
 		"ECONNRESET", "ENOBUFS", "EISCONN", "ENOTCONN", "ESHUTDOWN",
 		"ETOOMANYREFS", "ETIMEDOUT", "ECONNREFUSED", "EHOSTDOWN",
 		"EHOSTUNREACH", "EALREADY", "EINPROGRESS", "ESTALE", "EUCLEAN",
 		"ENOTNAM", "ENAVAIL", "EISNAM", "EREMOTEIO", "EDQUOT", "ENOMEDIUM",
 		"EMEDIUMTYPE", "ECANCELED", "ENOKEY", "EKEYEXPIRED", "EKEYREVOKED",
 		"EKEYREJECTED", "EOWNERDEAD", "ENOTRECOVERABLE", "ERFKILL",
 		"EHWPOISON"}

 	// Names used in the C++ FIDL bindings
 	fidlNames := []string{"FidlType", "HandleEvents",
 		"has_invalid_tag", "IsEmpty", "New", "Tag", "unknown", "Unknown",
 		"UnknownBytes", "UnknownData", "which", "Which"}
 	// TODO(ianloic) add: "Clone"
 	// There are Clone methods on a couple of protocols so this may be a breaking change.
 	// fxbug.dev/7785

 	// misc other names
 	// TODO(ianloic): confirm which of these can be removed
 	miscNames := []string{"assert", "import", "NULL", "offsetof",
 		"xunion"}

 	// Reserve names that are universally reserved:
 	for _, ctx := range []declarationContext{constantContext, typeContext,
 		serviceContext, protocolContext} {
 		ctx.ReserveNames(cppKeywords)
 		ctx.ReserveNames(errnos)
 		ctx.ReserveNames(fidlNames)
 		ctx.ReserveNames(miscNames)
 	}
 	for _, ctx := range []memberContext{
 		bitsMemberContext, enumMemberContext, structMemberContext,
 		tableMemberContext, unionMemberContext, serviceMemberContext,
 		methodNameContext} {
 		ctx.ReserveNames(cppKeywords)
 		ctx.ReserveNames(errnos)
 		ctx.ReserveNames(fidlNames)
 		ctx.ReserveNames(miscNames)
 	}
 	nsComponentContext.ReserveNames(cppKeywords)
 	nsComponentContext.ReserveNames(errnos)
 	nsComponentContext.ReserveNames(fidlNames)
 	nsComponentContext.ReserveNames(miscNames)

 	bitsMemberContext.ReserveNames([]string{"kMask"})
 }
	// 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 fidlgen_cpp

	import (
	"fmt"

	"go.fuchsia.dev/fuchsia/tools/fidl/lib/fidlgen"
	)

	func changeIfReserved(name string, ctx fidlgen.NameContext) string {
	if ctx.IsReserved(name) {
	return name + "_"
	}
	return name
	}

	type nameTransform func(string) string

	func (fn nameTransform) apply(s string) string {
	if fn == nil {
	return s
	}
	return fn(s)
	}

	type declarationTransform func(fidlgen.CompoundIdentifier, fidlgen.NameContext) name

	func simpleDeclarationTransform(
	nsFn func(fidlgen.LibraryIdentifier) namespace,
	nFn nameTransform) declarationTransform {
	return func(id fidlgen.CompoundIdentifier, ctx fidlgen.NameContext) name {
	return nsFn(id.Library).member(changeIfReserved(nFn.apply(string(id.Name)), ctx))
	}
	}

	type declarationTransforms struct {
	natural declarationTransform
	unified declarationTransform
	wire declarationTransform
	}
	type declarationContext struct {
	fidlgen.NameContext
	transforms declarationTransforms
	}

	func (ctx declarationContext) transform(id fidlgen.CompoundIdentifier) nameVariants {
	return nameVariants{
	Natural: ctx.transforms.natural(id, ctx.NameContext),
	Unified: ctx.transforms.unified(id, ctx.NameContext),
	Wire: ctx.transforms.wire(id, ctx.NameContext),
	}
	}

	type memberTransform func(fidlgen.Identifier) name
	type memberTransforms struct {
	natural nameTransform
	unified nameTransform
	wire nameTransform
	}
	type memberContext struct {
	fidlgen.NameContext
	transforms memberTransforms
	}

	// wireMemberContext returns a memberContext that just applies a transform to
	// the wire name, leaving the others alone.
	func wireMemberContext(wireTransform nameTransform) memberContext {
	return memberContext{
	fidlgen.NewNameContext(), memberTransforms{wire: wireTransform},
	}
	}

	// helper function used by transform
	func (ctx memberContext) makeName(n string) name {
	return simpleName(changeIfReserved(n, ctx.NameContext))
	}

	func (ctx memberContext) transform(id fidlgen.Identifier) nameVariants {
	n := string(id)
	return nameVariants{
	Natural: ctx.makeName(ctx.transforms.natural.apply(n)),
	Unified: ctx.makeName(ctx.transforms.unified.apply(n)),
	Wire: ctx.makeName(ctx.transforms.wire.apply(n)),
	}

	}

	// All data members are in lower_snake_case:
	// https://google.github.io/styleguide/cppguide.html#Variable_Names
	func newDataMemberContext() memberContext {
	return memberContext{
	fidlgen.NewNameContext(), memberTransforms{wire: fidlgen.ToSnakeCase},
	}
	}

	// All constants members are in kCamelCase:
	// https://google.github.io/styleguide/cppguide.html#Enumerator_Names
	func newConstantMemberContext() memberContext {
	return memberContext{
	fidlgen.NewNameContext(), memberTransforms{wire: fidlgen.ConstNameToKCamelCase},
	}
	}

	var (
	// Name of a bits member
	bitsMemberContext = newConstantMemberContext()
	// Name of an enum member
	enumMemberContext = newConstantMemberContext()
	// Name of a struct member
	structMemberContext = newDataMemberContext()
	// Name of a table member
	tableMemberContext = newDataMemberContext()
	// Name of a union member
	unionMemberContext = newDataMemberContext()
	// Name of a union member tag
	unionMemberTagContext = memberContext{
	NameContext: fidlgen.NewNameContext(),
	transforms: memberTransforms{
	natural: fidlgen.ConstNameToKCamelCase,
	unified: fidlgen.ConstNameToKCamelCase,
	wire: fidlgen.ConstNameToKCamelCase,
	},
	}
	// Name of a method
	// https://google.github.io/styleguide/cppguide.html#Function_Names
	methodNameContext = wireMemberContext(fidlgen.ToUpperCamelCase)
	// Name of a service member
	// https://google.github.io/styleguide/cppguide.html#Type_Names
	serviceMemberContext = wireMemberContext(fidlgen.ToSnakeCase)
	// Name of a constant
	// https://google.github.io/styleguide/cppguide.html#Constant_Names
	constantContext = declarationContext{
	NameContext: fidlgen.NewNameContext(),
	transforms: declarationTransforms{
	natural: simpleDeclarationTransform(naturalNamespace, nil),
	unified: simpleDeclarationTransform(unifiedNamespace, nil),
	wire: simpleDeclarationTransform(wireNamespace, fidlgen.ConstNameToKCamelCase),
	},
	}
	// Name of a data-type declaration
	// https://google.github.io/styleguide/cppguide.html#Type_Names
	typeContext = declarationContext{
	NameContext: fidlgen.NewNameContext(),
	transforms: declarationTransforms{
	natural: simpleDeclarationTransform(naturalNamespace, nil),
	unified: simpleDeclarationTransform(unifiedNamespace, nil),
	wire: simpleDeclarationTransform(wireNamespace, fidlgen.ToUpperCamelCase),
	},
	}
	// Name of a service declaration
	// https://google.github.io/styleguide/cppguide.html#Type_Names
	// TODO(yifeit): Protocols and services should not have DeclName.
	// Not all bindings generate these types.
	serviceContext = declarationContext{
	NameContext: fidlgen.NewNameContext(),
	transforms: declarationTransforms{
	natural: simpleDeclarationTransform(naturalNamespace, nil),
	// Intentionally using the natural namespace, since we would like
	// the unified bindings to transparently accept natural types, which
	// may certainly contain protocol endpoints.
	// TODO(fxbug.dev/72980): Switch to ClientEnd/ServerEnd and
	// underscore namespace when corresponding endpoint types can easily
	// convert into each other.
	unified: simpleDeclarationTransform(naturalNamespace, nil),
	wire: simpleDeclarationTransform(unifiedNamespace, fidlgen.ToUpperCamelCase),
	},
	}
	// Name of a protocol declaration
	// https://google.github.io/styleguide/cppguide.html#Type_Names
	// TODO(yifeit): Protocols and services should not have DeclName.
	// Not all bindings generate these types.
	protocolContext = declarationContext{
	NameContext: fidlgen.NewNameContext(),
	transforms: declarationTransforms{
	natural: simpleDeclarationTransform(naturalNamespace, nil),
	// Intentionally using the natural namespace, since we would like
	// the unified bindings to transparently accept natural types, which
	// may certainly contain protocol endpoints.
	// TODO(fxbug.dev/72980): Switch to ClientEnd/ServerEnd and
	// underscore namespace when corresponding endpoint types can easily
	// convert into each other.
	unified: simpleDeclarationTransform(naturalNamespace, nil),
	wire: simpleDeclarationTransform(unifiedNamespace, fidlgen.ToUpperCamelCase),
	},
	}

	// Namespace components
	// https://google.github.io/styleguide/cppguide.html#Namespace_Names
	nsComponentContext = fidlgen.NewNameContext()
	)

	func declContext(declType fidlgen.DeclType) declarationContext {
	switch declType {
	case fidlgen.ConstDeclType:
	return constantContext
	case fidlgen.BitsDeclType, fidlgen.EnumDeclType, fidlgen.StructDeclType,
	fidlgen.TableDeclType, fidlgen.UnionDeclType:
	return typeContext
	case fidlgen.ProtocolDeclType:
	return protocolContext
	case fidlgen.ServiceDeclType:
	return serviceContext
	default:
	panic(fmt.Sprintf("Unknown decl type: %#v", declType))
	}
	}

	func memberNameContext(declType fidlgen.DeclType) memberContext {
	switch declType {
	case fidlgen.BitsDeclType:
	return bitsMemberContext
	case fidlgen.EnumDeclType:
	return enumMemberContext
	case fidlgen.StructDeclType:
	return structMemberContext
	case fidlgen.TableDeclType:
	return tableMemberContext
	case fidlgen.UnionDeclType:
	return unionMemberContext
	case fidlgen.ProtocolDeclType:
	return methodNameContext
	case fidlgen.ServiceDeclType:
	return serviceMemberContext
	default:
	panic(fmt.Sprintf("Decl type %#v shouldn't have members", declType))
	}
	}

	func init() {
	// C++ keywords from: https://en.cppreference.com/w/cpp/keyword
	cppKeywords := []string{
	"alignas", "alignof", "and_eq", "and", "asm", "atomic_cancel",
	"atomic_commit", "atomic_noexcept", "auto", "bitand", "bitor",
	"bool", "break", "case", "catch", "char", "char16_t", "char32_t",
	"class", "co_await", "co_return", "co_yield", "compl", "concept",
	"const_cast", "const", "consteval", "constexpr", "constinit",
	"continue", "decltype", "default", "delete", "do", "double",
	"dynamic_cast", "else", "enum", "explicit", "export", "extern",
	"false", "float", "for", "friend", "goto", "if", "inline", "int",
	"long", "module", "mutable", "namespace", "new", "noexcept",
	"not_eq", "not", "nullptr", "operator", "or_eq", "or", "private",
	"protected", "public", "reflexexpr", "register",
	"reinterpret_cast", "requires", "return", "short", "signed",
	"sizeof", "static_assert", "static_cast", "static", "struct",
	"switch", "synchronized", "template", "this", "thread_local",
	"throw", "true", "try", "typedef", "typeid", "typename", "union",
	"unsigned", "using", "virtual", "void", "volatile", "wchar_t",
	"while", "xor_eq", "xor"}

	// All names from errno definitions.
	errnos := []string{"EPERM", "ENOENT", "ESRCH", "EINTR", "EIO",
	"ENXIO", "E2BIG", "ENOEXEC", "EBADF", "ECHILD", "EAGAIN", "ENOMEM",
	"EACCES", "EFAULT", "ENOTBLK", "EBUSY", "EEXIST", "EXDEV", "ENODEV",
	"ENOTDIR", "EISDIR", "EINVAL", "ENFILE", "EMFILE", "ENOTTY",
	"ETXTBSY", "EFBIG", "ENOSPC", "ESPIPE", "EROFS", "EMLINK", "EPIPE",
	"EDOM", "ERANGE", "EDEADLK", "ENAMETOOLONG", "ENOLCK", "ENOSYS",
	"ENOTEMPTY", "ELOOP", "EWOULDBLOCK", "ENOMSG", "EIDRM", "ECHRNG",
	"EL2NSYNC", "EL3HLT", "EL3RST", "ELNRNG", "EUNATCH", "ENOCSI",
	"EL2HLT", "EBADE", "EBADR", "EXFULL", "ENOANO", "EBADRQC",
	"EBADSLT", "EDEADLOCK", "EBFONT", "ENOSTR", "ENODATA", "ETIME",
	"ENOSR", "ENONET", "ENOPKG", "EREMOTE", "ENOLINK", "EADV", "ESRMNT",
	"ECOMM", "EPROTO", "EMULTIHOP", "EDOTDOT", "EBADMSG", "EOVERFLOW",
	"ENOTUNIQ", "EBADFD", "EREMCHG", "ELIBACC", "ELIBBAD", "ELIBSCN",
	"ELIBMAX", "ELIBEXEC", "EILSEQ", "ERESTART", "ESTRPIPE", "EUSERS",
	"ENOTSOCK", "EDESTADDRREQ", "EMSGSIZE", "EPROTOTYPE", "ENOPROTOOPT",
	"EPROTONOSUPPORT", "ESOCKTNOSUPPORT", "EOPNOTSUPP", "ENOTSUP",
	"EPFNOSUPPORT", "EAFNOSUPPORT", "EADDRINUSE", "EADDRNOTAVAIL",
	"ENETDOWN", "ENETUNREACH", "ENETRESET", "ECONNABORTED",
	"ECONNRESET", "ENOBUFS", "EISCONN", "ENOTCONN", "ESHUTDOWN",
	"ETOOMANYREFS", "ETIMEDOUT", "ECONNREFUSED", "EHOSTDOWN",
	"EHOSTUNREACH", "EALREADY", "EINPROGRESS", "ESTALE", "EUCLEAN",
	"ENOTNAM", "ENAVAIL", "EISNAM", "EREMOTEIO", "EDQUOT", "ENOMEDIUM",
	"EMEDIUMTYPE", "ECANCELED", "ENOKEY", "EKEYEXPIRED", "EKEYREVOKED",
	"EKEYREJECTED", "EOWNERDEAD", "ENOTRECOVERABLE", "ERFKILL",
	"EHWPOISON"}

	// Names used in the C++ FIDL bindings
	fidlNames := []string{"FidlType", "HandleEvents",
	"has_invalid_tag", "IsEmpty", "New", "Tag", "unknown", "Unknown",
	"UnknownBytes", "UnknownData", "which", "Which"}
	// TODO(ianloic) add: "Clone"
	// There are Clone methods on a couple of protocols so this may be a breaking change.
	// fxbug.dev/7785

	// misc other names
	// TODO(ianloic): confirm which of these can be removed
	miscNames := []string{"assert", "import", "NULL", "offsetof",
	"xunion"}

	// Reserve names that are universally reserved:
	for _, ctx := range []declarationContext{constantContext, typeContext,
	serviceContext, protocolContext} {
	ctx.ReserveNames(cppKeywords)
	ctx.ReserveNames(errnos)
	ctx.ReserveNames(fidlNames)
	ctx.ReserveNames(miscNames)
	}
	for _, ctx := range []memberContext{
	bitsMemberContext, enumMemberContext, structMemberContext,
	tableMemberContext, unionMemberContext, serviceMemberContext,
	methodNameContext} {
	ctx.ReserveNames(cppKeywords)
	ctx.ReserveNames(errnos)
	ctx.ReserveNames(fidlNames)
	ctx.ReserveNames(miscNames)
	}
	nsComponentContext.ReserveNames(cppKeywords)
	nsComponentContext.ReserveNames(errnos)
	nsComponentContext.ReserveNames(fidlNames)
	nsComponentContext.ReserveNames(miscNames)

	bitsMemberContext.ReserveNames([]string{"kMask"})
	}