Spoon

Code elements

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


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

CtArrayWrite


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

CtAssert

assert 1+1==2

CtAssignment


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

CtBinaryOperator


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

CtBlock


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

CtBreak


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

CtCase


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

CtConditional


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

CtConstructorCall


 new Object();

CtContinue


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

CtDo


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

CtExecutableReferenceExpression


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

CtFieldRead


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

CtFieldWrite


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

CtFor


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

CtForEach


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

CtIf


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

CtInvocation


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

CtJavaDoc


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

CtLambda


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

CtLiteral


 int x = 4; // 4 is a literal

CtLocalVariable


 // defines a local variable x
 int x = 0;
 // local variable in Java 10
 var x = 0;

CtNewArray


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

CtNewClass


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

CtOperatorAssignment


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

CtReturn


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

CtSuperAccess


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

CtSwitch


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

CtSwitchExpression


int i = 0;
int x = switch(i) { // <-- switch expression
 case 1 -> 10;
 case 2 -> 20;
 default -> 30;
};

CtSynchronized


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

CtTextBlock


 String example = """
		 Test String
 	 """;

CtThisAccess


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

CtThrow


 throw new RuntimeException("oops")

CtTry


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

CtTryWithResource


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

CtTypeAccess


 // 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

CtTypePattern


 Object obj = null;
 boolean longerThanTwo = false;
 // String s is the type pattern, declaring a local variable
 if (obj instanceof String s) {
 longerThanTwo = s.length() > 2;
 }

CtUnaryOperator


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

CtVariableRead


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

CtVariableWrite


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

CtWhile


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

CtYieldStatement


 int x = 0;
 x = switch ("foo") {
 default -> {
					x=x+1;
					yield x; //<--- yield statement
					}
 };
 int x = 0;
 x = switch ("foo") {
 default -> 4; //<--- implicit yield statement
 };

CtAnnotation


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

CtClass


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

CtInterface


 // an interface definition
 interface Foo {
 void bar();
 }

CtRecord


 record Point(int x, int y) {
 }