Cpp.DeleteExpression Class

Namespace: Cpp
Superclasses: AstNodeProperties

Represents the delete_expression nodes in the syntax tree of your code

Since R2026a

Description

The PQL class DeleteExpression represents the node delete_expression in the syntax tree of your code.

// example demonstrating delete_expression nodes
#include <iostream>

void f() {
    int *p = new int(42);
    delete p;           // delete_expression (non-array)
    int *a = new int[10];
    delete[] a;         // delete_expression (array form)
}

The two delete statements correspond to delete_expression nodes; the single-object form (delete p) and array form (delete[] a) are both matched by DeleteExpression.

Predicates

Type

Type	Raisable	Printable
DeleteExpression	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 DeleteExpression &de)	Matches a delete_expression node and returns it as de; use this to directly select delete operations.	This PQL defect checks for any delete_expression nodes. defect find_delete = when Cpp.DeleteExpression.is(&de) and de.nodeText(&txt) raise "Found delete expression: {txt}" on de In this C++ code, the defect finds both the single-object and array delete statements. #include <cstdlib> int main() { int *p = new int; delete p; int *a = new int[5]; delete[] a; return 0; }
cast(Cpp.Node.Node node, required DeleteExpression &cast)	Checks whether a generic Cpp.Node.Node is a delete_expression; if yes, returns it as cast. Useful when you start from a generic node and need delete-specific queries.	This PQL defect checks whether a given general node is a delete_expression. defect cast_to_delete = when Cpp.Node.is(&node, &,&,&) and Cpp.DeleteExpression.cast(node, &de) and de.nodeText(&txt) raise "Node is a delete expression: {txt}" on de In this C++ code, the defect identifies the node corresponding to delete p; by first treating it as a generic node then casting. #include <memory> struct S { void g() { int *p = new int; delete p; } }; int main() { S s; s.g(); }
isa(Cpp.Node.Node node)	Returns true when the provided generic node is a delete_expression (boolean check); use it for presence/absence tests or negation.	This PQL defect checks nodes to see if they are delete_expression nodes (boolean check). defect is_delete_bool = when Cpp.Node.is(&n, &,&,&) and Cpp.DeleteExpression.isa(n) and n.nodeText(&txt) raise "isa confirms delete_expression: {txt}" on n In this C++ code, the isa predicate detects the delete[] a; node as a delete_expression. int main() { int *a = new int[3]; delete[] a; return 0; }
expression(DeleteExpression self, Cpp.Node.Node &child)	Retrieves the operand expression inside the delete (the thing being deleted), e.g., the pointer expression.	This PQL defect checks for the operand expression used in a delete_expression. defect delete_operand = when Cpp.DeleteExpression.is(&de) and de.expression(&expr) and expr.nodeText(&txt) raise "Delete operand text: {txt}" on de In this C++ code, the defect extracts the identifier p used as the operand of delete p;. #include <iostream> void demo() { int *p = new int(7); delete p; // operand is 'p' } int main(){ demo(); }
getEnclosingDeleteExpression(Cpp.Node.Node child, required DeleteExpression &parent)	Finds the nearest surrounding delete_expression that encloses the given child node; useful when you start from a subnode (e.g., an identifier) and need the enclosing delete.	This PQL defect checks for the closest delete_expression ancestor of a given node. defect enclosing_delete = when Cpp.Node.is(&node, &,&,&) and Cpp.DeleteExpression.getEnclosingDeleteExpression(node, &de) and node.nodeText(&iname) and de.nodeText(&dtext) raise "Node {iname} is inside delete: {dtext}" on id In this C++ code, the defect finds a delete expression that encloses a generic syntax node. int main() { int *p = new int; delete p; // identifier 'p' is enclosed by this delete_expression return 0; }
isEnclosedInDeleteExpression(Cpp.Node.Node child)	Returns true if the given node has any delete_expression ancestor; use this to detect code elements that appear within a delete operation.	This PQL defect checks whether a node appears inside a delete_expression. defect inside_delete_check = when Cpp.Node.is(&node, &,&,&) and Cpp.DeleteExpression.isEnclosedInDeleteExpression(node) and node.nodeText(&txt) raise "Identifier {txt} is inside a delete expression" on id In this C++ code, the defect identifies all syntax nodes that are descendent of a delete expression. int main() { int *a = new int[4]; delete[] a; // 'a' is enclosed in a delete_expression return 0; }

Version History

Introduced in R2026a