=====================================
Return constant
=====================================

class A {
  int Sample() {
    return 1;
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (predefined_type)
      (identifier)
      (parameter_list)
      (block
        (return_statement (integer_literal)))))))

=====================================
Return nothing
=====================================

class A {
  void Sample() {
    return;
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list
      (method_declaration
        (void_keyword)
        (identifier)
        (parameter_list)
        (block
          (return_statement))))))

=====================================
Break statement
=====================================

class A {
  void Sample() {
    while (true) break;
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list
      (method_declaration
        (void_keyword)
        (identifier)
        (parameter_list)
        (block
          (while_statement (boolean_literal)
            (break_statement)))))))

=====================================
Continue statement
=====================================

class A {
  void Sample() {
    while (false) continue;
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (void_keyword)
      (identifier)
      (parameter_list)
      (block
        (while_statement (boolean_literal)
          (continue_statement)))))))

=====================================
Throw nothing
=====================================

class A {
  void Sample() {
    throw;
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (void_keyword)
      (identifier)
      (parameter_list)
      (block
        (throw_statement))))))

=====================================
Throw exception
=====================================

class A {
  void Sample() {
    throw ex;
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (void_keyword)
      (identifier)
      (parameter_list)
      (block
        (throw_statement (identifier)))))))

=====================================
Do while
=====================================

class A {
  void Sample(bool a) {
    do { } while (a);
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (void_keyword)
      (identifier)
      (parameter_list
        (parameter (predefined_type) (identifier)))
      (block
        (do_statement
          (block)
          (identifier)))))))

=====================================
Goto statement and label
=====================================

class A {
  void Sample() {
    goto end;
    end:
      return;
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (void_keyword)
      (identifier)
      (parameter_list)
      (block
        (goto_statement (label_name))
        (labeled_statement
          (label_name) (return_statement)))))))

=====================================
If statement
=====================================

class A {
  int Sample() {
    if (true) return 1;
  }
}

---

(compilation_unit
  (class_declaration
    name: (identifier)
    body: (declaration_list (method_declaration
      type: (predefined_type)
      name: (identifier)
      parameters: (parameter_list)
      body: (block
        (if_statement
          condition: (boolean_literal)
          consequence: (return_statement (integer_literal))))))))

=====================================
If Else statement
=====================================

class A {
  int Sample() {
    if (true) return 1;
    else return 0;
  }
}

---

(compilation_unit
  (class_declaration
    name: (identifier)
    body: (declaration_list (method_declaration
      type: (predefined_type)
      name: (identifier)
      parameters: (parameter_list)
      body: (block
        (if_statement
          condition: (boolean_literal)
          consequence: (return_statement (integer_literal))
          alternative: (return_statement (integer_literal))))))))

=====================================
Switch statement
=====================================

class A {
  int Sample(int a) {
    switch (a) {
      case 1:
      case 2:
        return 0;
      default: {
        return 1;
      }
    }
  }
}

---

(compilation_unit
  (class_declaration
    name: (identifier)
    body: (declaration_list (method_declaration
      type: (predefined_type)
      name: (identifier)
      parameters: (parameter_list
        (parameter
          type: (predefined_type)
          name: (identifier)))
      body: (block
        (switch_statement
          value: (identifier)
          body: (switch_body
            (switch_section
              (case_switch_label (integer_literal))
              (case_switch_label (integer_literal))
              (return_statement (integer_literal)))
            (switch_section
              (default_switch_label)
              (block
                (return_statement (integer_literal)))))))))))

=====================================
Try finally statement
=====================================

class A {
  void Sample() {
    try {
    } finally {
    }
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (void_keyword)
      (identifier)
      (parameter_list)
      (block
        (try_statement
          (block)
          (finally_clause
            (block))))))))

=====================================
Try catch statement
=====================================

class A {
  void Sample() {
    try {
    } catch (Exception ex) {
    }
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (void_keyword)
      (identifier)
      (parameter_list)
      (block
        (try_statement
          (block)
          (catch_clause
            (catch_declaration (identifier) (identifier))
            (block))))))))

=====================================
Try catch finally statement
=====================================

class A {
  void Sample() {
    try {
    } catch (Exception ex) {
    } finally {
    }
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (void_keyword)
      (identifier)
      (parameter_list)
      (block
        (try_statement
          (block)
          (catch_clause
            (catch_declaration (identifier) (identifier))
            (block))
          (finally_clause
            (block))))))))

=====================================
Try catch multiple statement
=====================================

class A {
  void Sample() {
    try {
    } catch (Exception ex) {
    } catch (OtherException ex) {
    }
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (void_keyword)
      (identifier)
      (parameter_list)
      (block
        (try_statement
          (block)
          (catch_clause
            (catch_declaration (identifier) (identifier))
            (block))
          (catch_clause
            (catch_declaration (identifier) (identifier))
            (block))))))))

