goto java; (Jfokus)

Please download original Powerpoint for animations to work :-)

1. Martin Skarsaune Java Developer and Co- Owner A peek into the OpenJDK compiler : goto java ; 高馬丁 We’re Hiring!

2. GOTO Statements in Java!

3. GOTO Statement – Objective Syntax goto identifier; Runtime Program control moves to target statement Other Semantics Target (statement label) must be defined in same scope, compilation error if not Potential circular gotos should give compilation warning.

4. GOTO Statement – Means OpenJDK Open source Java implementation Javac is implemented in plain Java  Modify compiler to support GOTO

5. public class GotoSuccess { public static void main(String[] args ) { one: System.out.print ( " goto " ); two: System.out.print ( ” J" ); goto four; three: System.out.print ( ” 2017" ); goto five; four: System.out.print ( ” Fokus " ); goto three; five: System.out.print ( "!" ); } } Success Case

6. GOTO AHEAD Dijkstra 1968 :

7. What i s a C ompiler? Compiler

8. What is a Compiler? front end back end

9. processAnnotations ( enterTrees (… parseFiles (…))),…) … generate( desugar (flow(attribute(…))))

10. processAnnotations ( enterTrees (… parseFiles (…))),…) … generate( desugar (flow(attribute(…))))

11. Syntax : goto identifier; First c onvert character stream to token stream ( Scanner.java ) [ g ][ o ][ t ][ o ][ ][f][o][u][r][;]

12. goto is already a reserved word in Java! Lucky for us , goto is therefore defined as a TokenKind . Tokens.java:141: GOTO (“ goto ”) The scanner therefore works out of the box !

13. ... import com.sun.tools.javac.parser.Scanner ; ... final Scanner scanner= factory. newScanner ( ” goto identifier ; ” , false );

14. final Scanner scanner= factory. newScanner ( ” goto identifier ; ” , false ); scanner .nextToken ();

15. final Scanner scanner= factory. newScanner ( ” goto identifier ; ” , false ); scanner .nextToken (); assertThat ( ”First token is GOTO”, scanner .token (). kind , is( GOTO ));

16. final Scanner scanner= factory. newScanner ( ” goto identifier ; ” , false ); scanner .nextToken (); assertThat ( ”First token is GOTO”, scanner .token (). kind , is( GOTO )); scanner .nextToken ();

17. final Scanner scanner= factory .newScanner ( ” goto identifier ; ” , false); scanner .nextToken (); assertThat ( ”First token is GOTO”, scanner .token (). kind , is( GOTO )); scanner .nextToken (); assertThat ( "Second token is IDENTIFIER" , scanner .token (). kind , is( IDENTIFIER ));

18. final Scanner scanner= factory .newScanner ( ” goto identifier ; ” , false); scanner . nextToken (); assertThat ( ”First token is GOTO”, scanner .token (). kind , is( GOTO )); scanner .nextToken (); assertThat ( "Second token is IDENTIFIER" , scanner .token (). kind , is( IDENTIFIER )); scanner .nextToken ();

19. final Scanner scanner= factory .newScanner ( ” goto identifier ; ” , false); scanner .nextToken (); assertThat ( ”First token is GOTO”, scanner .token (). kind , is( GOTO )); scanner .nextToken (); assertThat ( "Second token is IDENTIFIER" , scanner .token (). kind , is( IDENTIFIER )); scanner .nextToken (); assertThat ( "Third token is SEMI" , scanner .token (). kind , is( SEMI ));

20. visitClassDef (..) visitMethodDef (..) visitIf (..) Abstract Syntax Tree [g][o][t][o] [ ][f][o][u][r][;] Wikipedia: “ the visitor design pattern is a way of separating an algorithm from an object structure on which it operates ”

21. Class Interface

22. Interface based visitors

23. Class based visitors public void visitGoto ( JCGoto tree ) { try { print( "goto " + tree . label + ";" ); } catch ( IOException e ) { throw new UncheckedIOException ( e ); } } public void visitGoto ( JCGoto tree ) { //TODO  implement }

24. public static class JCLabeledStatement extends JCStatement implements LabeledStatementTree { … public GotoResolver handler ; … } public class GotoResolver { Map< GotoTree , Name> gotos ; Map<Name, LabeledStatementTree > targets; List< StatementTree > statementsInSequence ; ... } Helper object

25. JavacParser.parseStatement () case GOTO : { nextToken (); Name label = ident(); JCGoto t = to ( F .at ( pos ). Goto( label , getGotoResolver ()); accept ( SEMI ); return t ; } TreeMaker.java: public JCGoto Goto(Name label , GotoResolver resolver ) { JCGoto tree = new JCGoto( label , resolver ); tree . pos = pos ; return tree ; }

26. Demo

27. processAnnotations ( enterTrees (… parseFiles (…))),…) … generate( desugar (flow(attribute(…)))) ✔

28. processAnnotations ( enterTrees (… parseFiles (…))),…) … generate( desugar (flow(attribute(…))))

29. Basic sanity testing of compilation unit: File name and folder location Duplicate class names Corrections Add default constructor if no constructors are declared

30. Default Constructor public class SimpleClass { }

31. Default Constructor public class SimpleClass { public SimpleClass() { super (); } }

32. ✔ processAnnotations ( enterTrees (… parseFiles (…))),…) … generate( desugar (flow(attribute(…))))

