==================================
standalone assignment expression
==================================

x = 3;

---

(program
  (expression_statement (assignment_expression
    (identifier)
    (decimal_integer_literal))))

==================================
standalone binary expression
==================================

a > b;
a < b;
a == b;
a >= b;
a <= b;
a != b;
a && b;
a || b;
a & b;
a | b;
a ^ b;
a % b;
a << b;
a >> b;
a >>> b;
3 + 2;
3 - 2;
3 * 2;
9 / 3;

---

(program
  (expression_statement (binary_expression (identifier) (identifier)))
  (expression_statement (binary_expression (identifier) (identifier)))
  (expression_statement (binary_expression (identifier) (identifier)))
  (expression_statement (binary_expression (identifier) (identifier)))
  (expression_statement (binary_expression (identifier) (identifier)))
  (expression_statement (binary_expression (identifier) (identifier)))
  (expression_statement (binary_expression (identifier) (identifier)))
  (expression_statement (binary_expression (identifier) (identifier)))
  (expression_statement (binary_expression (identifier) (identifier)))
  (expression_statement (binary_expression (identifier) (identifier)))
  (expression_statement (binary_expression (identifier) (identifier)))
  (expression_statement (binary_expression (identifier) (identifier)))
  (expression_statement (binary_expression (identifier) (identifier)))
  (expression_statement (binary_expression (identifier) (identifier)))
  (expression_statement (binary_expression (identifier) (identifier)))
  (expression_statement (binary_expression (decimal_integer_literal) (decimal_integer_literal)))
  (expression_statement (binary_expression (decimal_integer_literal) (decimal_integer_literal)))
  (expression_statement (binary_expression (decimal_integer_literal) (decimal_integer_literal)))
  (expression_statement (binary_expression (decimal_integer_literal) (decimal_integer_literal))))

==================================
instanceof expressions
==================================

a instanceof C.D;
a instanceof List<B>;
c instanceof C[];

---

(program
  (expression_statement (instanceof_expression
    (identifier)
    (scoped_type_identifier (type_identifier) (type_identifier))))
  (expression_statement (instanceof_expression
    (identifier)
    (generic_type (type_identifier) (type_arguments (type_identifier)))))
  (expression_statement (instanceof_expression
    (identifier)
    (array_type (type_identifier) (dimensions)))))

===========================================================
if statements
===========================================================

if (x)
  y;

---

(program
  (if_statement
    condition: (parenthesized_expression (identifier))
    consequence: (expression_statement (identifier))))

===========================================================
if statements with braces
===========================================================

if (x) {
  y;
}

---

(program
  (if_statement
    condition: (parenthesized_expression (identifier))
    consequence: (block (expression_statement (identifier)))))

===========================================================
if statements with assignment without braces
===========================================================

if (x = 3)
  y = 2;

---

(program
  (if_statement
    condition: (parenthesized_expression
      (assignment_expression
        left: (identifier)
        right: (decimal_integer_literal)))
    consequence: (expression_statement
      (assignment_expression
        left: (identifier)
        right: (decimal_integer_literal)))))

==================================
if then else statement
==================================

if (x = 3) {
  y = 9;
} else {
  y = 0;
}

---

(program
  (if_statement
    condition: (parenthesized_expression
      (assignment_expression
        left: (identifier)
        right: (decimal_integer_literal)))
    consequence: (block
      (expression_statement (assignment_expression
        left: (identifier)
        right: (decimal_integer_literal))))
    alternative: (block
      (expression_statement (assignment_expression
        left: (identifier)
        right: (decimal_integer_literal))))))

==================================
nested if then else statements
==================================

if (a)
  if (b)
    c();
  else
    d();

---

(program
  (if_statement
    (parenthesized_expression (identifier))
    (if_statement
      (parenthesized_expression (identifier))
      (expression_statement (method_invocation (identifier) (argument_list)))
      (expression_statement (method_invocation (identifier) (argument_list))))))

==================================
ternary expressions
==================================

max = (a > b) ? a : b;

---

(program
  (expression_statement (assignment_expression
    left: (identifier)
    right: (ternary_expression
      condition: (parenthesized_expression (binary_expression
        left: (identifier)
        right: (identifier)))
      consequence: (identifier)
      alternative: (identifier)))))

==================================
for statement
==================================

for(int i = 1; i < 11; i++) {
  System.out.println("Count is: " + i);
}

for (j.init(i); j.check(); j.update()) {
  System.out.println(j);
}

---

(program
  (for_statement
    (for_init
      (local_variable_declaration
        (integral_type)
        (variable_declarator
          (identifier)
          (decimal_integer_literal))))
    (binary_expression (identifier) (decimal_integer_literal))
    (update_expression (identifier))
    (block
      (expression_statement (method_invocation
        (scoped_identifier (identifier) (identifier))
        (identifier)
        (argument_list (binary_expression (string_literal) (identifier)))))))
  (for_statement
    (for_init (method_invocation (identifier) (identifier) (argument_list (identifier))))
    (method_invocation (identifier) (identifier) (argument_list))
    (method_invocation (identifier) (identifier) (argument_list))
    (block
      (expression_statement (method_invocation
        (scoped_identifier (identifier) (identifier))
        (identifier)
        (argument_list (identifier)))))))

