Ast.SubscriptArgumentList Class

Namespace: Ast
Superclasses: AstNodeProperties

Represents the subscript_argument_list nodes in the syntax tree of your code

Since R2026a

Description

The PQL class SubscriptArgumentList represents the node subscript_argument_list in the syntax tree of your code.

Predicates

Type

Type	Raisable	Printable
`SubscriptArgumentList`	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

Predicates	Description	Example
`is(SubscriptArgumentList &args)`	The `is` predicate matches a `subscript_argument_list` syntax node. This node represents the arguments inside the square brackets of an array subscript expression. For example: int arr[3] = {1, 2, 3}; int x = arr[1]; // subscript_argument_list node with a single expression argument int y = arr[{1, 2}]; // subscript_argument_list node with an initializer_list argument The `is` predicate identifies these nodes. This enables analysis of the subscript arguments.	This example demonstrates using the `SubscriptArgumentList.is` predicate to match subscript argument lists in `C++` code (e.g. `arr[1]` or `arr[{1,2}]`). The `C++` snippet below contains two index usages that will trigger the rule. /* C++ source (triggers the rule) / int arr[3] = {1,2,3}; int a = arr[1]; int b = arr[{1, 2}]; / PQL rule */ rule CheckSubscriptArgumentListIs = { defectSubscriptArgumentListIs } defect defectSubscriptArgumentListIs = when Cpp.SubscriptArgumentList.is(&sal) and sal.nodeText(&txt) raise "Matched SubscriptArgumentList.is: "{txt}"" on sal
`isa(Cpp.Node.Node node, SubscriptArgumentList &cast)`	The `is` predicate matches a `subscript_argument_list` syntax node. This node represents the arguments inside the square brackets of an array subscript expression. For example: int arr[3] = {1, 2, 3}; int x = arr[1]; // subscript_argument_list node with a single expression argument int y = arr[{1, 2}]; // subscript_argument_list node with an initializer_list argument The `is` predicate identifies these nodes. This enables analysis of the subscript arguments.	This example demonstrates using the `SubscriptArgumentList.is` predicate to match subscript argument lists in `C++` code (e.g. `arr[1]` or `arr[{1,2}]`). The `C++` snippet below contains two index usages that will trigger the rule. /* C++ source (triggers the rule) / int arr[3] = {1,2,3}; int a = arr[1]; int b = arr[{1, 2}]; / PQL rule */ rule CheckSubscriptArgumentListIs = { defectSubscriptArgumentListIs } defect defectSubscriptArgumentListIs = when Cpp.SubscriptArgumentList.is(&sal) and sal.nodeText(&txt) raise "Matched SubscriptArgumentList.is: "{txt}"" on sal
`expression(SubscriptArgumentList self, Cpp.Node.Node &child)`	The `is` predicate matches a `subscript_argument_list` syntax node. This node represents the arguments inside the square brackets of an array subscript expression. For example: int arr[3] = {1, 2, 3}; int x = arr[1]; // subscript_argument_list node with a single expression argument int y = arr[{1, 2}]; // subscript_argument_list node with an initializer_list argument The `is` predicate identifies these nodes. This enables analysis of the subscript arguments.	This example demonstrates using the `SubscriptArgumentList.is` predicate to match subscript argument lists in `C++` code (e.g. `arr[1]` or `arr[{1,2}]`). The `C++` snippet below contains two index usages that will trigger the rule. /* C++ source (triggers the rule) / int arr[3] = {1,2,3}; int a = arr[1]; int b = arr[{1, 2}]; / PQL rule */ rule CheckSubscriptArgumentListIs = { defectSubscriptArgumentListIs } defect defectSubscriptArgumentListIs = when Cpp.SubscriptArgumentList.is(&sal) and sal.nodeText(&txt) raise "Matched SubscriptArgumentList.is: "{txt}"" on sal
`initializerList(SubscriptArgumentList self, Cpp.Node.Node &child)`	The `is` predicate matches a `subscript_argument_list` syntax node. This node represents the arguments inside the square brackets of an array subscript expression. For example: int arr[3] = {1, 2, 3}; int x = arr[1]; // subscript_argument_list node with a single expression argument int y = arr[{1, 2}]; // subscript_argument_list node with an initializer_list argument The `is` predicate identifies these nodes. This enables analysis of the subscript arguments.	This example demonstrates using the `SubscriptArgumentList.is` predicate to match subscript argument lists in `C++` code (e.g. `arr[1]` or `arr[{1,2}]`). The `C++` snippet below contains two index usages that will trigger the rule. /* C++ source (triggers the rule) / int arr[3] = {1,2,3}; int a = arr[1]; int b = arr[{1, 2}]; / PQL rule */ rule CheckSubscriptArgumentListIs = { defectSubscriptArgumentListIs } defect defectSubscriptArgumentListIs = when Cpp.SubscriptArgumentList.is(&sal) and sal.nodeText(&txt) raise "Matched SubscriptArgumentList.is: "{txt}"" on sal

