tools/fidl/lib/fidlgen_cpp/names.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"
 	"strings"

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

 var zxNs namespace = newNamespace("zx")
 var fidlNs namespace = newNamespace("fidl")
 var internalNs namespace = fidlNs.append("internal")

 // variant controls how we refer to domain object declarations.
 type variant string

 const (
 	noVariant      variant = ""
 	naturalVariant variant = "natural"
 	unifiedVariant variant = "unified"
 	wireVariant    variant = "wire"

 	// for use in testing:
 	testingVariant variant = "testing"
 )

 var currentVariant = noVariant

 // Namespace represents a C++ namespace.
 type namespace []string

 func newNamespace(ns string) namespace {
 	return namespace(strings.Split(ns, "::"))
 }

 // Namespace is implemented to satisfy the namespaced interface.
 func (ns namespace) Namespace() namespace {
 	return ns
 }

 // String returns the fully qualified namespace including leading ::.
 func (ns namespace) String() string {
 	if len(ns) == 0 {
 		return ""
 	}
 	return "::" + ns.NoLeading()
 }

 // NoLeading returns the fully qualified namespace without the leading ::.
 func (ns namespace) NoLeading() string {
 	return strings.Join(ns, "::")
 }

 // append returns a new namespace with an additional component.
 func (ns namespace) append(part string) namespace {
 	newNs := make([]string, len(ns)+1)
 	copy(newNs, ns)
 	newNs[len(ns)] = part
 	return namespace(newNs)
 }

 // member creates a named declaration within the namespace
 func (ns namespace) member(n string) name {
 	return name{name: stringNamePart(n), ns: ns}
 }

 // nameVariants is the name of a type or a template used in the various C++ bindings.
 //
 // Names are more general than FIDL declarations. All declarations have a corresponding
 // type name, but some types are not declared in the generated code (e.g. zx::vmo),
 // or are non-nominal (e.g. std::vector<FooBarDecl>).
 type nameVariants struct {
 	Natural name

 	// Unified is like Natural, except it consists of type aliases, declared in
 	// the unified bindings, to natural types. For example, the Natural name
 	//
 	//     fuchsia::my::lib::FooStruct
 	//
 	// would be aliased to the Unified name
 	//
 	//     fuchsia_my_lib::FooStruct.
 	//
 	// Similarly, if Natural is
 	//
 	//     std::array<std::unique_ptr<fuchsia::my::lib::FooStruct>, 5>
 	//
 	// then Unified would use the alias in the template argument:
 	//
 	//     std::array<std::unique_ptr<fuchsia_my_lib::FooStruct>, 5>.
 	//
 	// In case of client and server protocol endpoints, there is no alias,
 	// and Unified is the same as Natural.
 	Unified name

 	Wire name
 }

 // commonNameVariants returns a nameVariants with the same Name for both Wire and Natural variants.
 func commonNameVariants(decl name) nameVariants {
 	return nameVariants{
 		Natural: decl,
 		Unified: decl,
 		Wire:    decl,
 	}
 }

 func (dn nameVariants) String() string {
 	switch currentVariant {
 	case noVariant:
 		fidlgen.TemplateFatalf("Called nameVariants.String() on %s/%s when currentVariant isn't set.\n",
 			dn.Natural, dn.Wire)
 	case naturalVariant:
 		return dn.Natural.String()
 	case unifiedVariant:
 		return dn.Unified.String()
 	case wireVariant:
 		return dn.Wire.String()
 	case testingVariant:
 		return fmt.Sprintf("%#v", dn)
 	}
 	panic("not reached")
 }

 func (dn nameVariants) Name() string {
 	switch currentVariant {
 	case noVariant:
 		fidlgen.TemplateFatalf("Called nameVariants.Name() on %s/%s when currentVariant isn't set.\n",
 			dn.Natural, dn.Wire)
 	case naturalVariant:
 		return dn.Natural.Name()
 	case unifiedVariant:
 		return dn.Unified.Name()
 	case wireVariant:
 		return dn.Wire.Name()
 	}
 	panic("not reached")
 }

 func (dn nameVariants) Self() string {
 	switch currentVariant {
 	case noVariant:
 		fidlgen.TemplateFatalf("Called nameVariants.Self() on %s/%s when currentVariant isn't set.\n", dn.Natural, dn.Wire)
 	case naturalVariant:
 		return dn.Natural.Self()
 	case unifiedVariant:
 		return dn.Unified.Self()
 	case wireVariant:
 		return dn.Wire.Self()
 	}
 	panic("not reached")
 }

 func (dn nameVariants) NoLeading() string {
 	switch currentVariant {
 	case noVariant:
 		fidlgen.TemplateFatalf("Called nameVariants.NoLeading() on %s/%s when currentVariant isn't set.\n", dn.Natural, dn.Wire)
 	case naturalVariant:
 		return dn.Natural.NoLeading()
 	case unifiedVariant:
 		return dn.Unified.NoLeading()
 	case wireVariant:
 		return dn.Wire.NoLeading()
 	}
 	panic("not reached")
 }

 func (dn nameVariants) Namespace() namespace {
 	switch currentVariant {
 	case noVariant:
 		fidlgen.TemplateFatalf("Called nameVariants.Namespace() on %s/%s when currentVariant isn't set.\n",
 			dn.Natural, dn.Wire)
 	case naturalVariant:
 		return dn.Natural.Namespace()
 	case unifiedVariant:
 		return dn.Unified.Namespace()
 	case wireVariant:
 		return dn.Wire.Namespace()
 	}
 	panic("not reached")
 }

 // appendName returns a new nameVariants with an suffix appended to the name portions.
 func (dn nameVariants) appendName(suffix string) nameVariants {
 	return nameVariants{
 		Natural: dn.Natural.appendName(suffix),
 		Unified: dn.Unified.appendName(suffix),
 		Wire:    dn.Wire.appendName(suffix),
 	}
 }

 // prependName returns a new nameVariants with an prefix prepended to the name portions.
 func (dn nameVariants) prependName(prefix string) nameVariants {
 	return nameVariants{
 		Natural: dn.Natural.prependName(prefix),
 		Unified: dn.Unified.prependName(prefix),
 		Wire:    dn.Wire.prependName(prefix),
 	}
 }

 // appendNamespace returns a new nameVariants with additional C++ namespace components appended.
 func (dn nameVariants) appendNamespace(c string) nameVariants {
 	return nameVariants{
 		Natural: dn.Natural.appendNamespace(c),
 		Unified: dn.Unified.appendNamespace(c),
 		Wire:    dn.Wire.appendNamespace(c),
 	}
 }

 // nest returns a new name for a class nested inside the existing name.
 func (dn nameVariants) nest(c string) nameVariants {
 	return nameVariants{
 		Natural: dn.Natural.nest(c),
 		Unified: dn.Unified.nest(c),
 		Wire:    dn.Wire.nest(c),
 	}
 }

 // nestVariants returns a new name for a class nested inside the existing name.
 func (dn nameVariants) nestVariants(v nameVariants) nameVariants {
 	if len(v.Natural.Namespace()) != 0 {
 		panic(fmt.Sprintf("Can't nest a name with a namespace: %v", v.Natural.String()))
 	}
 	if len(v.Unified.Namespace()) != 0 {
 		panic(fmt.Sprintf("Can't nest a name with a namespace: %v", v.Unified.String()))
 	}
 	if len(v.Wire.Namespace()) != 0 {
 		panic(fmt.Sprintf("Can't nest a name with a namespace: %v", v.Wire.String()))
 	}
 	return nameVariants{
 		Natural: dn.Natural.nest(v.Natural.Name()),
 		Unified: dn.Unified.nest(v.Unified.Name()),
 		Wire:    dn.Wire.nest(v.Wire.Name()),
 	}
 }

 // nameVariantsForHandle returns the C++ name for a handle type
 func nameVariantsForHandle(t fidlgen.HandleSubtype) nameVariants {
 	return commonNameVariants(zxNs.member(string(t)))
 }

 // primitiveNameVariants returns a nameVariants for a primitive type, common across all bindings.
 func primitiveNameVariants(primitive string) nameVariants {
 	return commonNameVariants(makeName(primitive))
 }

 // namePart represents part of non-namespace part of a name.
 // It's implemented by three types: stringNamePart, nestedNamePart and templateNamePart.
 // These form a tree to hold the structure of a name so that it can be accessed and manipulated safely.
 // For example in fidl::WireInterface<fuchsia_library::Protocol>::ProtocolMethod this would be:
 //   WireInterface<fuchsia_library::Protocol>::ProtocolMethod
 //   |-nestedNP---------------------------------------------|
 //   |-templateNP---------------------------|  |-stringNP---|
 //   |-stringNP---|-Name--------------------|
 // TODO(ianloic): rename to idPart
 type namePart interface {
 	// String returns the full name.
 	String() string
 	// Self returns how the type refers to itself, like in constructor & destructor names.
 	// For a nested name like "Foo::Bar::Baz" this would be "Baz".
 	// For a template name like "Foo::Bar<Baz>" this would be "Bar".
 	Self() string

 	// nest returns a new name for a class nested inside the existing name.
 	nest(name string) namePart
 	// Template returns a new name with this name being an template applied to the |args|.
 	template(args string) namePart
 	// prependName returns a new name with a prefix prepended.
 	prependName(prefix string) namePart
 	// appendName returns a new name with a suffix appended.
 	appendName(suffix string) namePart
 }

 type stringNamePart string

 var _ namePart = (*stringNamePart)(nil)

 func (n stringNamePart) String() string {
 	return string(n)
 }

 func (n stringNamePart) Self() string {
 	return string(n)
 }

 func (n stringNamePart) nest(name string) namePart {
 	return newNestedNamePart(n, stringNamePart(name))
 }

 func (n stringNamePart) template(args string) namePart {
 	return newTemplateNamePart(n, args)
 }

 func (n stringNamePart) prependName(prefix string) namePart {
 	return stringNamePart(prefix + string(n))
 }

 func (n stringNamePart) appendName(suffix string) namePart {
 	return stringNamePart(string(n) + suffix)
 }

 type nestedNamePart struct {
 	left  namePart
 	right namePart
 }

 var _ namePart = (*nestedNamePart)(nil)

 func newNestedNamePart(left, right namePart) namePart {
 	return nestedNamePart{left, right}
 }

 func (n nestedNamePart) String() string {
 	return fmt.Sprintf("%s::%s", n.left, n.right)
 }

 func (n nestedNamePart) Self() string {
 	return n.right.Self()
 }

 func (n nestedNamePart) nest(name string) namePart {
 	return nestedNamePart{n.left, n.right.nest(name)}
 }

 func (n nestedNamePart) template(args string) namePart {
 	return newTemplateNamePart(n, args)
 }

 func (n nestedNamePart) prependName(prefix string) namePart {
 	return nestedNamePart{n.left, n.right.prependName(prefix)}
 }

 func (n nestedNamePart) appendName(suffix string) namePart {
 	return nestedNamePart{n.left, n.right.appendName(suffix)}
 }

 type templateNamePart struct {
 	tmpl namePart
 	args string
 }

 var _ namePart = (*templateNamePart)(nil)

 func newTemplateNamePart(tmpl namePart, args string) namePart {
 	return templateNamePart{tmpl, args}
 }

 func (n templateNamePart) String() string {
 	return fmt.Sprintf("%s<%s>", n.tmpl, n.args)
 }

 func (n templateNamePart) Self() string {
 	return n.tmpl.Self()
 }

 func (n templateNamePart) nest(name string) namePart {
 	return nestedNamePart{n, stringNamePart(name)}
 }

 func (n templateNamePart) template(args string) namePart {
 	panic(fmt.Sprintf("Can't make a template of a template: %s", n))
 }

 func (n templateNamePart) prependName(prefix string) namePart {
 	panic(fmt.Sprintf("Can't prepend to the name of a template: %s", n))
 }

 func (n templateNamePart) appendName(suffix string) namePart {
 	panic(fmt.Sprintf("Can't append to the name of a template: %s", n))
 }

 // name holds a C++ qualified identifier.
 // See: https://en.cppreference.com/w/cpp/language/identifiers#Qualified_identifiers
 // It consists of a Namespace and a namePart.
 // TODO(ianloic): move this to the top of the file since it's the most important type.
 type name struct {
 	name namePart
 	ns   namespace
 }

 // makeName takes a string with a :: separated name and makes a Name treating the last component
 // as the local name and the preceding components as the namespace.
 // This should only be used with string literals for creating well-known, simple names.
 func makeName(n string) name {
 	i := strings.LastIndex(n, "::")
 	if i == -1 {
 		return name{name: stringNamePart(n)}
 	}
 	if i == 0 {
 		panic(fmt.Sprintf("Don't call MakeName with leading double-colons: %v", n))
 	}
 	return name{
 		name: stringNamePart(n[i+2:]),
 		ns:   newNamespace(n[0:i]),
 	}
 }

 // simpleName return a name with a single component
 func simpleName(n string) name {
 	if strings.ContainsAny(n, ":-./") {
 		panic(fmt.Sprintf("%#v is not a simple name", n))
 	}
 	return name{name: stringNamePart(n)}
 }

 // String returns the full name with a leading :: if the name has a namespace.
 func (n name) String() string {
 	ns := n.ns.String()
 	if len(ns) > 0 {
 		ns = ns + "::"
 	}
 	return ns + n.name.String()
 }

 // Name returns the portion of the name that comes after the namespace.
 func (n name) Name() string {
 	return n.name.String()
 }

 // Self returns how the type refers to itself, like in constructor & destructor names.
 // For a nested name like "Foo::Bar::Baz" this would be "Baz".
 // For a template name like "Foo::Bar<Baz>" this would be "Bar".
 func (n name) Self() string {
 	return n.name.Self()
 }

 // TODO(ianloic): probably make this the default
 func (n name) NoLeading() string {
 	ns := n.ns.NoLeading()
 	if len(ns) > 0 {
 		ns = ns + "::"
 	}
 	return ns + n.name.String()
 }

 // namespace returns the namespace portion of the name.
 func (n name) Namespace() namespace {
 	return n.ns
 }

 // nest returns a new name for a class nested inside the existing name.
 func (n name) nest(nested string) name {
 	return name{name: n.name.nest(nested), ns: n.ns}
 }

 // Template returns a new name with this name being an template applied to the |arg|.
 func (n name) template(arg name) name {
 	return name{name: n.name.template(arg.String()), ns: n.ns}
 }

 // arrayTemplate returns a new name with this name being an template applied to the |arg| with a |count|.
 func (n name) arrayTemplate(arg name, count int) name {
 	return name{name: n.name.template(fmt.Sprintf("%s, %d", arg.String(), count)), ns: n.ns}
 }

 // prependName returns a new name with a prefix prepended to the last part of the name.
 func (n name) prependName(prefix string) name {
 	return name{name: n.name.prependName(prefix), ns: n.ns}
 }

 // appendName returns a new name with a suffix appended to the last part of the name.
 func (n name) appendName(suffix string) name {
 	return name{name: n.name.appendName(suffix), ns: n.ns}
 }

 // appendNamespace returns a new name with an additional namespace component added.
 func (n name) appendNamespace(part string) name {
 	return name{name: n.name, ns: n.ns.append(part)}
 }

 // makeTupleName returns a Name for a std::tuple of the supplied names.
 func makeTupleName(members []name) name {
 	t := makeName("std::tuple")
 	a := []string{}
 	for _, m := range members {
 		a = append(a, m.String())
 	}
 	return name{name: t.name.template(strings.Join(a, ", ")), ns: t.ns}
 }
	// 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"
	"strings"

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

	var zxNs namespace = newNamespace("zx")
	var fidlNs namespace = newNamespace("fidl")
	var internalNs namespace = fidlNs.append("internal")

	// variant controls how we refer to domain object declarations.
	type variant string

	const (
	noVariant variant = ""
	naturalVariant variant = "natural"
	unifiedVariant variant = "unified"
	wireVariant variant = "wire"

	// for use in testing:
	testingVariant variant = "testing"
	)

	var currentVariant = noVariant

	// Namespace represents a C++ namespace.
	type namespace []string

	func newNamespace(ns string) namespace {
	return namespace(strings.Split(ns, "::"))
	}

	// Namespace is implemented to satisfy the namespaced interface.
	func (ns namespace) Namespace() namespace {
	return ns
	}

	// String returns the fully qualified namespace including leading ::.
	func (ns namespace) String() string {
	if len(ns) == 0 {
	return ""
	}
	return "::" + ns.NoLeading()
	}

	// NoLeading returns the fully qualified namespace without the leading ::.
	func (ns namespace) NoLeading() string {
	return strings.Join(ns, "::")
	}

	// append returns a new namespace with an additional component.
	func (ns namespace) append(part string) namespace {
	newNs := make([]string, len(ns)+1)
	copy(newNs, ns)
	newNs[len(ns)] = part
	return namespace(newNs)
	}

	// member creates a named declaration within the namespace
	func (ns namespace) member(n string) name {
	return name{name: stringNamePart(n), ns: ns}
	}

	// nameVariants is the name of a type or a template used in the various C++ bindings.
	//
	// Names are more general than FIDL declarations. All declarations have a corresponding
	// type name, but some types are not declared in the generated code (e.g. zx::vmo),
	// or are non-nominal (e.g. std::vector<FooBarDecl>).
	type nameVariants struct {
	Natural name

	// Unified is like Natural, except it consists of type aliases, declared in
	// the unified bindings, to natural types. For example, the Natural name
	//
	// fuchsia::my::lib::FooStruct
	//
	// would be aliased to the Unified name
	//
	// fuchsia_my_lib::FooStruct.
	//
	// Similarly, if Natural is
	//
	// std::array<std::unique_ptr<fuchsia::my::lib::FooStruct>, 5>
	//
	// then Unified would use the alias in the template argument:
	//
	// std::array<std::unique_ptr<fuchsia_my_lib::FooStruct>, 5>.
	//
	// In case of client and server protocol endpoints, there is no alias,
	// and Unified is the same as Natural.
	Unified name

	Wire name
	}

	// commonNameVariants returns a nameVariants with the same Name for both Wire and Natural variants.
	func commonNameVariants(decl name) nameVariants {
	return nameVariants{
	Natural: decl,
	Unified: decl,
	Wire: decl,
	}
	}

	func (dn nameVariants) String() string {
	switch currentVariant {
	case noVariant:
	fidlgen.TemplateFatalf("Called nameVariants.String() on %s/%s when currentVariant isn't set.\n",
	dn.Natural, dn.Wire)
	case naturalVariant:
	return dn.Natural.String()
	case unifiedVariant:
	return dn.Unified.String()
	case wireVariant:
	return dn.Wire.String()
	case testingVariant:
	return fmt.Sprintf("%#v", dn)
	}
	panic("not reached")
	}

	func (dn nameVariants) Name() string {
	switch currentVariant {
	case noVariant:
	fidlgen.TemplateFatalf("Called nameVariants.Name() on %s/%s when currentVariant isn't set.\n",
	dn.Natural, dn.Wire)
	case naturalVariant:
	return dn.Natural.Name()
	case unifiedVariant:
	return dn.Unified.Name()
	case wireVariant:
	return dn.Wire.Name()
	}
	panic("not reached")
	}

	func (dn nameVariants) Self() string {
	switch currentVariant {
	case noVariant:
	fidlgen.TemplateFatalf("Called nameVariants.Self() on %s/%s when currentVariant isn't set.\n", dn.Natural, dn.Wire)
	case naturalVariant:
	return dn.Natural.Self()
	case unifiedVariant:
	return dn.Unified.Self()
	case wireVariant:
	return dn.Wire.Self()
	}
	panic("not reached")
	}

	func (dn nameVariants) NoLeading() string {
	switch currentVariant {
	case noVariant:
	fidlgen.TemplateFatalf("Called nameVariants.NoLeading() on %s/%s when currentVariant isn't set.\n", dn.Natural, dn.Wire)
	case naturalVariant:
	return dn.Natural.NoLeading()
	case unifiedVariant:
	return dn.Unified.NoLeading()
	case wireVariant:
	return dn.Wire.NoLeading()
	}
	panic("not reached")
	}

	func (dn nameVariants) Namespace() namespace {
	switch currentVariant {
	case noVariant:
	fidlgen.TemplateFatalf("Called nameVariants.Namespace() on %s/%s when currentVariant isn't set.\n",
	dn.Natural, dn.Wire)
	case naturalVariant:
	return dn.Natural.Namespace()
	case unifiedVariant:
	return dn.Unified.Namespace()
	case wireVariant:
	return dn.Wire.Namespace()
	}
	panic("not reached")
	}

	// appendName returns a new nameVariants with an suffix appended to the name portions.
	func (dn nameVariants) appendName(suffix string) nameVariants {
	return nameVariants{
	Natural: dn.Natural.appendName(suffix),
	Unified: dn.Unified.appendName(suffix),
	Wire: dn.Wire.appendName(suffix),
	}
	}

	// prependName returns a new nameVariants with an prefix prepended to the name portions.
	func (dn nameVariants) prependName(prefix string) nameVariants {
	return nameVariants{
	Natural: dn.Natural.prependName(prefix),
	Unified: dn.Unified.prependName(prefix),
	Wire: dn.Wire.prependName(prefix),
	}
	}

	// appendNamespace returns a new nameVariants with additional C++ namespace components appended.
	func (dn nameVariants) appendNamespace(c string) nameVariants {
	return nameVariants{
	Natural: dn.Natural.appendNamespace(c),
	Unified: dn.Unified.appendNamespace(c),
	Wire: dn.Wire.appendNamespace(c),
	}
	}

	// nest returns a new name for a class nested inside the existing name.
	func (dn nameVariants) nest(c string) nameVariants {
	return nameVariants{
	Natural: dn.Natural.nest(c),
	Unified: dn.Unified.nest(c),
	Wire: dn.Wire.nest(c),
	}
	}

	// nestVariants returns a new name for a class nested inside the existing name.
	func (dn nameVariants) nestVariants(v nameVariants) nameVariants {
	if len(v.Natural.Namespace()) != 0 {
	panic(fmt.Sprintf("Can't nest a name with a namespace: %v", v.Natural.String()))
	}
	if len(v.Unified.Namespace()) != 0 {
	panic(fmt.Sprintf("Can't nest a name with a namespace: %v", v.Unified.String()))
	}
	if len(v.Wire.Namespace()) != 0 {
	panic(fmt.Sprintf("Can't nest a name with a namespace: %v", v.Wire.String()))
	}
	return nameVariants{
	Natural: dn.Natural.nest(v.Natural.Name()),
	Unified: dn.Unified.nest(v.Unified.Name()),
	Wire: dn.Wire.nest(v.Wire.Name()),
	}
	}

	// nameVariantsForHandle returns the C++ name for a handle type
	func nameVariantsForHandle(t fidlgen.HandleSubtype) nameVariants {
	return commonNameVariants(zxNs.member(string(t)))
	}

	// primitiveNameVariants returns a nameVariants for a primitive type, common across all bindings.
	func primitiveNameVariants(primitive string) nameVariants {
	return commonNameVariants(makeName(primitive))
	}

	// namePart represents part of non-namespace part of a name.
	// It's implemented by three types: stringNamePart, nestedNamePart and templateNamePart.
	// These form a tree to hold the structure of a name so that it can be accessed and manipulated safely.
	// For example in fidl::WireInterface<fuchsia_library::Protocol>::ProtocolMethod this would be:
	// WireInterface<fuchsia_library::Protocol>::ProtocolMethod
	// \|-nestedNP---------------------------------------------\|
	// \|-templateNP---------------------------\| \|-stringNP---\|
	// \|-stringNP---\|-Name--------------------\|
	// TODO(ianloic): rename to idPart
	type namePart interface {
	// String returns the full name.
	String() string
	// Self returns how the type refers to itself, like in constructor & destructor names.
	// For a nested name like "Foo::Bar::Baz" this would be "Baz".
	// For a template name like "Foo::Bar<Baz>" this would be "Bar".
	Self() string

	// nest returns a new name for a class nested inside the existing name.
	nest(name string) namePart
	// Template returns a new name with this name being an template applied to the \|args\|.
	template(args string) namePart
	// prependName returns a new name with a prefix prepended.
	prependName(prefix string) namePart
	// appendName returns a new name with a suffix appended.
	appendName(suffix string) namePart
	}

	type stringNamePart string

	var _ namePart = (*stringNamePart)(nil)

	func (n stringNamePart) String() string {
	return string(n)
	}

	func (n stringNamePart) Self() string {
	return string(n)
	}

	func (n stringNamePart) nest(name string) namePart {
	return newNestedNamePart(n, stringNamePart(name))
	}

	func (n stringNamePart) template(args string) namePart {
	return newTemplateNamePart(n, args)
	}

	func (n stringNamePart) prependName(prefix string) namePart {
	return stringNamePart(prefix + string(n))
	}

	func (n stringNamePart) appendName(suffix string) namePart {
	return stringNamePart(string(n) + suffix)
	}

	type nestedNamePart struct {
	left namePart
	right namePart
	}

	var _ namePart = (*nestedNamePart)(nil)

	func newNestedNamePart(left, right namePart) namePart {
	return nestedNamePart{left, right}
	}

	func (n nestedNamePart) String() string {
	return fmt.Sprintf("%s::%s", n.left, n.right)
	}

	func (n nestedNamePart) Self() string {
	return n.right.Self()
	}

	func (n nestedNamePart) nest(name string) namePart {
	return nestedNamePart{n.left, n.right.nest(name)}
	}

	func (n nestedNamePart) template(args string) namePart {
	return newTemplateNamePart(n, args)
	}

	func (n nestedNamePart) prependName(prefix string) namePart {
	return nestedNamePart{n.left, n.right.prependName(prefix)}
	}

	func (n nestedNamePart) appendName(suffix string) namePart {
	return nestedNamePart{n.left, n.right.appendName(suffix)}
	}

	type templateNamePart struct {
	tmpl namePart
	args string
	}

	var _ namePart = (*templateNamePart)(nil)

	func newTemplateNamePart(tmpl namePart, args string) namePart {
	return templateNamePart{tmpl, args}
	}

	func (n templateNamePart) String() string {
	return fmt.Sprintf("%s<%s>", n.tmpl, n.args)
	}

	func (n templateNamePart) Self() string {
	return n.tmpl.Self()
	}

	func (n templateNamePart) nest(name string) namePart {
	return nestedNamePart{n, stringNamePart(name)}
	}

	func (n templateNamePart) template(args string) namePart {
	panic(fmt.Sprintf("Can't make a template of a template: %s", n))
	}

	func (n templateNamePart) prependName(prefix string) namePart {
	panic(fmt.Sprintf("Can't prepend to the name of a template: %s", n))
	}

	func (n templateNamePart) appendName(suffix string) namePart {
	panic(fmt.Sprintf("Can't append to the name of a template: %s", n))
	}

	// name holds a C++ qualified identifier.
	// See: https://en.cppreference.com/w/cpp/language/identifiers#Qualified_identifiers
	// It consists of a Namespace and a namePart.
	// TODO(ianloic): move this to the top of the file since it's the most important type.
	type name struct {
	name namePart
	ns namespace
	}

	// makeName takes a string with a :: separated name and makes a Name treating the last component
	// as the local name and the preceding components as the namespace.
	// This should only be used with string literals for creating well-known, simple names.
	func makeName(n string) name {
	i := strings.LastIndex(n, "::")
	if i == -1 {
	return name{name: stringNamePart(n)}
	}
	if i == 0 {
	panic(fmt.Sprintf("Don't call MakeName with leading double-colons: %v", n))
	}
	return name{
	name: stringNamePart(n[i+2:]),
	ns: newNamespace(n[0:i]),
	}
	}

	// simpleName return a name with a single component
	func simpleName(n string) name {
	if strings.ContainsAny(n, ":-./") {
	panic(fmt.Sprintf("%#v is not a simple name", n))
	}
	return name{name: stringNamePart(n)}
	}

	// String returns the full name with a leading :: if the name has a namespace.
	func (n name) String() string {
	ns := n.ns.String()
	if len(ns) > 0 {
	ns = ns + "::"
	}
	return ns + n.name.String()
	}

	// Name returns the portion of the name that comes after the namespace.
	func (n name) Name() string {
	return n.name.String()
	}

	// Self returns how the type refers to itself, like in constructor & destructor names.
	// For a nested name like "Foo::Bar::Baz" this would be "Baz".
	// For a template name like "Foo::Bar<Baz>" this would be "Bar".
	func (n name) Self() string {
	return n.name.Self()
	}

	// TODO(ianloic): probably make this the default
	func (n name) NoLeading() string {
	ns := n.ns.NoLeading()
	if len(ns) > 0 {
	ns = ns + "::"
	}
	return ns + n.name.String()
	}

	// namespace returns the namespace portion of the name.
	func (n name) Namespace() namespace {
	return n.ns
	}

	// nest returns a new name for a class nested inside the existing name.
	func (n name) nest(nested string) name {
	return name{name: n.name.nest(nested), ns: n.ns}
	}

	// Template returns a new name with this name being an template applied to the \|arg\|.
	func (n name) template(arg name) name {
	return name{name: n.name.template(arg.String()), ns: n.ns}
	}

	// arrayTemplate returns a new name with this name being an template applied to the \|arg\| with a \|count\|.
	func (n name) arrayTemplate(arg name, count int) name {
	return name{name: n.name.template(fmt.Sprintf("%s, %d", arg.String(), count)), ns: n.ns}
	}

	// prependName returns a new name with a prefix prepended to the last part of the name.
	func (n name) prependName(prefix string) name {
	return name{name: n.name.prependName(prefix), ns: n.ns}
	}

	// appendName returns a new name with a suffix appended to the last part of the name.
	func (n name) appendName(suffix string) name {
	return name{name: n.name.appendName(suffix), ns: n.ns}
	}

	// appendNamespace returns a new name with an additional namespace component added.
	func (n name) appendNamespace(part string) name {
	return name{name: n.name, ns: n.ns.append(part)}
	}

	// makeTupleName returns a Name for a std::tuple of the supplied names.
	func makeTupleName(members []name) name {
	t := makeName("std::tuple")
	a := []string{}
	for _, m := range members {
	a = append(a, m.String())
	}
	return name{name: t.name.template(strings.Join(a, ", ")), ns: t.ns}
	}