=====================================
Try catch filtered statement
=====================================

class A {
  void Sample() {
    try {
    } catch (Exception ex) when (a == 1) {
    }
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (void_keyword)
      (identifier)
      (parameter_list)
      (block
        (try_statement
          (block)
          (catch_clause
            (catch_declaration (identifier) (identifier))
            (catch_filter_clause (binary_expression (identifier) (integer_literal)))
            (block))))))))

=====================================
Checked statement
=====================================

class A {
  void Sample() {
    checked {
      return;
    }
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (void_keyword)
      (identifier)
      (parameter_list)
      (block
        (checked_statement
          (block
            (return_statement))))))))

=====================================
Unchecked statement
=====================================

class A {
  void Sample() {
    unchecked {
      return;
    }
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (void_keyword)
      (identifier)
      (parameter_list)
      (block
        (checked_statement
          (block
            (return_statement))))))))

=====================================
Lock statement
=====================================

class A {
  void Sample() {
    lock (this) {
      return;
    }
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (void_keyword)
      (identifier)
      (parameter_list)
      (block
        (lock_statement
          (this_expression)
          (block
            (return_statement))))))))

=====================================
Yield statement
=====================================

class A {
  IEnumerable<int> Sample() {
    yield return 1;
    yield break;
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (generic_name
        (identifier)
        (type_argument_list (predefined_type)))
      (identifier)
      (parameter_list)
      (block
        (yield_statement (integer_literal))
        (yield_statement))))))

=====================================
Implicit local variable with literal initializer
=====================================

class A {
  void Sample() {
    var a = 1;
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (void_keyword)
      (identifier)
      (parameter_list)
      (block
        (local_declaration_statement
          (variable_declaration
            (implicit_type)
            (variable_declarator
              (identifier)
              (equals_value_clause
                (integer_literal))))))))))

=====================================
Method with static local function block
=====================================

class A {
  void Sample() {
    private void A<T1, T2>(T1 a, T2 b) where T1:I1 {
      return a + b;
    }

    private static int X() {
      return 1;
    }
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list
      (method_declaration (void_keyword) (identifier) (parameter_list)
      (block
        (local_function_statement (modifier) (void_keyword) (identifier)
          (type_parameter_list
            (type_parameter (identifier))
            (type_parameter (identifier)))
          (parameter_list
            (parameter (identifier) (identifier))
            (parameter (identifier) (identifier)))
          (type_parameter_constraints_clause (identifier)
            (type_parameter_constraint (type_constraint (identifier))))
          (block
            (return_statement (binary_expression (identifier) (identifier)))))
        (local_function_statement (modifier) (modifier) (predefined_type) (identifier) (parameter_list)
          (block
            (return_statement (integer_literal)))))))))

=====================================
Method with local expression bodied function
=====================================

class A {
  void Sample() {
    void A<T1, T2>(T1 a, T2 b) => Test(a, b);
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (void_keyword)
      (identifier)
      (parameter_list)
      (block
        (local_function_statement (void_keyword) (identifier)
          (type_parameter_list
            (type_parameter (identifier))
            (type_parameter (identifier)))
          (parameter_list
            (parameter (identifier) (identifier))
            (parameter (identifier) (identifier)))
          (arrow_expression_clause
            (invocation_expression (identifier)
              (argument_list
                (argument (identifier))
                (argument (identifier)))))))))))

=====================================
Explicit local variable with no initializer
=====================================

class A {
  void Sample() {
    int a;
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (void_keyword)
      (identifier)
      (parameter_list)
      (block
        (local_declaration_statement
          (variable_declaration
            (predefined_type)
            (variable_declarator
              (identifier)))))))))

=====================================
Explicit local variables with multiple literal initializers
=====================================

class A {
  void Sample() {
    int a = 1, b = 2;
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (void_keyword)
      (identifier)
      (parameter_list)
      (block
        (local_declaration_statement
          (variable_declaration
            (predefined_type)
            (variable_declarator
              (identifier)
              (equals_value_clause
                (integer_literal)))
            (variable_declarator
              (identifier)
              (equals_value_clause
                (integer_literal))))))))))

=====================================
Explicit local constant with literal initializer
=====================================

class A {
  void Sample() {
    const int a = 1;
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (void_keyword)
      (identifier)
      (parameter_list)
      (block
        (local_declaration_statement
          (modifier)
          (variable_declaration
            (predefined_type)
              (variable_declarator (identifier)
                (equals_value_clause
                  (integer_literal))))))))))

=====================================
Explicit local constant with multiple literal initializers
=====================================

