deploy: v0.12 fix 存档key名

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

@@ -0,0 +1,203 @@
+# Single const declarations without types
+
+const zero = 0
+const one, two = 1, 2
+const three, four, five = 3, 4, 5
+
+==>
+
+SourceFile(
+  ConstDecl(const,ConstSpec(DefName,Number)),
+  ConstDecl(const,ConstSpec(DefName,DefName,Number,Number)),
+  ConstDecl(const,ConstSpec(DefName,DefName,DefName,Number,Number,Number)))
+
+# Single const declarations with types
+
+const zero int = 0
+const one, two uint64 = 1, 2
+
+==>
+
+SourceFile(
+  ConstDecl(const,ConstSpec(DefName,TypeName,Number)),
+  ConstDecl(const,ConstSpec(DefName,DefName,TypeName,Number,Number)))
+
+# Grouped const declarations
+
+const (
+  zero = 0
+  one = 1
+)
+
+==>
+
+SourceFile(ConstDecl(const,SpecList(ConstSpec(DefName,Number),ConstSpec(DefName,Number))))
+
+# Const declarations with implicit values
+
+const (
+  zero = iota
+  one
+  two
+)
+
+==>
+
+SourceFile(ConstDecl(const,SpecList(ConstSpec(DefName,VariableName),ConstSpec(DefName),ConstSpec(DefName))))
+
+# Var declarations without types
+
+var zero = 0
+var one, two = 1, 2
+var three, four, five = 3, 4, 5
+
+==>
+
+SourceFile(
+  VarDecl(var,VarSpec(DefName,Number)),
+  VarDecl(var,VarSpec(DefName,DefName,Number,Number)),
+  VarDecl(var,VarSpec(DefName,DefName,DefName,Number,Number,Number)))
+
+# Var declarations with types
+
+var zero int = 0
+var one, two uint64 = 1, 2
+
+==>
+
+SourceFile(
+  VarDecl(var,VarSpec(DefName,TypeName,Number)),
+  VarDecl(var,VarSpec(DefName,DefName,TypeName,Number,Number)))
+
+# Var declarations with no expressions
+
+var zero int
+var one, two uint64
+
+==>
+
+SourceFile(
+  VarDecl(var,VarSpec(DefName,TypeName)),
+  VarDecl(var,VarSpec(DefName,DefName,TypeName)))
+
+# Grouped var declarations
+
+var (
+  zero = 0
+  one = 1
+)
+
+==>
+
+SourceFile(VarDecl(var,SpecList(VarSpec(DefName,Number),VarSpec(DefName,Number))))
+
+# Function declarations
+
+func f1() {}
+func f2(a File, b, c, d Thing) int {}
+func f2() (File, Thing) {}
+func f2() (result int, err error) {}
+func f(x ... int, y ... int)
+func g1[T, U any, V interface{}, W Foo[Bar[T]]](a Foo[T]) {}
+func g2(a foo.bar[int]) {}
+func f[A int|string, B ~int, C ~int|~string]()
+func f2(a File, b, c, d Thing) int {}
+
+==>
+
+SourceFile(
+  FunctionDecl(func,DefName,Parameters,Block),
+  FunctionDecl(func,DefName,Parameters(
+    Parameter(DefName,TypeName),
+    Parameter(DefName,DefName,DefName,TypeName)
+  ),TypeName,Block),
+  FunctionDecl(func,DefName,Parameters,Parameters(Parameter(TypeName),Parameter(TypeName)),Block),
+  FunctionDecl(func,DefName,Parameters,Parameters(
+    Parameter(DefName,TypeName),
+    Parameter(DefName,TypeName)
+  ),Block),
+  FunctionDecl(func,DefName,Parameters(Parameter(DefName,TypeName),Parameter(DefName,TypeName))),
+  FunctionDecl(func,DefName,TypeParams(
+    TypeParam(TypeName,TypeName,TypeName),
+    TypeParam(TypeName,InterfaceType(interface,InterfaceBody)),
+    TypeParam(TypeName,ParameterizedType(TypeName,TypeArgs(ParameterizedType(TypeName,TypeArgs(TypeName)))))
+  ),Parameters(Parameter(DefName,ParameterizedType(TypeName,TypeArgs(TypeName)))),Block),
+  FunctionDecl(func,DefName,Parameters(
+    Parameter(DefName,ParameterizedType(QualifiedType(VariableName,TypeName),TypeArgs(TypeName)))
+  ),Block),
+  FunctionDecl(func,DefName,TypeParams(
+    TypeParam(TypeName,TypeElem(TypeName,LogicOp,TypeName)),
+    TypeParam(TypeName,UnderlyingType(TypeName)),
+    TypeParam(TypeName,TypeElem(UnderlyingType(TypeName),LogicOp,UnderlyingType(TypeName)))
+  ),Parameters),
+  FunctionDecl(func,DefName,Parameters(
+    Parameter(DefName,TypeName),
+    Parameter(DefName,DefName,DefName,TypeName)
+  ),TypeName,Block))
+
+# Single-line function declarations
+
+func f1() { a() }
+func f2() { a(); b() }
+func f3() { a(); b(); }
+
+==>
+
+SourceFile(
+  FunctionDecl(func,DefName,Parameters,Block(
+    ExprStatement(CallExpr(VariableName,Arguments)))),
+  FunctionDecl(func,DefName,Parameters,Block(
+    ExprStatement(CallExpr(VariableName,Arguments)),
+    ExprStatement(CallExpr(VariableName,Arguments)))),
+  FunctionDecl(func,DefName,Parameters,Block(
+    ExprStatement(CallExpr(VariableName,Arguments)),
+    ExprStatement(CallExpr(VariableName,Arguments)))))
+
+# Variadic function declarations
+
+func f1(a ...*int) {}
+func f2(a int, b ...int) {}
+func f3(...bool) {}
+
+==>
+
+SourceFile(
+  FunctionDecl(func,DefName,Parameters(
+    Parameter(DefName,"...",PointerType(TypeName))
+  ),Block),
+  FunctionDecl(func,DefName,Parameters(
+    Parameter(DefName,TypeName),
+    Parameter(DefName,"...",TypeName)
+  ),Block),
+  FunctionDecl(func,DefName,Parameters(Parameter("...",TypeName)),Block))
+
+# Method declarations
+
+func (self Person) Equals(other Person) bool {}
+func (v *Value) ObjxMap(optionalDefault ...(Map)) Map {}
+func (p *T1) M1()
+
+==>
+
+SourceFile(
+  MethodDecl(func,Parameters(Parameter(DefName,TypeName)),FieldName,
+    Parameters(Parameter(DefName,TypeName)),TypeName,Block),
+  MethodDecl(func,Parameters(Parameter(DefName,PointerType(TypeName))),FieldName,
+    Parameters(Parameter(DefName,"...",ParenthesizedType(TypeName))),TypeName,Block),
+  MethodDecl(func,Parameters(Parameter(DefName,PointerType(TypeName))),FieldName,Parameters))
+
+# Type declarations
+
+type a b
+type (
+  a b
+  c d
+)
+type a = d[e]
+
+==>
+
+SourceFile(
+  TypeDecl(type,TypeSpec(DefName,TypeName)),
+  TypeDecl(type,SpecList(TypeSpec(DefName,TypeName),TypeSpec(DefName,TypeName))),
+  TypeDecl(type,TypeSpec(DefName,ParameterizedType(TypeName,TypeArgs(TypeName)))))

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

