CHANGE PROJECT STRUCTURE;

ADD JAVA-FLOWCHART MODULE;

.gitignore

@@ -1 +1,2 @@
 /aidl-to-json/target/
+/java-control-flow/target/

.idea/compiler.xml

@@ -6,9 +6,10 @@
         <sourceOutputDir name="target/generated-sources/annotations" />
         <sourceTestOutputDir name="target/generated-test-sources/test-annotations" />
         <outputRelativeToContentRoot value="true" />
+        <module name="map-to-json" />
+        <module name="flowchart" />
         <module name="aidl-to-json" />
         <module name="java-control-flow" />
-        <module name="utils" />
       </profile>
     </annotationProcessing>
     <bytecodeTargetLevel>

.idea/misc.xml

@@ -34,7 +34,7 @@
       </list>
     </option>
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" project-jdk-name="1.8" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" project-jdk-name="1.8 201" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>

aidl-to-json/pom.xml

@@ -11,6 +11,12 @@
 
     <artifactId>aidl-to-json</artifactId>
     <dependencies>
+        <dependency>
+            <groupId>xyz.ignatz</groupId>
+            <artifactId>map-to-json</artifactId>
+            <version>1.0-SNAPSHOT</version>
+            <scope>compile</scope>
+        </dependency>
     </dependencies>
 
     <properties>

example/java/Test.java

@@ -0,0 +1,28 @@
+class Person{
+	public static void main(String[] args){
+		int age = 10;
+		if(age>10){
+			System.out.println("年龄太大");
+		}
+		else if(age>20){
+			System.out.println("123");
+		}
+		else{
+			age = 18;
+		}
+		for(int i =0;i<12;i++){
+			age = 19;
+			System.out.println("234");
+			System.out.println("456");
+		}
+		char i = 'a';
+		switch(i) {
+		case 'a':
+			System.out.println("123");
+			break;
+		case 'b':
+			System.out.println("456");
+			break;
+		}
+	}
+}

utils/pom.xml → flowchart/pom.xml

@@ -9,7 +9,7 @@
     </parent>
     <modelVersion>4.0.0</modelVersion>
 
-    <artifactId>utils</artifactId>
+    <artifactId>flowchart</artifactId>
 
     <properties>
         <maven.compiler.source>8</maven.compiler.source>

flowchart/src/main/java/xyz/ignatz/antlr/utils/Blocks.java

@@ -0,0 +1,38 @@
+package xyz.ignatz.antlr.utils;
+
+import org.antlr.v4.runtime.ParserRuleContext;
+import xyz.ignatz.flowchart.Block;
+import xyz.ignatz.flowchart.Node;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+
+public class Blocks {
+    public static Block build(ParserRuleContext ctx) {
+        return build(ctx, Arrays.asList(null));
+    }
+
+    public static Block build(ParserRuleContext ctx, String dsc) {
+        return build(ctx, Arrays.asList(dsc));
+    }
+
+    public static Block build(ParserRuleContext ctx, Map<String, Node> tps) {
+        return new Block(buildNode(ctx, tps));
+    }
+
+    public static Block build(ParserRuleContext ctx, Collection<String> tpDscs) {
+        Map<String, Node> tps = new HashMap<>();
+        tpDscs.forEach(dsc -> tps.put(dsc, null));
+        return build(ctx, tps);
+    }
+
+    public static Block buildJudgement(ParserRuleContext ctx) {
+        return build(ctx, Arrays.asList("true", "false"));
+    }
+
+    static Node buildNode(ParserRuleContext ctx, Map<String, Node> tps) {
+        return new Node(ctx.getText(), ctx.getStart().getLine(), tps);
+    }
+}

flowchart/src/main/java/xyz/ignatz/flowchart/Block.java

@@ -0,0 +1,87 @@
+package xyz.ignatz.flowchart;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.function.Predicate;
+
+public class Block {
+
+    class Edge {
+        Node src;
+        String dsc;
+        public Edge(Node src, String dsc) {
+            this.src = src;
+            this.dsc = dsc;
+        }
+    }
+
+    Node start;
+    Map<String, HashSet<Edge>> nullEdges = new HashMap<>();
+
+    public Block(Node node) {
+        start = node;
+        addEnd(node);
+    }
+
+    public Node getStart() {
+        return start;
+    }
+
+    public void addEnd(Node node) {
+        node.tps.forEach((dsc, dst) -> {
+            if (dst == null) {
+                nullEdges.putIfAbsent(dsc, new HashSet<>());
+                nullEdges.get(dsc).add(new Edge(node, dsc));
+            }
+        });
+    }
+
+    public void connectLoopJudgement(Block judgement, boolean judgeFirst) {
+        judgement.connect("true", start);
+        connect(str -> str == null || str == "continue", judgement);
+        replaceTpDsc("false", null);
+        replaceTpDsc("break", null);
+        if (judgeFirst) start = judgement.start;
+    }
+
+    public void connect(Block next) {
+        connect(str -> str == null, next);
+    }
+
+    public void connect(String dsc, Block next) {
+        connect(str -> dsc == null ? str == null : str.equals(dsc), next);
+    }
+
+    public void connect(Predicate<String> filter, Block next) {
+        connect(filter, next.start);
+        merge(next);
+    }
+
+    void replaceTpDsc(String old, String dsc) {
+        if (dsc == null ? old == null : old.equals(dsc)) return;
+        nullEdges.putIfAbsent(dsc, new HashSet<>());
+        nullEdges.get(dsc).addAll(nullEdges.remove(old));
+    }
+
+    void connect(String dsc, Node dst) {
+        connect(str -> dsc == null ? str == null : str.equals(dsc), dst);
+    }
+
+    void connect(Predicate<String> filter, Node dst) {
+        nullEdges.forEach((type, edges) -> {
+            if (filter.test(type)) {
+                edges.forEach(edge -> edge.src.connect(edge.dsc, dst));
+            } });
+    }
+
+    void merge(Block other) {
+        other.nullEdges.forEach((type, edges) ->
+                nullEdges.merge(type, edges, (old, value) -> {
+                    old.addAll(value);
+                    return old;
+                })
+        );
+        other.nullEdges = nullEdges;
+    }
+}

flowchart/src/main/java/xyz/ignatz/flowchart/Node.java

@@ -0,0 +1,23 @@
+package xyz.ignatz.flowchart;
+
+import java.util.*;
+
+public class Node {
+    String desc;
+    Integer line;
+    Map<String, Node> tps;
+
+    public Node(String desc, Integer line, Map<String, Node> tps) {
+        this.desc = desc;
+        this.line = line;
+        this.tps = tps;
+    }
+
+    public boolean connect(String tpDsc, Node dst) {
+        if (tps.containsKey(tpDsc) && tps.get(tpDsc) == null) {
+            tps.put(tpDsc, dst);
+            return true;
+        }
+        return false;
+    }
+}

java-flowchart/pom.xml

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>antlr</artifactId>
+        <groupId>xyz.ignatz</groupId>
+        <version>1.0-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>java-control-flow</artifactId>
+    <dependencies>
+        <dependency>
+            <groupId>xyz.ignatz</groupId>
+            <artifactId>flowchart</artifactId>
+            <version>1.0-SNAPSHOT</version>
+            <scope>compile</scope>
+        </dependency>
+    </dependencies>
+
+    <properties>
+        <maven.compiler.source>8</maven.compiler.source>
+        <maven.compiler.target>8</maven.compiler.target>
+    </properties>
+
+</project>

java-flowchart/src/main/java/xyz/ignatz/antlr/java9/JavaControlFlowGenerator.java

