Cpp.SwitchStatement Class

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

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

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

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