@@ -0,0 +1,150 @@
+# Call expressions
+
+func main() {
+  a(b, c...)
+
+  a(
+    b,
+    c,
+  )
+
+  a(
+    b,
+    c...,
+  )
+}
+
+==>
+
+SourceFile(FunctionDecl(func,DefName,Parameters,Block(
+  ExprStatement(CallExpr(VariableName,Arguments(VariableName,VariableName,"..."))),
+  ExprStatement(CallExpr(VariableName,Arguments(VariableName,VariableName))),
+  ExprStatement(CallExpr(VariableName,Arguments(VariableName,VariableName,"..."))))))
+
+# Nested call expressions
+
+a(b(c(d)))
+
+==>
+
+SourceFile(ExprStatement(CallExpr(VariableName,Arguments(
+  CallExpr(VariableName,Arguments(CallExpr(VariableName,Arguments(VariableName))))))))
+
+# Generic call expressions
+
+a[b](c)
+a[b, c](d)
+a[b[c], d](e[f])
+
+==>
+
+SourceFile(
+  ExprStatement(CallExpr(ParameterizedExpr(VariableName,TypeArgs(TypeName)),Arguments(VariableName))),
+  ExprStatement(CallExpr(ParameterizedExpr(VariableName,TypeArgs(TypeName,TypeName)),Arguments(VariableName))),
+  ExprStatement(CallExpr(
+    ParameterizedExpr(VariableName,TypeArgs(ParameterizedType(TypeName,TypeArgs(TypeName)),TypeName)),
+    Arguments(IndexExpr(VariableName,VariableName)))))
+
+# Calls to 'make' and 'new'
+
+make(chan<- int)
+
+// `new` and `make` can also be used as variable names
+make(chan<- int, (new - old), make.stuff)
+
+make(chan<- int, 5, 10)
+new(map[string]string)
+
+==>
+
+SourceFile(
+  ExprStatement(CallExpr(make,Arguments(ChannelType(chan,"<-",TypeName)))),
+  LineComment,
+  ExprStatement(CallExpr(make,Arguments(
+    ChannelType(chan,"<-",TypeName),
+    ParenthesizedExpr(BinaryExp(VariableName,ArithOp,VariableName)),
+    SelectorExpr(VariableName,FieldName)))),
+  ExprStatement(CallExpr(make,Arguments(ChannelType(chan,"<-",TypeName),Number,Number))),
+  ExprStatement(CallExpr(new,Arguments(MapType(map,TypeName,TypeName)))))
+
+# Selector expressions
+
+a.b.c()
+
+==>
+
+SourceFile(ExprStatement(CallExpr(SelectorExpr(SelectorExpr(VariableName,FieldName),FieldName),Arguments)))
+
+# Indexing expressions
+
+_ = a[1]
+_ = b[:]
+_ = c[1:]
+_ = d[1:2]
+_ = e[:2:3]
+_ = f[1:2:3]
+
+==>
+
+SourceFile(
+  Assignment(VariableName,IndexExpr(VariableName,Number)),
+  Assignment(VariableName,SliceExpr(VariableName)),
+  Assignment(VariableName,SliceExpr(VariableName,Number)),
+  Assignment(VariableName,SliceExpr(VariableName,Number,Number)),
+  Assignment(VariableName,SliceExpr(VariableName,Number,Number)),
+  Assignment(VariableName,SliceExpr(VariableName,Number,Number,Number)))
+
+# Type assertion expressions
+
+_ = a.(p.Person)
+
+==>
+
+SourceFile(
+  Assignment(VariableName,TypeAssertion(VariableName,QualifiedType(VariableName,TypeName))))
+
+# Type conversion expressions
+
+_ = []a.b(c.d)
+_ = ([]a.b)(c.d)
+_ = <-chan int(c) // conversion to channel type
+<-(chan int(c)) // receive statement
+// These type conversions cannot be distinguished from call expressions
+T(x)
+(*Point)(p)
+e.f(g)
+(e.f)(g)
+
+==>
+
+SourceFile(
+  Assignment(VariableName,Conversion(
+    SliceType(QualifiedType(VariableName,TypeName)),
+    SelectorExpr(VariableName,FieldName))),
+  Assignment(VariableName,Conversion(
+    ParenthesizedType(SliceType(QualifiedType(VariableName,TypeName))),
+    SelectorExpr(VariableName,FieldName))),
+  Assignment(VariableName,Conversion(
+    ChannelType("<-",chan,TypeName),
+    VariableName)),LineComment,
+  ExprStatement(UnaryExp("<-",ParenthesizedExpr(Conversion(
+    ChannelType(chan,TypeName),
+    VariableName)))),LineComment,
+  LineComment,
+  ExprStatement(CallExpr(VariableName,Arguments(VariableName))),
+  ExprStatement(CallExpr(ParenthesizedExpr(UnaryExp(DerefOp,VariableName)),Arguments(VariableName))),
+  ExprStatement(CallExpr(SelectorExpr(VariableName,FieldName),Arguments(VariableName))),
+  ExprStatement(CallExpr(ParenthesizedExpr(SelectorExpr(VariableName,FieldName)),Arguments(VariableName))))
+
+# Unary expressions
+
+func main() {
+  _ = !<-a
+  _ = *foo()
+}
+
+==>
+
+SourceFile(FunctionDecl(func,DefName,Parameters,Block(
+  Assignment(VariableName,UnaryExp(LogicOp,UnaryExp("<-",VariableName))),
+  Assignment(VariableName,CallExpr(UnaryExp(DerefOp,VariableName),Arguments)))))

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