is(SubscriptArgumentList &args)

The is predicate matches a subscript_argument_list syntax node. This node represents the arguments inside the square brackets of an array subscript expression.

For example:

int arr[3] = {1, 2, 3};
int x = arr[1];         // subscript_argument_list node with a single expression argument
int y = arr[{1, 2}];    // subscript_argument_list node with an initializer_list argument

The is predicate identifies these nodes. This enables analysis of the subscript arguments.

This example demonstrates using the SubscriptArgumentList.is predicate to match subscript argument lists in C++ code (e.g. arr[1] or arr[{1,2}]). The C++ snippet below contains two index usages that will trigger the rule.

/* C++ source (triggers the rule) */
int arr[3] = {1,2,3};
int a = arr[1];
int b = arr[{1, 2}];

/* PQL rule */
rule CheckSubscriptArgumentListIs = { defectSubscriptArgumentListIs }
defect defectSubscriptArgumentListIs =
    when
        Cpp.SubscriptArgumentList.is(&sal)
        and sal.nodeText(&txt)
    raise "Matched SubscriptArgumentList.is: "{txt}""
    on sal

isa(Cpp.Node.Node node, SubscriptArgumentList &cast)

The is predicate matches a subscript_argument_list syntax node. This node represents the arguments inside the square brackets of an array subscript expression.

For example:

int arr[3] = {1, 2, 3};
int x = arr[1];         // subscript_argument_list node with a single expression argument
int y = arr[{1, 2}];    // subscript_argument_list node with an initializer_list argument

The is predicate identifies these nodes. This enables analysis of the subscript arguments.

/* C++ source (triggers the rule) */
int arr[3] = {1,2,3};
int a = arr[1];
int b = arr[{1, 2}];

/* PQL rule */
rule CheckSubscriptArgumentListIs = { defectSubscriptArgumentListIs }
defect defectSubscriptArgumentListIs =
    when
        Cpp.SubscriptArgumentList.is(&sal)
        and sal.nodeText(&txt)
    raise "Matched SubscriptArgumentList.is: "{txt}""
    on sal

expression(SubscriptArgumentList self, Cpp.Node.Node &child)

The is predicate matches a subscript_argument_list syntax node. This node represents the arguments inside the square brackets of an array subscript expression.

For example:

int arr[3] = {1, 2, 3};
int x = arr[1];         // subscript_argument_list node with a single expression argument
int y = arr[{1, 2}];    // subscript_argument_list node with an initializer_list argument

The is predicate identifies these nodes. This enables analysis of the subscript arguments.

/* C++ source (triggers the rule) */
int arr[3] = {1,2,3};
int a = arr[1];
int b = arr[{1, 2}];

/* PQL rule */
rule CheckSubscriptArgumentListIs = { defectSubscriptArgumentListIs }
defect defectSubscriptArgumentListIs =
    when
        Cpp.SubscriptArgumentList.is(&sal)
        and sal.nodeText(&txt)
    raise "Matched SubscriptArgumentList.is: "{txt}""
    on sal

initializerList(SubscriptArgumentList self, Cpp.Node.Node &child)

The is predicate matches a subscript_argument_list syntax node. This node represents the arguments inside the square brackets of an array subscript expression.

For example:

int arr[3] = {1, 2, 3};
int x = arr[1];         // subscript_argument_list node with a single expression argument
int y = arr[{1, 2}];    // subscript_argument_list node with an initializer_list argument

The is predicate identifies these nodes. This enables analysis of the subscript arguments.

/* C++ source (triggers the rule) */
int arr[3] = {1,2,3};
int a = arr[1];
int b = arr[{1, 2}];

/* PQL rule */
rule CheckSubscriptArgumentListIs = { defectSubscriptArgumentListIs }
defect defectSubscriptArgumentListIs =
    when
        Cpp.SubscriptArgumentList.is(&sal)
        and sal.nodeText(&txt)
    raise "Matched SubscriptArgumentList.is: "{txt}""
    on sal

Version History

Introduced in R2026a