deploy: v0.12 fix 存档key名

node_modules/@lezer/java/test/comments.txt

@@ -0,0 +1,22 @@
+# comment
+
+// This is a comment
+/* This is also a comment */
+/* this comment /* // /** ends here: */
+
+==>
+
+Program(LineComment, BlockComment, BlockComment)
+
+
+# comments and literals
+
+123;
+// comment
+
+==>
+
+Program(
+  ExpressionStatement(IntegerLiteral),
+  LineComment)
+

node_modules/@lezer/java/test/declarations.txt

@@ -0,0 +1,577 @@
+# local variable
+
+class A {
+  public int b() {
+    int c = 5;
+  }
+}
+
+==>
+
+Program(
+  ClassDeclaration(class,
+    Definition,
+    ClassBody(
+      MethodDeclaration(
+        Modifiers(public),
+        PrimitiveType,
+        Definition,
+        FormalParameters,
+        Block(
+          LocalVariableDeclaration(
+            PrimitiveType,
+            VariableDeclarator(
+              Definition,
+              AssignOp,
+              IntegerLiteral)))))))
+
+
+# local array variable
+
+String[] nodeNames = internalCluster().getNodeNames();
+Integer[][] inputArrays = new Integer[0x100][];
+
+==>
+
+Program(
+  LocalVariableDeclaration(
+    ArrayType(
+      TypeName,
+      Dimension),
+    VariableDeclarator(
+      Definition,
+      AssignOp,
+      MethodInvocation(
+        MethodInvocation(
+          MethodName(Identifier),
+          ArgumentList),
+        MethodName(Identifier),
+        ArgumentList))),
+  LocalVariableDeclaration(
+    ArrayType(
+      TypeName,
+      Dimension, Dimension),
+    VariableDeclarator(
+      Definition,
+      AssignOp,
+      ArrayCreationExpression(new,
+        TypeName,
+        Dimension(IntegerLiteral),
+        Dimension))))
+
+
+# module
+
+module com.foo { }
+open module com.foo { }
+
+==>
+
+Program(
+  ModuleDeclaration(module,
+    ScopedIdentifier(
+      Identifier,
+      Identifier),
+    ModuleBody),
+  ModuleDeclaration(open, module,
+    ScopedIdentifier(
+      Identifier,
+      Identifier),
+    ModuleBody))
+
+
+# module with normal annotation
+
+@RequestForEnhancement(
+    id       = 2868724,
+    synopsis = "Provide time-travel functionality",
+    engineer = "Mr. Peabody",
+    date     = "4/1/2004"
+)
+module com.foo { }
+
+==>
+
+Program(
+  ModuleDeclaration(
+    Annotation(
+      Identifier,
+      AnnotationArgumentList(
+        ElementValuePair(Identifier, AssignOp, IntegerLiteral),
+        ElementValuePair(Identifier, AssignOp, StringLiteral),
+        ElementValuePair(Identifier, AssignOp, StringLiteral),
+        ElementValuePair(Identifier, AssignOp, StringLiteral))),
+    module,
+    ScopedIdentifier(Identifier, Identifier),
+    ModuleBody))
+
+
+# module with marker annotation
+
+@Preliminary module com.foo { }
+@Preliminary open module com.foo { }
+
+==>
+
+Program(
+  ModuleDeclaration(
+    MarkerAnnotation(Identifier),
+    module,
+    ScopedIdentifier(Identifier, Identifier),
+    ModuleBody),
+  ModuleDeclaration(
+    MarkerAnnotation(Identifier),
+    open, module,
+    ScopedIdentifier(Identifier, Identifier),
+    ModuleBody))
+
+
+# module with single element annotation
+
+@Copyright("a")
+module com.foo {}
+
+==>
+
+Program(
+  ModuleDeclaration(
+    Annotation(
+      Identifier,
+      AnnotationArgumentList(StringLiteral)),
+    module,
+    ScopedIdentifier(
+      Identifier,
+      Identifier),
+    ModuleBody))
+
+
+# package_declaration
+
+package myVector;
+
+==>
+
+Program(PackageDeclaration(package,Identifier))
+
+# module directive
+
+module com.example.foo {
+    requires com.example.foo.http;
+}
+
+==>
+
+Program(
+  ModuleDeclaration(module,
+    ScopedIdentifier(
+      ScopedIdentifier(
+        Identifier,
+        Identifier),
+      Identifier),
+    ModuleBody(
+      ModuleDirective(requires,
+        ScopedIdentifier(
+          ScopedIdentifier(
+            ScopedIdentifier(
+              Identifier,
+              Identifier),
+            Identifier),
+          Identifier)))))
+
+
+# module directive with requires, exports, opens, uses and provides
+
+module com.example.foo {
+    requires com.example.http;
+    requires java.logging;
+
+    requires transitive com.example.network;
+
+    exports com.example.bar;
+    exports com.example.internal to com.example.probe;
+
+    opens com.example.quux;
+    opens com.example.internal to com.example.network, com.example.probe;
+
+    uses com.example.Intf;
+    provides com.example.Intf with com.example.Impl;
+}
+
+==>
+
+Program(
+  ModuleDeclaration(module,
+    ScopedIdentifier(ScopedIdentifier(Identifier, Identifier), Identifier),
+    ModuleBody(
+      ModuleDirective(requires,
+        ScopedIdentifier(ScopedIdentifier(Identifier, Identifier), Identifier)),
+      ModuleDirective(requires,
+        ScopedIdentifier(Identifier, Identifier)),
+      ModuleDirective(requires, transitive,
+        ScopedIdentifier(ScopedIdentifier(Identifier, Identifier), Identifier)),
+      ModuleDirective(exports,
+        ScopedIdentifier(ScopedIdentifier(Identifier, Identifier), Identifier)),
+      ModuleDirective(exports,
+        ScopedIdentifier(ScopedIdentifier(Identifier, Identifier), Identifier),
+        to, ScopedIdentifier(ScopedIdentifier(Identifier, Identifier), Identifier)),
+      ModuleDirective(opens,
+        ScopedIdentifier(ScopedIdentifier(Identifier, Identifier), Identifier)),
+      ModuleDirective(opens,
+        ScopedIdentifier(ScopedIdentifier(Identifier, Identifier), Identifier),
+        to, ScopedIdentifier(ScopedIdentifier(Identifier, Identifier), Identifier),
+        ScopedIdentifier(ScopedIdentifier(Identifier, Identifier), Identifier)),
+      ModuleDirective(uses,
+        ScopedIdentifier(ScopedIdentifier(Identifier, Identifier), Identifier)),
+      ModuleDirective(provides,
+        ScopedIdentifier(ScopedIdentifier(Identifier, Identifier), Identifier),
+        with, ScopedIdentifier(ScopedIdentifier(Identifier, Identifier), Identifier)))))
+
+
+# single type import declaration
+
+import java.util.Vector;
+
+==>
+
+Program(ImportDeclaration(import,
+  ScopedIdentifier(ScopedIdentifier(Identifier, Identifier), Identifier)))
+
+
+# type_import_on_declaraction
+
+import java.util.*;
+
+==>
+
+Program(ImportDeclaration(import,
+  ScopedIdentifier(Identifier, Identifier), Asterisk))
+
+
+# single static import declaration
+
+import static java.util.Vector;
+
+==>
+
+Program(ImportDeclaration(import, static,
+  ScopedIdentifier(
+    ScopedIdentifier(Identifier, Identifier),
+    Identifier)))
+
+
+# static import on demand declaration
+
+import static java.util.*;
+
+==>
+
+Program(ImportDeclaration(import, static,
+  ScopedIdentifier(Identifier, Identifier),
+  Asterisk))
+
+
+# class declaration
+
+class Point {
+}
+
+==>
+
+Program(
+  ClassDeclaration(class, Definition, ClassBody))
+
+
+# class declaration involving public, private, abstract and superclass
+
+public class Point {
+}
+
+private class Point {
+}
+
+abstract class ColoredPoint extends Point {
+}
+
+==>
+
+Program(
+  ClassDeclaration(Modifiers(public), class, Definition, ClassBody),
+  ClassDeclaration(Modifiers(private), class, Definition, ClassBody),
+  ClassDeclaration(Modifiers(abstract), class, Definition, Superclass(extends, TypeName), ClassBody))
+
+
+# class declaration with implements
+
+public class Dog implements ISpeak {
+}
+
+==>
+
+Program(
+  ClassDeclaration(
+     Modifiers(public), class, Definition,
+     SuperInterfaces(implements,InterfaceTypeList(TypeName)), ClassBody))
+
+
+# class declaration with body
+
+class Point {
+  int x;
+
+  void bar() {
+    x = 2;
+  }
+}
+
+==>
+
+Program(
+  ClassDeclaration(class,
+    Definition,
+    ClassBody(
+      FieldDeclaration(
+        PrimitiveType,
+        VariableDeclarator(Definition)),
+      MethodDeclaration(
+        void,
+        Definition,
+        FormalParameters,
+        Block(
+          ExpressionStatement(
+            AssignmentExpression(Identifier, AssignOp, IntegerLiteral)))))))
+
+
+# interface declaration
+
+interface Top {
+}
+
+==>
+
+Program(
+  InterfaceDeclaration(
+    interface,
+    Definition,
+    InterfaceBody))
+
+
+# interface declaration with extends
+
+interface Left extends Top {
+}
+
+interface Bottom extends Left, Right {}
+
+==>
+
+Program(
+  InterfaceDeclaration(
+    interface,
+    Definition,
+    ExtendsInterfaces(extends,InterfaceTypeList(TypeName)),
+    InterfaceBody),
+  InterfaceDeclaration(
+    interface,
+    Definition,
+    ExtendsInterfaces(extends,InterfaceTypeList(TypeName, TypeName)), InterfaceBody))
+
+
+# interface with annotation type declaration
+
+@interface SelfRef {}
+
+==>
+
+Program(
+  AnnotationTypeDeclaration(Identifier, AnnotationTypeBody))
+
+
+# method declaration
+
+class Beyonce {
+  void calculateAnswer(double wingSpan, int numberOfEngines,
+                       double length, double grossTons) {
+      //do the calculation here
+  }
+}
+
+==>
+
+Program(
+  ClassDeclaration(class,
+    Definition,
+    ClassBody(
+      MethodDeclaration(
+        void,
+        Definition,
+        FormalParameters(
+          FormalParameter(PrimitiveType, Definition),
+          FormalParameter(PrimitiveType, Definition),
+          FormalParameter(PrimitiveType, Definition),
+          FormalParameter(PrimitiveType, Definition)),
+        Block(LineComment)))))
+
+
+# constructor declaration
+
+class Point {
+  int x, y;
+  Point(int x, int y) {
+    this.x = x;
+    this.y = y;
+  }
+
+  Point() {
+    this(0, 0);
+  }
+}
+
+==>
+
+Program(
+  ClassDeclaration(class,
+    Definition,
+    ClassBody(
+      FieldDeclaration(
+        PrimitiveType,
+        VariableDeclarator(Definition),
+        VariableDeclarator(Definition)),
+      ConstructorDeclaration(
+        Definition,
+        FormalParameters(
+          FormalParameter(
+            PrimitiveType,
+            Definition),
+          FormalParameter(
+            PrimitiveType,
+            Definition)),
+        ConstructorBody(
+          ExpressionStatement(AssignmentExpression(
+            FieldAccess(
+              this,
+              Identifier),
+            AssignOp,
+            Identifier)),
+          ExpressionStatement(AssignmentExpression(
+            FieldAccess(
+              this,
+              Identifier),
+            AssignOp,
+            Identifier)))),
+      ConstructorDeclaration(
+        Definition,
+        FormalParameters,
+        ConstructorBody(
+          ExplicitConstructorInvocation(
+            this,
+            ArgumentList(
+              IntegerLiteral,
+              IntegerLiteral)))))))
+
+
+# throws
+
+class Beyonce {
+  BufferedReader newReader() throws FileNotFoundException {
+    new BufferedReader(new InputStreamReader(new FileInputStream(file), charset));
+  }
+}
+
+==>
+
+Program(
+  ClassDeclaration(class,
+    Definition,
+      ClassBody(
+        MethodDeclaration(
+          TypeName,
+          Definition,
+          FormalParameters,
+          Throws(throws,TypeName),
+          Block(
+            ExpressionStatement(
+              ObjectCreationExpression(new,
+                TypeName,
+                ArgumentList(
+                  ObjectCreationExpression(new,
+                    TypeName,
+                    ArgumentList(
+                      ObjectCreationExpression(new,
+                        TypeName,
+                        ArgumentList(Identifier)),
+                      Identifier))))))))))
+
+
+# object instantiation
+
+class Point {
+  public double Foo() {
+    new BufferedWriter();
+    Foo.new BufferedWriter();
+  }
+}
+
+==>
+
+Program(
+  ClassDeclaration(class,
+    Definition,
+    ClassBody(
+      MethodDeclaration(
+        Modifiers(public),
+        PrimitiveType,
+        Definition,
+        FormalParameters,
+        Block(
+          ExpressionStatement(
+            ObjectCreationExpression(new,
+              TypeName,
+              ArgumentList)),
+          ExpressionStatement(
+            ObjectCreationExpression(
+              Identifier, new,
+              TypeName,
+              ArgumentList)))))))
+
+
+# variable declaration
+
+class JayZ {
+  public void Beyonce() {
+    int blue_ivy_carter;
+  };
+}
+
+==>
+
+Program(
+  ClassDeclaration(class,
+    Definition,
+    ClassBody(
+      MethodDeclaration(
+        Modifiers(public),
+        void,
+        Definition,
+        FormalParameters,
+        Block(
+          LocalVariableDeclaration(
+            PrimitiveType,
+            VariableDeclarator(Definition)))))))
+
+
+# enum declaration
+
+enum HandSign {
+   SCISSOR, PAPER, STONE
+}
+
+==>
+
+Program(
+  EnumDeclaration(enum,
+    Definition,
+    EnumBody(
+      EnumConstant(Definition),
+      EnumConstant(Definition),
+      EnumConstant(Definition))))
+

