normalizer

Documentation

Index

• Variables

Variables

var Annotations = []Mapping{
	AnnotateType("internal-type", nil, role.Incomplete),
	AnnotateType("CPPASTTranslationUnit", nil, role.File, role.Module),
	AnnotateType("CPPASTExpressionStatement", nil, role.Expression),

	Map(Obj{
		"IASTClass":   String("CPPASTName"),
		"Name":        String(""),
		"IsQualified": Var("isqual"),
	}, Obj{
		uast.KeyType:  String("CPPASTName"),
		uast.KeyRoles: Roles(role.Identifier),
		uast.KeyToken: String(""),
		"IsQualified": Var("isqual"),
	}),

	AnnotateType("CPPASTName", FieldRoles{
		"Name": {Rename: uast.KeyToken},
	}, role.Identifier),

	AnnotateType("CPPASTImplicitName", FieldRoles{
		"Name": {Rename: uast.KeyToken},
	}, role.Identifier),

	AnnotateType("ASTInclusionStatement", FieldRoles{
		"Name": {Rename: uast.KeyToken},
	}, role.Import),

	AnnotateType("ExpansionLocation", nil, role.Noop),
	AnnotateType("BodyPosition", nil, role.Noop),
	AnnotateType("ASTMacroDefinition", nil, role.Declaration, role.Variable, role.Incomplete),
	AnnotateType("ASTIfdef", nil, role.If, role.Then, role.Incomplete),
	AnnotateType("ASTElif", nil, role.If, role.Else, role.Incomplete),
	AnnotateType("ASTElse", nil, role.Else, role.Incomplete),
	AnnotateType("ASTEndif", nil, role.Noop, role.Incomplete),

	AnnotateType("CPPASTProblemDeclaration", nil, role.Noop),
	AnnotateType("CPPASTIdExpression", nil, role.Expression, role.Variable),
	AnnotateType("CPPASTNullStatement", nil, role.Literal, role.Null, role.Expression,
		role.Primitive),
	AnnotateType("CPPASTGotoStatement", nil, role.Goto, role.Statement),
	AnnotateType("CPPASTBreakStatement", nil, role.Break, role.Statement),
	AnnotateType("CPPASTContinueStatement", nil, role.Continue, role.Statement),
	AnnotateType("CPPASTLabelStatement", nil, role.Name, role.Incomplete),
	AnnotateType("CPPASTSimpleDeclaration", nil, role.Declaration, role.Statement),
	AnnotateType("CPPASTDeclarationStatement", nil, role.Declaration, role.Statement),
	AnnotateType("CPPASTFieldReference", nil, role.Qualified, role.Expression),
	AnnotateType("CPPASTBaseSpecifier", nil, role.Type, role.Declaration, role.Base),
	AnnotateType("CPPASTNamedTypeSpecifier", nil, role.Type, role.Instance),
	AnnotateType("CPPASTProblemStatement", nil, role.Incomplete),
	AnnotateType("CPPASTUsingDirective", nil, role.Scope, role.Alias),
	AnnotateType("CPPASTNewExpression", nil, role.Instance, role.Value),
	AnnotateType("CPPASTTypeId", nil, role.Type),
	AnnotateType("CPPASTTemplateDeclaration", nil, role.Type, role.Declaration,
		role.Incomplete),
	AnnotateType("CPPASTSimpleTypeTemplateParameter", nil, role.Type, role.Declaration,
		role.Argument, role.Incomplete),
	AnnotateType("CPPASTTemplateId", nil, role.Type, role.Incomplete),
	AnnotateType("CPPASTDeleteExpression", nil, role.Call, role.Expression,
		role.Incomplete),
	AnnotateType("CPPASTInitializerList", nil, role.Initialization, role.List),
	AnnotateType("CPPASTCastExpression", nil, role.Expression, role.Incomplete),
	AnnotateType("CPPASTDesignatedInitializer", nil, role.Expression,
		role.Initialization),
	AnnotateType("CPPASTConditionalExpression", nil, role.Expression, role.Condition),
	AnnotateType("CPPASTEnumerationSpecifier", nil, role.Declaration, role.Type, role.Enumeration),

	AnnotateTypeCustom("CPPASTUnaryExpression",
		FieldRoles{
			"operator": {Op: Var("operator")},
		},
		LookupArrOpVar("operator", unaryExprRoles)),

	AnnotateTypeCustom("CPPASTSimpleDeclSpecifier",
		FieldRoles{
			"Type": {Rename: uast.KeyToken, Op: Var("type")},
		},
		LookupArrOpVar("type", typeRoles),
	),

	AnnotateType("CPPASTASMDeclaration", FieldRoles{
		"Assembly": {Rename: uast.KeyToken},
	}, role.Declaration, role.Block, role.Incomplete),

	AnnotateType("CPPASTLinkageSpecification", FieldRoles{
		"Literal": {Rename: uast.KeyToken},
	}, role.Declaration, role.Block, role.Incomplete),

	AnnotateTypeCustom("CPPASTLiteralExpression",
		FieldRoles{
			"LiteralValue": {Rename: uast.KeyToken},
			"kind":         {Op: Var("kind")},
		},
		LookupArrOpVar("kind", litExprRoles),
	),

	AnnotateType("CPPASTCompoundStatement", nil, role.Body),
	AnnotateType("CPPASTDeclarator", FieldRoles{
		"Name": {Rename: uast.KeyToken},
	}, role.Declaration, role.Variable, role.Name),
	AnnotateType("CPPASTDeclarator", nil, role.Declaration, role.Variable, role.Name),

	AnnotateType("ASTFunctionStyleMacroDefinition", nil, role.Function, role.Declaration,
		role.Incomplete),

	AnnotateType("CPPASTFunctionDefinition", ObjRoles{
		"Prop_Body":          {role.Function, role.Declaration, role.Body},
		"Prop_DeclSpecifier": {role.Function, role.Declaration, role.Return, role.Type},
	}, role.Function, role.Declaration),

	AnnotateType("CPPASTFunctionDeclarator", FieldRoles{
		"Prop_Name": {Roles: role.Roles{role.Function, role.Declaration, role.Name}},

		"Prop_Parameters": {Arr: true, Roles: role.Roles{role.Function, role.Declaration,
			role.Argument}},
	}, role.Function, role.Declaration),

	AnnotateType("CPPASTFunctionDeclarator", FieldRoles{
		"Prop_Name": {Roles: role.Roles{role.Function, role.Declaration, role.Name}},
	}, role.Function, role.Declaration),

	AnnotateType("CPPASTFunctionDeclarator", nil, role.Function, role.Declaration),

	AnnotateType("CPPASTReturnStatement", ObjRoles{
		"Prop_ReturnArgument": {role.Return, role.Value},
	}, role.Statement, role.Return),

	AnnotateTypeCustom("CPPASTBinaryExpression", MapObj(Obj{
		"Operator":          Var("operator"),
		"Prop_Operand1":     ObjectRoles("operand1"),
		"Prop_Operand2":     ObjectRoles("operand2"),
		"Prop_InitOperand2": ObjectRoles("init_operand2"),
	}, Obj{
		uast.KeyToken:   Var("operator"),
		"Prop_Operand1": ObjectRoles("operand1", role.Binary, role.Expression, role.Left),
		"Prop_Operand2": ObjectRoles("operand2", role.Binary, role.Expression, role.Right),
		"Prop_InitOperand2": ObjectRoles("init_operand2", role.Binary, role.Expression, role.Right,
			role.Initialization, role.Incomplete),
	}), LookupArrOpVar("operator", binaryExprRoles), role.Operator),

	AnnotateType("CPPASTEqualsInitializer", nil, role.Declaration, role.Assignment,
		role.Expression, role.Right),

	AnnotateType("CPPASTCompositeTypeSpecifier", FieldRoles{
		"Key": {Op: String("struct")},
	}, role.Declaration, role.Type),

	AnnotateType("CPPASTCompositeTypeSpecifier", FieldRoles{
		"Key":          {Op: String("struct")},
		"Prop_Members": {Arr: true, Roles: role.Roles{role.Declaration, role.Type}},
	}, role.Declaration, role.Type),

	AnnotateType("CPPASTElaboratedTypeSpecifier", FieldRoles{
		"Kind": {Op: String("enum")},
	}, role.Declaration, role.Type, role.Enumeration),

	AnnotateType("CPPASTElaboratedTypeSpecifier", FieldRoles{
		"Kind": {Op: String("enum")},
	}, role.Declaration, role.Type, role.Enumeration),

	AnnotateType("CPPASTCompositeTypeSpecifier", FieldRoles{
		"Key": {Op: String("class")},
	}, role.Declaration, role.Type),

	AnnotateType("CPPASTCompositeTypeSpecifier", FieldRoles{
		"Key": {Op: String("union")},
		"Prop_Members": {Arr: true, Roles: role.Roles{role.Declaration, role.Type,
			role.Incomplete}},
		"Prop_Clauses": {Arr: true, Roles: role.Roles{role.Declaration, role.Type,
			role.Incomplete}},
	}, role.Declaration, role.Type, role.Incomplete),

	AnnotateType("CPPASTCompositeTypeSpecifier", FieldRoles{
		"Key": {Op: String("union")},
		"Prop_Members": {Arr: true, Roles: role.Roles{role.Declaration, role.Type,
			role.Incomplete}},
	}, role.Declaration, role.Type, role.Incomplete),

	AnnotateType("CPPASTCompositeTypeSpecifier", FieldRoles{
		"Key":          {Op: String("class")},
		"Prop_Members": {Arr: true, Roles: role.Roles{role.Declaration}},
	}, role.Declaration, role.Type),

	AnnotateType("CPPASTCompositeTypeSpecifier", FieldRoles{
		"Key":          {Op: String("class")},
		"Prop_Members": {Arr: true, Roles: role.Roles{role.Declaration, role.Type}},
		"Prop_BaseSpecifiers": {Arr: true, Roles: role.Roles{role.Base,
			role.Declaration}},
	}, role.Declaration, role.Type),

	AnnotateType("CPPASTWhileStatement", ObjRoles{
		"Prop_Body":      {role.While},
		"Prop_Condition": {role.While, role.Condition},
	}, role.Statement, role.While),

	AnnotateType("CPPASTDoStatement", ObjRoles{
		"Prop_Body":      {role.DoWhile},
		"Prop_Condition": {role.DoWhile, role.Condition},
	}, role.Statement, role.DoWhile),

	AnnotateType("CPPASTSwitchStatement", ObjRoles{
		"Prop_Body":                 {role.Switch},
		"Prop_ControllerExpression": {role.Switch, role.Condition, role.Expression},
	}, role.Statement, role.Switch),
	AnnotateType("CPPASTCaseStatement", nil, role.Switch, role.Case),
	AnnotateType("CPPASTDefaultStatement", nil, role.Switch, role.Case, role.Default),

	AnnotateType("CPPASTAliasDeclaration", ObjRoles{
		"Prop_Alias":         {role.Alias, role.Left},
		"Prop_MappingTypeId": {role.Alias, role.Right},
	}, role.Alias),

	AnnotateType("CPPASTForStatement", ObjRoles{
		"Prop_Body":                 {role.For},
		"Prop_InitializerStatement": {role.For, role.Initialization},
		"Prop_IterationExpression":  {role.For, role.Update, role.Expression},
	}, role.For, role.Statement),

	AnnotateType("CPPASTRangeBasedForStatement", ObjRoles{
		"Prop_Body":              {role.For, role.Body},
		"Prop_Declaration":       {role.For, role.Declaration, role.Variable},
		"Prop_InitializerClause": {role.For, role.Iterator},
	}, role.For, role.Iterator, role.Statement),

	AnnotateType("CPPASTIfStatement", ObjRoles{
		"Prop_ThenClause":            {role.If, role.Then},
		"Prop_ElseClause":            {role.If, role.Else},
		"Prop_ConditionalExpression": {role.If, role.Condition, role.Expression},
	}, role.If, role.Statement),

	AnnotateType("CPPASTFunctionCallExpression", FieldRoles{
		"Prop_Arguments": {Arr: true, Roles: role.Roles{role.Function, role.Call,
			role.Argument}},
		"Prop_FunctionNameExpression": {Roles: role.Roles{role.Function, role.Call,
			role.Name}},
	}, role.Function, role.Call, role.Expression),

	AnnotateType("CPPASTFunctionCallExpression", FieldRoles{
		"Prop_FunctionNameExpression": {Roles: role.Roles{role.Function, role.Call,
			role.Name}},
	}, role.Function, role.Call, role.Expression),

	AnnotateType("CPPASTLambdaExpression", FieldRoles{
		"Prop_Body": {Roles: role.Roles{role.Function, role.Declaration}},
		"Prop_Declarator": {Roles: role.Roles{role.Function, role.Declaration,
			role.Type}},
		"Prop_Captures": {Arr: true, Roles: role.Roles{role.Function, role.Declaration,
			role.Incomplete}},
	}, role.Function, role.Declaration, role.Anonymous, role.Expression),

	AnnotateType("CPPASTLambdaExpression", FieldRoles{
		"Prop_Body": {Roles: role.Roles{role.Function, role.Declaration}},
		"Prop_Declarator": {Roles: role.Roles{role.Function, role.Declaration,
			role.Type}},
	}, role.Function, role.Declaration, role.Anonymous, role.Expression),

	AnnotateType("CPPASTArrayDeclarator", FieldRoles{
		"Prop_Initializer": {Opt: true, Roles: role.Roles{role.List, role.Initialization,
			role.Right}},

		"Prop_ArrayModifiers": {Arr: true, Roles: role.Roles{role.List,
			role.Declaration}},
	}, role.List, role.Declaration),

	AnnotateType("CPPASTArrayModifier", nil, role.Type, role.Incomplete),

	AnnotateType("CPPASTArraySubscriptExpression", nil, role.List, role.Value,
		role.Incomplete),

	AnnotateType("CPPASTTryBlockStatement", FieldRoles{
		"Prop_TryBody":       {Roles: role.Roles{role.Try, role.Body}},
		"Prop_CatchHandlers": {Arr: true, Roles: role.Roles{role.Try, role.Catch}},
	}, role.Try, role.Statement),

	AnnotateType("CPPASTCatchHandler", ObjRoles{
		"Prop_Declaration": {role.Catch, role.Type, role.Argument},
		"Prop_CatchBody":   {role.Catch, role.Body},
	}),

	AnnotateType("CPPASTQualifiedName", FieldRoles{
		"Prop_AllSegments": {Arr: true, Roles: role.Roles{role.Qualified}},
		"Prop_Qualifier":   {Arr: true, Roles: role.Roles{role.Identifier}},
	}, role.Qualified),

	AnnotateType("CPPASTQualifiedName", FieldRoles{
		"Prop_AllSegments": {Arr: true, Roles: role.Roles{role.Qualified}},
	}, role.Qualified),

	AnnotateType("CPPASTConstructorChainInitializer", ObjRoles{
		"Prop_MemberInitializerId": {role.Type, role.Declaration, role.Initialization,
			role.Incomplete},
	}, role.Type, role.Declaration, role.Initialization, role.Incomplete),

	AnnotateType("CPPASTConstructorInitializer", FieldRoles{
		"Prop_Arguments": {Arr: true, Roles: role.Roles{role.Initialization,
			role.Declaration, role.Argument, role.Value, role.Incomplete}},
		"Prop_Expression": {Roles: role.Roles{role.Initialization, role.Declaration,
			role.Value, role.Incomplete}},
	}, role.Initialization, role.Declaration, role.Incomplete),
	AnnotateType("CPPASTConstructorInitializer", nil, role.Initialization,
		role.Declaration, role.Incomplete),

	AnnotateType("Comment", MapObj(Obj{
		"Comment": UncommentCLike("text"),
	}, Obj{
		uast.KeyToken: Var("text"),
	}), role.Noop, role.Comment),

	AnnotateType("CPPASTFieldDeclarator", ObjRoles{
		"Prop_BitFieldSize": {role.Type, role.Declaration, role.Number, role.Incomplete},
	}, role.Type, role.Declaration, role.Incomplete),
}

