Cpp.FunctionDeclarator Class

Namespace: Cpp
Superclasses: AstNodeProperties

Represents the function_declarator nodes in the syntax tree of your code

Since R2026a

Description

The PQL class FunctionDeclarator represents the node function_declarator in the syntax tree of your code.

[[nodiscard]] void foo(int a) noexcept [[gnu::always_inline]] __asm__("bar") & requires (true) -> int;
int main() { return 0; }

The preceding example contains several function_declarator nodes:

In foo(int a), foo is a function declarator.
In main(){...}, main() is a function declarator.

Predicates

expand all

Type

Type	Raisable	Printable
`FunctionDeclarator`	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 FunctionDeclarator &fd)`	Matches any `function_declarator` node and returns it as `fd`. Use to obtain the function-declarator node for further inspection.	This PQL defect checks for any `function_declarator` node. defect find_fd = when Cpp.FunctionDeclarator.is(&fd) and fd.nodeText(&txt) raise "Found function declarator: \"{txt}\"" on fd In this C++ code, the defect checks for the top-level function declarator for `foo`. void foo(int) {}
`cast(Cpp.Node.Node node, required FunctionDeclarator &cast)`	Checks whether a generic `Cpp.Node.Node` is a `function_declarator`; if so, returns it as `cast` for further predicates.	This PQL defect checks whether a given node is a `function_declarator`. defect cast_check = when Cpp.Node.is(&n, &,&,&) and Cpp.FunctionDeclarator.cast(n, &fd) and fd.nodeText(&txt) raise "Node cast to function_declarator: \"{txt}\"" on fd In this C++ code, the defect finds the node for `bar` and verifies it is a function declarator. int bar(double);
`isa(Cpp.Node.Node node)`	Checks whether `node` is a `function_declarator`. Useful for negation or presence checks.	This PQL defect checks if a node is a `function_declarator` by using `isa`. defect isa_check = when Cpp.Node.is(&n, &,&,&) and Cpp.FunctionDeclarator.isa(n) raise "Node is a function_declarator" on n In this C++ code, the defect verifies the `foo(int)` declarator node is a function declarator. void foo(int);
`declarator(FunctionDeclarator self, Cpp.Node.Node &child)`	Returns the nested declarator node (e.g., the identifier and possible nested declarator) inside the function declarator.	This PQL defect checks for the inner declarator portion of a `function_declarator`. defect decl_part = when Cpp.FunctionDeclarator.is(&fd) and fd.declarator(&d) and d.nodeText(&txt) raise "Declarator part: \"{txt}\"" on fd In this C++ code, the defect extracts the `foo` identifier declarator from `void foo(int)`. void foo(int);
`parameters(FunctionDeclarator self, Cpp.Node.Node &child)`	Matches the parameter list node (the parentheses and contents) of the function declarator.	This PQL defect checks for the parameter list of a `function_declarator`. defect params_check = when Cpp.FunctionDeclarator.is(&fd) and fd.parameters(&p) and p.nodeText(&txt) raise "Parameters: \"{txt}\"" on fd In this C++ code, the defect captures `(int, double)` as the parameters for `f`. void f(int, double);
`throwSpecifier(FunctionDeclarator self, Cpp.Node.Node &child)`	Matches the exception-specification node (old-style `throw(type)` form) present on the function declarator.	This PQL defect checks for an old-style `throw(...)` exception specification on a function. defect throw_spec = when Cpp.FunctionDeclarator.is(&fd) and fd.throwSpecifier(&ts) and ts.nodeText(&txt) raise "Throw spec: \"{txt}\"" on fd In this C++ code, the defect finds `throw(int)` applied to `foo`. void foo() throw(int); int main() { return 0; }
`attributeSpecifier(FunctionDeclarator self, Cpp.Node.Node &child)`	Matches attribute-specifier sequences (e.g., `[[nodiscard]]`) attached to the function declarator.	This PQL defect checks for `[[...]]` attribute specifiers on a function declarator. defect attr_spec = when Cpp.FunctionDeclarator.is(&fd) and fd.attributeSpecifier(&as) and as.nodeText(&txt) raise "Attribute specifier: \"{txt}\"" on fd In this C++ code, the defect finds the function declarator that has an attribute specifier like the `__attribute__((section(".my_funcs")))`. void my_function() __attribute__((section(".my_funcs")));
`trailingReturnType(FunctionDeclarator self, Cpp.Node.Node &child)`	Matches a trailing return type (`-> type`) attached to a function declarator.	This PQL defect checks for a trailing return type on a function declarator. defect trailing_rt = when Cpp.FunctionDeclarator.is(&fd) and fd.trailingReturnType(&tr) and tr.nodeText(&txt) raise "Trailing return: \"{txt}\"" on fd In this C++ code, the defect finds `-> int` used as a trailing return for `foo`. auto foo() -> int; int main() { return 0; }
`gnuAsmExpression(FunctionDeclarator self, Cpp.Node.Node &child)`	Matches a GNU-style `__asm__("...")` expression attached to the function declarator.	This PQL defect checks for a `__asm__` expression on a function declarator. defect asm_expr = when Cpp.FunctionDeclarator.is(&fd) and fd.gnuAsmExpression(&ga) and ga.nodeText(&txt) raise "GNU asm: \"{txt}\"" on fd
`typeQualifier(FunctionDeclarator self, Cpp.Node.Node &child)`	Matches trailing cv-qualifiers (e.g., `const`, `volatile`) on the function declarator.	This PQL defect checks for `const`/`volatile` qualifiers on member function declarators. defect type_qual = when Cpp.FunctionDeclarator.is(&fd) and fd.typeQualifier(&tq) and tq.nodeText(&txt) raise "Type qualifier: \"{txt}\"" on fd In this C++ code, the defect finds `const` on the member function declaration. struct S { void m() const; }; int main() { return 0; }
`noexcept(FunctionDeclarator self, Cpp.Node.Node &child)`	Matches a `noexcept` specifier (with or without expression) on the function declarator.	This PQL defect checks for `noexcept` on a function declarator. defect noex = when Cpp.FunctionDeclarator.is(&fd) and fd.noexcept(&ne) and ne.nodeText(&txt) raise "Noexcept: \"{txt}\"" on fd In this C++ code, the defect captures `noexcept(true)` attached to `foo`. void foo() noexcept(true); int main() { return 0; }
`virtualSpecifier(FunctionDeclarator self, Cpp.Node.Node &child)`	Matches a `override` or `final` specifier present on a member function declarator.	This PQL defect checks for the `virtual` keyword on a function declarator. defect virt_spec = when Cpp.FunctionDeclarator.is(&fd) and fd.virtualSpecifier(&vs) and vs.nodeText(&txt) raise "Virtual specifier: \"{txt}\"" on fd In this C++ code, the defect finds `final` on a class member function declarator. class Shape { public: double area() final; };
`refQualifier(FunctionDeclarator self, Cpp.Node.Node &child)`	Matches ref-qualifiers (`&` or `&&`) applied to member function declarators.	This PQL defect checks for reference qualifiers on a member function declarator. defect ref_q = when Cpp.FunctionDeclarator.is(&fd) and fd.refQualifier(&rq) and rq.nodeText(&txt) raise "Ref qualifier: \"{txt}\"" on fd In this C++ code, the defect detects the `&` ref-qualifier on `g`. struct S { void g() &; }; int main() { return 0; }
`requiresClause(FunctionDeclarator self, Cpp.Node.Node &child)`	Matches a trailing `requires` clause (C++20 constraints) on the function declarator.	This PQL defect checks for a `requires` clause on a function declarator. defect req_clause = when Cpp.FunctionDeclarator.is(&fd) and fd.requiresClause(&rc) and rc.nodeText(&txt) raise "Requires clause: \"{txt}\"" on fd In this C++ code, the defect finds `requires (true)` on the function template. template<typename T> void h() requires (true); int main() { return 0; }
`attributeDeclaration(FunctionDeclarator self, Cpp.Node.Node &child)`	Matches an attribute-declaration (attribute-list) that applies to the function declarator (often same as attributeSpecifier but placed differently in grammar).	This PQL defect checks for attribute declarations (the `[[...]]` syntax) attached to a function declarator. defect attr_decl = when Cpp.FunctionDeclarator.is(&fd) and fd.attributeDeclaration(&ad) and ad.nodeText(&txt) raise "Attribute declaration: \"{txt}\"" on fd
`getEnclosingFunctionDeclarator(Cpp.Node.Node child, required FunctionDeclarator &parent)`	Finds the closest enclosing `function_declarator` ancestor of `child` and returns it as `parent`.	This PQL defect checks which function declarator encloses a given child node. defect enclosing_fd = when Cpp.Node.is(&n, &,&,&) and Cpp.FunctionDeclarator.getEnclosingFunctionDeclarator(n, &fd) and fd.nodeText(&txt) raise "Enclosing function declarator: \"{txt}\"" on fd In this C++ code, the defect finds the function declarator that encloses a child node. void foo(int a) {}
`isEnclosedInFunctionDeclarator(Cpp.Node.Node child)`	Matches any `function_declarator` ancestor of `child`.	This PQL defect checks all function declarator ancestors of a node. defect all_enclosing = when Cpp.Node.is(&n, &,&,&) and Cpp.FunctionDeclarator.isEnclosedInFunctionDeclarator(n) and n.nodeText(&txt) raise "Node enclosws in function declarator ancestor: \"{txt}\"" on n In this C++ code, the defect enumerates any function declarators that enclose a child node. int (*fp(int x))(double) { return nullptr; } int main() { return 0; }

Version History

Introduced in R2026a