node_modules/@lezer/java/test/expressions.txt

@@ -0,0 +1,758 @@
+# standalone assignment expression
+
+x = 3;
+
+==>
+
+Program(
+  ExpressionStatement(AssignmentExpression(
+    Identifier,
+    AssignOp,
+    IntegerLiteral)))
+
+
+# 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(
+  ExpressionStatement(BinaryExpression(Identifier, CompareOp, Identifier)),
+  ExpressionStatement(BinaryExpression(Identifier, CompareOp, Identifier)),
+  ExpressionStatement(BinaryExpression(Identifier, CompareOp, Identifier)),
+  ExpressionStatement(BinaryExpression(Identifier, CompareOp, Identifier)),
+  ExpressionStatement(BinaryExpression(Identifier, CompareOp, Identifier)),
+  ExpressionStatement(BinaryExpression(Identifier, CompareOp, Identifier)),
+  ExpressionStatement(BinaryExpression(Identifier, LogicOp, Identifier)),
+  ExpressionStatement(BinaryExpression(Identifier, LogicOp, Identifier)),
+  ExpressionStatement(BinaryExpression(Identifier, BitOp, Identifier)),
+  ExpressionStatement(BinaryExpression(Identifier, BitOp, Identifier)),
+  ExpressionStatement(BinaryExpression(Identifier, BitOp, Identifier)),
+  ExpressionStatement(BinaryExpression(Identifier, ArithOp, Identifier)),
+  ExpressionStatement(BinaryExpression(Identifier, BitOp, Identifier)),
+  ExpressionStatement(BinaryExpression(Identifier, BitOp, Identifier)),
+  ExpressionStatement(BinaryExpression(Identifier, BitOp, Identifier)),
+  ExpressionStatement(BinaryExpression(IntegerLiteral, ArithOp, IntegerLiteral)),
+  ExpressionStatement(BinaryExpression(IntegerLiteral, ArithOp, IntegerLiteral)),
+  ExpressionStatement(BinaryExpression(IntegerLiteral, ArithOp, IntegerLiteral)),
+  ExpressionStatement(BinaryExpression(IntegerLiteral, ArithOp, IntegerLiteral)))
+
+
+# instanceof expressions
+
+a instanceof C.D;
+a instanceof List<B>;
+c instanceof C[];
+
+==>
+
+Program(
+  ExpressionStatement(InstanceofExpression(
+    Identifier,
+    instanceof,
+    ScopedTypeName(TypeName, TypeName))),
+  ExpressionStatement(InstanceofExpression(
+    Identifier,
+    instanceof,
+    GenericType(TypeName, TypeArguments(TypeName)))),
+  ExpressionStatement(InstanceofExpression(
+    Identifier,
+    instanceof,
+    ArrayType(TypeName, Dimension))))
+
+
+# if statements
+
+if (x)
+  y;
+
+==>
+
+Program(
+  IfStatement(if,
+    ParenthesizedExpression(Identifier),
+    ExpressionStatement(Identifier)))
+
+
+# if statements with braces
+
+if (x) {
+  y;
+}
+
+==>
+
+Program(
+  IfStatement(if,
+    ParenthesizedExpression(Identifier),
+    Block(ExpressionStatement(Identifier))))
+
+
+# if statements with assignment without braces
+
+if (x = 3)
+  y = 2;
+
+==>
+
+Program(
+  IfStatement(if,
+    ParenthesizedExpression(
+      AssignmentExpression(
+        Identifier,
+        AssignOp,
+        IntegerLiteral)),
+    ExpressionStatement(
+      AssignmentExpression(
+        Identifier,
+        AssignOp,
+        IntegerLiteral))))
+
+
+# if then else statement
+
+if (x = 3) {
+  y = 9;
+} else {
+  y = 0;
+}
+
+==>
+
+Program(
+  IfStatement(if,
+    ParenthesizedExpression(
+      AssignmentExpression(
+        Identifier,
+        AssignOp,
+        IntegerLiteral)),
+    Block(
+      ExpressionStatement(AssignmentExpression(
+        Identifier,
+        AssignOp,
+        IntegerLiteral))),
+    else,
+    Block(
+      ExpressionStatement(AssignmentExpression(
+        Identifier,
+        AssignOp,
+        IntegerLiteral)))))
+
+
+# nested if then else statements
+
+if (a)
+  if (b)
+    c();
+  else
+    d();
+
+==>
+
+Program(
+  IfStatement(if,
+    ParenthesizedExpression(Identifier),
+    IfStatement(if,
+      ParenthesizedExpression(Identifier),
+      ExpressionStatement(MethodInvocation(MethodName(Identifier), ArgumentList)),
+      else,
+      ExpressionStatement(MethodInvocation(MethodName(Identifier), ArgumentList)))))
+
+
+# ternary expressions
+
+max = (a > b) ? a : b;
+
+==>
+
+Program(
+  ExpressionStatement(AssignmentExpression(
+    Identifier,
+    AssignOp,
+    TernaryExpression(
+      ParenthesizedExpression(BinaryExpression(
+        Identifier,
+        CompareOp,
+        Identifier)),
+      LogicOp,
+      Identifier,
+      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(
+  ForStatement(for, ForSpec(
+    LocalVariableDeclaration(
+      PrimitiveType,
+      VariableDeclarator(
+        Definition,
+        AssignOp,
+        IntegerLiteral)),
+    BinaryExpression(
+      Identifier,
+      CompareOp,
+      IntegerLiteral),
+    UpdateExpression(Identifier, UpdateOp,)),
+    Block(
+      ExpressionStatement(MethodInvocation(
+        FieldAccess(
+          Identifier,
+          Identifier),
+        MethodName(Identifier),
+        ArgumentList(BinaryExpression(
+          StringLiteral,
+          ArithOp,
+          Identifier)))))),
+  ForStatement(for, ForSpec(
+    MethodInvocation(
+      Identifier,
+      MethodName(Identifier),
+      ArgumentList(Identifier)),
+    MethodInvocation(
+      Identifier,
+      MethodName(Identifier),
+      ArgumentList),
+    MethodInvocation(
+      Identifier,
+      MethodName(Identifier),
+      ArgumentList)),
+    Block(
+      ExpressionStatement(MethodInvocation(
+        FieldAccess(
+          Identifier,
+          Identifier),
+        MethodName(Identifier),
+        ArgumentList(Identifier))))))
+
+
+# Enhanced for statements
+
+for (A b : c) {
+  d(b);
+}
+
+==>
+
+Program(
+  EnhancedForStatement(for, ForSpec(
+    TypeName,
+    Definition,
+    Identifier),
+    Block(
+      ExpressionStatement(MethodInvocation(
+        MethodName(Identifier),
+        ArgumentList(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(
+  ClassDeclaration(class,
+    Definition,
+    ClassBody(
+      MethodDeclaration(
+        Modifiers(public, static),
+        void,
+        Definition,
+        FormalParameters(
+          FormalParameter(
+            ArrayType(
+              TypeName,
+              Dimension),
+            Definition)),
+        Block(
+          LocalVariableDeclaration(
+            PrimitiveType,
+            VariableDeclarator(
+              Definition,
+              AssignOp,
+              IntegerLiteral)),
+          WhileStatement(while,
+            ParenthesizedExpression(
+              BinaryExpression(
+                Identifier,
+                CompareOp,
+                IntegerLiteral)),
+            Block(
+              ExpressionStatement(MethodInvocation(
+                FieldAccess(
+                  Identifier,
+                  Identifier),
+                MethodName(Identifier),
+                ArgumentList(
+                  BinaryExpression(StringLiteral, ArithOp, Identifier)))),
+              ExpressionStatement(UpdateExpression(Identifier, UpdateOp)))))))))
+
+
+# try-with-resources statements
+
+try (FileInputStream input = new FileInputStream("file.txt")) {
+  int data = input.read();
+}
+
+==>
+
+Program(
+  TryWithResourcesStatement(try,
+    ResourceSpecification(
+      Resource(
+        TypeName,
+        Definition,
+        AssignOp,
+        ObjectCreationExpression(new,
+          TypeName,
+          ArgumentList(StringLiteral)))),
+    Block(
+      LocalVariableDeclaration(
+        PrimitiveType,
+        VariableDeclarator(
+          Definition,
+          AssignOp,
+          MethodInvocation(
+            Identifier,
+            MethodName(Identifier),
+            ArgumentList))))))
+
+
+# return statement
+
+return x;
+return x * y;
+return x + 2;
+return fire(x);
+
+==>
+
+Program(
+  ReturnStatement(return,Identifier),
+  ReturnStatement(return,BinaryExpression(Identifier, ArithOp, Identifier)),
+  ReturnStatement(return,BinaryExpression(Identifier, ArithOp, IntegerLiteral)),
+  ReturnStatement(return,MethodInvocation(MethodName(Identifier), ArgumentList(Identifier))))
+
+
+# annotation
+
+@SuppressWarnings(value = "unchecked")
+@GwtCompatible(emulated = true)
+class Duck {
+
+}
+
+==>
+
+Program(
+  ClassDeclaration(
+    Modifiers(
+      Annotation(
+        Identifier,
+        AnnotationArgumentList(
+          ElementValuePair(
+            Identifier,
+            AssignOp,
+            StringLiteral))),
+      Annotation(
+        Identifier,
+        AnnotationArgumentList(
+          ElementValuePair(
+            Identifier,
+            AssignOp,
+            BooleanLiteral)))),
+    class,
+    Definition,
+    ClassBody))
+
+
+# marker annotation
+
+@Override
+class Quack {
+  @bar
+  public void foo() {
+
+  }
+}
+
+==>
+
+Program(
+  ClassDeclaration(
+    Modifiers(MarkerAnnotation(Identifier)),
+    class,
+    Definition,
+    ClassBody(
+      MethodDeclaration(
+        Modifiers(MarkerAnnotation(Identifier), public),
+        void,
+        Definition,
+        FormalParameters,
+        Block))))
+
+
+# single element annotation
+
+@Duck(waddle.swim)
+@SuppressWarnings("unchecked")
+class Quack {
+
+}
+
+==>
+
+Program(
+  ClassDeclaration(
+    Modifiers(
+      Annotation(Identifier, AnnotationArgumentList(FieldAccess(Identifier, Identifier))),
+      Annotation(Identifier, AnnotationArgumentList(StringLiteral))),
+    class,
+    Definition,
+    ClassBody))
+
+
+# lambda expression
+
+class LambdaTest {
+  void singleton() {
+    version -> create;
+    (a, b) -> a + b;
+  }
+}
+
+==>
+
+Program(
+  ClassDeclaration(class,
+    Definition,
+    ClassBody(
+      MethodDeclaration(
+        void,
+        Definition,
+        FormalParameters,
+        Block(
+          ExpressionStatement(LambdaExpression(
+            Definition,
+            Identifier)),
+          ExpressionStatement(LambdaExpression(
+            InferredParameters(Definition, Definition),
+            BinaryExpression(Identifier, ArithOp, 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(
+  ClassDeclaration(
+    Modifiers(public),
+    class,
+    Definition,
+    ClassBody(
+      MethodDeclaration(
+        Modifiers(public, static),
+        void,
+        Definition,
+        FormalParameters(
+          FormalParameter(
+            ArrayType(
+              TypeName,
+              Dimension),
+            Definition)),
+        Block(
+          LocalVariableDeclaration(
+            PrimitiveType,
+            VariableDeclarator(
+              Definition,
+              AssignOp,
+              IntegerLiteral)),
+          LocalVariableDeclaration(
+            TypeName,
+            VariableDeclarator(Definition)),
+          SwitchStatement(switch,
+            ParenthesizedExpression(Identifier),
+            SwitchBlock(
+              SwitchLabel(case,IntegerLiteral),
+              ExpressionStatement(AssignmentExpression(
+                Identifier,
+                AssignOp,
+                StringLiteral)),
+              BreakStatement(break),
+              SwitchLabel(case,IntegerLiteral),
+              ExpressionStatement(AssignmentExpression(
+                Identifier,
+                AssignOp,
+                StringLiteral)),
+              BreakStatement(break),
+              SwitchLabel(case,IntegerLiteral),
+              ExpressionStatement(AssignmentExpression(
+                Identifier,
+                AssignOp,
+                StringLiteral)),
+              BreakStatement(break),
+              SwitchLabel(default),
+              ExpressionStatement(AssignmentExpression(
+                Identifier,
+                AssignOp,
+                StringLiteral)),
+              BreakStatement(break))),
+          ExpressionStatement(MethodInvocation(
+            FieldAccess(
+              Identifier,
+              Identifier),
+            MethodName(Identifier),
+            ArgumentList(Identifier))))))))
+
+
+# type arguments
+
+class Box <T> {
+  private T theObject;
+  public Box( T arg) { theObject = arg; }
+  // more code
+}
+
+==>
+
+Program(
+  ClassDeclaration(class,
+    Definition,
+      TypeParameters(
+        TypeParameter(
+          Definition)),
+    ClassBody(
+      FieldDeclaration(
+        Modifiers(private),
+          TypeName,
+          VariableDeclarator(Definition)),
+      ConstructorDeclaration(
+        Modifiers(public),
+        Definition,
+        FormalParameters(
+          FormalParameter(
+            TypeName,
+            Definition)),
+        ConstructorBody(
+          ExpressionStatement(AssignmentExpression(
+            Identifier, AssignOp, Identifier)))),
+      LineComment)))
+
+
+# wildcard
+
+class WildcardDemo {
+  List<? extends B> a;
+}
+
+==>
+
+Program(
+  ClassDeclaration(class,
+    Definition,
+      ClassBody(
+        FieldDeclaration(
+          GenericType(
+            TypeName,
+            TypeArguments(
+              Wildcard(extends, TypeName))),
+          VariableDeclarator(Definition)))))
+
+
+# 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(
+  ClassDeclaration(class,
+    Definition,
+    TypeParameters(
+      TypeParameter(
+        Definition)),
+      ClassBody(
+        MethodDeclaration(
+          Modifiers(public),
+            GenericType(
+              TypeName,
+              TypeArguments(TypeName)),
+            Definition,
+            FormalParameters,
+            Block(
+              LocalVariableDeclaration(
+                GenericType(
+                  TypeName,
+                  TypeArguments(TypeName)),
+                VariableDeclarator(
+                  Definition,
+                  AssignOp,
+                  MethodInvocation(
+                    Identifier,
+                    TypeArguments(TypeName),
+                    MethodName(Identifier),
+                    ArgumentList))),
+              ReturnStatement(return,Identifier))),
+        MethodDeclaration(
+          Modifiers(public, static),
+          TypeParameters(
+            TypeParameter(
+              Definition)),
+          void,
+            Definition,
+            FormalParameters(
+              FormalParameter(
+                TypeName,
+                Definition)),
+            Block(
+              LocalVariableDeclaration(
+                GenericType(
+                  TypeName,
+                  TypeArguments(TypeName)),
+                VariableDeclarator(
+                  Definition,
+                  AssignOp,
+                  MethodInvocation(
+                    Identifier,
+                    TypeArguments(TypeName),
+                    MethodName(Identifier),
+                    ArgumentList))))))))
+
+
+# empty type arguments
+
+Box<Integer> integerBox = new Box<>();
+
+==>
+
+Program(
+  LocalVariableDeclaration(
+    GenericType(TypeName, TypeArguments(TypeName)),
+    VariableDeclarator(
+      Definition,
+      AssignOp,
+      ObjectCreationExpression(new,
+        GenericType(TypeName, TypeArguments),
+        ArgumentList))))
+
+
+# method references
+
+action = bar::method;
+foo.bar::method;
+String[]::new;
+Foo<T>::apply;
+super::something;
+
+==>
+
+Program(
+  ExpressionStatement(AssignmentExpression(Identifier, AssignOp, MethodReference(Identifier, Identifier))),
+  ExpressionStatement(MethodReference(FieldAccess(Identifier, Identifier), Identifier)),
+  ExpressionStatement(MethodReference(ArrayType(TypeName, Dimension), new)),
+  ExpressionStatement(MethodReference(GenericType(TypeName, TypeArguments(TypeName)), Identifier)),
+  ExpressionStatement(MethodReference(super, Identifier)))
+
+# text block
+
+x = """
+    hello
+    multi-""-line
+    foo""";
+
+==>
+
+Program(ExpressionStatement(AssignmentExpression(Identifier,AssignOp,TextBlock)))
+
+# precedence
+
+x = 1 < 2 || a & b ^ c * 2 && 1 + d | e;
+
+==>
+
+Program(ExpressionStatement(AssignmentExpression(Identifier,AssignOp,
+  BinaryExpression(
+    BinaryExpression(IntegerLiteral,CompareOp,IntegerLiteral),
+    LogicOp,
+    BinaryExpression(
+      BinaryExpression(
+        BinaryExpression(Identifier,BitOp,Identifier),
+        BitOp,
+        BinaryExpression(Identifier,ArithOp,IntegerLiteral)),
+      LogicOp,
+      BinaryExpression(
+        BinaryExpression(IntegerLiteral,ArithOp,Identifier),
+        BitOp,
+        Identifier))))))
+
+# Unicode identifiers
+
+Amélie + 橘子;
+
+==>
+
+Program(ExpressionStatement(BinaryExpression(Identifier,ArithOp,Identifier)))

node_modules/@lezer/java/test/literals.txt

@@ -0,0 +1,259 @@
+# decimal integer literals
+
+123;
+4l;
+50L;
+
+==>
+
+Program(
+  ExpressionStatement(IntegerLiteral),
+  ExpressionStatement(IntegerLiteral),
+  ExpressionStatement(IntegerLiteral))
+
+
+# hex integer literals
+
+0xa_bcd_ef0;
+0Xa_bcd_ef0;
+0X8000L;
+
+==>
+
+Program(
+  ExpressionStatement(IntegerLiteral),
+  ExpressionStatement(IntegerLiteral),
+  ExpressionStatement(IntegerLiteral))
+
+
+# octal integer literals
+
+0o123;
+0O123;
+
+==>
+
+Program(
+  ExpressionStatement(IntegerLiteral),
+  ExpressionStatement(IntegerLiteral))
+
+
+# binary integer literal
+
+0b001;
+0B001;
+0b10;
+0B1000;
+
+==>
+
+Program(
+  ExpressionStatement(IntegerLiteral),
+  ExpressionStatement(IntegerLiteral),
+  ExpressionStatement(IntegerLiteral),
+  ExpressionStatement(IntegerLiteral))
+
+
+# floating point literals
+
+4.23e9;
+4.23e-9;
+4.23e+9;
+40.3e6;
+40.3e-6;
+1.234;
+0.123456;
+.12345;
+1e4;
+0.2e-2;
+0.0e-4;
+.2e-2;
+0x5.4p-10;
+
+==>
+
+Program(
+  ExpressionStatement(FloatingPointLiteral),
+  ExpressionStatement(FloatingPointLiteral),
+  ExpressionStatement(FloatingPointLiteral),
+  ExpressionStatement(FloatingPointLiteral),
+  ExpressionStatement(FloatingPointLiteral),
+  ExpressionStatement(FloatingPointLiteral),
+  ExpressionStatement(FloatingPointLiteral),
+  ExpressionStatement(FloatingPointLiteral),
+  ExpressionStatement(FloatingPointLiteral),
+  ExpressionStatement(FloatingPointLiteral),
+  ExpressionStatement(FloatingPointLiteral),
+  ExpressionStatement(FloatingPointLiteral),
+  ExpressionStatement(FloatingPointLiteral))
+
+
+# boolean literals
+
+true;
+false;
+
+==>
+
+Program(
+  ExpressionStatement(BooleanLiteral),
+  ExpressionStatement(BooleanLiteral))
+
+
+# character literals
+
+'a';
+'%';
+'\t';
+'\\';
+'\'';
+'\u03a9';
+'\uFFFF';
+'\177';
+'™';
+
+==>
+
+Program(
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral))
+
+
+# string literals
+
+"";
+"\"";
+"This is a string";
+"'";
+
+==>
+
+Program(
+  ExpressionStatement(StringLiteral),
+  ExpressionStatement(StringLiteral),
+  ExpressionStatement(StringLiteral),
+  ExpressionStatement(StringLiteral))
+
+
+# null literals
+
+null;
+
+==>
+
+Program(
+  ExpressionStatement(null))
+
+
+# char escapes
+
+'\b';
+'\t';
+'\n';
+'\f';
+'\r';
+'\"';
+'\'';
+'\\' + 'a';
+
+==>
+
+Program(
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(BinaryExpression(CharacterLiteral, ArithOp, CharacterLiteral)))
+
+
+# octal escapes
+
+'\7';
+
+==>
+
+Program(
+  ExpressionStatement(CharacterLiteral))
+
+
+# ascii escapes
+
+'\NUL';
+'\SOH';
+'\STX';
+'\ETX';
+'\EOT';
+'\ENQ';
+'\ACK';
+'\BEL';
+'\BS';
+'\TAB';
+'\LF';
+'\VT';
+'\FF';
+'\CR';
+'\SO';
+'\SI';
+'\DLE';
+'\DC1';
+'\DC2';
+'\DC3';
+'\DC4';
+'\NAK';
+'\SYN';
+'\ETB';
+'\CAN';
+'\EM';
+'\SUB';
+'\ESC';
+'\FS';
+'\GS';
+'\RS';
+'\US';
+
+==>
+
+Program(
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral),
+  ExpressionStatement(CharacterLiteral))
+

node_modules/@lezer/java/test/test-java.js

@@ -0,0 +1,17 @@
+import {parser} from "../dist/index.js"
+import {fileTests} from "@lezer/generator/dist/test"
+
+import * as fs from "fs"
+import * as path from "path"
+import {fileURLToPath} from "url"
+let caseDir = path.dirname(fileURLToPath(import.meta.url))
+
+for (let file of fs.readdirSync(caseDir)) {
+  if (!/\.txt$/.test(file)) continue
+
+  let name = /^[^\.]*/.exec(file)[0]
+  describe(name, () => {
+    for (let {name, run} of fileTests(fs.readFileSync(path.join(caseDir, file), "utf8"), file))
+      it(name, () => run(parser))
+  })
+}

node_modules/@lezer/java/test/types.txt

@@ -0,0 +1,67 @@
+# integral types
+
+class Beyonce {
+  int formation() {
+    int x;
+    byte x;
+    short x;
+    long x;
+    char x;
+  }
+}
+
+==>
+
+Program(
+  ClassDeclaration(class,
+    Definition,
+    ClassBody(
+      MethodDeclaration(
+        PrimitiveType,
+        Definition,
+        FormalParameters,
+        Block(
+          LocalVariableDeclaration(
+            PrimitiveType,
+              VariableDeclarator(Definition)),
+          LocalVariableDeclaration(
+            PrimitiveType,
+              VariableDeclarator(Definition)),
+          LocalVariableDeclaration(
+            PrimitiveType,
+              VariableDeclarator(Definition)),
+          LocalVariableDeclaration(
+            PrimitiveType,
+              VariableDeclarator(Definition)),
+          LocalVariableDeclaration(
+            PrimitiveType,
+              VariableDeclarator(Definition)))))))
+
+
+# floating point types
+
+class Beyonce {
+  int formation() {
+    float x;
+    double x;
+  }
+}
+
+==>
+
+Program(
+  ClassDeclaration(class,
+    Definition,
+    ClassBody(
+      MethodDeclaration(
+        PrimitiveType,
+        Definition,
+        FormalParameters,
+        Block(
+          LocalVariableDeclaration(
+            PrimitiveType,
+            VariableDeclarator(Definition)),
+          LocalVariableDeclaration(
+            PrimitiveType,
+            VariableDeclarator(Definition)))))))
+