var Native = Transformers([][]Transformer{
	{Mappings(Annotations...)},
	{
		RolesDedup(),
	},
}...)

var Normalize = Transformers([][]Transformer{
	{Mappings(Normalizers...)},
}...)

var Normalizers = []Mapping{

	MapSemantic("ASTInclusionStatement", uast.InlineImport{}, MapObj(
		Fields{
			{Name: "Name", Op: Var("path")},
			{Name: "IsSystem", Op: Bool(true)},

			{Name: "Path", Op: String("")},

			{Name: "Resolved", Op: Any()},
			{Name: "LeadingComments", Drop: true, Op: Any()},
			{Name: "TrailingComments", Drop: true, Op: Any()},
		},
		Obj{
			"Path": UASTType(uast.String{}, Obj{
				"Value":  Var("path"),
				"Format": String(""),
			}),
			"All":   Bool(true),
			"Names": Is(nil),
		},
	)),

	MapSemantic("ASTInclusionStatement", uast.InlineImport{}, MapObj(
		Fields{
			{Name: "Name", Op: StringConv(Var("path"), prependDotSlash, removeDotSlash)},
			{Name: "IsSystem", Op: Bool(false)},

			{Name: "Path", Op: String("")},

			{Name: "Resolved", Op: Any()},
			{Name: "LeadingComments", Drop: true, Op: Any()},
			{Name: "TrailingComments", Drop: true, Op: Any()},
		},
		Obj{
			"Path": UASTType(uast.String{}, Obj{
				"Value":  Var("path"),
				"Format": String(""),
			}),
			"All":   Bool(true),
			"Names": Is(nil),
		},
	)),

	MapSemantic("CPPASTCompoundStatement", uast.Block{}, MapObj(
		Fields{
			{Name: "Prop_Statements", Op: Var("statements")},

			{Name: "ExpandedFromMacro", Drop: true, Op: Any()},
			{Name: "LeadingComments", Drop: true, Op: Any()},
			{Name: "FreestadingComments", Drop: true, Op: Any()},
			{Name: "TrailingComments", Drop: true, Op: Any()},
		},
		Obj{
			"Statements": Var("statements"),
		},
	)),

	MapSemantic("CPPASTCompoundStatement", uast.Block{}, MapObj(
		Fields{

			{Name: "LeadingComments", Drop: true, Op: Any()},
			{Name: "FreestadingComments", Drop: true, Op: Any()},
			{Name: "TrailingComments", Drop: true, Op: Any()},
		},
		Obj{"Statements": Arr()},
	)),

	MapSemantic("CPPASTLiteralExpression", uast.String{}, MapObj(
		Obj{
			"LiteralValue":            Quote(Var("val")),
			"kind":                    String("string_literal"),
			"ExpressionValueCategory": String("LVALUE"),
			"IsLValue":                Bool(true),

			"ExpressionType": Any(),
		},
		Obj{
			"Value":  Var("val"),
			"Format": String(""),
		},
	)),

	MapSemantic("Comment", uast.Comment{}, MapObj(
		Obj{
			"Comment":        CommentText([2]string{"/*", "*/"}, "comm"),
			"IsBlockComment": Bool(true),
		},
		CommentNode(true, "comm", nil),
	)),

	MapSemantic("Comment", uast.Comment{}, MapObj(
		Obj{
			"Comment":        CommentText([2]string{"//", ""}, "comm"),
			"IsBlockComment": Bool(false),
		},
		CommentNode(false, "comm", nil),
	)),

	Map(
		Fields{
			{Name: "IASTClass", Op: String("CPPASTName")},
			{Name: "Name", Op: String("")},

			{Name: "ExpandedFromMacro", Drop: true, Op: Any()},
		},
		Is(nil),
	),

	mapIASTNameDerived("CPPASTName"),
	mapIASTNameDerived("CPPASTOperatorName"),
	AnnotateType("CPPASTTemplateId", MapObj(
		Obj{
			"Name": Var("name"),
		},
		Obj{
			"Name": UASTType(uast.Identifier{}, Obj{
				"Name": Var("name"),
			}),
		},
	)),
	AnnotateType("CPPASTConversionName", MapObj(
		Obj{
			"Name": Var("name"),
		},
		Obj{
			"Name": UASTType(uast.Identifier{}, Obj{
				"Name": Var("name"),
			}),
		},
	)),

	MapSemantic("CPPASTQualifiedName", uast.QualifiedIdentifier{}, MapObj(
		Fields{
			{Name: "Prop_AllSegments", Op: Each("qualParts", Cases("caseQualParts",
				Fields{
					{Name: uast.KeyType, Op: String("uast:Identifier")},
					{Name: uast.KeyPos, Op: Any()},
					{Name: "Name", Op: Var("name")},
				},
				Fields{
					{Name: uast.KeyType, Op: String("CPPASTTemplateId")},
					{Name: uast.KeyPos, Op: Any()},
					{Name: "Name", Op: Obj{
						uast.KeyType: String("uast:Identifier"),
						"Name":       Var("name"),
					}},
					{Name: "Prop_TemplateArguments", Op: Any()},
					{Name: "Prop_TemplateName", Op: Any()},
				},
				Fields{
					{Name: uast.KeyType, Op: String("CPPASTConversionName")},
					{Name: uast.KeyPos, Op: Any()},
					{Name: "Name", Op: Obj{
						uast.KeyType: String("uast.Identifier"),
						"Name":       Var("name"),
					}},
				},
				Is(nil),
			))},
			{Name: "IsConversionOperator", Op: Bool(false)},

			{Name: "Prop_Qualifier", Drop: true, Op: Any()},

			{Name: "ExpandedFromMacro", Drop: true, Op: Any()},
			{Name: "IsFullyQualified", Op: Any()},

			{Name: "Name", Op: Any()},
		},
		Obj{
			"Names": Each("qualParts", Cases("caseQualParts",
				UASTType(uast.Identifier{}, Obj{
					"Name": Var("name"),
				}),
				UASTType(uast.Identifier{}, Obj{
					"Name": Var("name"),
				}),
				UASTType(uast.Identifier{}, Obj{
					"Name": Var("name"),
				}),
				Is(nil),
			)),
		},
	)),

	MapSemantic("CPPASTFunctionDefinition", uast.FunctionGroup{}, MapObj(
		Fields{
			{Name: "IsDefaulted", Op: Any()},
			{Name: "IsDeleted", Op: Any()},

			{Name: "ExpandedFromMacro", Drop: true, Op: Any()},
			{Name: "Prop_Body", Optional: "optBody", Op: Var("body")},
			{Name: "LeadingComments", Optional: "optLeadingComments", Op: Var("leadingComments")},
			{Name: "FreestadingComments", Optional: "optFSComments", Op: Var("fsComments")},
			{Name: "TrailingComments", Optional: "optTlComments", Op: Var("tsComments")},
			{Name: "Prop_MemberInitializers", Optional: "optMemberInitializers", Op: Var("memberInitializers")},

			{Name: "Prop_DeclSpecifier", Op: Cases("retTypeCase",
				Fields{
					{Name: uast.KeyType, Op: String("CPPASTSimpleDeclSpecifier")},
					{Name: uast.KeyPos, Op: Any()},
					{Name: "IsComplex", Drop: true, Op: Any()},
					{Name: "IsConst", Drop: true, Op: Any()},
					{Name: "IsConstExpr", Drop: true, Op: Any()},
					{Name: "IsExplicit", Drop: true, Op: Any()},
					{Name: "IsFriend", Drop: true, Op: Any()},
					{Name: "IsImaginary", Drop: true, Op: Any()},
					{Name: "IsInline", Drop: true, Op: Any()},
					{Name: "IsLong", Drop: true, Op: Any()},
					{Name: "IsLongLong", Drop: true, Op: Any()},
					{Name: "IsRestrict", Drop: true, Op: Any()},
					{Name: "IsShort", Drop: true, Op: Any()},
					{Name: "IsSigned", Drop: true, Op: Any()},
					{Name: "IsThreadLocal", Drop: true, Op: Any()},
					{Name: "IsUnsigned", Drop: true, Op: Any()},
					{Name: "IsVirtual", Drop: true, Op: Any()},
					{Name: "IsVolatile", Drop: true, Op: Any()},
					{Name: "StorageClass", Drop: true, Op: Any()},
					{Name: "ExpandedFromMacro", Drop: true, Op: Any()},
					{Name: "Type", Op: String("void")},
				},

				Fields{
					{Name: uast.KeyType, Op: String("CPPASTSimpleDeclSpecifier")},
					{Name: uast.KeyPos, Drop: true, Op: Any()},
					{Name: "IsComplex", Drop: true, Op: Any()},
					{Name: "IsConst", Drop: true, Op: Any()},
					{Name: "IsConstExpr", Drop: true, Op: Any()},
					{Name: "IsExplicit", Drop: true, Op: Any()},
					{Name: "IsFriend", Drop: true, Op: Any()},
					{Name: "IsImaginary", Drop: true, Op: Any()},
					{Name: "IsInline", Drop: true, Op: Any()},
					{Name: "IsLong", Drop: true, Op: Any()},
					{Name: "IsLongLong", Drop: true, Op: Any()},
					{Name: "IsRestrict", Drop: true, Op: Any()},
					{Name: "IsShort", Drop: true, Op: Any()},
					{Name: "IsSigned", Drop: true, Op: Any()},
					{Name: "IsThreadLocal", Drop: true, Op: Any()},
					{Name: "IsUnsigned", Drop: true, Op: Any()},
					{Name: "IsVirtual", Drop: true, Op: Any()},
					{Name: "IsVolatile", Drop: true, Op: Any()},
					{Name: "StorageClass", Drop: true, Op: Any()},
					{Name: "ExpandedFromMacro", Drop: true, Op: Any()},
					{Name: "Type", Op: String("unspecified")},
				},
				Fields{

					{Name: uast.KeyType, Op: String("CPPASTSimpleDeclSpecifier")},
					{Name: uast.KeyPos, Op: Any()},
					{Name: "IsComplex", Op: Any()},
					{Name: "IsConst", Op: Any()},
					{Name: "IsConstExpr", Op: Any()},
					{Name: "IsExplicit", Op: Any()},
					{Name: "IsFriend", Op: Any()},
					{Name: "IsImaginary", Op: Any()},
					{Name: "IsInline", Op: Any()},
					{Name: "IsLong", Op: Any()},
					{Name: "IsLongLong", Op: Any()},
					{Name: "IsRestrict", Op: Any()},
					{Name: "IsShort", Op: Any()},
					{Name: "IsSigned", Op: Any()},
					{Name: "IsThreadLocal", Op: Any()},
					{Name: "IsUnsigned", Op: Any()},
					{Name: "IsVirtual", Op: Any()},
					{Name: "IsVolatile", Op: Any()},
					{Name: "StorageClass", Op: Var("StorageClass")},
					{Name: "ExpandedFromMacro", Drop: true, Op: Any()},
					{Name: "Type", Op: Var("retType")},
				},
				Fields{

					{Name: uast.KeyType, Op: String("CPPASTNamedTypeSpecifier")},
					{Name: uast.KeyPos, Op: Any()},
					{Name: "StorageClass", Op: Var("StorageClass")},
					{Name: "IsConst", Op: Any()},
					{Name: "IsConstExpr", Op: Any()},
					{Name: "IsExplicit", Op: Any()},
					{Name: "IsFriend", Op: Any()},
					{Name: "IsInline", Op: Any()},
					{Name: "IsRestrict", Op: Any()},
					{Name: "IsThreadLocal", Op: Any()},
					{Name: "IsTypeName", Op: Any()},
					{Name: "IsVirtual", Op: Any()},
					{Name: "IsVolatile", Op: Any()},
					{Name: "ExpandedFromMacro", Drop: true, Op: Any()},
					{Name: "Prop_Name", Op: Var("retType")},
				},
			)},

			{Name: "Prop_Declarator", Op: Fields{
				{Name: uast.KeyType, Op: String("CPPASTFunctionDeclarator")},
				{Name: uast.KeyPos, Op: Var("fdpos")},
				{Name: "IsConst", Op: Any()},
				{Name: "IsFinal", Op: Any()},
				{Name: "IsMutable", Op: Any()},
				{Name: "IsOverride", Op: Any()},
				{Name: "IsPureVirtual", Op: Any()},
				{Name: "IsVolatile", Op: Any()},
				{Name: "ExpandedFromMacro", Drop: true, Op: Any()},
				{Name: "Prop_NoexceptExpression", Drop: true, Op: Any()},
				{Name: "Prop_VirtSpecifiers", Drop: true, Op: Any()},

				{Name: "Prop_Name", Op: Cases("caseName",

					Is(nil),

					Fields{
						{Name: uast.KeyType, Op: String("uast:Identifier")},
						{Name: uast.KeyPos, Op: Any()},
						{Name: "Name", Op: Var("name")},
					},

					Fields{
						{Name: uast.KeyType, Op: String("uast:QualifiedIdentifier")},
						{Name: uast.KeyPos, Op: Any()},

						{Name: "Names", Op: Var("qualnames")},
					},
				)},

				{Name: "TakesVarArgs", Op: Cases("takesVarArgs", Bool(false), Bool(true))},
				{Name: "Prop_ConstructorChain", Drop: true, Op: Any()},
				{Name: "Prop_PointerOperators", Drop: true, Op: Any()},

				{Name: "Prop_Parameters", Optional: "optArgs", Op: Each("args", Cases("caseParams",
					Fields{
						{Name: uast.KeyType, Op: String("CPPASTDeclarator")},
						{Name: uast.KeyPos, Op: Var("parampos")},
						{Name: "Prop_Name", Op: Var("aname")},
						{Name: "Prop_TypeNode", Op: Var("atype")},
						{Name: "Prop_Initializer", Optional: "optInitializer", Op: Var("ainit")},

						{Name: "DeclaresParameterPack", Drop: true, Op: Any()},
						{Name: "Prop_PointerOperators", Drop: true, Op: Any()},
						{Name: "ExpandedFromMacro", Drop: true, Op: Any()},
						{Name: "Prop_PointerOperators", Drop: true, Op: Any()},
					},
					Fields{
						{Name: uast.KeyType, Op: String("CPPASTArrayDeclarator")},
						{Name: uast.KeyPos, Op: Var("parampos")},
						{Name: "Prop_Name", Op: Var("aname")},
						{Name: "Prop_TypeNode", Op: Var("atype")},
						{Name: "Prop_Initializer", Optional: "optInitializer", Op: Var("ainit")},

						{Name: "DeclaresParameterPack", Drop: true, Op: Any()},
						{Name: "Prop_ArrayModifiers", Drop: true, Op: Any()},
						{Name: "ExpandedFromMacro", Drop: true, Op: Any()},
						{Name: "Prop_PointerOperators", Drop: true, Op: Any()},
					},
					Fields{
						{Name: uast.KeyType, Op: String("CPPASTElaboratedTypeSpecifier")},
						{Name: uast.KeyPos, Op: Var("parampos")},
						{Name: "Prop_Name", Op: Var("aname")},
						{Name: "Prop_Initializer", Optional: "optInitializer", Op: Var("ainit")},
						{Name: "Kind", Op: Var("eltype")},
						{Name: "IsConst", Op: Any()},
						{Name: "IsConstExpr", Op: Any()},
						{Name: "IsExplicit", Op: Any()},
						{Name: "IsFriend", Op: Any()},
						{Name: "IsInline", Op: Any()},
						{Name: "IsRestrict", Op: Any()},
						{Name: "IsThreadLocal", Op: Any()},
						{Name: "IsVirtual", Op: Any()},
						{Name: "IsVolatile", Op: Any()},
						{Name: "StorageClass", Op: Any()},

						{Name: "ExpandedFromMacro", Drop: true, Op: Any()},
					},
				))},
			}},
		},
		Obj{
			"Nodes": Arr(
				Fields{
					{Name: "Comments", Op: Fields{
						{Name: "LeadingComments", Optional: "optLeadingComments", Op: Var("leadingComments")},
						{Name: "FreestadingComments", Optional: "optFSComments", Op: Var("fsComments")},
						{Name: "TrailingComments", Optional: "optTlComments", Op: Var("tsComments")},
					}},
					{Name: "MemberInitializers", Optional: "optMemberInitializers", Op: Var("memberInitializers")},
				},
				UASTType(uast.Alias{}, Obj{
					"Name": UASTType(uast.Identifier{}, CasesObj("caseName", Obj{},
						Objs{

							{
								"Name": Any(),
							},

							{
								"Name": Var("name"),
							},

							{
								"Name": opJoinNamesArray{qualified: Var("qualnames")},
							},
						},
					)),

					"Node": UASTType(uast.Function{}, Fields{
						{Name: "Body", Optional: "optBody", Op: Var("body")},

						{Name: "Type", Op: UASTType(uast.FunctionType{}, Fields{
							{Name: "Returns", Op: Cases("retTypeCase",

								Any(),
								Any(),

								Arr(UASTType(uast.Argument{},
									Obj{
										"Type": UASTType(uast.Identifier{}, Obj{
											"Name": Var("retType"),
										})})),

								Arr(UASTType(uast.Argument{},
									Obj{
										"Type": Var("retType"),
									})),
							)},

							{Name: "Arguments", Optional: "optArgs", Op: Cases("takesVarArgs",

								Each("args", Cases("caseParams",
									UASTType(uast.Argument{}, Obj{
										"Name": Var("aname"),
										"Type": Var("atype"),
										"Init": If("optInitializer", Var("ainit"), Is(nil)),
									}),
									UASTType(uast.Argument{}, Obj{
										"Name": Var("aname"),
										"Type": Var("atype"),
										"Init": If("optInitializer", Var("ainit"), Is(nil)),
									}),
									UASTType(uast.Argument{}, Obj{
										"Name": Var("aname"),
										"Type": UASTType(uast.Identifier{}, Obj{
											"Name": Var("eltype"),
										}),
										"Init": If("optInitializer", Var("ainit"), Is(nil)),
									})),
								),

								Append(
									Each("args", UASTType(uast.Argument{}, Obj{
										"Name": Var("aname"),
										"Type": Var("atype"),
										"Init": If("optInitializer", Var("ainit"), Is(nil)),
									})),
									Arr(
										UASTType(uast.Argument{}, Obj{
											"Variadic": Bool(true),
										}),
									),
								),
							)},
						})},
					}),
				}),
			),
		},
	)),
}

var Preprocess = Transformers([][]Transformer{
	{
		ResponseMetadata{
			TopLevelIsRootNode: false,
		},
	},
	{Mappings(Preprocessors...)},
}...)

var PreprocessCode = []CodeTransformer{
	positioner.FromUTF16Offset(),
}

var Preprocessors = []Mapping{
	ObjectToNode{
		InternalTypeKey: "IASTClass",
		OffsetKey:       "LocOffsetStart",
		EndOffsetKey:    "LocOffsetEnd",
	}.Mapping(),
}

var Transforms = driver.Transforms{
	Namespace:      "cpp",
	Preprocess:     Preprocess,
	PreprocessCode: PreprocessCode,
	Normalize:      Normalize,
	Annotations:    Native,
}