Cpp.LambdaExpression Class

Namespace: Cpp
Superclasses: AstNodeProperties

Represents the lambda_expression nodes in the syntax tree of your code

Since R2026a

Description

The PQL class Cpp.LambdaExpression represents the node lambda_expression in the syntax tree of your code.

#include <functional>

int main() {
    auto l1 = []() { return 42; };
    auto l2 = [x, &y]() { return x + y; };
    auto l3 = []<typename T>(T x) { return x; };
    auto l4 = []() requires true { return 0; };
    auto l5 = [](int x) mutable -> int { return x; };
    (void)l1; (void)l2; (void)l3; (void)l4; (void)l5;
}

The code declares several lambda expressions; each lambda corresponds to a lambda_expression node that Cpp.LambdaExpression models.

Predicates

expand all

Type

Type	Raisable	Printable
`LambdaExpression`	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 LambdaExpression &le)`	Checks whether a syntax node is a `lambda_expression` and binds it to `le` for further queries.	This PQL defect checks for any lambda expression node. defect find_lambda = when Cpp.LambdaExpression.is(&le) and le.nodeText(&txt) raise "found lambda: \"{txt}\"" on le In this C++ code, the defect finds any lambda expression declaration. int main() { auto l = [](){ return 1; }; (void)l; }
`cast(Cpp.Node.Node node, required LambdaExpression &cast)`	If `node` is a `lambda_expression` then convert it to a `Cpp.LambdaExpression` and bind it to `cast`.	This PQL defect checks whether an arbitrary node is a lambda and casts it to `LambdaExpression`. defect cast_from_node = when Cpp.Node.is(&node, &,&,&) and Cpp.LambdaExpression.cast(node, &le) and le.nodeText(&txt) raise "casted node to lambda: \"{txt}\"" on le In this C++ code, the defect tests a generic node and reports when that node is a lambda expression. int main() { auto lambda = [](){}; (void)lambda; }
`isa(Cpp.Node.Node node)`	True when `node` is a `lambda_expression` node; can be used to filter or negate matches.	This PQL defect checks whether a generic node is a lambda expression using `isa`. defect check_isa = when Cpp.Node.is(&node, &,&,&) and Cpp.LambdaExpression.isa(node) raise "node is a lambda" on node In this C++ code, the defect identifies the lambda expression node among other nodes. int main() { auto f = [](int){}; (void)f; }
`body(LambdaExpression self, Cpp.Node.Node &child)`	Retrieves the lambda's function body block or expression and binds it to `child`.	This PQL defect checks for the body node inside a lambda expression. defect lambda_body = when Cpp.LambdaExpression.is(&le) and le.body(&body) and body.nodeText(&txt) raise "lambda body: \"{txt}\"" on le In this C++ code, the defect extracts and reports the `{ ... }` body of the lambda. int main() { auto l = [](){ return 42; }; (void)l; }
`captures(LambdaExpression self, Cpp.Node.Node &child)`	Matches the capture list of the lambda and binds that capture node to `child`.	This PQL defect checks for the capture clause of a lambda. defect lambda_captures = when Cpp.LambdaExpression.is(&le) and le.captures(&cap) and cap.nodeText(&txt) raise "lambda captures: \"{txt}\"" on le In this C++ code, the defect finds and reports the capture list like `[x, &y]`. int main() { int x = 1, y = 2; auto l = [x, &y]() { return x + y; }; (void)l; }
`constraint(LambdaExpression self, Cpp.Node.Node &child)`	Matches the requires-clause or constraint on a templated or constrained lambda and binds it to `child`.	This PQL defect checks for a `requires` constraint attached to a lambda. defect lambda_constraint = when Cpp.LambdaExpression.is(&le) and le.constraint(&c) and c.nodeText(&txt) raise "lambda constraint: \"{txt}\"" on le In this C++ code, the defect finds the `requires` clause on the lambda. int main() { auto l = []() requires true { return 0; }; (void)l; }
`declarator(LambdaExpression self, Cpp.Node.Node &child)`	Matches the lambda's parameter list, mutable specifier and trailing return type and binds that part to `child`.	This PQL defect checks for the declarator portion of a lambda such as parameters, `mutable`, and `->` return. defect lambda_declarator = when Cpp.LambdaExpression.is(&le) and le.declarator(&d) and d.nodeText(&txt) raise "lambda declarator: \"{txt}\"" on le In this C++ code, the defect reports the `(int x) mutable -> int` declarator of the lambda. int main() { auto l = [](int x) mutable -> int { return x; }; (void)l; }
`template_parameters(LambdaExpression self, Cpp.Node.Node &child)`	Matches the template parameter list of a templated lambda and binds it to `child`.	This PQL defect checks for template parameters on a lambda such as `<>` before the parameter list. defect lambda_template_params = when Cpp.LambdaExpression.is(&le) and le.template_parameters(&tp) and tp.nodeText(&txt) raise "lambda template parameters: \"{txt}\"" on le In this C++ code, the defect finds the `template` parameter list `<typename T>` for the lambda. int main() { auto l = []<typename T>(T x){ return x; }; (void)l; }
`getEnclosingLambdaExpression(Cpp.Node.Node child, required LambdaExpression &parent)`	Finds the nearest enclosing `lambda_expression` ancestor of `child` and binds it to `parent`.	This PQL defect checks for the closest lambda that encloses a given inner node. defect enclosing_lambda = when Cpp.ReturnStatement.is(&ret) and ret.toNode(&node) and Cpp.LambdaExpression.getEnclosingLambdaExpression(node, &le) and le.nodeText(&txt) raise "enclosing lambda: \"{txt}\"" on le In this C++ code, the defect detects the lambda that directly contains a `return` statement. int main() { auto l = [](){ return 5; }; (void)l; }
`isEnclosedInLambdaExpression(Cpp.Node.Node child)`	True when `child` has a `lambda_expression` ancestor anywhere above it in the tree.	This PQL defect checks whether a given node sits inside any lambda expression. defect inside_lambda = when Cpp.ReturnStatement.is(&ret) and ret.toNode(&node) and Cpp.LambdaExpression.isEnclosedInLambdaExpression(node) raise "node is enclosed in a lambda" on node In this C++ code, the defect confirms that the `return` statement is inside the lambda body. int main() { auto l = [](){ return 7; }; (void)l; }

Version History

Introduced in R2026a