@@ -0,0 +1,223 @@
+# Int literals
+
+const (
+  i1 = 42
+  i2 = 4_2
+  i3 = 0600
+  i4 = 0_600
+  i5 = 0o600
+  i6 = 0O600
+  i7 = 0xBadFace
+  i8 = 0xBad_Face
+  i9 = 0x_67_7a_2f_cc_40_c6
+  i10 = 170141183460469231731687303715884105727
+  i11 = 170_141183_460469_231731_687303_715884_105727
+)
+
+==>
+
+SourceFile(ConstDecl(const,SpecList(
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number))))
+
+# Float literals
+
+const (
+  f1 = 0.
+  f2 = 72.40
+  f3 = 072.40
+  f4 = 2.71828
+  f5 = 1.e+0
+  f6 = 6.67428e-11
+  f7 = 1E6
+  f8 = .25
+  f9 = .12345E+5
+  f10 = 1_5.
+  f11 = 0.15e+0_2
+  f12 = 0x1p-2
+  f13 = 0x2.p10
+  f14 = 0x1.Fp+0
+  f15 = 0X.8p-0
+  f16 = 0X_1FFFP-16
+)
+
+==>
+
+SourceFile(ConstDecl(const,SpecList(
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number))))
+
+# Rune literals
+
+const (
+  a = '0'
+  b = '\''
+  c = '\\'
+  c = '\n'
+  c = '\u0000'
+  c = '\U01234567'
+)
+
+==>
+
+SourceFile(ConstDecl(const,SpecList(
+  ConstSpec(DefName,Rune),
+  ConstSpec(DefName,Rune),
+  ConstSpec(DefName,Rune),
+  ConstSpec(DefName,Rune),
+  ConstSpec(DefName,Rune),
+  ConstSpec(DefName,Rune))))
+
+# Imaginary literals
+
+const (
+  a = 0i
+  b = 0123i
+  c = 0o123i
+  d = 0xabci
+  e = 0.i
+  f = 2.71828i
+  g = 1.e+0i
+  h = 6.67428e-11i
+  i = 1E6i
+  j = .25i
+  k = .12345E+5i
+  l = 0x1p-2i
+)
+
+==>
+
+SourceFile(ConstDecl(const,SpecList(
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number),
+  ConstSpec(DefName,Number))))
+
+# String literals
+
+const (
+  a = "0"
+  b = "`\"`"
+  c = "\x0c"
+  d = "errorstring
+  "
+)
+
+==>
+
+SourceFile(ConstDecl(const,SpecList(
+  ConstSpec(DefName,String),
+  ConstSpec(DefName,String),
+  ConstSpec(DefName,String),
+  ConstSpec(DefName,String),
+  ⚠(String))))
+
+# Slice literals
+
+const s1 = []string{}
+
+const s2 = []string{"hi"}
+
+const s3 = []string{
+  "hi",
+  "hello",
+}
+
+==>
+
+SourceFile(
+  ConstDecl(const,ConstSpec(DefName,TypedLiteral(SliceType(TypeName),LiteralValue))),
+  ConstDecl(const,ConstSpec(DefName,TypedLiteral(SliceType(TypeName),LiteralValue(Element(String))))),
+  ConstDecl(const,ConstSpec(DefName,TypedLiteral(SliceType(TypeName),LiteralValue(Element(String),Element(String))))))
+
+# Array literals with implicit length
+
+const a1 = [...]int{1, 2, 3}
+
+==>
+
+SourceFile(ConstDecl(const,ConstSpec(DefName,TypedLiteral(
+  SliceType(TypeName),LiteralValue(Element(Number),Element(Number),Element(Number))))))
+
+# Map literals
+
+const s = map[string]string{
+  "hi": "hello",
+  "bye": "goodbye",
+}
+
+==>
+
+SourceFile(ConstDecl(const,ConstSpec(DefName,TypedLiteral(
+  MapType(map,TypeName,TypeName),
+  LiteralValue(Element(Key(String),String),Element(Key(String),String))))))
+
+# Struct literals
+
+const s1 = Person{
+  name: "Frank",
+  Age: "5 months",
+}
+
+const s2 = struct{i int;}{i: 5}
+
+const s3 = time.Time{}
+
+const g1 = Foo[float64, Bar[int]] { }
+
+==>
+
+SourceFile(
+  ConstDecl(const,ConstSpec(DefName,TypedLiteral(
+    TypeName,
+    LiteralValue(Element(Key(VariableName),String),Element(Key(VariableName),String))))),
+  ConstDecl(const,ConstSpec(DefName,TypedLiteral(
+    StructType(struct,StructBody(FieldDecl(FieldName,TypeName))),
+    LiteralValue(Element(Key(VariableName),Number))))),
+  ConstDecl(const,ConstSpec(DefName,TypedLiteral(QualifiedType(VariableName,TypeName),LiteralValue))),
+  ConstDecl(const,ConstSpec(DefName,TypedLiteral(
+    ParameterizedType(TypeName,TypeArgs(TypeName,ParameterizedType(TypeName,TypeArgs(TypeName)))),
+    LiteralValue))))
+
+# Function literals
+
+const s1 = func(s string) (int, int) {
+  return 1, 2
+}
+
+==>
+
+SourceFile(ConstDecl(const,ConstSpec(DefName,FunctionLiteral(
+  func,Parameters(Parameter(DefName,TypeName)),Parameters(Parameter(TypeName),Parameter(TypeName)),
+  Block(ReturnStatement(return,Number,Number))))))

