Cpp.ParenthesizedDeclarator Class

Namespace: Cpp
Superclasses: AstNodeProperties

Represents the parenthesized_declarator nodes in the syntax tree of your code

Since R2026a

Description

The PQL class ParenthesizedDeclarator represents the node parenthesized_declarator in the syntax tree of your code.

// example.cpp
struct MyType { int (MyType::*m)(int); };

int (*f)[10];
int (*g)(int);
int (__stdcall *h)(int);

int main() {
    (void)f; (void)g; (void)h;
    return 0;
}

The above C++ file contains several parenthesized_declarator occurrences such as (*f)[10], (*g)(int) and (__stdcall *h)(int). These nodes match the PQL ParenthesizedDeclarator class.

Predicates

expand all

Type

Type	Raisable	Printable
`ParenthesizedDeclarator`	Yes	No

Syntaxes

This class defines these predicates that act on the objects of this class. In addition, objects of this class can access the predicates defined by the base class AstNodeProperties. An object of this class is an object of AstNodeProperties class.

Predicates	Description	Example
`is(required ParenthesizedDeclarator &pd)`	Checks for a `parenthesized_declarator` node and returns it as `pd`; use this to directly select parenthesized declarators.	This PQL defect checks for any `parenthesized_declarator` node. defect parenthesized_found = when Cpp.ParenthesizedDeclarator.is(&pd) raise "Found parenthesized declarator" on pd In this C++ code, the defect finds occurrences like `(g)(int)` and `(f)[10]`. int (g)(int); int (f)[10];
`cast(Cpp.Node.Node node, required ParenthesizedDeclarator &cast)`	If `node` is a `parenthesized_declarator`, binds that node to `cast` for further inspection.	This PQL defect checks whether a generic node is actually a `parenthesized_declarator`. defect cast_check = when Cpp.Node.is(&n, &,&,&) and Cpp.ParenthesizedDeclarator.cast(n, &pd) raise "Node is a parenthesized_declarator" on pd In this C++ code, the checker identifies `(MyType::m)` inside a member-pointer declaration as a `parenthesized_declarator`. struct MyType { int (MyType::m)(int); };
`isa(Cpp.Node.Node node)`	Returns true if `node` is a `parenthesized_declarator`; useful for boolean checks or negation.	This PQL defect checks nodes with a boolean test to see if they are `parenthesized_declarator`. defect isa_check = when Cpp.Node.is(&n, &,&,&) and Cpp.ParenthesizedDeclarator.isa(n) raise "Node isa parenthesized_declarator" on n In this C++ code, the predicate detects the `(__stdcall h)` construct as a `parenthesized_declarator`. int (__stdcall h)(int); int main(){ (void)h; }
`fieldDeclarator(ParenthesizedDeclarator self, Cpp.Node.Node &child)`	Matches a `field_declarator` child inside a given `parenthesized_declarator`.	This PQL defect checks for a `field_declarator` inside a `parenthesized_declarator`. defect field_decl_check = when Cpp.ParenthesizedDeclarator.is(&pd) and pd.fieldDeclarator(&fd) and fd.nodeText(&txt) raise "Has field_declarator \"{txt}\" inside parenthesized_declarator" on pd
`declarator(ParenthesizedDeclarator self, Cpp.Node.Node &child)`	Matches a `declarator` child inside the `parenthesized_declarator` (the identifier part).	This PQL defect checks for the inner `declarator` (the identifier) within a parenthesized declarator. defect inner_declarator_check = when Cpp.ParenthesizedDeclarator.is(&pd) and pd.declarator(&d) and d.nodeText(&txt) raise "ParenthesizedDeclarator contains a declarator \"{txt}\"" on pd
`msCallModifier(ParenthesizedDeclarator self, Cpp.Node.Node &child)`	Matches a Microsoft calling-convention modifier (e.g., `__stdcall`) inside the `parenthesized_declarator`.	This PQL defect checks for MS calling-convention modifiers within a `parenthesized_declarator`. defect mscc_check = when Cpp.ParenthesizedDeclarator.is(&pd) and pd.msCallModifier(&mc) and mc.nodeText(&txt) raise "MS call modifier \"{txt}\" present in parenthesized_declarator" on pd In this C++ code, `__stdcall` inside `(__stdcall h)` is what the predicate locates. int (__stdcall h)(int); int main(){ (void)h; }
`typeDeclarator(ParenthesizedDeclarator self, Cpp.Node.Node &child)`	Matches a `type_declarator` child inside a `parenthesized_declarator`, such as a `MyType::*` member-pointer form.	This PQL defect checks for a `type_declarator` inside a `parenthesized_declarator`. defect type_decl_check = when Cpp.ParenthesizedDeclarator.is(&pd) and pd.typeDeclarator(&td) and td.nodeText(&txt) raise "Contains a type_declarator \"{txt}\"" on pd In this C++ code, `MyType::m` inside `int (MyType::m)(int)` is matched as a `type_declarator`. struct MyType { int (MyType::*m)(int); }; int main(){ MyType t; (void)t; }
`getEnclosingParenthesizedDeclarator(Cpp.Node.Node child, required ParenthesizedDeclarator &parent)`	Finds the nearest enclosing `parenthesized_declarator` ancestor of `child` and returns it as `parent`.	This PQL defect checks for the closest enclosing `parenthesized_declarator` around a given node. defect enclosing_check = when Cpp.Node.is(&n, &,&,&) and Cpp.ParenthesizedDeclarator.getEnclosingParenthesizedDeclarator(n, &pd) raise "Identifier is inside parenthesized_declarator" on pd In this C++ code, the identifier `g` is inside `(g)(int)`, so the enclosing parenthesized declarator is detected. int (g)(int); int main(){ (void)g; }
`isEnclosedInParenthesizedDeclarator(Cpp.Node.Node child)`	Matches every `parenthesized_declarator` ancestor of `child`.	This PQL defect checks for any ancestor `parenthesized_declarator` nodes that enclose a given child. defect all_enclosing_check = when Cpp.Node.is(&n, &,&,&) and Cpp.ParenthesizedDeclarator.isEnclosedInParenthesizedDeclarator(n) raise "Identifier is enclosed by a parenthesized_declarator" on n In this C++ code, the identifier `m` inside `int (MyType::m)(int)` is enclosed by the member-pointer parenthesized declarator. struct MyType { int (MyType::m)(int); }; int main(){ MyType t; (void)t; }

Version History

Introduced in R2026a