Cpp.AlignofExpression Class

Namespace: Cpp
Superclasses: AstNodeProperties

Represents the alignof_expression nodes in the syntax tree of your code

Since R2026a

Description

The PQL class AlignofExpression represents the node alignof_expression in the syntax tree of your code.

// minimal example showing alignof expressions
#include <cstddef>
int a = alignof(int);
int b = alignof(double);
int c = alignof(a);
int main() { return a + b + c; }

The three alignof(...) usages in the C++ demo correspond to alignof_expression nodes; PQL AlignofExpression predicates operate on those nodes.

Predicates

expand all

Type

Type	Raisable	Printable
`AlignofExpression`	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 AlignofExpression &ae)`	Checks that a node is an `alignof_expression` and returns it as `&ae` for further inspection.	This PQL defect checks for any `alignof_expression` node in the file. defect find_alignof = when Cpp.AlignofExpression.is(&ae) and ae.nodeText(&txt) raise "Found alignof: {txt}" on ae In this C++ code, the defect finds each `alignof(...)` expression. #include <cstddef> int x = alignof(long); int main() { return x; }
`cast(Cpp.Node.Node node, required AlignofExpression &cast)`	If the generic `node` is an `alignof_expression`, this binds the `alignof_expression` to `&cast` so you can treat it with `AlignofExpression` predicates.	This PQL defect checks whether an arbitrary node is actually an `alignof_expression`. defect cast_to_alignof = when Cpp.Node.is(&n, &,&,&) and Cpp.AlignofExpression.cast(n, &ae) and ae.nodeText(&txt) raise "Node is alignof: {txt}" on ae In this C++ code, the defect finds an `alignof(...)` expression even when starting from a generic node query. #include <cstddef> int y = alignof(char); int main() { return y; }
`isa(Cpp.Node.Node node)`	Returns true when the provided generic `node` is an `alignof_expression`; useful in boolean checks or negation.	This PQL defect checks for nodes that are `alignof_expression` using a boolean test. defect isa_alignof = when Cpp.Node.is(&n, &,&,&) and Cpp.AlignofExpression.isa(n) and n.nodeText(&txt) raise "isa confirms alignof: {txt}" on n In this C++ code, the predicate identifies the `alignof(...)` node by testing its node kind. #include <cstddef> int z = alignof(short); int main() { return z; }
`type(AlignofExpression self, Cpp.Node.Node &child)`	Matches the type node inside the `alignof(...)` expression (e.g., the `int` in `alignof(int)`), returning it as `&child`.	This PQL defect checks for the inner type node of an `alignof_expression`. defect alignof_type = when Cpp.AlignofExpression.is(&ae) and ae.type(&ty) and ty.nodeText(&txt) raise "alignof type: {txt}" on ae In this C++ code, the defect extracts the type used inside each `alignof(...)` expression. #include <cstddef> int a = alignof(long long); int b = alignof(unsigned int); int main() { return a + b; }
`getEnclosingAlignofExpression(Cpp.Node.Node child, required AlignofExpression &parent)`	Finds the nearest enclosing `alignof_expression` ancestor of `child` and binds it to `&parent`.	This PQL defect checks for nodes that are inside an `alignof(...)` and returns the surrounding `alignof_expression`. defect parent_alignof = when Cpp.Node.is(&inner, &,&,&) and Cpp.AlignofExpression.getEnclosingAlignofExpression(inner, &ae) and ae.nodeText(&txt) raise "Enclosing alignof: {txt}" on ae In this C++ code, the defect finds nodes that have an enclosing parent `alignof(...)` and reports the violation on the parent #include <cstddef> int v = alignof(unsigned long); int main() { return v; }
`isEnclosedInAlignofExpression(Cpp.Node.Node child)`	Returns true when `child` has an `alignof_expression` ancestor; useful to detect usage contexts within `alignof(...)`.	This PQL defect checks for any node that lives inside an `alignof(...)` expression. defect inside_alignof = when Cpp.Node.is(&n, &,&,&) and Cpp.AlignofExpression.isEnclosedInAlignofExpression(n) and n.nodeText(&txt) raise "Node inside alignof: {txt}" on n In this C++ code, the defect detects the identifier or type node that appears within an `alignof(...)` expression. #include <cstddef> int u = alignof(int); int main() { return u; }

Version History

Introduced in R2026a