node_modules/@lezer/go/test/source_files.txt

@@ -0,0 +1,104 @@
+# Package clauses
+
+package main
+
+==>
+
+SourceFile(PackageClause(package,DefName))
+
+# Single import declarations
+
+import "net/http"
+import . "some/dsl"
+import _ "os"
+import alias "some/package"
+
+==>
+
+SourceFile(
+  ImportDecl(import,ImportSpec(String)),
+  ImportDecl(import,ImportSpec(".",String)),
+  ImportDecl(import,ImportSpec(DefName,String)),
+  ImportDecl(import,ImportSpec(DefName,String)))
+
+# Grouped import declarations
+
+import()
+import ("fmt")
+import (
+  "net/http"
+  . "some/dsl"
+  _ "os"
+  alias "some/package"
+)
+
+==>
+
+SourceFile(
+  ImportDecl(import,SpecList),
+  ImportDecl(import,SpecList(ImportSpec(String))),
+  ImportDecl(import,SpecList(
+    ImportSpec(String),
+    ImportSpec(".",String),
+    ImportSpec(DefName,String),
+    ImportSpec(DefName,String))))
+
+# Block comments
+/*
+ * This is a great package
+ */
+
+==>
+
+SourceFile(BlockComment)
+
+# Comments with asterisks
+
+/* a */
+const a
+
+/* b **/
+const b
+
+/* c ***/
+const c
+
+/* d
+
+***/
+const d
+
+==>
+
+SourceFile(
+  BlockComment,
+  ConstDecl(const,ConstSpec(DefName)),
+  BlockComment,
+  ConstDecl(const,ConstSpec(DefName)),
+  BlockComment,
+  ConstDecl(const,ConstSpec(DefName)),
+  BlockComment,
+  ConstDecl(const,ConstSpec(DefName)))
+
+# Non-ascii variable names
+
+const (
+  α
+  Α
+  µs  // micro sign (not mu)
+  δ1
+  ΔΔΔ
+  ω_omega
+  Ω_OMEGA
+)
+
+==>
+
+SourceFile(ConstDecl(const,SpecList(
+  ConstSpec(DefName),
+  ConstSpec(DefName),
+  ConstSpec(DefName),LineComment,
+  ConstSpec(DefName),
+  ConstSpec(DefName),
+  ConstSpec(DefName),
+  ConstSpec(DefName))))