class A {
  void Sample() {
    const int a = 1, b = 2;
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (void_keyword)
      (identifier)
      (parameter_list)
      (block
        (local_declaration_statement
          (modifier)
          (variable_declaration
            (predefined_type)
              (variable_declarator (identifier)
                (equals_value_clause
                  (integer_literal)))
              (variable_declarator (identifier)
                (equals_value_clause
                  (integer_literal))))))))))

=====================================
Using statement with implicit local variable
=====================================

class A {
  void Sample() {
    using (var a = b) {
      return;
    }
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (void_keyword)
      (identifier)
      (parameter_list)
      (block
        (using_statement
          (variable_declaration
            (implicit_type)
            (variable_declarator
              (identifier)
              (equals_value_clause
                (identifier))))
          (block
            (return_statement))))))))

=====================================
Using statement with explicit local variable
=====================================

class A {
  void Sample() {
    using (Object a = b) {
      return;
    }
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (void_keyword)
      (identifier)
      (parameter_list)
      (block
        (using_statement
          (variable_declaration
            (identifier)
            (variable_declarator
              (identifier)
              (equals_value_clause
                (identifier))))
          (block
            (return_statement))))))))

=====================================
Using statement with expression
=====================================

class A {
  void Sample() {
    using (this) {
      return;
    }
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (void_keyword)
      (identifier)
      (parameter_list)
      (block
        (using_statement
          (this_expression)
          (block
            (return_statement))))))))

=====================================
Foreach inline declaration
=====================================

class A {
  void Sample() {
    foreach(int x in y)
      z += x;
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (void_keyword)
      (identifier)
      (parameter_list)
      (block
        (for_each_statement
          (predefined_type)
          (identifier)
          (identifier)
          (expression_statement
            (assignment_expression
              (identifier)
              (assignment_operator)
              (identifier)))))))))

=====================================
Foreach existing expression
=====================================

class A {
  void Sample() {
    foreach(x in y)
      z += x;
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (void_keyword)
      (identifier)
      (parameter_list)
      (block
        (for_each_statement
          (identifier)
          (identifier)
          (expression_statement
            (assignment_expression
              (identifier)
              (assignment_operator)
              (identifier)))))))))

=====================================
Unsafe statement
=====================================

class A {
  void Sample() {
    unsafe { x = y; }
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (void_keyword)
      (identifier)
      (parameter_list)
      (block
        (unsafe_statement
          (block
            (expression_statement
              (assignment_expression
                (identifier)
                (assignment_operator)
                (identifier))))))))))

=====================================
Fixed statement
=====================================

class A {
  void Sample() {
    fixed (double p = arr) { }
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (void_keyword)
      (identifier)
      (parameter_list)
      (block
        (fixed_statement
          (variable_declaration
            (predefined_type)
            (variable_declarator
              (identifier)
              (equals_value_clause
                (identifier))))
                (block)))))))

=====================================
For inline declaration fully populated
=====================================

class A {
  void Sample() {
    for(int x = 0; x < 100; x++) {
      z += x;
    }
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (void_keyword)
      (identifier)
      (parameter_list)
      (block
        (for_statement
          (variable_declaration
            (predefined_type)
            (variable_declarator
              (identifier)
              (equals_value_clause
                (integer_literal))))
          (binary_expression
            (identifier)
            (integer_literal))
          (postfix_unary_expression
            (identifier))
          (block
            (expression_statement
              (assignment_expression
                (identifier)
                (assignment_operator)
                (identifier))))))))))

=====================================
For no population
=====================================

class A {
  void Sample() {
    for(;;) {
    }
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list (method_declaration
      (void_keyword)
      (identifier)
      (parameter_list)
      (block
        (for_statement
          (block)))))))

=====================================
Deconstruction
=====================================

class A {
  void Sample() {
    (var a, var b) = c;
    var (a, b) = c;
    (a, b) = c;
    var (a, _) = c;
  }
}

---

(compilation_unit
  (class_declaration
    (identifier)
    (declaration_list
      (method_declaration
        (void_keyword)
        (identifier)
        (parameter_list)
        (block
          (expression_statement
            (assignment_expression
              (tuple_expression
                (argument (declaration_expression (implicit_type) (identifier)))
                (argument (declaration_expression (implicit_type) (identifier))))
              (assignment_operator)
              (identifier)))
          (local_declaration_statement (variable_declaration
            (implicit_type)
            (variable_declarator
              (tuple_pattern (identifier) (identifier))
              (equals_value_clause (identifier)))))
          (expression_statement
            (assignment_expression
              (tuple_expression (argument (identifier)) (argument (identifier)))
              (assignment_operator)
              (identifier)))
          (local_declaration_statement (variable_declaration
            (implicit_type)
            (variable_declarator
              (tuple_pattern (identifier) (discard))
              (equals_value_clause (identifier))))))))))