Cpp.OffsetofExpression Class

Namespace: Cpp
Superclasses: AstNodeProperties

Represents the offsetof_expression nodes in the syntax tree of your code

Since R2026a

Description

The PQL class Cpp.OffsetofExpression represents the node offsetof_expression in the syntax tree of your code. It models an offsetof(type, member) expression in C/C++.

#include <cstddef>

struct MyStruct {
  int field;
  double anotherField;
};

void foo() {
  std::size_t offset1 = offsetof(MyStruct, field);
  std::size_t offset2 = offsetof(MyStruct, anotherField);
}

The two offsetof(MyStruct, ...) expressions in foo correspond to offsetof_expression nodes and are the nodes matched by Cpp.OffsetofExpression class.

Predicates

Type

Type	Raisable	Printable
OffsetofExpression	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 OffsetofExpression &oe)	Checks whether a node in the query is an offsetof_expression and binds it to oe. Use it to start working directly with an offsetof node.	This PQL defect checks for any offsetof expression node. defect find_offsetof = when Cpp.OffsetofExpression.is(&oe) and oe.nodeText(&txt) raise "Found offsetof: \"{txt}\"" on oe In this C++ code, the defect finds each offsetof(MyStruct, ...) call in the function. #include <cstddef> struct MyStruct { int field; }; int main() { std::size_t o = offsetof(MyStruct, field); (void)o; return 0; }
cast(Cpp.Node.Node node, required OffsetofExpression &cast)	Binds cast to the offsetof_expression if the given node is such an expression. Use when you already have a generic Node and need the specific OffsetofExpression.	This PQL defect checks for an offsetof node within the descendant nodes of a compound statement. defect cast_node_to_offsetof = when Cpp.CompoundStatement.is(&cs) and cs.getADescendant(&node) and Cpp.OffsetofExpression.cast(node, &oe) and oe.nodeText(&txt) raise "Cast to offsetof matched: \"{txt}\"" on oe In this C++ code, the defect finds the offsetofstatement in within a compound statement. #include <cstddef> struct S { int a; }; int main() { std::size_t off = offsetof(S, a); (void)off; return 0; }
isa(Cpp.Node.Node node)	Returns true if the given generic node is an offsetof_expression. Use in boolean checks or negations where you have a Node.	This PQL defect checks for offsetof nodes among generic syntax nodes using the isa predicate. defect cast_node_to_offsetof = when Cpp.CompoundStatement.is(&cs) and cs.getADescendant(&node) and Cpp.OffsetofExpression.isa(node) and node.nodeText(&txt) raise " offsetof matched: \"{txt}\"" on node In this C++ code, the defect finds the offsetofstatement in within a compound statement. #include <cstddef> struct T { double x; }; int main() { std::size_t o = offsetof(T, x); (void)o; return 0; }
type(OffsetofExpression self, Cpp.Node.Node &child)	Binds child to the type node used as the first argument of the offsetof. Use it to inspect the type whose member offset is taken.	This PQL defect checks for the type component inside an offsetof expression. defect offsetof_type = when Cpp.OffsetofExpression.is(&oe) and oe.type(&tp) and tp.nodeText(&txt) raise "offsetof type: \"{txt}\"" on oe In this C++ code, the defect extracts MyStruct as the type argument of offsetof(MyStruct, field). #include <cstddef> struct MyStruct { int field; }; int main() { std::size_t x = offsetof(MyStruct, field); (void)x; return 0; }
member(OffsetofExpression self, Cpp.Node.Node &child)	Binds child to the member node used as the second argument of the offsetof. Use it to inspect which member's offset is requested.	This PQL defect checks for the member identifier inside an offsetof expression. defect offsetof_member = when Cpp.OffsetofExpression.is(&oe) and oe.member(&mb) and mb.nodeText(&txt) raise "offsetof member: \"{txt}\"" on oe In this C++ code, the defect extracts field as the member argument of offsetof(MyStruct, field). #include <cstddef> struct MyStruct { int field; }; int main() { std::size_t y = offsetof(MyStruct, field); (void)y; return 0; }
getEnclosingOffsetofExpression(Cpp.Node.Node child, required OffsetofExpression &parent)	Finds the nearest offsetof_expression ancestor of child and binds it to parent. Use it when you have a subnode and need the surrounding offsetof.	This PQL defect checks for an offsetof expression that encloses a type identifier subnode. defect find_enclosing_offsetof = when Cpp.TypeIdentifier.is(&id) and id.toNode(&node) and Cpp.OffsetofExpression.getEnclosingOffsetofExpression(node, &oe) and oe.nodeText(&txt) raise "Enclosing offsetof: \"{txt}\"" on oe In this C++ code, the defect starts from the type identifier node MyStruct and finds the enclosing offsetof(MyStruct, field) expression. #include <cstddef> struct MyStruct { int field; }; int main() { std::size_t z = offsetof(MyStruct, field); (void)z; return 0; }
isEnclosedInOffsetofExpression(Cpp.Node.Node child)	Returns true when the given child node has an offsetof_expression as an ancestor. Use it to test whether a node appears inside an offsetof.	This PQL defect checks whether a node is inside any offsetof expression. defect inside_offsetof = when Cpp.FieldIdentifier.is(&id) and id.toNode(&node) and Cpp.OffsetofExpression.isEnclosedInOffsetofExpression(node) raise "Field Identifier is inside an offsetof" on node In this C++ code, the defect detects that the identifier field occurs inside the offsetof(MyStruct, field) call. #include <cstddef> struct MyStruct { int field; }; int main() { std::size_t k = offsetof(MyStruct, field); (void)k; return 0; }

Version History

Introduced in R2026a