389 lines
8.4 KiB
Plaintext
389 lines
8.4 KiB
Plaintext
# 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)))))
|