================================
Enhanced for statements
================================

for (A b : c) {
  d(b);
}

---

(program
  (enhanced_for_statement
    (type_identifier)
    (identifier)
    (identifier)
    (block
      (expression_statement (method_invocation
        (identifier)
        (argument_list (identifier)))))))

==================================
while statement
==================================

class WhileDemo {
    public static void main(String[] args){
        int count = 1;
        while (count < 11) {
            System.out.println("Count is: " + count);
            count++;
        }
    }
}

---

 (program
  (class_declaration
    name: (identifier)
    body: (class_body
      (method_declaration
        (modifiers)
        type: (void_type)
        name: (identifier)
        parameters: (formal_parameters
          (formal_parameter
            type: (array_type
              element: (type_identifier)
              dimensions: (dimensions))
            name: (identifier)))
        body: (block
          (local_variable_declaration_statement
            (local_variable_declaration
              type: (integral_type)
              declarator: (variable_declarator
                name: (identifier)
                value: (decimal_integer_literal))))
          (while_statement
            condition: (parenthesized_expression
              (binary_expression
                left: (identifier)
                right: (decimal_integer_literal)))
            body: (block
              (expression_statement (method_invocation
                object: (scoped_identifier (identifier) (identifier))
                name: (identifier)
                arguments: (argument_list
                  (binary_expression left: (string_literal) right: (identifier)))))
              (expression_statement (update_expression (identifier))))))))))

==================================
try-with-resources statements
==================================

try (FileInputStream input = new FileInputStream("file.txt")) {
  int data = input.read();
}

---

(program
  (try_with_resources_statement
    resources: (resource_specification
      (resource
        type: (type_identifier)
        name: (identifier)
        value: (object_creation_expression
          type: (type_identifier)
          arguments: (argument_list (string_literal)))))
    body: (block
      (local_variable_declaration_statement
        (local_variable_declaration
          type: (integral_type)
          declarator: (variable_declarator
            name: (identifier)
            value: (method_invocation
              object: (identifier)
              name: (identifier)
              arguments: (argument_list))))))))

==================================
return statement
==================================

return x;
return x * y;
return x + 2;
return fire(x);

---

(program
  (return_statement (identifier))
  (return_statement (binary_expression (identifier) (identifier)))
  (return_statement (binary_expression (identifier) (decimal_integer_literal)))
  (return_statement (method_invocation (identifier) (argument_list (identifier)))))

==================================
annotation
==================================

@SuppressWarnings(value = "unchecked")
@GwtCompatible(emulated = true)
class Duck {

}

---

(program
  (class_declaration
    (modifiers
      (annotation
        (identifier)
        (annotation_argument_list
          (element_value_pair
            (identifier)
            (string_literal))))
      (annotation
        (identifier)
        (annotation_argument_list
          (element_value_pair
            (identifier)
            (true)))))
    (identifier)
    (class_body)))

==================================
marker annotation
==================================

@Override
class Quack {
  @bar
  public void foo() {

  }
}

---

(program
  (class_declaration
    (modifiers (marker_annotation (identifier)))
    (identifier)
    (class_body
      (method_declaration
        (modifiers (marker_annotation (identifier)))
        (void_type)
        (identifier)
        (formal_parameters)
        (block)))))

==================================
single element annotation
==================================

@Duck(waddle.swim)
@SuppressWarnings("unchecked")
class Quack {

}

---

(program
  (class_declaration
    (modifiers
      (annotation (identifier) (annotation_argument_list (scoped_identifier (identifier) (identifier))))
      (annotation (identifier) (annotation_argument_list (string_literal))))
    (identifier)
    (class_body)))

==================================
lambda expression
==================================

class LambdaTest {
  void singleton() {
    version -> create;
    (a, b) -> a + b;
  }
}

---

(program
  (class_declaration
    (identifier)
    (class_body
      (method_declaration
        (void_type)
        (identifier)
        (formal_parameters)
        (block
          (expression_statement (lambda_expression
            (identifier)
            (identifier)))
          (expression_statement (lambda_expression
            (inferred_parameters (identifier) (identifier))
            (binary_expression (identifier) (identifier)))))))))

==================================
switch statement
==================================

public class SwitchDemo {
  public static void main(String[] args) {
    int destinysChild = 2;
    String destinysChildString;
    switch (destinysChild) {
        case 1:  destinysChildString = "Beyonce";
                 break;
        case 2:  destinysChildString = "Kelly";
                 break;
        case 3:  destinysChildString = "Michelle";
                 break;
        default: destinysChildString = "Invalid";
                 break;
    }
    System.out.println(destinysChildString);
  }
}

