Ast.TypeQualifier Class

Namespace: Ast
Superclasses: AstNodeProperties

Represents the type_qualifier nodes in the syntax tree of your code

Since R2026a

Description

The PQL class Cpp.TypeQualifier represents the node type_qualifier in the syntax tree of your code.

#include <cstddef>

const int x = 5;
volatile int y;
alignas(16) int z;
int main() { return x + y + z; }

The three declarations show const, volatile, and alignas(16) which correspond to type_qualifier nodes that Cpp.TypeQualifier models.

Predicates

expand all

Type

Type	Raisable	Printable
`TypeQualifier`	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 TypeQualifier &qual)`	Matches a `type_qualifier` node and returns it as `qual`. Use this to directly find qualifiers like `const volatile` or `alignas(...)`.	This PQL defect checks for any `type_qualifier` node in the code. defect find_tq = when Cpp.TypeQualifier.is(&tq) and tq.nodeText(&txt) raise "Found type qualifier: \"{txt}\"" on tq In this C++ code the defect finds occurrences of type qualifiers such as `const`, `volatile`, or `alignas(16)` as `type_qualifier` nodes. const int x = 5; volatile int y; alignas(16) int z; int main() { return 0; }
`cast(Cpp.Node.Node node, required TypeQualifier &cast)`	Checks whether a given `Node` is a `type_qualifier` and if so returns the node as `cast`. Use this to confirm and extract a `type_qualifier` from a generic node reference.	This PQL defect checks for a node that can be converted to a `type_qualifier` by casting it. defect cast_check = when Cpp.Node.is(&node, &,&,&) and Cpp.TypeQualifier.cast(node, &tq2) and tq2.nodeText(&txt) raise "cast succeeded: \"{txt}\"" on tq2 In this C++ code the defect finds type qualifiers by casting. const int x = 5; int main() { return x; }
`isa(Cpp.Node.Node node)`	Returns true if the given `Node` is a `type_qualifier`. Use this when you need to test the node kind without binding.	This PQL defect checks whether a previously obtained node is a `type_qualifier`. defect isa_check = when Cpp.Node.is(&node,&,&,&) and Cpp.TypeQualifier.isa(node) and tq.nodeText(&txt) raise "isa true for: \"{txt}\"" on tq In this C++ code the defect finds type qualifiers by boolean check. volatile int y; int main() { return y; }
`alignasQualifier(TypeQualifier self, Cpp.Node.Node &child)`	If `self` is an `alignas(...)` qualifier this returns the `alignas` child node as `child`. Use this to locate the `alignas` expression inside a qualifier.	This PQL defect checks for `type_qualifier` nodes that contain an `alignas` child node. defect find_alignas = when Cpp.TypeQualifier.is(&tq) and tq.alignasQualifier(&aq) and aq.nodeText(&txt) raise "Found alignas qualifier: \"{txt}\"" on tq In this C++ code the defect searches for the `alignas(16)` qualifier attached to a declaration. #include <cstddef> alignas(16) int z; int main() { return z; }

Version History

Introduced in R2026a