@@ -0,0 +1,39 @@
+package xyz.ignatz.antlr.java9;
+
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.CharStreams;
+import org.antlr.v4.runtime.CommonTokenStream;
+import xyz.ignatz.antlr.java9.recognizer.Java9Lexer;
+import xyz.ignatz.antlr.java9.recognizer.Java9Loader;
+import xyz.ignatz.antlr.java9.recognizer.Java9Parser;
+
+import java.io.IOException;
+import java.util.Formatter;
+
+public class JavaControlFlowGenerator {
+    public static void main(String[] args) {
+        if (args.length < 2) {
+            System.out.println("JavaControlFlowGenerator input_filename output_directory");
+            return;
+        }
+        CharStream input = null;
+        try {
+            input = CharStreams.fromFileName(args[0]);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        String[] lines = input.toString().split("\n|\r\n|\n\r");
+        for (int i=0; i<lines.length; ++i) {
+            Formatter formatter = new Formatter();
+            System.out.println(formatter.format("%4d. %s\n", i+1, lines[i]));
+        }
+        Java9Lexer lexer = new Java9Lexer(input);
+        CommonTokenStream tokens = new CommonTokenStream(lexer);
+        Java9Parser parser = new Java9Parser(tokens);
+        ParseTree tree = parser.compilationUnit();
+        Java9Loader loader = new Java9Loader();
+        loader.visit(tree);
+
+    }
+}

java-flowchart/src/main/java/xyz/ignatz/antlr/java9/recognizer/Java9Loader.java

@@ -0,0 +1,198 @@
+package xyz.ignatz.antlr.java9.recognizer;
+
+import xyz.ignatz.antlr.java9.utils.JavaName;
+import xyz.ignatz.flowchart.Block;
+import xyz.ignatz.flowchart.Node;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+
+import xyz.ignatz.antlr.utils.Blocks;
+
+
+public class Java9Loader extends Java9BaseVisitor<Block> {
+    Map<String, Block> blocks;
+    JavaName name = new JavaName();
+
+    @Override
+    public Block visitIfThenStatement(Java9Parser.IfThenStatementContext ctx) {
+        Block body = visitStatement(ctx.statement());
+        Block block = Blocks.buildJudgement(ctx.expression());
+        block.connect("true", body);
+        return block;
+    }
+
+    @Override
+    public Block visitIfThenElseStatement(Java9Parser.IfThenElseStatementContext ctx) {
+        Block bodyTrue = visitStatementNoShortIf(ctx.statementNoShortIf());
+        Block bodyFalse = visitStatement(ctx.statement());
+        Block block = Blocks.buildJudgement(ctx.expression());
+        block.connect("true", bodyTrue);
+        block.connect("false", bodyFalse);
+        return block;
+    }
+
+    @Override
+    public Block visitIfThenElseStatementNoShortIf(Java9Parser.IfThenElseStatementNoShortIfContext ctx) {
+        Block bodyTrue = visitStatementNoShortIf(ctx.statementNoShortIf().get(0));
+        Block bodyFalse = visitStatementNoShortIf(ctx.statementNoShortIf().get(1));
+        Block block = Blocks.buildJudgement(ctx.expression());
+        block.connect("true", bodyTrue);
+        block.connect("false", bodyFalse);
+        return block;
+    }
+
+    @Override
+    public Block visitSwitchStatement(Java9Parser.SwitchStatementContext ctx) {
+        Map<String, Node> map = new HashMap<>();
+        Block body = null;
+        for (Java9Parser.SwitchBlockStatementGroupContext group : ctx.switchBlock().switchBlockStatementGroup()) {
+            Block block = visitBlockStatements(group.blockStatements());
+            Node start = block.getStart();
+            group.switchLabels().switchLabel().forEach(lab -> map.put(lab.getText(), start));
+            body = aggregateResult(body, block);
+        }
+        Block block = Blocks.build(ctx, map);
+        block.connect(body);
+        return block;
+    }
+
+    @Override
+    public Block visitDoStatement(Java9Parser.DoStatementContext ctx) {
+        Block block = visitStatement(ctx.statement());
+        Block judge = Blocks.buildJudgement(ctx.expression());
+        block.connectLoopJudgement(judge, false);
+        return block;
+    }
+
+    @Override
+    public Block visitBasicForStatement(Java9Parser.BasicForStatementContext ctx) {
+        Block init = visitForInit(ctx.forInit());
+        Block judge = Blocks.buildJudgement(ctx.expression());
+        Block update = visitForUpdate(ctx.forUpdate());
+        Block body = visitStatement(ctx.statement());
+        body.connect(update);
+        body.connectLoopJudgement(judge, true);
+        init.connect(body);
+        return init;
+    }
+
+    @Override
+    public Block visitBasicForStatementNoShortIf(Java9Parser.BasicForStatementNoShortIfContext ctx) {
+        Block block = visitForInit(ctx.forInit());
+        Block judge = Blocks.buildJudgement(ctx.expression());
+        Block update = visitForUpdate(ctx.forUpdate());
+        Block body = visitStatementNoShortIf(ctx.statementNoShortIf());
+        body.connect(update);
+        body.connectLoopJudgement(judge, true);
+        block.connect(body);
+        return block;
+    }
+
+    @Override
+    public Block visitWhileStatement(Java9Parser.WhileStatementContext ctx) {
+        Block judge = Blocks.buildJudgement(ctx.expression());
+        Block body = visitStatement(ctx.statement());
+        body.connectLoopJudgement(judge, true);
+        return body;
+    }
+
+    @Override
+    public Block visitWhileStatementNoShortIf(Java9Parser.WhileStatementNoShortIfContext ctx) {
+        Block judge = Blocks.buildJudgement(ctx.expression());
+        Block body = visitStatementNoShortIf(ctx.statementNoShortIf());
+        body.connectLoopJudgement(judge, true);
+        return body;
+    }
+
+    @Override
+    protected Block aggregateResult(Block block, Block next) {
+        if (block == null) return next;
+        if (next == null) return block;
+        block.connect(next);
+        return block;
+    }
+
+    @Override
+    public Block visitNormalClassDeclaration(Java9Parser.NormalClassDeclarationContext ctx) {
+        name.push('$', ctx.identifier().getText());
+        super.visitNormalClassDeclaration(ctx);
+        name.pop('$');
+        return null;
+    }
+
+    @Override
+    public Block visitEnumDeclaration(Java9Parser.EnumDeclarationContext ctx) {
+        name.push('$', ctx.identifier().getText());
+        super.visitEnumDeclaration(ctx);
+        name.pop('$');
+        return null;
+    }
+
+    @Override
+    public Block visitNormalInterfaceDeclaration(Java9Parser.NormalInterfaceDeclarationContext ctx) {
+        name.push('$', ctx.identifier().getText());
+        super.visitNormalInterfaceDeclaration(ctx);
+        name.pop('$');
+        return null;
+    }
+
+    @Override
+    public Block visitAnnotationTypeDeclaration(Java9Parser.AnnotationTypeDeclarationContext ctx) {
+        name.push('$', ctx.identifier().getText());
+        super.visitAnnotationTypeDeclaration(ctx);
+        name.pop('$');
+        return null;
+    }
+
+    @Override
+    public Block visitMethodDeclaration(Java9Parser.MethodDeclarationContext ctx) {
+        name.push('#', ctx.methodHeader().methodDeclarator().identifier().getText());
+        String blockName = name.toString();
+        Block block = Blocks.build(ctx);
+        Block body = visitMethodBody(ctx.methodBody());
+        block.connect(body);
+        blocks.put(blockName, block);
+        name.pop('#');
+        return null;
+    }
+
+    @Override
+    public Block visitLocalVariableDeclarationStatement(Java9Parser.LocalVariableDeclarationStatementContext ctx) {
+        return Blocks.build(ctx);
+    }
+
+    @Override
+    public Block visitEmptyStatement(Java9Parser.EmptyStatementContext ctx) {
+        return Blocks.build(ctx);
+    }
+
+    @Override
+    public Block visitExpressionStatement(Java9Parser.ExpressionStatementContext ctx) {
+        return Blocks.build(ctx);
+    }
+
+    @Override
+    public Block visitAssertStatement(Java9Parser.AssertStatementContext ctx) {
+        return Blocks.build(ctx, Arrays.asList(null, "assert failed"));
+        // TODO: assertStatement
+    }
+
+    @Override
+    public Block visitBreakStatement(Java9Parser.BreakStatementContext ctx) {
+        return Blocks.build(ctx, "break");
+        // TODO: break label
+    }
+
+    @Override
+    public Block visitContinueStatement(Java9Parser.ContinueStatementContext ctx) {
+        return Blocks.build(ctx, "continue");
+        // TODO: continue label
+    }
+
+    @Override
+    public Block visitReturnStatement(Java9Parser.ReturnStatementContext ctx) {
+        return Blocks.build(ctx, "return");
+    }
+}

java-flowchart/src/main/java/xyz/ignatz/antlr/java9/utils/JavaName.java

@@ -0,0 +1,21 @@
+package xyz.ignatz.antlr.java9.utils;
+
+public class JavaName {
+    String name = "";
+
+    public void push(char c, String name) {
+        this.name += c + name;
+    }
+
+    public String pop(char c) {
+        int idx = name.lastIndexOf(c);
+        String top = name.substring(idx + 1);
+        name = name.substring(0, idx);
+        return top;
+    }
+
+    @Override
+    public String toString() {
+        return name.length() > 0 ? name.substring(1) : "";
+    }
+}

java-flowchart/target/classes/grammar/Java9.g4

@@ -0,0 +1,1862 @@
+/*
+ * [The "BSD license"]
+ *  Copyright (c) 2014 Terence Parr
+ *  Copyright (c) 2014 Sam Harwell
+ *  Copyright (c) 2017 Chan Chung Kwong
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *  3. The name of the author may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ *  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ *  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ *  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/**
+ * A Java 9 grammar for ANTLR 4 derived from the Java Language Specification
+ * chapter 19.
+ *
+ * NOTE: This grammar results in a generated parser that is much slower
+ *       than the Java 7 grammar in the grammars-v4/java directory. This
+ *     one is, however, extremely close to the spec.
+ *
+ * You can test with
+ *
+ *  $ antlr4 Java9.g4
+ *  $ javac *.java
+ *  $ grun Java9 compilationUnit *.java
+ *
+ * Or,
+~/antlr/code/grammars-v4/java9 $ java Test .
+/Users/parrt/antlr/code/grammars-v4/java9/./Java9BaseListener.java
+/Users/parrt/antlr/code/grammars-v4/java9/./Java9Lexer.java
+/Users/parrt/antlr/code/grammars-v4/java9/./Java9Listener.java
+/Users/parrt/antlr/code/grammars-v4/java9/./Java9Parser.java
+/Users/parrt/antlr/code/grammars-v4/java9/./Test.java
+Total lexer+parser time 30844ms.
+~/antlr/code/grammars-v4/java9 $ java Test examples/module-info.java
+/home/kwong/projects/grammars-v4/java9/examples/module-info.java
+Total lexer+parser time 914ms.
+~/antlr/code/grammars-v4/java9 $ java Test examples/TryWithResourceDemo.java
+/home/kwong/projects/grammars-v4/java9/examples/TryWithResourceDemo.java
+Total lexer+parser time 3634ms.
+~/antlr/code/grammars-v4/java9 $ java Test examples/helloworld.java
+/home/kwong/projects/grammars-v4/java9/examples/helloworld.java
+Total lexer+parser time 2497ms.
+
+ */
+grammar Java9;
+
+/*
+ * Productions from §3 (Lexical Structure)
+ */
+
+literal
+	:	IntegerLiteral
+	|	FloatingPointLiteral
+	|	BooleanLiteral
+	|	CharacterLiteral
+	|	StringLiteral
+	|	NullLiteral
+	;
+
+/*
+ * Productions from §4 (Types, Values, and Variables)
+ */
+
+primitiveType
+	:	annotation* numericType
+	|	annotation* 'boolean'
+	;
+
+numericType
+	:	integralType
+	|	floatingPointType
+	;
+
+integralType
+	:	'byte'
+	|	'short'
+	|	'int'
+	|	'long'
+	|	'char'
+	;
+
+floatingPointType
+	:	'float'
+	|	'double'
+	;
+
+referenceType
+	:	classOrInterfaceType
+	|	typeVariable
+	|	arrayType
+	;
+
+/*classOrInterfaceType
+	:	classType
+	|	interfaceType
+	;
+*/
+classOrInterfaceType
+	:	(	classType_lfno_classOrInterfaceType
+		|	interfaceType_lfno_classOrInterfaceType
+		)
+		(	classType_lf_classOrInterfaceType
+		|	interfaceType_lf_classOrInterfaceType
+		)*
+	;
+
+classType
+	:	annotation* identifier typeArguments?
+	|	classOrInterfaceType '.' annotation* identifier typeArguments?
+	;
+
+classType_lf_classOrInterfaceType
+	:	'.' annotation* identifier typeArguments?
+	;
+
+classType_lfno_classOrInterfaceType
+	:	annotation* identifier typeArguments?
+	;
+
+interfaceType
+	:	classType
+	;
+
+interfaceType_lf_classOrInterfaceType
+	:	classType_lf_classOrInterfaceType
+	;
+
+interfaceType_lfno_classOrInterfaceType
+	:	classType_lfno_classOrInterfaceType
+	;
+
+typeVariable
+	:	annotation* identifier
+	;
+
+arrayType
+	:	primitiveType dims
+	|	classOrInterfaceType dims
+	|	typeVariable dims
+	;
+
+dims
+	:	annotation* '[' ']' (annotation* '[' ']')*
+	;
+
+typeParameter
+	:	typeParameterModifier* identifier typeBound?
+	;
+
+typeParameterModifier
+	:	annotation
+	;
+
+typeBound
+	:	'extends' typeVariable
+	|	'extends' classOrInterfaceType additionalBound*
+	;
+
+additionalBound
+	:	'&' interfaceType
+	;
+
+typeArguments
+	:	'<' typeArgumentList '>'
+	;
+
+typeArgumentList
+	:	typeArgument (',' typeArgument)*
+	;
+
+typeArgument
+	:	referenceType
+	|	wildcard
+	;
+
+wildcard
+	:	annotation* '?' wildcardBounds?
+	;
+
+wildcardBounds
+	:	'extends' referenceType
+	|	'super' referenceType
+	;
+
+/*
+ * Productions from §6 (Names)
+ */
+
+moduleName
+	:	identifier
+	|	moduleName '.' identifier
+	;
+
+packageName
+	:	identifier
+	|	packageName '.' identifier
+	;
+
+typeName
+	:	identifier
+	|	packageOrTypeName '.' identifier
+	;
+
+packageOrTypeName
+	:	identifier
+	|	packageOrTypeName '.' identifier
+	;
+
+expressionName
+	:	identifier
+	|	ambiguousName '.' identifier
+	;
+
+methodName
+	:	identifier
+	;
+
+ambiguousName
+	:	identifier
+	|	ambiguousName '.' identifier
+	;
+
+/*
+ * Productions from §7 (Packages)
+ */
+
+compilationUnit
+	:	ordinaryCompilation
+	|	modularCompilation
+	;
+
+ordinaryCompilation
+	:	packageDeclaration? importDeclaration* typeDeclaration* EOF
+	;
+
+modularCompilation
+	:	importDeclaration* moduleDeclaration
+	;
+
+packageDeclaration
+	:	packageModifier* 'package' packageName ';'
+	;
+
+packageModifier
+	:	annotation
+	;
+
+importDeclaration
+	:	singleTypeImportDeclaration
+	|	typeImportOnDemandDeclaration
+	|	singleStaticImportDeclaration
+	|	staticImportOnDemandDeclaration
+	;
+
+singleTypeImportDeclaration
+	:	'import' typeName ';'
+	;
+
+typeImportOnDemandDeclaration
+	:	'import' packageOrTypeName '.' '*' ';'
+	;
+
+singleStaticImportDeclaration
+	:	'import' 'static' typeName '.' identifier ';'
+	;
+
+staticImportOnDemandDeclaration
+	:	'import' 'static' typeName '.' '*' ';'
+	;
+
+typeDeclaration
+	:	classDeclaration
+	|	interfaceDeclaration
+	|	';'
+	;
+
+moduleDeclaration
+	:	annotation* 'open'? 'module' moduleName '{' moduleDirective* '}'
+	;
+
+moduleDirective
+	:	'requires' requiresModifier* moduleName ';'
+	|	'exports' packageName ('to' moduleName (',' moduleName)*)? ';'
+	|	'opens' packageName ('to' moduleName (',' moduleName)*)? ';'
+	|	'uses' typeName ';'
+	|	'provides' typeName 'with' typeName (',' typeName)* ';'
+	;
+
+requiresModifier
+	:	'transitive'
+	|	'static'
+	;
+
+/*
+ * Productions from §8 (Classes)
+ */
+
+classDeclaration
+	:	normalClassDeclaration
+	|	enumDeclaration
+	;
+
+normalClassDeclaration
+	:	classModifier* 'class' identifier typeParameters? superclass? superinterfaces? classBody
+	;
+
+classModifier
+	:	annotation
+	|	'public'
+	|	'protected'
+	|	'private'
+	|	'abstract'
+	|	'static'
+	|	'final'
+	|	'strictfp'
+	;
+
+typeParameters
+	:	'<' typeParameterList '>'
+	;
+
+typeParameterList
+	:	typeParameter (',' typeParameter)*
+	;
+
+superclass
+	:	'extends' classType
+	;
+
+superinterfaces
+	:	'implements' interfaceTypeList
+	;
+
+interfaceTypeList
+	:	interfaceType (',' interfaceType)*
+	;
+
+classBody
+	:	'{' classBodyDeclaration* '}'
+	;
+
+classBodyDeclaration
+	:	classMemberDeclaration
+	|	instanceInitializer
+	|	staticInitializer
+	|	constructorDeclaration
+	;
+
+classMemberDeclaration
+	:	fieldDeclaration
+	|	methodDeclaration
+	|	classDeclaration
+	|	interfaceDeclaration
+	|	';'
+	;
+
+fieldDeclaration
+	:	fieldModifier* unannType variableDeclaratorList ';'
+	;
+
+fieldModifier
+	:	annotation
+	|	'public'
+	|	'protected'
+	|	'private'
+	|	'static'
+	|	'final'
+	|	'transient'
+	|	'volatile'
+	;
+
+variableDeclaratorList
+	:	variableDeclarator (',' variableDeclarator)*
+	;
+
+variableDeclarator
+	:	variableDeclaratorId ('=' variableInitializer)?
+	;
+
+variableDeclaratorId
+	:	identifier dims?
+	;
+
+variableInitializer
+	:	expression
+	|	arrayInitializer
+	;
+
+unannType
+	:	unannPrimitiveType
+	|	unannReferenceType
+	;
+
+unannPrimitiveType
+	:	numericType
+	|	'boolean'
+	;
+
+unannReferenceType
+	:	unannClassOrInterfaceType
+	|	unannTypeVariable
+	|	unannArrayType
+	;
+
+/*unannClassOrInterfaceType
+	:	unannClassType
+	|	unannInterfaceType
+	;
+*/
+
+unannClassOrInterfaceType
+	:	(	unannClassType_lfno_unannClassOrInterfaceType
+		|	unannInterfaceType_lfno_unannClassOrInterfaceType
+		)
+		(	unannClassType_lf_unannClassOrInterfaceType
+		|	unannInterfaceType_lf_unannClassOrInterfaceType
+		)*
+	;
+
+unannClassType
+	:	identifier typeArguments?
+	|	unannClassOrInterfaceType '.' annotation* identifier typeArguments?
+	;
+
+unannClassType_lf_unannClassOrInterfaceType
+	:	'.' annotation* identifier typeArguments?
+	;
+
+unannClassType_lfno_unannClassOrInterfaceType
+	:	identifier typeArguments?
+	;
+
+unannInterfaceType
+	:	unannClassType
+	;
+
+unannInterfaceType_lf_unannClassOrInterfaceType
+	:	unannClassType_lf_unannClassOrInterfaceType
+	;
+
+unannInterfaceType_lfno_unannClassOrInterfaceType
+	:	unannClassType_lfno_unannClassOrInterfaceType
+	;
+
+unannTypeVariable
+	:	identifier
+	;
+
+unannArrayType
+	:	unannPrimitiveType dims
+	|	unannClassOrInterfaceType dims
+	|	unannTypeVariable dims
+	;
+
+methodDeclaration
+	:	methodModifier* methodHeader methodBody
+	;
+
+methodModifier
+	:	annotation
+	|	'public'
+	|	'protected'
+	|	'private'
+	|	'abstract'
+	|	'static'
+	|	'final'
+	|	'synchronized'
+	|	'native'
+	|	'strictfp'
+	;
+
+methodHeader
+	:	result methodDeclarator throws_?
+	|	typeParameters annotation* result methodDeclarator throws_?
+	;
+
+result
+	:	unannType
+	|	'void'
+	;
+
+methodDeclarator
+	:	identifier '(' formalParameterList? ')' dims?
+	;
+
+formalParameterList
+	:	formalParameters ',' lastFormalParameter
+	|	lastFormalParameter
+	|	receiverParameter
+	;
+
+formalParameters
+	:	formalParameter (',' formalParameter)*
+	|	receiverParameter (',' formalParameter)*
+	;
+
+formalParameter
+	:	variableModifier* unannType variableDeclaratorId
+	;
+
+variableModifier
+	:	annotation
+	|	'final'
+	;
+
+lastFormalParameter
+	:	variableModifier* unannType annotation* '...' variableDeclaratorId
+	|	formalParameter
+	;
+
+receiverParameter
+	:	annotation* unannType (identifier '.')? 'this'
+	;
+
+throws_
+	:	'throws' exceptionTypeList
+	;
+
+exceptionTypeList
+	:	exceptionType (',' exceptionType)*
+	;
+
+exceptionType
+	:	classType
+	|	typeVariable
+	;
+
+methodBody
+	:	block
+	|	';'
+	;
+
+instanceInitializer
+	:	block
+	;
+
+staticInitializer
+	:	'static' block
+	;
+
+constructorDeclaration
+	:	constructorModifier* constructorDeclarator throws_? constructorBody
+	;
+
+constructorModifier
+	:	annotation
+	|	'public'
+	|	'protected'
+	|	'private'
+	;
+
+constructorDeclarator
+	:	typeParameters? simpleTypeName '(' formalParameterList? ')'
+	;
+
+simpleTypeName
+	:	identifier
+	;
+
+constructorBody
+	:	'{' explicitConstructorInvocation? blockStatements? '}'
+	;
+
+explicitConstructorInvocation
+	:	typeArguments? 'this' '(' argumentList? ')' ';'
+	|	typeArguments? 'super' '(' argumentList? ')' ';'
+	|	expressionName '.' typeArguments? 'super' '(' argumentList? ')' ';'
+	|	primary '.' typeArguments? 'super' '(' argumentList? ')' ';'
+	;
+
+enumDeclaration
+	:	classModifier* 'enum' identifier superinterfaces? enumBody
+	;
+
+enumBody
+	:	'{' enumConstantList? ','? enumBodyDeclarations? '}'
+	;
+
+enumConstantList
+	:	enumConstant (',' enumConstant)*
+	;
+
+enumConstant
+	:	enumConstantModifier* identifier ('(' argumentList? ')')? classBody?
+	;
+
+enumConstantModifier
+	:	annotation
+	;
+
+enumBodyDeclarations
+	:	';' classBodyDeclaration*
+	;
+
+/*
+ * Productions from §9 (Interfaces)
+ */
+
+interfaceDeclaration
+	:	normalInterfaceDeclaration
+	|	annotationTypeDeclaration
+	;
+
+normalInterfaceDeclaration
+	:	interfaceModifier* 'interface' identifier typeParameters? extendsInterfaces? interfaceBody
+	;
+
+interfaceModifier
+	:	annotation
+	|	'public'
+	|	'protected'
+	|	'private'
+	|	'abstract'
+	|	'static'
+	|	'strictfp'
+	;
+
+extendsInterfaces
+	:	'extends' interfaceTypeList
+	;
+
+interfaceBody
+	:	'{' interfaceMemberDeclaration* '}'
+	;
+
+interfaceMemberDeclaration
+	:	constantDeclaration
+	|	interfaceMethodDeclaration
+	|	classDeclaration
+	|	interfaceDeclaration
+	|	';'
+	;
+
+constantDeclaration
+	:	constantModifier* unannType variableDeclaratorList ';'
+	;
+
+constantModifier
+	:	annotation
+	|	'public'
+	|	'static'
+	|	'final'
+	;
+
+interfaceMethodDeclaration
+	:	interfaceMethodModifier* methodHeader methodBody
+	;
+
+interfaceMethodModifier
+	:	annotation
+	|	'public'
+	|	'private'//Introduced in Java 9
+	|	'abstract'
+	|	'default'
+	|	'static'
+	|	'strictfp'
+	;
+
+annotationTypeDeclaration
+	:	interfaceModifier* '@' 'interface' identifier annotationTypeBody
+	;
+
+annotationTypeBody
+	:	'{' annotationTypeMemberDeclaration* '}'
+	;
+
+annotationTypeMemberDeclaration
+	:	annotationTypeElementDeclaration
+	|	constantDeclaration
+	|	classDeclaration
+	|	interfaceDeclaration
+	|	';'
+	;
+
+annotationTypeElementDeclaration
+	:	annotationTypeElementModifier* unannType identifier '(' ')' dims? defaultValue? ';'
+	;
+
+annotationTypeElementModifier
+	:	annotation
+	|	'public'
+	|	'abstract'
+	;
+
+defaultValue
+	:	'default' elementValue
+	;
+
+annotation
+	:	normalAnnotation
+	|	markerAnnotation
+	|	singleElementAnnotation
+	;
+
+normalAnnotation
+	:	'@' typeName '(' elementValuePairList? ')'
+	;
+
+elementValuePairList
+	:	elementValuePair (',' elementValuePair)*
+	;
+
+elementValuePair
+	:	identifier '=' elementValue
+	;
+
+elementValue
+	:	conditionalExpression
+	|	elementValueArrayInitializer
+	|	annotation
+	;
+
+elementValueArrayInitializer
+	:	'{' elementValueList? ','? '}'
+	;
+
+elementValueList
+	:	elementValue (',' elementValue)*
+	;
+
+markerAnnotation
+	:	'@' typeName
+	;
+
+singleElementAnnotation
+	:	'@' typeName '(' elementValue ')'
+	;
+
+/*
+ * Productions from §10 (Arrays)
+ */
+
+arrayInitializer
+	:	'{' variableInitializerList? ','? '}'
+	;
+
+variableInitializerList
+	:	variableInitializer (',' variableInitializer)*
+	;
+
+/*
+ * Productions from §14 (Blocks and Statements)
+ */
+
+block
+	:	'{' blockStatements? '}'
+	;
+
+blockStatements
+	:	blockStatement+
+	;
+
+blockStatement
+	:	localVariableDeclarationStatement
+	|	classDeclaration
+	|	statement
+	;
+
+localVariableDeclarationStatement
+	:	localVariableDeclaration ';'
+	;
+
+localVariableDeclaration
+	:	variableModifier* unannType variableDeclaratorList
+	;
+
+statement
+	:	statementWithoutTrailingSubstatement
+	|	labeledStatement
+	|	ifThenStatement
+	|	ifThenElseStatement
+	|	whileStatement
+	|	forStatement
+	;
+
+statementNoShortIf
+	:	statementWithoutTrailingSubstatement
+	|	labeledStatementNoShortIf
+	|	ifThenElseStatementNoShortIf
+	|	whileStatementNoShortIf
+	|	forStatementNoShortIf
+	;
+
+statementWithoutTrailingSubstatement
+	:	block
+	|	emptyStatement
+	|	expressionStatement
+	|	assertStatement
+	|	switchStatement
+	|	doStatement
+	|	breakStatement
+	|	continueStatement
+	|	returnStatement
+	|	synchronizedStatement
+	|	throwStatement
+	|	tryStatement
+	;
+
+emptyStatement
+	:	';'
+	;
+
+labeledStatement
+	:	identifier ':' statement
+	;
+
+labeledStatementNoShortIf
+	:	identifier ':' statementNoShortIf
+	;
+
+expressionStatement
+	:	statementExpression ';'
+	;
+
+statementExpression
+	:	assignment
+	|	preIncrementExpression
+	|	preDecrementExpression
+	|	postIncrementExpression
+	|	postDecrementExpression
+	|	methodInvocation
+	|	classInstanceCreationExpression
+	;
+
+ifThenStatement
+	:	'if' '(' expression ')' statement
+	;
+
+ifThenElseStatement
+	:	'if' '(' expression ')' statementNoShortIf 'else' statement
+	;
+
+ifThenElseStatementNoShortIf
+	:	'if' '(' expression ')' statementNoShortIf 'else' statementNoShortIf
+	;
+
+assertStatement
+	:	'assert' expression ';'
+	|	'assert' expression ':' expression ';'
+	;
+
+switchStatement
+	:	'switch' '(' expression ')' switchBlock
+	;
+
+switchBlock
+	:	'{' switchBlockStatementGroup* switchLabel* '}'
+	;
+
+switchBlockStatementGroup
+	:	switchLabels blockStatements
+	;
+
+switchLabels
+	:	switchLabel+
+	;
+
+switchLabel
+	:	'case' constantExpression ':'
+	|	'case' enumConstantName ':'
+	|	'default' ':'
+	;
+
+enumConstantName
+	:	identifier
+	;
+
+whileStatement
+	:	'while' '(' expression ')' statement
+	;
+
+whileStatementNoShortIf
+	:	'while' '(' expression ')' statementNoShortIf
+	;
+
+doStatement
+	:	'do' statement 'while' '(' expression ')' ';'
+	;
+
+forStatement
+	:	basicForStatement
+	|	enhancedForStatement
+	;
+
+forStatementNoShortIf
+	:	basicForStatementNoShortIf
+	|	enhancedForStatementNoShortIf
+	;
+
+basicForStatement
+	:	'for' '(' forInit? ';' expression? ';' forUpdate? ')' statement
+	;
+
+basicForStatementNoShortIf
+	:	'for' '(' forInit? ';' expression? ';' forUpdate? ')' statementNoShortIf
+	;
+
+forInit
+	:	statementExpressionList
+	|	localVariableDeclaration
+	;
+
+forUpdate
+	:	statementExpressionList
+	;
+
+statementExpressionList
+	:	statementExpression (',' statementExpression)*
+	;
+
+enhancedForStatement
+	:	'for' '(' variableModifier* unannType variableDeclaratorId ':' expression ')' statement
+	;
+
+enhancedForStatementNoShortIf
+	:	'for' '(' variableModifier* unannType variableDeclaratorId ':' expression ')' statementNoShortIf
+	;
+
+breakStatement
+	:	'break' identifier? ';'
+	;
+
+continueStatement
+	:	'continue' identifier? ';'
+	;
+
+returnStatement
+	:	'return' expression? ';'
+	;
+
+throwStatement
+	:	'throw' expression ';'
+	;
+
+synchronizedStatement
+	:	'synchronized' '(' expression ')' block
+	;
+
+tryStatement
+	:	'try' block catches
+	|	'try' block catches? finally_
+	|	tryWithResourcesStatement
+	;
+
+catches
+	:	catchClause+
+	;
+
+catchClause
+	:	'catch' '(' catchFormalParameter ')' block
+	;
+
+catchFormalParameter
+	:	variableModifier* catchType variableDeclaratorId
+	;
+
+catchType
+	:	unannClassType ('|' classType)*
+	;
+
+finally_
+	:	'finally' block
+	;
+
+tryWithResourcesStatement
+	:	'try' resourceSpecification block catches? finally_?
+	;
+
+resourceSpecification
+	:	'(' resourceList ';'? ')'
+	;
+
+resourceList
+	:	resource (';' resource)*
+	;
+
+resource
+	:	variableModifier* unannType variableDeclaratorId '=' expression
+	|	variableAccess//Introduced in Java 9
+	;
+
+variableAccess
+	:	expressionName
+	|	fieldAccess
+	;
+
+/*
+ * Productions from §15 (Expressions)
+ */
+
+/*primary
+	:	primaryNoNewArray
+	|	arrayCreationExpression
+	;
+*/
+
+primary
+	:	(	primaryNoNewArray_lfno_primary
+		|	arrayCreationExpression
+		)
+		(	primaryNoNewArray_lf_primary
+		)*
+	;
+
+primaryNoNewArray
+	:	literal
+	|	classLiteral
+	|	'this'
+	|	typeName '.' 'this'
+	|	'(' expression ')'
+	|	classInstanceCreationExpression
+	|	fieldAccess
+	|	arrayAccess
+	|	methodInvocation
+	|	methodReference
+	;
+
+primaryNoNewArray_lf_arrayAccess
+	:
+	;
+
+primaryNoNewArray_lfno_arrayAccess
+	:	literal
+	|	typeName ('[' ']')* '.' 'class'
+	|	'void' '.' 'class'
+	|	'this'
+	|	typeName '.' 'this'
+	|	'(' expression ')'
+	|	classInstanceCreationExpression
+	|	fieldAccess
+	|	methodInvocation
+	|	methodReference
+	;
+
+primaryNoNewArray_lf_primary
+	:	classInstanceCreationExpression_lf_primary
+	|	fieldAccess_lf_primary
+	|	arrayAccess_lf_primary
+	|	methodInvocation_lf_primary
+	|	methodReference_lf_primary
+	;
+
+primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary
+	:
+	;
+
+primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary
+	:	classInstanceCreationExpression_lf_primary
+	|	fieldAccess_lf_primary
+	|	methodInvocation_lf_primary
+	|	methodReference_lf_primary
+	;
+
+primaryNoNewArray_lfno_primary
+	:	literal
+	|	typeName ('[' ']')* '.' 'class'
+	|	unannPrimitiveType ('[' ']')* '.' 'class'
+	|	'void' '.' 'class'
+	|	'this'
+	|	typeName '.' 'this'
+	|	'(' expression ')'
+	|	classInstanceCreationExpression_lfno_primary
+	|	fieldAccess_lfno_primary
+	|	arrayAccess_lfno_primary
+	|	methodInvocation_lfno_primary
+	|	methodReference_lfno_primary
+	;
+
+primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary
+	:
+	;
+
+primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary
+	:	literal
+	|	typeName ('[' ']')* '.' 'class'
+	|	unannPrimitiveType ('[' ']')* '.' 'class'
+	|	'void' '.' 'class'
+	|	'this'
+	|	typeName '.' 'this'
+	|	'(' expression ')'
+	|	classInstanceCreationExpression_lfno_primary
+	|	fieldAccess_lfno_primary
+	|	methodInvocation_lfno_primary
+	|	methodReference_lfno_primary
+	;
+
+classLiteral
+	:	(typeName|numericType|'boolean') ('[' ']')* '.' 'class'
+	|	'void' '.' 'class'
+	;
+
+classInstanceCreationExpression
+	:	'new' typeArguments? annotation* identifier ('.' annotation* identifier)* typeArgumentsOrDiamond? '(' argumentList? ')' classBody?
+	|	expressionName '.' 'new' typeArguments? annotation* identifier typeArgumentsOrDiamond? '(' argumentList? ')' classBody?
+	|	primary '.' 'new' typeArguments? annotation* identifier typeArgumentsOrDiamond? '(' argumentList? ')' classBody?
+	;
+
+classInstanceCreationExpression_lf_primary
+	:	'.' 'new' typeArguments? annotation* identifier typeArgumentsOrDiamond? '(' argumentList? ')' classBody?
+	;
+
+classInstanceCreationExpression_lfno_primary
+	:	'new' typeArguments? annotation* identifier ('.' annotation* identifier)* typeArgumentsOrDiamond? '(' argumentList? ')' classBody?
+	|	expressionName '.' 'new' typeArguments? annotation* identifier typeArgumentsOrDiamond? '(' argumentList? ')' classBody?
+	;
+
+typeArgumentsOrDiamond
+	:	typeArguments
+	|	'<' '>'
+	;
+
+fieldAccess
+	:	primary '.' identifier
+	|	'super' '.' identifier
+	|	typeName '.' 'super' '.' identifier
+	;
+
+fieldAccess_lf_primary
+	:	'.' identifier
+	;
+
+fieldAccess_lfno_primary
+	:	'super' '.' identifier
+	|	typeName '.' 'super' '.' identifier
+	;
+
+/*arrayAccess
+	:	expressionName '[' expression ']'
+	|	primaryNoNewArray '[' expression ']'
+	;
+*/
+
+arrayAccess
+	:	(	expressionName '[' expression ']'
+		|	primaryNoNewArray_lfno_arrayAccess '[' expression ']'
+		)
+		(	primaryNoNewArray_lf_arrayAccess '[' expression ']'
+		)*
+	;
+
+arrayAccess_lf_primary
+	:	(	primaryNoNewArray_lf_primary_lfno_arrayAccess_lf_primary '[' expression ']'
+		)
+		(	primaryNoNewArray_lf_primary_lf_arrayAccess_lf_primary '[' expression ']'
+		)*
+	;
+
+arrayAccess_lfno_primary
+	:	(	expressionName '[' expression ']'
+		|	primaryNoNewArray_lfno_primary_lfno_arrayAccess_lfno_primary '[' expression ']'
+		)
+		(	primaryNoNewArray_lfno_primary_lf_arrayAccess_lfno_primary '[' expression ']'
+		)*
+	;
+
+
+methodInvocation
+	:	methodName '(' argumentList? ')'
+	|	typeName '.' typeArguments? identifier '(' argumentList? ')'
+	|	expressionName '.' typeArguments? identifier '(' argumentList? ')'
+	|	primary '.' typeArguments? identifier '(' argumentList? ')'
+	|	'super' '.' typeArguments? identifier '(' argumentList? ')'
+	|	typeName '.' 'super' '.' typeArguments? identifier '(' argumentList? ')'
+	;
+
+methodInvocation_lf_primary
+	:	'.' typeArguments? identifier '(' argumentList? ')'
+	;
+
+methodInvocation_lfno_primary
+	:	methodName '(' argumentList? ')'
+	|	typeName '.' typeArguments? identifier '(' argumentList? ')'
+	|	expressionName '.' typeArguments? identifier '(' argumentList? ')'
+	|	'super' '.' typeArguments? identifier '(' argumentList? ')'
+	|	typeName '.' 'super' '.' typeArguments? identifier '(' argumentList? ')'
+	;
+
+argumentList
+	:	expression (',' expression)*
+	;
+
+methodReference
+	:	expressionName '::' typeArguments? identifier
+	|	referenceType '::' typeArguments? identifier
+	|	primary '::' typeArguments? identifier
+	|	'super' '::' typeArguments? identifier
+	|	typeName '.' 'super' '::' typeArguments? identifier
+	|	classType '::' typeArguments? 'new'
+	|	arrayType '::' 'new'
+	;
+
+methodReference_lf_primary
+	:	'::' typeArguments? identifier
+	;
+
+methodReference_lfno_primary
+	:	expressionName '::' typeArguments? identifier
+	|	referenceType '::' typeArguments? identifier
+	|	'super' '::' typeArguments? identifier
+	|	typeName '.' 'super' '::' typeArguments? identifier
+	|	classType '::' typeArguments? 'new'
+	|	arrayType '::' 'new'
+	;
+
+arrayCreationExpression
+	:	'new' primitiveType dimExprs dims?
+	|	'new' classOrInterfaceType dimExprs dims?
+	|	'new' primitiveType dims arrayInitializer
+	|	'new' classOrInterfaceType dims arrayInitializer
+	;
+
+dimExprs
+	:	dimExpr+
+	;
+
+dimExpr
+	:	annotation* '[' expression ']'
+	;
+
+constantExpression
+	:	expression
+	;
+
+expression
+	:	lambdaExpression
+	|	assignmentExpression
+	;
+
+lambdaExpression
+	:	lambdaParameters '->' lambdaBody
+	;
+
+lambdaParameters
+	:	identifier
+	|	'(' formalParameterList? ')'
+	|	'(' inferredFormalParameterList ')'
+	;
+
+inferredFormalParameterList
+	:	identifier (',' identifier)*
+	;
+
+lambdaBody
+	:	expression
+	|	block
+	;
+
+assignmentExpression
+	:	conditionalExpression
+	|	assignment
+	;
+
+assignment
+	:	leftHandSide assignmentOperator expression
+	;
+
+leftHandSide
+	:	expressionName
+	|	fieldAccess
+	|	arrayAccess
+	;
+
+assignmentOperator
+	:	'='
+	|	'*='
+	|	'/='
+	|	'%='
+	|	'+='
+	|	'-='
+	|	'<<='
+	|	'>>='
+	|	'>>>='
+	|	'&='
+	|	'^='
+	|	'|='
+	;
+
+conditionalExpression
+	:	conditionalOrExpression
+	|	conditionalOrExpression '?' expression ':' (conditionalExpression|lambdaExpression)
+	;
+
+conditionalOrExpression
+	:	conditionalAndExpression
+	|	conditionalOrExpression '||' conditionalAndExpression
+	;
+
+conditionalAndExpression
+	:	inclusiveOrExpression
+	|	conditionalAndExpression '&&' inclusiveOrExpression
+	;
+
+inclusiveOrExpression
+	:	exclusiveOrExpression
+	|	inclusiveOrExpression '|' exclusiveOrExpression
+	;
+
+exclusiveOrExpression
+	:	andExpression
+	|	exclusiveOrExpression '^' andExpression
+	;
+
+andExpression
+	:	equalityExpression
+	|	andExpression '&' equalityExpression
+	;
+
+equalityExpression
+	:	relationalExpression
+	|	equalityExpression '==' relationalExpression
+	|	equalityExpression '!=' relationalExpression
+	;
+
+relationalExpression
+	:	shiftExpression
+	|	relationalExpression '<' shiftExpression
+	|	relationalExpression '>' shiftExpression
+	|	relationalExpression '<=' shiftExpression
+	|	relationalExpression '>=' shiftExpression
+	|	relationalExpression 'instanceof' referenceType
+	;
+
+shiftExpression
+	:	additiveExpression
+	|	shiftExpression '<' '<' additiveExpression
+	|	shiftExpression '>' '>' additiveExpression
+	|	shiftExpression '>' '>' '>' additiveExpression
+	;
+
+additiveExpression
+	:	multiplicativeExpression
+	|	additiveExpression '+' multiplicativeExpression
+	|	additiveExpression '-' multiplicativeExpression
+	;
+
+multiplicativeExpression
+	:	unaryExpression
+	|	multiplicativeExpression '*' unaryExpression
+	|	multiplicativeExpression '/' unaryExpression
+	|	multiplicativeExpression '%' unaryExpression
+	;
+
+unaryExpression
+	:	preIncrementExpression
+	|	preDecrementExpression
+	|	'+' unaryExpression
+	|	'-' unaryExpression
+	|	unaryExpressionNotPlusMinus
+	;
+
+preIncrementExpression
+	:	'++' unaryExpression
+	;
+
+preDecrementExpression
+	:	'--' unaryExpression
+	;
+
+unaryExpressionNotPlusMinus
+	:	postfixExpression
+	|	'~' unaryExpression
+	|	'!' unaryExpression
+	|	castExpression
+	;
+
+/*postfixExpression
+	:	primary
+	|	expressionName
+	|	postIncrementExpression
+	|	postDecrementExpression
+	;
+*/
+
+postfixExpression
+	:	(	primary
+		|	expressionName
+		)
+		(	postIncrementExpression_lf_postfixExpression
+		|	postDecrementExpression_lf_postfixExpression
+		)*
+	;
+
+postIncrementExpression
+	:	postfixExpression '++'
+	;
+
+postIncrementExpression_lf_postfixExpression
+	:	'++'
+	;
+
+postDecrementExpression
+	:	postfixExpression '--'
+	;
+
+postDecrementExpression_lf_postfixExpression
+	:	'--'
+	;
+
+castExpression
+	:	'(' primitiveType ')' unaryExpression
+	|	'(' referenceType additionalBound* ')' unaryExpressionNotPlusMinus
+	|	'(' referenceType additionalBound* ')' lambdaExpression
+	;
+
+// LEXER
+
+identifier : Identifier | 'to' | 'module' | 'open' | 'with' | 'provides' | 'uses' | 'opens' | 'requires' | 'exports';
+
+// §3.9 Keywords
+
+ABSTRACT : 'abstract';
+ASSERT : 'assert';
+BOOLEAN : 'boolean';
+BREAK : 'break';
+BYTE : 'byte';
+CASE : 'case';
+CATCH : 'catch';
+CHAR : 'char';
+CLASS : 'class';
+CONST : 'const';
+CONTINUE : 'continue';
+DEFAULT : 'default';
+DO : 'do';
+DOUBLE : 'double';
+ELSE : 'else';
+ENUM : 'enum';
+EXTENDS : 'extends';
+FINAL : 'final';
+FINALLY : 'finally';
+FLOAT : 'float';
+FOR : 'for';
+IF : 'if';
+GOTO : 'goto';
+IMPLEMENTS : 'implements';
+IMPORT : 'import';
+INSTANCEOF : 'instanceof';
+INT : 'int';
+INTERFACE : 'interface';
+LONG : 'long';
+NATIVE : 'native';
+NEW : 'new';
+PACKAGE : 'package';
+PRIVATE : 'private';
+PROTECTED : 'protected';
+PUBLIC : 'public';
+RETURN : 'return';
+SHORT : 'short';
+STATIC : 'static';
+STRICTFP : 'strictfp';
+SUPER : 'super';
+SWITCH : 'switch';
+SYNCHRONIZED : 'synchronized';
+THIS : 'this';
+THROW : 'throw';
+THROWS : 'throws';
+TRANSIENT : 'transient';
+TRY : 'try';
+VOID : 'void';
+VOLATILE : 'volatile';
+WHILE : 'while';
+UNDER_SCORE : '_';//Introduced in Java 9
+
+// §3.10.1 Integer Literals
+
+IntegerLiteral
+	:	DecimalIntegerLiteral
+	|	HexIntegerLiteral
+	|	OctalIntegerLiteral
+	|	BinaryIntegerLiteral
+	;
+
+fragment
+DecimalIntegerLiteral
+	:	DecimalNumeral IntegerTypeSuffix?
+	;
+
+fragment
+HexIntegerLiteral
+	:	HexNumeral IntegerTypeSuffix?
+	;
+
+fragment
+OctalIntegerLiteral
+	:	OctalNumeral IntegerTypeSuffix?
+	;
+
+fragment
+BinaryIntegerLiteral
+	:	BinaryNumeral IntegerTypeSuffix?
+	;
+
+fragment
+IntegerTypeSuffix
+	:	[lL]
+	;
+
+fragment
+DecimalNumeral
+	:	'0'
+	|	NonZeroDigit (Digits? | Underscores Digits)
+	;
+
+fragment
+Digits
+	:	Digit (DigitsAndUnderscores? Digit)?
+	;
+
+fragment
+Digit
+	:	'0'
+	|	NonZeroDigit
+	;
+
+fragment
+NonZeroDigit
+	:	[1-9]
+	;
+
+fragment
+DigitsAndUnderscores
+	:	DigitOrUnderscore+
+	;
+
+fragment
+DigitOrUnderscore
+	:	Digit
+	|	'_'
+	;
+
+fragment
+Underscores
+	:	'_'+
+	;
+
+fragment
+HexNumeral
+	:	'0' [xX] HexDigits
+	;
+
+fragment
+HexDigits
+	:	HexDigit (HexDigitsAndUnderscores? HexDigit)?
+	;
+
+fragment
+HexDigit
+	:	[0-9a-fA-F]
+	;
+
+fragment
+HexDigitsAndUnderscores
+	:	HexDigitOrUnderscore+
+	;
+
+fragment
+HexDigitOrUnderscore
+	:	HexDigit
+	|	'_'
+	;
+
+fragment
+OctalNumeral
+	:	'0' Underscores? OctalDigits
+	;
+
+fragment
+OctalDigits
+	:	OctalDigit (OctalDigitsAndUnderscores? OctalDigit)?
+	;
+
+fragment
+OctalDigit
+	:	[0-7]
+	;
+
+fragment
+OctalDigitsAndUnderscores
+	:	OctalDigitOrUnderscore+
+	;
+
+fragment
+OctalDigitOrUnderscore
+	:	OctalDigit
+	|	'_'
+	;
+
+fragment
+BinaryNumeral
+	:	'0' [bB] BinaryDigits
+	;
+
+fragment
+BinaryDigits
+	:	BinaryDigit (BinaryDigitsAndUnderscores? BinaryDigit)?
+	;
+
+fragment
+BinaryDigit
+	:	[01]
+	;
+
+fragment
+BinaryDigitsAndUnderscores
+	:	BinaryDigitOrUnderscore+
+	;
+
+fragment
+BinaryDigitOrUnderscore
+	:	BinaryDigit
+	|	'_'
+	;
+
+// §3.10.2 Floating-Point Literals
+
+FloatingPointLiteral
+	:	DecimalFloatingPointLiteral
+	|	HexadecimalFloatingPointLiteral
+	;
+
+fragment
+DecimalFloatingPointLiteral
+	:	Digits '.' Digits? ExponentPart? FloatTypeSuffix?
+	|	'.' Digits ExponentPart? FloatTypeSuffix?
+	|	Digits ExponentPart FloatTypeSuffix?
+	|	Digits FloatTypeSuffix
+	;
+
+fragment
+ExponentPart
+	:	ExponentIndicator SignedInteger
+	;
+
+fragment
+ExponentIndicator
+	:	[eE]
+	;
+
+fragment
+SignedInteger
+	:	Sign? Digits
+	;
+
+fragment
+Sign
+	:	[+-]
+	;
+
+fragment
+FloatTypeSuffix
+	:	[fFdD]
+	;
+
+fragment
+HexadecimalFloatingPointLiteral
+	:	HexSignificand BinaryExponent FloatTypeSuffix?
+	;
+
+fragment
+HexSignificand
+	:	HexNumeral '.'?
+	|	'0' [xX] HexDigits? '.' HexDigits
+	;
+
+fragment
+BinaryExponent
+	:	BinaryExponentIndicator SignedInteger
+	;
+
+fragment
+BinaryExponentIndicator
+	:	[pP]
+	;
+
+// §3.10.3 Boolean Literals
+
+BooleanLiteral
+	:	'true'
+	|	'false'
+	;
+
+// §3.10.4 Character Literals
+
+CharacterLiteral
+	:	'\'' SingleCharacter '\''
+	|	'\'' EscapeSequence '\''
+	;
+
+fragment
+SingleCharacter
+	:	~['\\\r\n]
+	;
+
+// §3.10.5 String Literals
+
+StringLiteral
+	:	'"' StringCharacters? '"'
+	;
+
+fragment
+StringCharacters
+	:	StringCharacter+
+	;
+
+fragment
+StringCharacter
+	:	~["\\\r\n]
+	|	EscapeSequence
+	;
+
+// §3.10.6 Escape Sequences for Character and String Literals
+
+fragment
+EscapeSequence
+	:	'\\' [btnfr"'\\]
+	|	OctalEscape
+    |   UnicodeEscape // This is not in the spec but prevents having to preprocess the input
+	;
+
+fragment
+OctalEscape
+	:	'\\' OctalDigit
+	|	'\\' OctalDigit OctalDigit
+	|	'\\' ZeroToThree OctalDigit OctalDigit
+	;
+
+fragment
+ZeroToThree
+	:	[0-3]
+	;
+
+// This is not in the spec but prevents having to preprocess the input
+fragment
+UnicodeEscape
+    :   '\\' 'u'+ HexDigit HexDigit HexDigit HexDigit
+    ;
+
+// §3.10.7 The Null Literal
+
+NullLiteral
+	:	'null'
+	;
+
+// §3.11 Separators
+
+LPAREN : '(';
+RPAREN : ')';
+LBRACE : '{';
+RBRACE : '}';
+LBRACK : '[';
+RBRACK : ']';
+SEMI : ';';
+COMMA : ',';
+DOT : '.';
+ELLIPSIS : '...';
+AT : '@';
+COLONCOLON : '::';
+
+
+// §3.12 Operators
+
+ASSIGN : '=';
+GT : '>';
+LT : '<';
+BANG : '!';
+TILDE : '~';
+QUESTION : '?';
+COLON : ':';
+ARROW : '->';
+EQUAL : '==';
+LE : '<=';
+GE : '>=';
+NOTEQUAL : '!=';
+AND : '&&';
+OR : '||';
+INC : '++';
+DEC : '--';
+ADD : '+';
+SUB : '-';
+MUL : '*';
+DIV : '/';
+BITAND : '&';
+BITOR : '|';
+CARET : '^';
+MOD : '%';
+//LSHIFT : '<<';
+//RSHIFT : '>>';
+//URSHIFT : '>>>';
+
+ADD_ASSIGN : '+=';
+SUB_ASSIGN : '-=';
+MUL_ASSIGN : '*=';
+DIV_ASSIGN : '/=';
+AND_ASSIGN : '&=';
+OR_ASSIGN : '|=';
+XOR_ASSIGN : '^=';
+MOD_ASSIGN : '%=';
+LSHIFT_ASSIGN : '<<=';
+RSHIFT_ASSIGN : '>>=';
+URSHIFT_ASSIGN : '>>>=';
+
+// §3.8 Identifiers (must appear after all keywords in the grammar)
+
+Identifier
+	:	JavaLetter JavaLetterOrDigit*
+	;
+
+fragment
+JavaLetter
+	:	[a-zA-Z$_] // these are the "java letters" below 0x7F
+	|	// covers all characters above 0x7F which are not a surrogate
+		~[\u0000-\u007F\uD800-\uDBFF]
+		{Character.isJavaIdentifierStart(_input.LA(-1))}?
+	|	// covers UTF-16 surrogate pairs encodings for U+10000 to U+10FFFF
+		[\uD800-\uDBFF] [\uDC00-\uDFFF]
+		{Character.isJavaIdentifierStart(Character.toCodePoint((char)_input.LA(-2), (char)_input.LA(-1)))}?
+	;
+
+fragment
+JavaLetterOrDigit
+	:	[a-zA-Z0-9$_] // these are the "java letters or digits" below 0x7F
+	|	// covers all characters above 0x7F which are not a surrogate
+		~[\u0000-\u007F\uD800-\uDBFF]
+		{Character.isJavaIdentifierPart(_input.LA(-1))}?
+	|	// covers UTF-16 surrogate pairs encodings for U+10000 to U+10FFFF
+		[\uD800-\uDBFF] [\uDC00-\uDFFF]
+		{Character.isJavaIdentifierPart(Character.toCodePoint((char)_input.LA(-2), (char)_input.LA(-1)))}?
+	;
+
+//
+// Whitespace and comments
+//
+
+WS  :  [ \t\r\n\u000C]+ -> skip
+    ;
+
+COMMENT
+    :   '/*' .*? '*/' -> channel(HIDDEN)
+    ;
+
+LINE_COMMENT
+    :   '//' ~[\r\n]* -> channel(HIDDEN)
+    ;