---

(program
  (class_declaration
    (modifiers)
    name: (identifier)
    body: (class_body
      (method_declaration
        (modifiers)
        type: (void_type)
        name: (identifier)
        parameters: (formal_parameters
          (formal_parameter
            type: (array_type
              element: (type_identifier)
              dimensions: (dimensions))
            name: (identifier)))
        body: (block
          (local_variable_declaration_statement
            (local_variable_declaration
              type: (integral_type)
              declarator: (variable_declarator
                name: (identifier)
                value: (decimal_integer_literal))))
            (local_variable_declaration_statement
              (local_variable_declaration
                type: (type_identifier)
                declarator: (variable_declarator name: (identifier))))
            (switch_statement
              condition: (parenthesized_expression (identifier))
              body: (switch_block
                (switch_label (decimal_integer_literal))
                (expression_statement (assignment_expression
                  left: (identifier)
                  right: (string_literal)))
                (break_statement)
                (switch_label (decimal_integer_literal))
                (expression_statement (assignment_expression
                  left: (identifier)
                  right: (string_literal)))
                (break_statement)
                (switch_label (decimal_integer_literal))
                (expression_statement (assignment_expression
                  left: (identifier)
                  right: (string_literal)))
                (break_statement)
                (switch_label)
                (expression_statement (assignment_expression
                  left: (identifier)
                  right: (string_literal)))
                (break_statement)))
            (expression_statement (method_invocation
              object: (scoped_identifier (identifier) (identifier))
              name: (identifier)
              arguments: (argument_list (identifier)))))))))

==================================
type arguments
==================================

class Box <T> {
  private T theObject;
  public Box( T arg) { theObject = arg; }
  // more code
}

---

(program
  (class_declaration
    (identifier)
      (type_parameters
        (type_parameter
          (identifier)))
    (class_body
      (field_declaration
        (modifiers)
          (type_identifier)
          (variable_declarator (identifier)))
      (constructor_declaration
        (modifiers)
        (identifier)
        (formal_parameters
          (formal_parameter
            (type_identifier)
            (identifier)))
        (constructor_body
          (expression_statement (assignment_expression
            (identifier)
              (identifier)))))
      (comment))))

==================================
wildcard
==================================

class WildcardDemo {
  List<? extends B> a;
}

---

(program
  (class_declaration
    (identifier)
      (class_body
        (field_declaration
          (generic_type
            (type_identifier)
            (type_arguments
              (wildcard (type_identifier))))
          (variable_declarator (identifier))))))

==================================
type arguments with generic types
==================================

class someClass <T> {
  public List<T> someMethod() {
     List< T > list = Collections.< T >emptyList();
     return list;
  }
  public static <S> void anotherMethod(S arg) {
     List< S > list = Collections.< S >emptyList();
  }
}

---

(program
  (class_declaration
    (identifier)
    (type_parameters
      (type_parameter
        (identifier)))
      (class_body
        (method_declaration
          (modifiers)
            (generic_type
              (type_identifier)
              (type_arguments (type_identifier)))
            (identifier)
            (formal_parameters)
            (block
              (local_variable_declaration_statement
                (local_variable_declaration
                  (generic_type
                    (type_identifier)
                    (type_arguments (type_identifier)))
                  (variable_declarator
                    (identifier)
                    (method_invocation
                      (identifier)
                      (type_arguments (type_identifier))
                      (identifier)
                      (argument_list)))))
              (return_statement (identifier))))
        (method_declaration
          (modifiers)
          (type_parameters
            (type_parameter
              (identifier)))
          (void_type)
            (identifier)
            (formal_parameters
              (formal_parameter
                (type_identifier)
                (identifier)))
            (block
              (local_variable_declaration_statement
                (local_variable_declaration
                  (generic_type
                    (type_identifier)
                    (type_arguments (type_identifier)))
                  (variable_declarator
                    (identifier)
                    (method_invocation
                      (identifier)
                      (type_arguments (type_identifier))
                      (identifier)
                      (argument_list))))))))))

==================================
empty type arguments
==================================

Box<Integer> integerBox = new Box<>();

---

(program
  (local_variable_declaration_statement (local_variable_declaration
    (generic_type (type_identifier) (type_arguments (type_identifier)))
    (variable_declarator
      (identifier)
      (object_creation_expression
        (generic_type (type_identifier) (type_arguments))
        (argument_list))))))

=================
method references
=================

action = bar::method;
foo.bar::method;
String[]::new;
Foo<T>::apply;
super::something;

---

(program
  (expression_statement (assignment_expression (identifier) (method_reference (identifier) (identifier))))
  (expression_statement (method_reference (scoped_identifier (identifier) (identifier)) (identifier)))
  (expression_statement (method_reference (array_type (type_identifier) (dimensions))))
  (expression_statement (method_reference (generic_type (type_identifier) (type_arguments (type_identifier))) (identifier)))
  (expression_statement (method_reference (super) (identifier))))