node_modules/@lezer/go/test/statements.txt

@@ -0,0 +1,388 @@
+# Declaration statements
+
+package main
+
+func main() {
+  var x = y
+  const x = 5
+}
+
+==>
+
+SourceFile(
+  PackageClause(package,DefName),
+  FunctionDecl(func,DefName,Parameters,Block(
+    VarDecl(var,VarSpec(DefName,VariableName)),
+    ConstDecl(const,ConstSpec(DefName,Number)))))
+
+# Expression statements
+
+func main() {
+  foo(5)
+}
+
+==>
+
+SourceFile(FunctionDecl(func,DefName,Parameters,Block(
+  ExprStatement(CallExpr(VariableName,Arguments(Number))))))
+
+# Send statements
+
+func main() {
+  foo <- 5
+}
+
+==>
+
+SourceFile(FunctionDecl(func,DefName,Parameters,Block(
+  SendStatement(VariableName,Number))))
+
+# Increment/Decrement statements
+
+func main() {
+  i++
+  j--
+}
+
+==>
+
+SourceFile(FunctionDecl(func,DefName,Parameters,Block(
+  IncDecStatement(VariableName,IncDecOp),
+  IncDecStatement(VariableName,IncDecOp))))
+
+# Assignment statements
+
+func main() {
+  a = 1
+  b, c += 2, 3
+  d *= 3
+  e += 1
+  f /= 2
+  g <<= 1
+  h >>= 1
+  i %= 1
+  j &= 2
+  k &^= 3
+  l -= 1
+  m |= 2
+  n ^= 2
+}
+
+==>
+
+SourceFile(FunctionDecl(func,DefName,Parameters,Block(
+  Assignment(VariableName,Number),
+  Assignment(VariableName,VariableName,UpdateOp,Number,Number),
+  Assignment(VariableName,UpdateOp,Number),
+  Assignment(VariableName,UpdateOp,Number),
+  Assignment(VariableName,UpdateOp,Number),
+  Assignment(VariableName,UpdateOp,Number),
+  Assignment(VariableName,UpdateOp,Number),
+  Assignment(VariableName,UpdateOp,Number),
+  Assignment(VariableName,UpdateOp,Number),
+  Assignment(VariableName,UpdateOp,Number),
+  Assignment(VariableName,UpdateOp,Number),
+  Assignment(VariableName,UpdateOp,Number),
+  Assignment(VariableName,UpdateOp,Number))))
+
+# Short var declarations
+
+func main() {
+  a, b := 1, 2
+}
+
+==>
+
+SourceFile(FunctionDecl(func,DefName,Parameters,Block(
+  VarDecl(DefName,DefName,Number,Number))))
+
+# If statements
+
+func main() {
+  if a {
+    b()
+  }
+
+  if a := b(); c {
+    d()
+  }
+
+  if a {
+    b()
+  } else {
+    c()
+  }
+
+  if b {
+    c()
+  } else if d {
+    e()
+  } else {
+    f()
+  }
+}
+
+==>
+
+SourceFile(FunctionDecl(func,DefName,Parameters,Block(
+  IfStatement(if,VariableName,Block(
+    ExprStatement(CallExpr(VariableName,Arguments)))),
+  IfStatement(if,VarDecl(DefName,CallExpr(VariableName,Arguments)),VariableName,Block(
+    ExprStatement(CallExpr(VariableName,Arguments)))),
+  IfStatement(if,VariableName,Block(
+    ExprStatement(CallExpr(VariableName,Arguments))
+  ),else,Block(
+    ExprStatement(CallExpr(VariableName,Arguments)))),
+  IfStatement(if,VariableName,Block(
+    ExprStatement(CallExpr(VariableName,Arguments))
+  ),else,IfStatement(if,VariableName,Block(
+    ExprStatement(CallExpr(VariableName,Arguments))
+  ),else,Block(
+    ExprStatement(CallExpr(VariableName,Arguments))))))))
+
+# For statements
+
+func main() {
+  for {
+    a()
+    goto loop
+  }
+
+  loop: for i := 0; i < 5; i++ {
+    a()
+    break loop
+  }
+
+loop2:
+  for ; i < 10; i++ {
+    a()
+    continue loop2
+  }
+
+  for ;; {
+    a()
+    continue
+  }
+
+  for x := range y {
+    a(x)
+    break
+  }
+}
+
+==>
+
+SourceFile(FunctionDecl(func,DefName,Parameters,Block(
+  ForStatement(for,Block(ExprStatement(CallExpr(VariableName,Arguments)),GotoStatement(goto,LabelName))),
+  LabeledStatement(LabelName,ForStatement(for,ForClause(
+    VarDecl(DefName,Number),
+    BinaryExp(VariableName,CompareOp,Number),
+    IncDecStatement(VariableName,IncDecOp)
+  ),Block(ExprStatement(CallExpr(VariableName,Arguments)),GotoStatement(break,LabelName)))),
+  LabeledStatement(LabelName,ForStatement(for,ForClause(
+    BinaryExp(VariableName,CompareOp,Number),
+    IncDecStatement(VariableName,IncDecOp)
+  ),Block(ExprStatement(CallExpr(VariableName,Arguments)),GotoStatement(continue,LabelName)))),
+  ForStatement(for,ForClause,Block(ExprStatement(CallExpr(VariableName,Arguments)),GotoStatement(continue))),
+  ForStatement(for,RangeClause(DefName,range,VariableName),Block(
+    ExprStatement(CallExpr(VariableName,Arguments(VariableName))),GotoStatement(break))))))
+
+# Switch statements
+
+func main() {
+  switch e {
+    case 1, 2:
+      a()
+      fallthrough
+    case 3:
+      d()
+    default:
+      c()
+      break
+  }
+
+  switch {
+    case true:
+      return
+  }
+
+  switch f := y(); f {
+  }
+}
+
+==>
+
+SourceFile(FunctionDecl(func,DefName,Parameters,Block(
+  SwitchStatement(switch,VariableName,SwitchBlock(
+    Case(case,Number,Number),
+    ExprStatement(CallExpr(VariableName,Arguments)),
+    FallthroughStatement(fallthrough),
+    Case(case,Number),
+    ExprStatement(CallExpr(VariableName,Arguments)),
+    Case(default),
+    ExprStatement(CallExpr(VariableName,Arguments)),
+    GotoStatement(break))),
+  SwitchStatement(switch,SwitchBlock(Case(case,Bool),ReturnStatement(return))),
+  SwitchStatement(switch,VarDecl(DefName,CallExpr(VariableName,Arguments)),VariableName,SwitchBlock))))
+
+# Type switch statements
+
+func main() {
+  switch e.(type) {
+    case []Person:
+      a()
+    case *Dog:
+      break
+  }
+  switch i := x.(type) {
+    case nil:
+    	printString("x is nil")
+    case int:
+    	printInt(i)
+    case float64:
+    	printFloat64(i)
+    case func(int) float64:
+    	printFunction(i)
+    case bool, string:
+    	printString("type is bool or string")
+    default:
+    	printString("don't know the type")
+  }
+}
+
+==>
+
+SourceFile(FunctionDecl(func,DefName,Parameters,Block(
+  TypeSwitchStatement(switch,VariableName,type,SwitchBlock(
+    Case(case,SliceType(TypeName)),
+    ExprStatement(CallExpr(VariableName,Arguments)),
+    Case(case,PointerType(TypeName)),
+    GotoStatement(break))),
+  TypeSwitchStatement(switch,DefName,VariableName,type,SwitchBlock(
+    Case(case,TypeName),
+    ExprStatement(CallExpr(VariableName,Arguments(String))),
+    Case(case,TypeName),
+    ExprStatement(CallExpr(VariableName,Arguments(VariableName))),
+    Case(case,TypeName),
+    ExprStatement(CallExpr(VariableName,Arguments(VariableName))),
+    Case(case,FunctionType(func,Parameters(Parameter(TypeName)),TypeName)),
+    ExprStatement(CallExpr(VariableName,Arguments(VariableName))),
+    Case(case,TypeName,TypeName),
+    ExprStatement(CallExpr(VariableName,Arguments(String))),
+    Case(default),
+    ExprStatement(CallExpr(VariableName,Arguments(String))))))))
+
+# Select statements
+
+func main() {
+  select {
+    case x := <-c:
+      println(x)
+    case y <- c:
+      println(5)
+    case <-time.After(1):
+      println(6)
+    default:
+      return
+  }
+}
+
+==>
+
+SourceFile(FunctionDecl(func,DefName,Parameters,Block(
+  SelectStatement(select,SelectBlock(
+    Case(case,ReceiveStatement(DefName,UnaryExp("<-",VariableName))),
+    ExprStatement(CallExpr(VariableName,Arguments(VariableName))),
+    Case(case,SendStatement(VariableName,"<-",VariableName)),
+    ExprStatement(CallExpr(VariableName,Arguments(Number))),
+    Case(case,ReceiveStatement(CallExpr(SelectorExpr(UnaryExp("<-",VariableName),FieldName),Arguments(Number)))),
+    ExprStatement(CallExpr(VariableName,Arguments(Number))),
+    Case(default),
+    ReturnStatement(return))))))
+
+# Go and defer statements
+
+func main() {
+  defer x.y()
+  go x.y()
+}
+
+==>
+
+SourceFile(FunctionDecl(func,DefName,Parameters,Block(
+  DeferStatement(defer,CallExpr(SelectorExpr(VariableName,FieldName),Arguments)),
+  GoStatement(go,CallExpr(SelectorExpr(VariableName,FieldName),Arguments)))))
+
+# Nested statement blocks
+
+func main() {
+  {
+    println("hi")
+  }
+  {
+    println("bye")
+  }
+}
+
+==>
+
+SourceFile(FunctionDecl(func,DefName,Parameters,Block(
+  Block(ExprStatement(CallExpr(VariableName,Arguments(String)))),
+  Block(ExprStatement(CallExpr(VariableName,Arguments(String)))))))
+
+# Labels at the ends of statement blocks
+
+func main() {
+  {
+  end_of_block:
+  }
+}
+
+==>
+
+SourceFile(FunctionDecl(func,DefName,Parameters,Block(
+  Block(LabeledStatement(LabelName)))))
+
+# Empty statements
+
+func main() {
+	;
+}
+
+==>
+
+SourceFile(FunctionDecl(func,DefName,Parameters,Block))
+
+# Nested control statements
+
+func main() {
+  for i, v := range vectors {
+    func() {
+      if v == v {
+        fmt.Println("something: %v", vectors[i])
+      }
+    }()
+  }
+}
+
+==>
+
+SourceFile(FunctionDecl(func,DefName,Parameters,Block(
+  ForStatement(for,RangeClause(DefName,DefName,range,VariableName),Block(
+    ExprStatement(CallExpr(
+      FunctionLiteral(func,Parameters,Block(
+        IfStatement(if,BinaryExp(VariableName,CompareOp,VariableName),Block(
+          ExprStatement(CallExpr(SelectorExpr(VariableName,FieldName),Arguments(
+            String,IndexExpr(VariableName,VariableName)))))))),
+      Arguments)))))))
+
+# Top-level statements
+
+foo(5)
+x := T { a: b }
+
+==>
+
+SourceFile(
+  ExprStatement(CallExpr(VariableName,Arguments(Number))),
+  VarDecl(DefName,TypedLiteral(TypeName,LiteralValue(Element(Key(VariableName),VariableName)))))