33. processAnnotations ( enterTrees (… parseFiles (…))),…) … generate( desugar (flow(attribute(…))))

34. Process Annitations Annotation processing API Part of ordinary javac process since Java 1.6 Plugin API (see javac documentation)

35. Output controlled by command line switches @ - proc:only – only process annotations, do not compile - proc:none – do not process annotations

36. processAnnotations ( enterTrees (… parseFiles (…))),…) … generate( desugar (flow(attribute( …)))) ✔

37. processAnnotations ( enterTrees (… parseFiles (…))),…) … generate( desugar (flow( attribute ( …))))

38. Attribution Semantic checks Types References Corrections Add required calls to super constructor

39. Ensure target label exists in current scope public class GotoMissingLabel { public static void main(String[] args ) { one: System.out.print ( " goto " ); two: System.out.print ( ”Java" ); goto six ; three: System.out.print ( ”2016" ); goto five; four: System.out.print ( ”One " ); goto three; five: System.out.print ( "!" ); } }

40. Attr.java : @Override public void visitGoto ( JCGoto that ) { that .findTarget (); if ( that . target == null ) log .error ( that .pos (), " undef.label " , that . label ); result = null ; } class JCGoto : … public void findTarget () { this . target = ( JCLabeledStatement ) this . handler .findTarget ( this ); }

41. Demo

42. processAnnotations ( enterTrees (… parseFiles (…))),…) … generate( desugar (flow( attribute ( …)))) ✔

43. processAnnotations ( enterTrees (… parseFiles (…))),…) … generate( desugar ( flow ( attribute ( …))))

44. Flow analysis Detect unreachable code Verify assignments Ensure proper method return Verify (effectively) final Check exception flow

45. Detect circular gotos public class GotoCircularWarning { public static void main(String[] args ) { one: System.out.print ( " goto " ); two: System.out.print ( ”Java" ); goto four; three: System.out.print ( ”2016" ); goto five; four: System.out.print ( ”One " ); goto three; five: System.out.println ( "!" ); g oto one ; //forms infinite loop } }

46. Flow.FlowAnalyzer class: compiler.properties : @Override public void visitGoto ( JCGoto tree ) { if ( tree . handler . detectCircularGotoPosition ( tree )) log .warning ( tree . pos , " circular.goto " ); } ... compiler.warn.circular.goto =circular goto ...

47. Demo

48. ✔ processAnnotations ( enterTrees (… parseFiles (…))),…) … generate( desugar ( flow ( attribute ( …))))

49. processAnnotations ( enterTrees (… parseFiles (…))),…) … generate( desugar (flow( attribute ( …))))

50. Erase generic types public class Bridge implements Comparator { } public interface Comparator< T > { int compare( T o1 , T o1 ); } or<T> {

51. Erase generic types public class Bridge implements Comparator< Integer > { public int compare( Integer first , Integer second ) { return first - second ; } } public interface Comparator< T > { int compare( T o1 , T o1 ); } or<T > {

52. Erasure - Runtime public class Bridge implements Comparator { public int compare( Integer first , Integer second ) { return first - second ; } }

53. Erasure - Bridge public class Bridge implements Comparator { public int compare( Integer first , Integer second ) { return first - second ; } /*synthetic*/ public int compare(Object first , Object second ) { return this .compare ((Integer) first , (Integer) second ); } }

54. Extract inner class public class Outer { private void foo() { } public Runnable fooRunner() { return new Runnable() { public void run() { foo(); } }; } }

55. Extract inner class public class Outer { private void foo() { } public Runnable fooRunner() { return new Runnable() { public void run() { foo(); } }; } }

56. Extract inner class public class Outer { private void foo() { } public Runnable fooRunner () { return new Outer$1( this ); } } class Outer$1 implements Runnable { final Outer this$0 ; Outer$1( final Outer this$0 ) { this . this$0 = this$0 ; super (); } public void run() { this$0 .foo(); } }

57. Extract inner class public class Outer { private void foo() { } public Runnable fooRunner () { return new Outer$1( this ); } } class Outer$1 implements Runnable { final Outer this$0 ; Outer$1( final Outer this$0 ) { this . this$0 = this$0 ; super (); } public void run() { this$0 . foo() ; } }

58. Extract inner class public class Outer { private void foo() { } public Runnable fooRunner () { return new Outer$1( this ); } /*synthetic*/ static void access$000( Outer x0 ) { x0 .foo(); } } class Outer$1 implements Runnable { final Outer this$0 ; Outer$1( final Outer this$0 ) { this . this$0 = this$0 ; super (); } public void run() { Outer.access$000( this$0) ; } }

59. Boxing List<Integer> list = Arrays. asList (1 , 2); for (Integer i : list ) { System . out .println ( ”Double: “ + i * 2 ); }

60. Boxing List<Integer> list = Arrays. asList (1 , 2); for (Integer i : list ) { System . out .println ( ”Double: “ + i * 2); } public static < T > List< T > asList ( T ... a ) { return new ArrayList <>( a ); }

61. Boxing List<Integer> list = Arrays. asList ( Integer.valueOf (1), Integer.valueOf (2) ); for (Integer i : list ) { System . out .println ( ”Double: “ + i * 2); }

62. Unboxing List<Integer> list = Arrays. asList ( Integer.valueOf (1), Integer.valueOf (2)); for (Integer i : list ) { System . out .println ( ”Double: “ + i * 2); }

63. Unboxing List<Integer> list = Arrays. asList ( Integer.valueOf (1), Integer.valueOf (2)); for (Integer i : list ) { System . out .println ( ”Double: “ + i.intValue () * 2); }

64. Varargs List<Integer> list = Arrays. asList ( Integer.valueOf (1), Integer.valueOf (2)); for (Integer i : list ) { System . out .println ( ”Double: “ + i .intValue () * 2); } public static < T > List< T > asList ( T ... a ) { return new ArrayList <>( a ); }

65. Varargs List<Integer> list = Arrays. asList ( Integer.valueOf (1), Integer.valueOf (2) ); for (Integer i : list ) { System . out .println ( ”Double: “ + i .intValue () * 2); } public static < T > List< T > asList ( T... a ) { return new ArrayList <>( a ); }

66. Varargs - runtime List<Integer> list = Arrays. asList ( new Integer[]{ Integer.valueOf (1 ), Integer.valueOf (2 ) } ); for (Integer i : list ) { System . out .println ( ”Double: “ + i .intValue () * 2); }

67. For each loop List<Integer> list = Arrays.asList ( new Integer[]{ Integer.valueOf (1), Integer.valueOf (2) } ); for (Integer i : list) { System . out .println ( ”Double: “ + i .intValue () * 2); }

68. For each loop List<Integer> list = Arrays.asList ( new Integer[]{ Integer.valueOf (1), Integer.valueOf (2) } ); for (Integer i : list ) { System . out .println ( ”Double: “ + i .intValue () * 2); } public interface Iterable <T> { Iterator<T> iterator (); }

69. For each loop List<Integer> list = Arrays.asList ( new Integer[]{ Integer.valueOf (1), Integer.valueOf (2) } ); for (;; ) { System . out .println ( ”Double: “ + i .intValue () * 2); }

70. For each loop List<Integer> list = Arrays.asList ( new Integer[]{ Integer.valueOf (1), Integer.valueOf (2) } ); for ( Iterator i $ = list.iterator ();;) { Integer i System . out .println ( ”Double: “ + i .intValue () * 2); }

71. For each loop List<Integer> list = Arrays.asList ( new Integer[]{ Integer.valueOf (1), Integer.valueOf (2) } ); for ( Iterator i $ = list.iterator (); i $ . hasNext ();) { Integer i System . out .println ( ”Double: “ + i .intValue () * 2); }

72. For each loop List<Integer> list = Arrays.asList ( new Integer[]{ Integer.valueOf (1), Integer.valueOf (2) } ); for ( Iterator i $ = list.iterator (); i $ . hasNext ();) { Integer i = (Integer) i $ .next(); System . out .println ( ”Double: “ + i .intValue () * 2); }

73. Enums public enum Status { YES , NO , MAYBE }

74. Enums - constructor public enum Status { YES , NO , MAYBE private Status(String $ enum$name , int $ enum$ordinal ) { super ($ enum$name , $ enum$ordinal ); } } public static final Status TRUE = new Status( "TRUE" , 0); public static final Status FALSE = new Status( "FALSE" , 1); public static final Status MAYBE = new Status( "MAYBE" , 2);

75. Enums - valueOf public enum Status { YES , NO , MAYBE private Status(String $enum$name, int $enum$ordinal) { super ($enum$name, $enum$ordinal); } public static Status valueOf(String name) { return (Status)Enum.valueOf(Status. class , name); } }

76. Enums - values public enum Status { YES , NO , MAYBE private Status(String $ enum$name , int $ enum$ordinal ) { super ($ enum$name , $ enum$ordinal ); } public static Status valueOf (String name) { return (Status) Enum.valueOf ( Status. class , name); } private static final Status[] $VALUES = new Status[]{ Status.YES , Status.NO , Status.MAYBE }; public static Status[] values() { return (Status[])$ VALUES.clone (); } }

77. Enum switch statement public class SwitchStatus { void switchStatus (Status status ) { switch ( status ) { case MAYBE : return ; default : break ; } } }

78. Enum switch statement public class SwitchStatus { void switchStatus (Status status ) { switch ( status ) { case MAYBE : return ; default : break ; } } }

79. Enum switch statement public class SwitchStatus { void switchStatus (Status status ) { switch ( SwitchStatus$1.$SwitchMap$Status[ (status).ordinal() ] ) { case 1 : return ; default : break ; } } } class SwitchStatus$1 { }

80. Enum switch statement public class SwitchStatus { void switchStatus (Status status ) { switch ( SwitchStatus$1.$SwitchMap$Status[ (status).ordinal() ] ) { case 1 : return ; default : break ; } } } class SwitchStatus$1 { static final int [] $ SwitchMap$Status = new int [ Status.values (). length ]; }

81. Enum switch statement public class SwitchStatus { void switchStatus (Status status ) { switch ( SwitchStatus$1.$SwitchMap$Status[ (status).ordinal() ] ) { case 1 : return ; default : break ; } } } class SwitchStatus$1 { static final int [] $ SwitchMap$Status = new int [ Status.values (). length ]; [ 0][0][0] }

82. Enum switch statement public class SwitchStatus { void switchStatus (Status status ) { switch ( SwitchStatus$1.$SwitchMap$Status[ (status).ordinal() ] ) { case 1 : return ; default : break ; } } } class SwitchStatus$1 { static final int [] $ SwitchMap$Status = new int [ Status.values (). length ]; [ 0][0] [1] static { try { SwitchStatus$1. $SwitchMap$Status [ Status.MAYBE.ordinal () ] = 1 ; } catch ( NoSuchFieldError ex ) { } } }

83. processAnnotations ( enterTrees (… parseFiles (…))),…) … generate( desugar (flow( attribute ( …)))) ✔

84. processAnnotations ( enterTrees (… parseFiles (…))),…) … generate ( desugar (flow( attribute ( …))))

85. Organize initializers String concatenation Generate bytecodes

86. Organize < init > (Constructor ) public class InstanceInitialization { String key = "key" ; String value ; public InstanceInitialization (String value ) { this . value = value ; } }

87. Organize < init > (Constructor ) public class InstanceInitialization { String key = "key" ; String value ; public InstanceInitialization (String value ) { super(); this . value = value ; } }

88. Organize < init > (Constructor ) public class InstanceInitialization { String key ; String value ; public InstanceInitialization (String value ) { super (); key = ”key”; this . value = value ; } }

89. Organize < init > (Constructor ) public class InstanceInitialization { String key ; String value ; public void < init > () { super (); key = ”key”; this . value = value ; } }

90. Organize < clinit > (static initialization) public class StaticInitialization { static String key = "key" ; static { init (); } }

91. Organize < clinit > (static initialization) public class StaticInitialization { static String key; static { key = "key" ; init (); } }

92. Organize < clinit > (static initialization) public class StaticInitialization { static String key; static void < clinit >() { key = "key" ; init (); } }

93. String concatenation Source code “Generated code” ” string ” + value

94. String concatenation Source code “Generated code” ” string ” + value new StringBuilder ()

95. String concatenation Source code “Generated code” ” string ” + value new StringBuilder () .append( ”string” )

96. String concatenation Source code “Generated code” ” string ” + value new StringBuilder () .append( ”string” ) .append( value )

97. String concatenation Source code “Generated code” ” string ” + value new StringBuilder () .append( ”string” ) .append( value ) . toString ()

98. Goto generation Luckily for us there is a GOTO byte code goto < addr >

99. if (< test> ) { < ifblock > } else { < elseblock > } < codeafter > Source code Byte code C I 9 ifeq < elseblock > goto < stackmap > 22 < ifblock > 22 < stackmap > 29 < codeafter > 29 Java >= 1.6: Stack map frames must be embedded at target of jump instruction Code generator ( Code.java ) marked as not alive. Goto instruction added to list of pending jumps ( Chain.java ) Pending jumps processed Normal GOTO usage

100. Source code Byte code C I … label: < somecode > … g oto label ; … 2 … goto 20 < stackmap > < somecode > Used by goto ? Must emit stackmap Emit goto to label and turn code generation on again GOTO scenario 1 : jump back

101. Source code Byte code C I GOTO scenario 2 : jump forward … g oto label ; … label: < somecode > … … 29 < somecode > goto < stackmap > Label position not yet known? emit goto add to list of pending gotos t urn generation on again 29 Label used? emit stack frame patch pending gotos

102. Goto generation Gen.java , visitor for code generation Modify for LabelledStatement Add implementation for Goto

103. Gen.java – Labelled Statement public void visitLabelled ( JCLabeledStatement tree ) { // if the label is used from gotos , have to emit stack map if ( tree . handler .isUsed ( tree )) code .emitStackMap (); … }

104. Gen.java – Goto public void visitGoto ( JCGoto tree ) { tree . handler .addBranch ( new Chain( code .emitJump ( goto _ ), null , code . state .dup ()), tree . target ); //normally goto marks code as not alive, turn generation on code .entryPoint (); } Target position known? Yes – patch immediately No – add to list of pending gotos

105. Demo

106. ambda λ

107. Lambda implementation in Java 8 Language change Compilation Runtime support Many interesting design considerations

108. Simple Example public Comparator<String> lambdaExample () { return (String a , String b ) -> a .compareTo ( b ); }

109. LambdaToMethod.java public Comparator<String> lambdaExample () { return (String a , String b ) -> a .compareTo ( b ); } /*synthetic*/ private static int lambda$lambdaExample$0( , ) { return ; } final String a final String b a.compareTo (b)

110. Runtime public Comparator<String> lambdaExample () { return < invokedynamic > LambdaMetafactory.metafactory ( } /*synthetic*/ private static int lambda$lambdaExample$0 ( final String a , final String b ) { return a .compareTo ( b ); } Lookup ( LambdaExample ) , / *caller* / "compare" , ()Comparator, /* MethodType */ ( Object,Object ) int , / * MethodType * / lambda$lambdaexample$0, /* MethodHandle * / ( String,String ) int ); /* MethodType */ final class LambdaExample $$Lambda$1/1834188994 implements Comparator { private LambdaExample $$Lambda$1/1834188994() public int compare( Object,Object ) } public interface Comparator { / *erased* / int compare(Object o1 , Object o2 ); }

111. Runtime implementation Lambda Class

112. Serialization Lambda Instance Serialize Serialized Lambda Deserialize Lambda Meta Factory

113. Possible to back port ? Capture generated class ? Compile time generation of inner class!

114. Step 1: Source.java public boolean allowLambda () { return compareTo ( ) >= 0; } JDK1_8 JDK1_5

115. Step 2: Special handling boolean mustBackportLambda () { retur n thi s.target.compareTo (Target.JDK1_8) < 0 ; }

116. Step 3: Call backport if (! this . attr .mustBackportLambda () ) { result = makeMetafactoryIndyCall ( ... ); } else { result = new LambdaBackPorter ( ... ). implementLambdaClass ( ... ); }

117. Example implementation private static final class Lambda$$2 implements Comparator<String> { Lambda$$2 { super (); } public int compare(String arg0 , String arg1 ) { return LambdaExample.lambda$lambdaExample$0( arg0 , arg1 ); } public int compare(Object o1 , Object o2 ) { return this .compare ((String) o1 , (String) o2 ); } }

118. Example invoking public Comparator<String> lambdaExample () { } return LambdaMetafactory. metafactory (...); return new Lambda$$ 2();

119. Demo

120. ambda λ

121. Experiment

122. < invokedynamic > “playground” @ InvokeIndy annotation on method with reference to boostrap method Annotation processor that validates reference Compiler plugin that replaces method invocation with invokedynamic

123. @ IndyMethod public class SomeService { //must refer to a valid public static method //with certain characteristics @ IndyMethod ( implementation = " no.kantega.jvm.indy.example.SomeProvider " , method = " dummyMethod " ) public static void doStuff () { throw new UnsupportedOperationException ( "..." ); } }

124. no.kantega.jvm.indy.compiler.plugin.IndyAnnotationChecker Hooking in the processor: META-INF/services/ javax.annotation.processing.Processor :

125. Annotation processor : setup, compliance + mapping @ SupportedAnnotationTypes ( " no.... IndyMethod " ) @ SupportedSourceVersion (SourceVersion. RELEASE_8 ) //Java version public class IndyAnnotationChecker extends AbstractProcessor { //... public boolean process(Set <...> annotations , RoundEnvironment roundEnv ) { for ( TypeElement annotation : annotations ) { for (Element element : roundEnv .getElementsAnnotatedWith ( annotation )) { //...raise error if earlier than Java 7 or missing plugin IndyMethod indyMethodRef = element .getAnnotation ( IndyMethod . class ); if ( indyMethodRef != null ) { //...check existance of type and compliance of method ... processingEnv .getMessager (). printMessage ( Kind. ERROR , "..." , element ); } } //...

126. ... < build > < plugins > < plugin > < artifactId > maven-compiler-plugin </ artifactId > < configuration > <!-- Disable annotation processing for ourselves. --> < compilerArgument > - proc:none </ compilerArgument > </ configuration > </ plugin > </ plugins > </ build > ... Disable annotation processing in the project that implements the plugin (!): pom.xml :

127. Devoxx BE 2014 : “Plugging into the Java Compiler” , https ://www.parleys.com/tutorial/plugging-java-compiler -1 Google the session title for additional resources.

128. Compiler plugin Hook straight into the compilation process Respond to events from compilation process Make changes to AST

129. no.kantega.jvm.indy.compiler.plugin.IndyPlugin Hooking in the plugin: META-INF/services/ com.sun.source.util.Plugin :

130. public class IndyPlugin implements Plugin { public String getName () { return " IndyPlugin " ; } public void init ( JavacTask paramJavacTask , String ... paramArrayOfString ) { paramJavacTask .addTaskListener ( new GenerateInvokeDynamicHandler ()); } } Typical plugin definition: Unique name Delegate to task listener(s)

131. public class GenerateInvokeDynamicHandler implements TaskListener { public void started( TaskEvent start ) { if ( start .getKind () == Kind. GENERATE ) { for (Tree tree : start .getCompilationUnit (). getTypeDecls ()) { tree .accept ( new IndyMethodInvocationReplacer (), tree ); } } } Task listener: Receive callback, check stage Insert visitor to process ASTs

132. public class IndyMethodInvocationReplacer extends TreeScanner { public Object visitMethodInvocation ( MethodInvocationTree node , Tree p ) { { //...various checks on the method call //...see if annotation processor has created mapping for it MethodSymbol replacementMethod = IndyMethodMappings. getInstance (). mappingFor (( MethodSymbol ) identifier . sym ); if ( replacementMethod != null ) { //insert reference to bootstrap identifier . sym = new Symbol.DynamicMethodSymbol (...); } } } } return super .visitMethodInvocation ( node , p ); } } Visitor: Make modifications

133. < build > < plugins > < plugin > < artifactId > maven-compiler-plugin </ artifactId > < configuration > < compilerArgs > < arg > - Xplugin:IndyPlugin </ arg > </ compilerArgs > < source > 1.8 </ source > < target > 1.8 </ target > </ configuration > </ plugin > </plugins> </build> Users: Enable plugin in compilation

134. Demo

135. Wrap Up The Java compiler is written in pure Java Compilation is done in phases Programming language advances (syntactic sugar) require good compiler support Lambdas are compiled in a forward compatible manner Annotation processors and compiler plugins may be used to tailor the compilation process to specific needs

136. Resources OpenJDK Source : http://hg.openjdk.java.net/ Compiler hacking tutorial http ://www.ahristov.com/tutorial/java-compiler.html Sample code: https :// github.com/skarsaune/goto https://github.com/skarsaune/indy-plugin Slide pack: http :// www.slideshare.net/MartinSkarsaune 60 minute video ( Devoxx ) : https:// youtu.be/gGTDQq6ZjIk

137. Questions or Comments ? Martin Skarsaune Java Developer and Co- Owner

138. Thank You for Your Time! Martin Skarsaune Java Developer and Co- Owner