Figure at the end of this page shows the meta model for Java executable code. There are two main kinds of code elements. First, statements CtStatement (javadoc) are untyped top-level instructions that can be used directly in a block of code. Second, expressions CtExpression (javadoc) are used inside the statements. For instance, a CtLoop (javadoc) (which is a statement) points to CtExpression which expresses its boolean condition.

Some code elements such as invocations and assignments are both statements and expressions (multiple inheritance links). Concretely, this is translated as an interface CtInvocation (javadoc) inheriting from both interfaces CtStatement and CtExpression. The generic type of CtExpression is used to add static type-checking when transforming programs.

Code part of the Spoon Java 8 metamodel

CtArrayRead

(javadoc)

    int[] array = new int[10];
    System.out.println(
    array[0] // <-- array read
    );

CtArrayWrite

(javadoc)

    Object[] array = new Object[10];
    // array write
    array[0] = "new value";

CtAssert

(javadoc)

assert 1+1==2

CtAssignment

(javadoc)

    int x;
    x = 4; // <-- an assignment

CtBinaryOperator

(javadoc)

    // 3+4 is the binary expression
    int x = 3 + 4;

CtBlock

(javadoc)

 { // <-- block start
  System.out.println("foo");
 }

CtBreak

(javadoc)

    for(int i=0; i<10; i++) {
        if (i>3) {
                break; // <-- break statement
        }
    }

CtCase

(javadoc)

int x = 0;
switch(x) {
    case 1: // <-- case statement
      System.out.println("foo");
}

CtConditional

(javadoc)

    System.out.println(
       1==0 ? "foo" : "bar" // <-- ternary conditional
    );

CtConstructorCall

(javadoc)

    new Object();

CtContinue

(javadoc)

    for(int i=0; i<10; i++) {
        if (i>3) {
                continue; // <-- continue statement
        }
    }

CtDo

(javadoc)

    int x = 0;
    do {
        x=x+1;
    } while (x<10);

CtExecutableReferenceExpression

(javadoc)

    java.util.function.Supplier p =
      Object::new;

CtFieldRead

(javadoc)

    class Foo { int field; }
    Foo x = new Foo();
    System.out.println(x.field);

CtFieldWrite

(javadoc)

    class Foo { int field; }
    Foo x = new Foo();
    x.field = 0;

CtFor

(javadoc)

    // a for statement
    for(int i=0; i<10; i++) {
        System.out.println("foo");
    }

CtForEach

(javadoc)

    java.util.List l = new java.util.ArrayList();
    for(Object o : l) { // <-- foreach loop
        System.out.println(o);
    }

CtIf

(javadoc)

    if (1==0) {
        System.out.println("foo");
    } else {
        System.out.println("bar");
    }

CtInvocation

(javadoc)

    // invocation of method println
    // the target is "System.out"
    System.out.println("foo");

CtJavaDoc

(javadoc)

/**
 * Description
 * @tag a tag in the javadoc
*/

CtLambda

(javadoc)

    java.util.List l = new java.util.ArrayList();
    l.stream().map(
      x -> { return x.toString(); } // a lambda
    );

CtLiteral

(javadoc)

    int x = 4; // 4 is a literal

CtLocalVariable

(javadoc)

    // defines a local variable x
    int x = 0;

CtNewArray

(javadoc)

    // inline creation of array content
    int[] x = new int[] { 0, 1, 42}

CtNewClass

(javadoc)

   // an anonymous class creation
   Runnable r = new Runnable() {
        @Override
        public void run() {
          System.out.println("foo");
        }
   };

CtOperatorAssignment

(javadoc)

    int x = 0;
    x *= 3; // <-- a CtOperatorAssignment

CtReturn

(javadoc)

   Runnable r = new Runnable() {
        @Override
        public void run() {
          return; // <-- CtReturn statement
        }
   };

CtSuperAccess

(javadoc)

    class Foo { int foo() { return 42;}};
    class Bar extends Foo {
    int foo() {
      return super.foo(); // <-- access to super
    }
    };

CtSwitch

(javadoc)

int x = 0;
switch(x) { // <-- switch statement
    case 1:
      System.out.println("foo");
}

CtSynchronized

(javadoc)

   java.util.List l = new java.util.ArrayList();
   synchronized(l) {
        System.out.println("foo");
   }

CtThisAccess

(javadoc)

    class Foo {
    int value = 42;
    int foo() {
      return this.value; // <-- access to this
    }
    };

CtThrow

(javadoc)

    throw new RuntimeException("oops")

CtTry

(javadoc)

    try {
        System.out.println("foo");
    } catch (Exception ignore) {}

CtTryWithResource

(javadoc)

   // br is the resource
   try (java.io.BufferedReader br = new java.io.BufferedReader(new java.io.FileReader("/foo"))) {
    br.readLine();
  }

CtTypeAccess

(javadoc)

    // access to static field
    java.io.PrintStream ps = System.out;


    // call to static method
    Class.forName("Foo")


    // method reference
    java.util.function.Supplier p =
      Object::new;


    // instanceof test
    boolean x = new Object() instanceof Integer // Integer is represented as an access to type Integer


    // fake field "class"
    Class x = Number.class

CtUnaryOperator

(javadoc)

    int x=3;
    --x; // <-- unary --

CtVariableRead

(javadoc)

    String variable = "";
    System.out.println(
      variable // <-- a variable read
    );

CtVariableWrite

(javadoc)

    String variable = "";
    variable = "new value"; // variable write


    String variable = "";
    variable += "";

CtWhile

(javadoc)

    int x = 0;
    while (x!=10) {
        x=x+1;
    };

CtAnnotation

(javadoc)

    // statement annotated by annotation @SuppressWarnings
    @SuppressWarnings("unchecked")
    java.util.List<?> x = new java.util.ArrayList<>()

CtClass

(javadoc)

    // a class definition
    class Foo {
       int x;
    }