Cpp.SwitchStatement Class

Namespace: Cpp
Superclasses: AstNodeProperties

Represents the switch_statement nodes in the syntax tree of your code

Since R2026a

Description

The PQL class SwitchStatement represents the node switch_statement in the syntax tree of your code.

switch (value) {
    case 1:
        doSomething();
        break;
    default:
        break;
}

In this code, the switch_statement node corresponds to the overall switch construct in the C++ source.

Predicates

expand all

Type

Type	Raisable	Printable
`SwitchStatement`	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(SwitchStatement &switchStatement)`	The predicate `is` identifies if a syntax node represents a `SwitchStatement` in the C++ abstract syntax tree. For example: switch (x) { case 1: doSomething(); break; default: doDefault(); } The Tree-sitter node is `switch_statement`. The predicate `is` confirms that this node corresponds to a switch statement in the syntax tree.	This example demonstrates using the `SwitchStatement.is` predicate to match switch statements in a C++ file. The simple C++ snippet below would trigger the rule because it contains a switch statement: rule CheckSwitchIs = { defectSwitchIs } defect defectSwitchIs = when Cpp.SwitchStatement.is(&sw) and sw.nodeText(&txt) raise "SwitchStatement.is matched: '{txt}'" on sw
`isa(Ast.Node.Node node, SwitchStatement &cast)`	The predicate `is` identifies if a syntax node represents a `SwitchStatement` in the C++ abstract syntax tree. For example: switch (x) { case 1: doSomething(); break; default: doDefault(); } The Tree-sitter node is `switch_statement`. The predicate `is` confirms that this node corresponds to a switch statement in the syntax tree.	This example demonstrates using the `SwitchStatement.is` predicate to match switch statements in a C++ file. The simple C++ snippet below would trigger the rule because it contains a switch statement: rule CheckSwitchIs = { defectSwitchIs } defect defectSwitchIs = when Cpp.SwitchStatement.is(&sw) and sw.nodeText(&txt) raise "SwitchStatement.is matched: '{txt}'" on sw
`condition(SwitchStatement self, Ast.Node.Node &child)`	The `condition` predicate retrieves the expression used as the controlling condition of a switch statement. For example: switch (x) { case 1: break; } The equivalent tree-sitter node is `switch_statement`. The `condition` predicate applied to the `switch_statement` node matches the expression `x` inside the parentheses. This expression determines the value the switch compares against its cases.	This example demonstrates using the `SwitchStatement.condition` predicate to find switch statements and capture their controlling expression. The `C++` snippet below would trigger the rule because the switch has a condition expression (`x + 1`): int f(int x) { switch (x + 1) { case 1: return 0; default: return 1; } } The rule captures the switch node and the condition expression node and emits the condition text. rule CheckCondition = { defectCondition } defect defectCondition = when Cpp.SwitchStatement.is(&sw) and sw.condition(&cond) and cond.nodeText(&txt) raise "Switch condition matched: "{txt}"" on sw
`body(SwitchStatement self, Ast.Node.Node &child)`	The `body` predicate retrieves the block statement that forms the body of a switch statement. Example C++ code: switch (x) { case 1: doSomething(); break; default: doDefault(); } Equivalent tree-sitter node: (switch_statement condition: (identifier) ; corresponds to 'x' body: (compound_statement (case_statement ...) (default_statement ...))) The `body` predicate matches the `compound_statement` node that contains the cases inside the switch.	This example demonstrates using the `SwitchStatement.body` predicate to find switch statements and report the text of their body. The following `C++` snippet would trigger the rule because it contains a switch with a compound statement as its body: void f(int x) { switch (x) { case 1: break; default: break; } } rule CheckSwitchBody = { defectSwitchBody } defect defectSwitchBody = when Cpp.SwitchStatement.is(&sw) and sw.body(&body) // &body is an output binding to the switch body node and body.nodeText(&txt) raise "SwitchStatement.body matched: \"{txt}\"" on sw

is(SwitchStatement &switchStatement)

The predicate is identifies if a syntax node represents a SwitchStatement in the C++ abstract syntax tree.

For example:

switch (x) {
    case 1:
        doSomething();
        break;
    default:
        doDefault();
}

The Tree-sitter node is switch_statement. The predicate is confirms that this node corresponds to a switch statement in the syntax tree.

This example demonstrates using the SwitchStatement.is predicate to match switch statements in a C++ file. The simple C++ snippet below would trigger the rule because it contains a switch statement:

rule CheckSwitchIs = { defectSwitchIs }
defect defectSwitchIs =
    when
        Cpp.SwitchStatement.is(&sw)
        and sw.nodeText(&txt)
    raise "SwitchStatement.is matched: '{txt}'"
    on sw

isa(Ast.Node.Node node, SwitchStatement &cast)

The predicate is identifies if a syntax node represents a SwitchStatement in the C++ abstract syntax tree.

For example:

switch (x) {
    case 1:
        doSomething();
        break;
    default:
        doDefault();
}

The Tree-sitter node is switch_statement. The predicate is confirms that this node corresponds to a switch statement in the syntax tree.

rule CheckSwitchIs = { defectSwitchIs }
defect defectSwitchIs =
    when
        Cpp.SwitchStatement.is(&sw)
        and sw.nodeText(&txt)
    raise "SwitchStatement.is matched: '{txt}'"
    on sw

condition(SwitchStatement self, Ast.Node.Node &child)

The condition predicate retrieves the expression used as the controlling condition of a switch statement.

For example:

switch (x) {
  case 1:
    break;
}

The equivalent tree-sitter node is switch_statement. The condition predicate applied to the switch_statement node matches the expression x inside the parentheses. This expression determines the value the switch compares against its cases.

This example demonstrates using the SwitchStatement.condition predicate to find switch statements and capture their controlling expression. The C++ snippet below would trigger the rule because the switch has a condition expression (x + 1):

int f(int x) {
    switch (x + 1) {
        case 1: return 0;
        default: return 1;
    }
}

The rule captures the switch node and the condition expression node and emits the condition text.

rule CheckCondition = { defectCondition }
defect defectCondition =
    when
        Cpp.SwitchStatement.is(&sw)
        and sw.condition(&cond)
        and cond.nodeText(&txt)
    raise "Switch condition matched: "{txt}""
    on sw

body(SwitchStatement self, Ast.Node.Node &child)

The body predicate retrieves the block statement that forms the body of a switch statement.

Example C++ code:

switch (x) {
    case 1:
        doSomething();
        break;
    default:
        doDefault();
}

Equivalent tree-sitter node:

(switch_statement
  condition: (identifier) ; corresponds to 'x'
  body: (compound_statement
           (case_statement ...)
           (default_statement ...)))

The body predicate matches the compound_statement node that contains the cases inside the switch.

This example demonstrates using the SwitchStatement.body predicate to find switch statements and report the text of their body. The following C++ snippet would trigger the rule because it contains a switch with a compound statement as its body:

void f(int x) {
    switch (x) {
      case 1: break;
      default: break;
    }
}

rule CheckSwitchBody = { defectSwitchBody }
defect defectSwitchBody =
    when
        Cpp.SwitchStatement.is(&sw)
        and sw.body(&body)                     // &body is an output binding to the switch body node
        and body.nodeText(&txt)
    raise "SwitchStatement.body matched: \"{txt}\""
    on sw

Version History

Introduced in R2026a