node_modules/@lezer/go/test/test-go.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/go/test/types.txt

@@ -0,0 +1,211 @@
+# Qualified type names
+
+type a b.c
+
+==>
+
+SourceFile(
+  TypeDecl(type,TypeSpec(DefName,QualifiedType(VariableName,TypeName))))
+
+# Array types
+
+type a [2+2]c
+
+==>
+
+SourceFile(
+  TypeDecl(type,TypeSpec(DefName,ArrayType(BinaryExp(Number,ArithOp,Number),TypeName))))
+
+# Slice types
+
+type a []c
+type b [][]d
+
+==>
+SourceFile(
+  TypeDecl(type,TypeSpec(DefName,SliceType(TypeName))),
+  TypeDecl(type,TypeSpec(DefName,SliceType(SliceType(TypeName)))))
+
+# Struct types
+
+type s1 struct {}
+
+type s2 struct { Person }
+
+type s2 struct {
+  f, g int
+}
+
+type s3 struct {
+  // an embedded struct
+  p.s1
+
+  // a tag
+  h int `json:"h"`
+}
+
+type g1 struct {
+    normal Array[T]
+    nested Array[Array[T]]
+}
+
+type g2[T, U any, V interface{}, W Foo[Bar[T]]] struct {}
+
+==>
+
+SourceFile(
+  TypeDecl(type,TypeSpec(DefName,StructType(struct,StructBody))),
+  TypeDecl(type,TypeSpec(DefName,StructType(struct,StructBody(
+    FieldDecl(TypeName))))),
+  TypeDecl(type,TypeSpec(DefName,StructType(struct,StructBody(
+    FieldDecl(FieldName,FieldName,TypeName))))),
+  TypeDecl(type,TypeSpec(DefName,StructType(struct,StructBody(
+    LineComment,
+    FieldDecl(QualifiedType(VariableName,TypeName)),
+    LineComment,
+    FieldDecl(FieldName,TypeName,String))))),
+  TypeDecl(type,TypeSpec(DefName,StructType(struct,StructBody(
+    FieldDecl(FieldName,ParameterizedType(TypeName,TypeArgs(TypeName))),
+    FieldDecl(FieldName,ParameterizedType(TypeName,TypeArgs(ParameterizedType(TypeName,TypeArgs(TypeName))))))))),
+  TypeDecl(type,TypeSpec(DefName,TypeParams(
+    TypeParam(TypeName,TypeName,TypeName),
+    TypeParam(TypeName,InterfaceType(interface,InterfaceBody)),
+    TypeParam(TypeName,ParameterizedType(TypeName,TypeArgs(ParameterizedType(TypeName,TypeArgs(TypeName)))))
+  ),StructType(struct,StructBody))))
+
+# Interface types
+
+type i1 interface {}
+
+type i1 interface { io.Reader }
+
+type i2 interface {
+  i1
+  io.Reader
+  SomeMethod(s string) error
+  OtherMethod(int, ...bool) bool
+}
+
+type SignedInteger interface {
+  int | int8 | ~uint | ~uint8
+}
+
+==>
+
+SourceFile(
+  TypeDecl(type,TypeSpec(DefName,InterfaceType(interface,InterfaceBody))),
+  TypeDecl(type,TypeSpec(DefName,InterfaceType(interface,InterfaceBody(
+    QualifiedType(VariableName,TypeName))))),
+  TypeDecl(type,TypeSpec(DefName,InterfaceType(interface,InterfaceBody(
+    TypeName,
+    QualifiedType(VariableName,TypeName),
+    MethodElem(FieldName,Parameters(Parameter(DefName,TypeName)),TypeName),
+    MethodElem(FieldName,Parameters(Parameter(TypeName),Parameter("...",TypeName)),TypeName))))),
+  TypeDecl(type,TypeSpec(DefName,InterfaceType(interface,InterfaceBody(
+    TypeElem(TypeName,LogicOp,TypeName,LogicOp,UnderlyingType(TypeName),LogicOp,UnderlyingType(TypeName)))))))
+
+# Interface embedded struct types
+
+type NewEmbeddings interface {
+        struct{ f int }
+        ~struct{ f int }
+        *struct{ f int }
+        struct{ f int } | ~struct{ f int }
+}
+
+==>
+
+SourceFile(TypeDecl(type,TypeSpec(DefName,InterfaceType(interface,InterfaceBody(
+  StructType(struct,StructBody(FieldDecl(FieldName,TypeName))),
+  UnderlyingType(StructType(struct,StructBody(FieldDecl(FieldName,TypeName)))),
+  PointerType(StructType(struct,StructBody(FieldDecl(FieldName,TypeName)))),
+  TypeElem(
+    StructType(struct,StructBody(FieldDecl(FieldName,TypeName))),
+    LogicOp,
+    UnderlyingType(StructType(struct,StructBody(FieldDecl(FieldName,TypeName))))))))))
+
+# Map types
+
+type m1 map[string]error
+
+==>
+
+SourceFile(
+  TypeDecl(type,TypeSpec(DefName,MapType(map,TypeName,TypeName))))
+
+# Pointer types
+
+type (
+  p1 *string
+  p2 **p1
+)
+
+==>
+
+SourceFile(TypeDecl(type,SpecList(
+  TypeSpec(DefName,PointerType(TypeName)),
+  TypeSpec(DefName,PointerType(PointerType(TypeName))))))
+
+# Channel types
+
+type (
+  c1 chan<- chan int
+  c2 chan<- chan<- struct{}
+  c3 chan<- <-chan int
+)
+
+==>
+
+SourceFile(TypeDecl(type,SpecList(
+  TypeSpec(DefName,ChannelType(chan,ChannelType("<-",chan,TypeName))),
+  TypeSpec(DefName,ChannelType(chan,"<-",ChannelType(chan,"<-",StructType(struct,StructBody)))),
+  TypeSpec(DefName,ChannelType(chan,"<-",ChannelType("<-",chan,TypeName))))))
+
+# Function types
+
+type (
+  a func(int) int
+  b func(int, *string) (bool, error)
+  c func(int, ...*string) bool
+)
+
+==>
+
+SourceFile(TypeDecl(type,SpecList(
+  TypeSpec(DefName,FunctionType(func,Parameters(Parameter(TypeName)),TypeName)),
+  TypeSpec(DefName,FunctionType(func,Parameters(
+    Parameter(TypeName),
+    Parameter(PointerType(TypeName))
+  ),Parameters(Parameter(TypeName),Parameter(TypeName)))),
+  TypeSpec(DefName,FunctionType(func,Parameters(
+    Parameter(TypeName),
+    Parameter("...",PointerType(TypeName))
+  ),TypeName)))))
+
+# Type Aliases
+
+type H1 = G1
+type _ = G2
+type _ = struct{}
+type (
+	A0 = T0
+	A1 = int
+	A2 = struct{}
+	A3 = reflect.Value
+	A4 = Value
+	A5 = Value
+)
+
+==>
+
+SourceFile(
+  TypeDecl(type,TypeSpec(DefName,TypeName)),
+  TypeDecl(type,TypeSpec(DefName,TypeName)),
+  TypeDecl(type,TypeSpec(DefName,StructType(struct,StructBody))),
+  TypeDecl(type, SpecList(
+    TypeSpec(DefName,TypeName),
+    TypeSpec(DefName,TypeName),
+    TypeSpec(DefName,StructType(struct,StructBody)),
+    TypeSpec(DefName,QualifiedType(VariableName,TypeName)),
+    TypeSpec(DefName,TypeName),
+    TypeSpec(DefName,TypeName))))