Cpp.NewExpression Class

Namespace: Cpp
Superclasses: AstNodeProperties

Represents the new_expression nodes in the syntax tree of your code

Since R2026a

Description

The PQL class Cpp.NewExpression represents the node new_expression in the syntax tree of your code.

struct MyClass {
  MyClass(int, int) {}
};
void foo() {
  int *a = new int;
  int *b = new int[10];
  MyClass *c = new MyClass(1, 2);
  MyClass *d = new(ptr) MyClass;
}

The example contains four new_expression occurrences. Each new expression in the code corresponds to a Cpp.NewExpression node.

Predicates

Type

Type	Raisable	Printable
NewExpression	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 NewExpression &ne)	Matches a new_expression node and binds it to ne. Use this to select new expressions directly.	This PQL defect checks for new_expression nodes in a translation unit. defect find_new = when Cpp.NewExpression.is(&ne) raise "Found new expression" on ne In this C++ code the defect finds each new expression used for dynamic allocation. void f() { int *p = new int; }
cast(Cpp.Node.Node node, required NewExpression &cast)	Checks whether the given node is a new_expression and if so binds that new_expression to cast. Use this to narrow a generic node to a new_expression.	This PQL defect checks whether a node within a declaration statement is a new_expression. defect cast_to_new = when Cpp.Declaration.is(&decl) and decl.getADescendant(&node) and Cpp.NewExpression.cast(node, &ne) raise "Identifier's node is a new expression" on ne In this C++ code the defect finds new expressions that are part of declarations. void g() { int *p = new int; // new in declaration }
isa(Cpp.Node.Node node)	True when the given node is a new_expression. Use this in boolean tests or negations to filter nodes.	This PQL defect checks whether a node that is a descendant of a declaration is also a new_expression. defect is_new_node = when Cpp.Declaration.is(&decl) and decl.getADescendant(&node) and Cpp.NewExpression.isa(node) raise "Node is a new expression" on node In this C++ code the defects flags new expressions within a declaration. void h() { int *p = new int; }
arguments(NewExpression self, Cpp.Node.Node &child)	Matches the argument list of a new_expression and binds the parentheses content node to child.	This PQL defect checks for new_expression nodes that supply constructor arguments. defect new_with_args = when Cpp.NewExpression.is(&ne) and ne.arguments(&args) raise "new expression has arguments" on args In this C++ code the defect finds the new that constructs MyClass with two integer arguments. struct MyClass { MyClass(int, int) {} }; void i() { MyClass *m = new MyClass(1, 2); // arguments = (1, 2) }
declarator(NewExpression self, Cpp.Node.Node &child)	Matches the array declarator portion of a new_expression and binds the size/index expression node to child.	This PQL defect checks for new_expression nodes that allocate arrays with a declarator. defect new_array = when Cpp.NewExpression.is(&ne) and ne.declarator(&decl) raise "new expression has declarator" on decl In this C++ code the defect finds the new that allocates an array of 10 integers. void j() { int *arr = new int[10]; // declarator = [10] }
placement(NewExpression self, Cpp.Node.Node &child)	Matches the placement arguments of a placement new and binds the placement list node to child.	This PQL defect checks for new_expression nodes that use placement syntax. defect placement_new = when Cpp.NewExpression.is(&ne) and ne.placement(&plc) raise "placement new used" on plc In this C++ code the defect detects the placement new that supplies a pointer as placement. #include <new> class MyClass{}; void k(void *ptr) { MyClass *m = new(ptr) MyClass; // placement = (ptr) }
type(NewExpression self, Cpp.Node.Node &child)	Matches the allocated type portion of a new_expression and binds the type node to child.	This PQL defect checks which type is being allocated by a new_expression. defect new_type = when Cpp.NewExpression.is(&ne) and ne.type(&typ) raise "new allocates type" on typ In this C++ code the defect identifies the int and MyClass types being allocated with new. struct MyClass {}; void l() { int *p = new int; // type = int MyClass *m = new MyClass; // type = MyClass }
getEnclosingNewExpression(Cpp.Node.Node child, required NewExpression &parent)	Finds the nearest ancestor new_expression that encloses the given child node and binds it to parent.	This PQL defect checks for the closest new_expression ancestor of a type identifier. defect enclosing_new = when Cpp.TypeIdentifier.is(&id) and id.toNode(&node) and Cpp.NewExpression.getEnclosingNewExpression(node, &ne) raise "Type Identifier is inside a new expression" on ne In this C++ code the defect finds the new expression that encloses a type identifier such as MyClass. struct MyClass { MyClass(int x) {} }; void m() { MyClass *mobj = new MyClass(42); // MyClass is enclosed by the new expression }
isEnclosedInNewExpression(Cpp.Node.Node child)	True when the given child node has any ancestor that is a new_expression. Use this to test whether a node is located inside a new.	This PQL defect checks whether a type identifier node lies anywhere within a new_expression. defect inside_new = when Cpp.TypeIdentifier.is(&id) and id.toNode(&node) and Cpp.NewExpression.isEnclosedInNewExpression(node) raise "Node is inside a new expression" on node In this C++ code the defect detects that a type identifier such as MyClass is enclosed in a new expression. struct MyClass { MyClass(int) {} }; void n() { MyClass *m = new MyClass(5); // MyClass is enclosed in the new expression }

Version History

Introduced in R2026a