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),
	AnnotateType("CPPASTName", FieldRoles{"Name": {Rename: uast.KeyToken}},
		role.Identifier),
	AnnotateType("CPPASTImplicitName", FieldRoles{"Name": {Rename: uast.KeyToken}},
		role.Identifier),

	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),

	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("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("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("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),
	}), LookupArrOpVar("operator", binaryExprRoles)),

	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("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.While},
		"Prop_Condition": {role.While, role.Condition},
	}, role.Statement, role.While),

	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},
		"Prop_Declaration":       {role.For, role.Declaration, role.Variable},
		"Prop_InitializerClause": {role.For, role.Iterator},
	}, role.For, 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("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 Code = []CodeTransformer{
	positioner.NewFillLineColFromOffset(),
}

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

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

var Normalizers = []Mapping{}

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

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

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