cznic / gc Goto Github PK
View Code? Open in Web Editor NEWgithub.com/cznic/gc has moved to modernc.org/gc
Home Page: https://godoc.org/modernc.org/gc
License: Other
gc's People
Stargazers
Watchers
gc's Issues
Error in Build
Hello,
after press Make , this show very long errors.
guest@system:~/go/src/github.com/cznic/gc$ make
go test -i
go generate 2>&1 | tee log-generate
generate.go:81: Parse table entries: 34392 of 99370, x 16 bits == 68784 bytes
stringer: checking package: ast.go:12:2: could not import github.com/cznic/xc (reading export data: /home/guest/go/pkg/linux_amd64/github.com/cznic/xc.a: invalid encoding format in export data: got 'v'; want 'c' or 'd')
gc.go:7: running "stringer": exit status 1
gofmt -l -s -w *.go
go test -i
go test 2>&1 | tee log
--- FAIL: TestLoad (1.04s)
all_test.go:260: 38
all_test.go:262: /usr/lib/go-1.8/src/runtime/cgocall.go:409:35: invalid operation: (type interface{} does not support indexing)
/usr/lib/go-1.8/src/reflect/type.go:2804:3: cannot use type bool as type bool in assignment
/usr/lib/go-1.8/src/reflect/value.go:1828:18: invalid operation: (type reflect.Value does not support indexing)
/usr/lib/go-1.8/src/syscall/exec_unix.go:206:16: cannot convert type error to syscall.Errno
/usr/lib/go-1.8/src/os/path.go:76:40: invalid operation: && (mismatched types *os.PathError and bool)
/usr/lib/go-1.8/src/os/types.go:70:18: cannot convert type string to byte
/usr/lib/go-1.8/src/os/types.go:81:18: cannot convert type string to byte
/usr/lib/go-1.8/src/fmt/print.go:864:16: assignment count mismatch: 2 = 1
/usr/lib/go-1.8/src/fmt/scan.go:100:31: cannot convert type *string to *fmt.stringReader
/usr/lib/go-1.8/src/fmt/scan.go:106:33: cannot convert type *string to *fmt.stringReader
--- FAIL: ExampleArgument (0.00s)
got:
&gc.Argument{
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example2.go:1:19: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
}
want:
--- FAIL: ExampleArgument_case1 (0.00s)
got:
&gc.Argument{
· Case: 1,
· TypeLiteral: &gc.TypeLiteral{
· · Case: 2,
· · ChanType: &gc.ChanType{
· · · Token: example3.go:1:19: CHAN,
· · · Typ: &gc.Typ{
· · · · Case: 7,
· · · · QualifiedIdent: &gc.QualifiedIdent{
· · · · · Token: example3.go:1:24: IDENTIFIER "c",
· · · · },
· · · },
· · },
· },
}
want:
--- FAIL: ExampleArgumentList (0.00s)
got:
&gc.ArgumentList{
· Argument: &gc.Argument{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'c',
· · · · · · · Token: example4.go:1:19: CHAR_LIT "'c'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
}
want:
--- FAIL: ExampleArgumentList_case1 (0.00s)
got:
&gc.ArgumentList{
· Argument: &gc.Argument{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'c',
· · · · · · · Token: example5.go:1:19: CHAR_LIT "'c'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· ArgumentList: &gc.ArgumentList{
· · Argument: &gc.Argument{
· · · Expression: &gc.Expression{
· · · · UnaryExpression: &gc.UnaryExpression{
· · · · · Case: 7,
· · · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · · Operand: &gc.Operand{
· · · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · · Value: 'd',
· · · · · · · · Token: example5.go:1:25: CHAR_LIT "'d'",
· · · · · · · },
· · · · · · · Case: 2,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · Case: 1,
· · Token: example5.go:1:23: ',',
· },
}
want:
--- FAIL: ExampleArrayType (0.00s)
got:
&gc.ArrayType{
· Token: example6.go:1:13: '[',
· Token2: example6.go:1:15: DDD,
· Token3: example6.go:1:19: ']',
· Typ: &gc.Typ{
· · Case: 7,
· · QualifiedIdent: &gc.QualifiedIdent{
· · · Token: example6.go:1:21: IDENTIFIER "b",
· · },
· },
}
want:
--- FAIL: ExampleArrayType_case1 (0.00s)
got:
&gc.ArrayType{
· Case: 1,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example7.go:1:15: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example7.go:1:13: '[',
· Token2: example7.go:1:19: ']',
· Typ: &gc.Typ{
· · Case: 7,
· · QualifiedIdent: &gc.QualifiedIdent{
· · · Token: example7.go:1:21: IDENTIFIER "c",
· · },
· },
}
want:
--- FAIL: ExampleAssignment (0.00s)
got:
&gc.Assignment{
· ExpressionList: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'b',
· · · · · · · Token: example8.go:1:13: CHAR_LIT "'b'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· ExpressionList2: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'c',
· · · · · · · Token: example8.go:1:19: CHAR_LIT "'c'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example8.go:1:17: '=',
}
want:
--- FAIL: ExampleAssignment_case01 (0.00s)
got:
&gc.Assignment{
· Case: 1,
· ExpressionList: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'b',
· · · · · · · Token: example9.go:1:13: CHAR_LIT "'b'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· ExpressionList2: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'c',
· · · · · · · Token: example9.go:1:20: CHAR_LIT "'c'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example9.go:1:17: ADD_ASSIGN,
}
want:
--- FAIL: ExampleAssignment_case02 (0.00s)
got:
&gc.Assignment{
· Case: 2,
· ExpressionList: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'b',
· · · · · · · Token: example10.go:1:13: CHAR_LIT "'b'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· ExpressionList2: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'c',
· · · · · · · Token: example10.go:1:21: CHAR_LIT "'c'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example10.go:1:17: ANDNOT_ASSIGN,
}
want:
--- FAIL: ExampleAssignment_case03 (0.00s)
got:
&gc.Assignment{
· Case: 3,
· ExpressionList: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'b',
· · · · · · · Token: example11.go:1:13: CHAR_LIT "'b'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· ExpressionList2: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'c',
· · · · · · · Token: example11.go:1:20: CHAR_LIT "'c'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example11.go:1:17: AND_ASSIGN,
}
want:
--- FAIL: ExampleAssignment_case04 (0.00s)
got:
&gc.Assignment{
· Case: 4,
· ExpressionList: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'b',
· · · · · · · Token: example12.go:1:13: CHAR_LIT "'b'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· ExpressionList2: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'c',
· · · · · · · Token: example12.go:1:20: CHAR_LIT "'c'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example12.go:1:17: DIV_ASSIGN,
}
want:
--- FAIL: ExampleAssignment_case05 (0.00s)
got:
&gc.Assignment{
· Case: 5,
· ExpressionList: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'b',
· · · · · · · Token: example13.go:1:13: CHAR_LIT "'b'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· ExpressionList2: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'c',
· · · · · · · Token: example13.go:1:21: CHAR_LIT "'c'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example13.go:1:17: LSH_ASSIGN,
}
want:
--- FAIL: ExampleAssignment_case06 (0.00s)
got:
&gc.Assignment{
· Case: 6,
· ExpressionList: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'b',
· · · · · · · Token: example14.go:1:13: CHAR_LIT "'b'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· ExpressionList2: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'c',
· · · · · · · Token: example14.go:1:20: CHAR_LIT "'c'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example14.go:1:17: MOD_ASSIGN,
}
want:
--- FAIL: ExampleAssignment_case07 (0.00s)
got:
&gc.Assignment{
· Case: 7,
· ExpressionList: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'b',
· · · · · · · Token: example15.go:1:13: CHAR_LIT "'b'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· ExpressionList2: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'c',
· · · · · · · Token: example15.go:1:20: CHAR_LIT "'c'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example15.go:1:17: MUL_ASSIGN,
}
want:
--- FAIL: ExampleAssignment_case08 (0.00s)
got:
&gc.Assignment{
· Case: 8,
· ExpressionList: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'b',
· · · · · · · Token: example16.go:1:13: CHAR_LIT "'b'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· ExpressionList2: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'c',
· · · · · · · Token: example16.go:1:20: CHAR_LIT "'c'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example16.go:1:17: OR_ASSIGN,
}
want:
--- FAIL: ExampleAssignment_case09 (0.00s)
got:
&gc.Assignment{
· Case: 9,
· ExpressionList: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'b',
· · · · · · · Token: example17.go:1:13: CHAR_LIT "'b'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· ExpressionList2: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'c',
· · · · · · · Token: example17.go:1:21: CHAR_LIT "'c'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example17.go:1:17: RSH_ASSIGN,
}
want:
--- FAIL: ExampleAssignment_case10 (0.00s)
got:
&gc.Assignment{
· Case: 10,
· ExpressionList: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'b',
· · · · · · · Token: example18.go:1:13: CHAR_LIT "'b'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· ExpressionList2: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'c',
· · · · · · · Token: example18.go:1:20: CHAR_LIT "'c'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example18.go:1:17: SUB_ASSIGN,
}
want:
--- FAIL: ExampleAssignment_case11 (0.00s)
got:
&gc.Assignment{
· Case: 11,
· ExpressionList: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'b',
· · · · · · · Token: example19.go:1:13: CHAR_LIT "'b'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· ExpressionList2: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'c',
· · · · · · · Token: example19.go:1:20: CHAR_LIT "'c'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example19.go:1:17: XOR_ASSIGN,
}
want:
--- FAIL: ExampleBasicLiteral (0.00s)
got:
&gc.BasicLiteral{
· Value: 'b',
· Token: example20.go:1:13: CHAR_LIT "'b'",
}
want:
--- FAIL: ExampleBasicLiteral_case1 (0.00s)
got:
&gc.BasicLiteral{
· Value: 1.98,
· Case: 1,
· Token: example21.go:1:13: FLOAT_LIT "1.98",
}
want:
--- FAIL: ExampleBasicLiteral_case2 (0.00s)
got:
&gc.BasicLiteral{
· Value: (0+98i),
· Case: 2,
· Token: example22.go:1:13: IMAG_LIT "98i",
}
want:
--- FAIL: ExampleBasicLiteral_case3 (0.00s)
got:
&gc.BasicLiteral{
· Value: 98,
· Case: 3,
· Token: example23.go:1:13: INT_LIT "98",
}
want:
--- FAIL: ExampleBasicLiteral_case4 (0.00s)
got:
&gc.BasicLiteral{
· Value: "b",
· Case: 4,
· Token: example24.go:1:13: STRING_LIT "\"b\"",
}
want:
--- FAIL: ExampleBlock (0.00s)
got:
&gc.Block{
· Token: example26.go:1:17: '{',
· Token2: example26.go:1:19: '}',
}
want:
--- FAIL: ExampleBody (0.00s)
got:
&gc.Body{
· Token: example28.go:1:16: '{',
· Token2: example28.go:1:18: '}',
}
want:
--- FAIL: ExampleCall (0.00s)
got:
&gc.Call{
· Token: example29.go:1:17: '(',
· Token2: example29.go:1:19: ')',
}
want:
--- FAIL: ExampleCall_case1 (0.00s)
got:
&gc.Call{
· ArgumentList: &gc.ArgumentList{
· · Argument: &gc.Argument{
· · · Expression: &gc.Expression{
· · · · UnaryExpression: &gc.UnaryExpression{
· · · · · Case: 7,
· · · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · · Operand: &gc.Operand{
· · · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · · Value: 'c',
· · · · · · · · Token: example30.go:1:19: CHAR_LIT "'c'",
· · · · · · · },
· · · · · · · Case: 2,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Case: 1,
· Token: example30.go:1:17: '(',
· Token2: example30.go:1:23: ')',
}
want:
--- FAIL: ExampleCall_case2 (0.00s)
got:
&gc.Call{
· ArgumentList: &gc.ArgumentList{
· · Argument: &gc.Argument{
· · · Expression: &gc.Expression{
· · · · UnaryExpression: &gc.UnaryExpression{
· · · · · Case: 7,
· · · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · · Operand: &gc.Operand{
· · · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · · Value: 'c',
· · · · · · · · Token: example31.go:1:19: CHAR_LIT "'c'",
· · · · · · · },
· · · · · · · Case: 2,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Case: 2,
· Token: example31.go:1:17: '(',
· Token2: example31.go:1:23: DDD,
· Token3: example31.go:1:27: ')',
}
want:
--- FAIL: ExampleChanType (0.00s)
got:
&gc.ChanType{
· Token: example32.go:1:13: CHAN,
· Typ: &gc.Typ{
· · Case: 7,
· · QualifiedIdent: &gc.QualifiedIdent{
· · · Token: example32.go:1:18: IDENTIFIER "b",
· · },
· },
}
want:
--- FAIL: ExampleChanType_case1 (0.00s)
got:
&gc.ChanType{
· Case: 1,
· Token: example33.go:1:13: CHAN,
· Token2: example33.go:1:18: TXCHAN,
· Typ: &gc.Typ{
· · Case: 7,
· · QualifiedIdent: &gc.QualifiedIdent{
· · · Token: example33.go:1:21: IDENTIFIER "b",
· · },
· },
}
want:
--- FAIL: ExampleChanType_case2 (0.00s)
got:
&gc.ChanType{
· Case: 2,
· Token: example34.go:1:13: RXCHAN,
· Token2: example34.go:1:16: CHAN,
· Typ: &gc.Typ{
· · Case: 7,
· · QualifiedIdent: &gc.QualifiedIdent{
· · · Token: example34.go:1:21: IDENTIFIER "b",
· · },
· },
}
want:
--- FAIL: ExampleCommaOpt (0.00s)
got:
true
want:
--- FAIL: ExampleCommaOpt_case1 (0.00s)
got:
&gc.CommaOpt{
· Token: example36.go:1:22: ',',
}
want:
--- FAIL: ExampleCompLitItem (0.00s)
got:
&gc.CompLitItem{
· CompLitValue: &gc.CompLitValue{
· · Token: example37.go:1:19: '{',
· · Token2: example37.go:1:21: '}',
· },
}
want:
--- FAIL: ExampleCompLitItem_case1 (0.00s)
got:
&gc.CompLitItem{
· Case: 1,
· CompLitValue: &gc.CompLitValue{
· · Token: example38.go:1:19: '{',
· · Token2: example38.go:1:21: '}',
· },
· CompLitValue2: &gc.CompLitValue{
· · Token: example38.go:1:25: '{',
· · Token2: example38.go:1:27: '}',
· },
· Token: example38.go:1:23: ':',
}
want:
--- FAIL: ExampleCompLitItem_case2 (0.00s)
got:
&gc.CompLitItem{
· Case: 2,
· CompLitValue: &gc.CompLitValue{
· · Token: example39.go:1:19: '{',
· · Token2: example39.go:1:21: '}',
· },
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example39.go:1:25: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example39.go:1:23: ':',
}
want:
--- FAIL: ExampleCompLitItem_case3 (0.00s)
got:
&gc.CompLitItem{
· Case: 3,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example40.go:1:19: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
}
want:
--- FAIL: ExampleCompLitItem_case4 (0.00s)
got:
&gc.CompLitItem{
· Case: 4,
· CompLitValue: &gc.CompLitValue{
· · Token: example41.go:1:25: '{',
· · Token2: example41.go:1:27: '}',
· },
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example41.go:1:19: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example41.go:1:23: ':',
}
want:
--- FAIL: ExampleCompLitItem_case5 (0.00s)
got:
&gc.CompLitItem{
· Case: 5,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example42.go:1:19: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Expression2: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'd',
· · · · · · Token: example42.go:1:25: CHAR_LIT "'d'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example42.go:1:23: ':',
}
want:
--- FAIL: ExampleCompLitItemList (0.00s)
got:
&gc.CompLitItemList{
· CompLitItem: &gc.CompLitItem{
· · Case: 3,
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'c',
· · · · · · · Token: example43.go:1:19: CHAR_LIT "'c'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
}
want:
--- FAIL: ExampleCompLitItemList_case1 (0.00s)
got:
&gc.CompLitItemList{
· CompLitItem: &gc.CompLitItem{
· · Case: 3,
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'c',
· · · · · · · Token: example44.go:1:19: CHAR_LIT "'c'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· CompLitItemList: &gc.CompLitItemList{
· · Case: 1,
· · CompLitItem: &gc.CompLitItem{
· · · Case: 3,
· · · Expression: &gc.Expression{
· · · · UnaryExpression: &gc.UnaryExpression{
· · · · · Case: 7,
· · · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · · Operand: &gc.Operand{
· · · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · · Value: 'd',
· · · · · · · · Token: example44.go:1:25: CHAR_LIT "'d'",
· · · · · · · },
· · · · · · · Case: 2,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · Token: example44.go:1:23: ',',
· },
}
want:
--- FAIL: ExampleCompLitType (0.00s)
got:
&gc.CompLitType{
· ArrayType: &gc.ArrayType{
· · Case: 1,
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'b',
· · · · · · · Token: example45.go:1:15: CHAR_LIT "'b'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· · Token: example45.go:1:13: '[',
· · Token2: example45.go:1:19: ']',
· · Typ: &gc.Typ{
· · · Case: 7,
· · · QualifiedIdent: &gc.QualifiedIdent{
· · · · Token: example45.go:1:21: IDENTIFIER "c",
· · · },
· · },
· },
}
want:
--- FAIL: ExampleCompLitType_case1 (0.00s)
got:
&gc.CompLitType{
· Case: 1,
· MapType: &gc.MapType{
· · Token: example46.go:1:13: MAP,
· · Token2: example46.go:1:17: '[',
· · Token3: example46.go:1:21: ']',
· · Typ: &gc.Typ{
· · · Case: 7,
· · · QualifiedIdent: &gc.QualifiedIdent{
· · · · Token: example46.go:1:19: IDENTIFIER "b",
· · · },
· · },
· · Typ2: &gc.Typ{
· · · Case: 7,
· · · QualifiedIdent: &gc.QualifiedIdent{
· · · · Token: example46.go:1:23: IDENTIFIER "c",
· · · },
· · },
· },
}
want:
--- FAIL: ExampleCompLitType_case2 (0.00s)
got:
&gc.CompLitType{
· Case: 2,
· SliceType: &gc.SliceType{
· · Token: example47.go:1:13: '[',
· · Token2: example47.go:1:15: ']',
· · Typ: &gc.Typ{
· · · Case: 7,
· · · QualifiedIdent: &gc.QualifiedIdent{
· · · · Token: example47.go:1:17: IDENTIFIER "b",
· · · },
· · },
· },
}
want:
--- FAIL: ExampleCompLitType_case3 (0.00s)
got:
&gc.CompLitType{
· Case: 3,
· StructType: &gc.StructType{
· · LBrace: &gc.LBrace{
· · · Case: 1,
· · · Token: example48.go:1:20: '{',
· · },
· · Token: example48.go:1:13: STRUCT,
· · Token2: example48.go:1:22: '}',
· },
}
want:
--- FAIL: ExampleCompLitValue (0.00s)
got:
&gc.CompLitValue{
· Token: example49.go:1:17: '{',
· Token2: example49.go:1:19: '}',
}
want:
--- FAIL: ExampleCompLitValue_case1 (0.00s)
got:
&gc.CompLitValue{
· Case: 1,
· CompLitItemList: &gc.CompLitItemList{
· · CompLitItem: &gc.CompLitItem{
· · · Case: 3,
· · · Expression: &gc.Expression{
· · · · UnaryExpression: &gc.UnaryExpression{
· · · · · Case: 7,
· · · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · · Operand: &gc.Operand{
· · · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · · Value: 'c',
· · · · · · · · Token: example50.go:1:19: CHAR_LIT "'c'",
· · · · · · · },
· · · · · · · Case: 2,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example50.go:1:17: '{',
· Token2: example50.go:1:23: '}',
}
want:
--- FAIL: ExampleConstDecl (0.00s)
got:
&gc.ConstDecl{
· Token: example51.go:1:13: CONST,
· Token2: example51.go:1:19: '(',
· Token3: example51.go:1:21: ')',
}
want:
--- FAIL: ExampleConstDecl_case1 (0.00s)
got:
&gc.ConstDecl{
· Case: 1,
· ConstSpecList: &gc.ConstSpecList{
· · ConstSpec: &gc.ConstSpec{
· · · IdentifierList: &gc.IdentifierList{
· · · · Token: example52.go:1:21: IDENTIFIER "b",
· · · },
· · },
· },
· Token: example52.go:1:13: CONST,
· Token2: example52.go:1:19: '(',
· Token3: example52.go:1:23: ')',
}
want:
--- FAIL: ExampleConstDecl_case2 (0.00s)
got:
&gc.ConstDecl{
· Case: 2,
· ConstSpec: &gc.ConstSpec{
· · IdentifierList: &gc.IdentifierList{
· · · Token: example53.go:1:19: IDENTIFIER "b",
· · },
· },
· Token: example53.go:1:13: CONST,
}
want:
--- FAIL: ExampleConstSpec (0.00s)
got:
&gc.ConstSpec{
· IdentifierList: &gc.IdentifierList{
· · Token: example54.go:1:19: IDENTIFIER "b",
· },
}
want:
--- FAIL: ExampleConstSpec_case1 (0.00s)
got:
&gc.ConstSpec{
· Case: 1,
· ExpressionList: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'c',
· · · · · · · Token: example55.go:1:23: CHAR_LIT "'c'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· IdentifierList: &gc.IdentifierList{
· · Token: example55.go:1:19: IDENTIFIER "b",
· },
· Token: example55.go:1:21: '=',
}
want:
--- FAIL: ExampleConstSpec_case2 (0.00s)
got:
&gc.ConstSpec{
· Case: 2,
· ExpressionList: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'd',
· · · · · · · Token: example56.go:1:25: CHAR_LIT "'d'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· IdentifierList: &gc.IdentifierList{
· · Token: example56.go:1:19: IDENTIFIER "b",
· },
· Token: example56.go:1:23: '=',
· Typ: &gc.Typ{
· · Case: 7,
· · QualifiedIdent: &gc.QualifiedIdent{
· · · Token: example56.go:1:21: IDENTIFIER "c",
· · },
· },
}
want:
--- FAIL: ExampleConstSpecList (0.00s)
got:
&gc.ConstSpecList{
· ConstSpec: &gc.ConstSpec{
· · Case: 1,
· · ExpressionList: &gc.ExpressionList{
· · · Expression: &gc.Expression{
· · · · UnaryExpression: &gc.UnaryExpression{
· · · · · Case: 7,
· · · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · · Operand: &gc.Operand{
· · · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · · Value: 42,
· · · · · · · · Case: 3,
· · · · · · · · Token: example57.go:1:25: INT_LIT "42",
· · · · · · · },
· · · · · · · Case: 2,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · IdentifierList: &gc.IdentifierList{
· · · Token: example57.go:1:21: IDENTIFIER "b",
· · },
· · Token: example57.go:1:23: '=',
· },
}
want:
--- FAIL: ExampleConstSpecList_case1 (0.00s)
got:
&gc.ConstSpecList{
· ConstSpec: &gc.ConstSpec{
· · Case: 1,
· · ExpressionList: &gc.ExpressionList{
· · · Expression: &gc.Expression{
· · · · UnaryExpression: &gc.UnaryExpression{
· · · · · Case: 7,
· · · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · · Operand: &gc.Operand{
· · · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · · Value: 42,
· · · · · · · · Case: 3,
· · · · · · · · Token: example58.go:1:25: INT_LIT "42",
· · · · · · · },
· · · · · · · Case: 2,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · IdentifierList: &gc.IdentifierList{
· · · Token: example58.go:1:21: IDENTIFIER "b",
· · },
· · Token: example58.go:1:23: '=',
· },
· ConstSpecList: &gc.ConstSpecList{
· · Case: 1,
· · ConstSpec: &gc.ConstSpec{
· · · Case: 1,
· · · ExpressionList: &gc.ExpressionList{
· · · · Expression: &gc.Expression{
· · · · · UnaryExpression: &gc.UnaryExpression{
· · · · · · Case: 7,
· · · · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · · · Operand: &gc.Operand{
· · · · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · · · Value: 314,
· · · · · · · · · Case: 3,
· · · · · · · · · Token: example58.go:1:34: INT_LIT "314",
· · · · · · · · },
· · · · · · · · Case: 2,
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · · IdentifierList: &gc.IdentifierList{
· · · · Token: example58.go:1:30: IDENTIFIER "c",
· · · },
· · · Token: example58.go:1:32: '=',
· · },
· · Token: example58.go:1:28: ';',
· },
}
want:
--- FAIL: ExampleElif (0.00s)
got:
&gc.Elif{
· Body: &gc.Body{
· · Token: example59.go:1:28: '{',
· · Token2: example59.go:1:30: '}',
· },
· Token: example59.go:1:20: ELSE,
· Token2: example59.go:1:25: IF,
}
want:
--- FAIL: ExampleElifList (0.00s)
got:
true
want:
--- FAIL: ExampleElifList_case1 (0.00s)
got:
&gc.ElifList{
· Elif: &gc.Elif{
· · Body: &gc.Body{
· · · Token: example61.go:1:28: '{',
· · · Token2: example61.go:1:30: '}',
· · },
· · Token: example61.go:1:20: ELSE,
· · Token2: example61.go:1:25: IF,
· },
}
want:
--- FAIL: ExampleElseOpt (0.00s)
got:
true
want:
--- FAIL: ExampleElseOpt_case1 (0.00s)
got:
&gc.ElseOpt{
· Block: &gc.Block{
· · Token: example63.go:1:25: '{',
· · Token2: example63.go:1:27: '}',
· },
· Token: example63.go:1:20: ELSE,
}
want:
--- FAIL: ExampleExpression (0.00s)
got:
&gc.Expression{
· UnaryExpression: &gc.UnaryExpression{
· · Case: 7,
· · PrimaryExpression: &gc.PrimaryExpression{
· · · Operand: &gc.Operand{
· · · · BasicLiteral: &gc.BasicLiteral{
· · · · · Value: 'b',
· · · · · Token: example64.go:1:13: CHAR_LIT "'b'",
· · · · },
· · · · Case: 2,
· · · },
· · },
· },
}
want:
--- FAIL: ExampleExpression_case01 (0.00s)
got:
&gc.Expression{
· Case: 1,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example65.go:1:13: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Expression2: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example65.go:1:19: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example65.go:1:17: '%',
}
want:
--- FAIL: ExampleExpression_case02 (0.00s)
got:
&gc.Expression{
· Case: 2,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example66.go:1:13: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Expression2: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example66.go:1:19: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example66.go:1:17: '&',
}
want:
--- FAIL: ExampleExpression_case03 (0.00s)
got:
&gc.Expression{
· Case: 3,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example67.go:1:13: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Expression2: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example67.go:1:19: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example67.go:1:17: '*',
}
want:
--- FAIL: ExampleExpression_case04 (0.00s)
got:
&gc.Expression{
· Case: 4,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example68.go:1:13: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Expression2: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example68.go:1:19: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example68.go:1:17: '+',
}
want:
--- FAIL: ExampleExpression_case05 (0.00s)
got:
&gc.Expression{
· Case: 5,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example69.go:1:13: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Expression2: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example69.go:1:19: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example69.go:1:17: '-',
}
want:
--- FAIL: ExampleExpression_case06 (0.00s)
got:
&gc.Expression{
· Case: 6,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example70.go:1:13: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Expression2: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example70.go:1:19: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example70.go:1:17: '/',
}
want:
--- FAIL: ExampleExpression_case07 (0.00s)
got:
&gc.Expression{
· Case: 7,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example71.go:1:13: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Expression2: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example71.go:1:19: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example71.go:1:17: '<',
}
want:
--- FAIL: ExampleExpression_case08 (0.00s)
got:
&gc.Expression{
· Case: 8,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example72.go:1:13: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Expression2: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example72.go:1:19: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example72.go:1:17: '>',
}
want:
--- FAIL: ExampleExpression_case09 (0.00s)
got:
&gc.Expression{
· Case: 9,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example73.go:1:13: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Expression2: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example73.go:1:19: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example73.go:1:17: '^',
}
want:
--- FAIL: ExampleExpression_case10 (0.00s)
got:
&gc.Expression{
· Case: 10,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example74.go:1:13: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Expression2: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example74.go:1:19: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example74.go:1:17: '|',
}
want:
--- FAIL: ExampleExpression_case11 (0.00s)
got:
&gc.Expression{
· Case: 11,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example75.go:1:13: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Expression2: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example75.go:1:20: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example75.go:1:17: ANDAND,
}
want:
--- FAIL: ExampleExpression_case12 (0.00s)
got:
&gc.Expression{
· Case: 12,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example76.go:1:13: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Expression2: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example76.go:1:20: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example76.go:1:17: ANDNOT,
}
want:
--- FAIL: ExampleExpression_case13 (0.00s)
got:
&gc.Expression{
· Case: 13,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example77.go:1:13: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Expression2: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example77.go:1:20: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example77.go:1:17: EQ,
}
want:
--- FAIL: ExampleExpression_case14 (0.00s)
got:
&gc.Expression{
· Case: 14,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example78.go:1:13: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Expression2: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example78.go:1:20: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example78.go:1:17: GEQ,
}
want:
--- FAIL: ExampleExpression_case15 (0.00s)
got:
&gc.Expression{
· Case: 15,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example79.go:1:13: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Expression2: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example79.go:1:20: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example79.go:1:17: LEQ,
}
want:
--- FAIL: ExampleExpression_case16 (0.00s)
got:
&gc.Expression{
· Case: 16,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example80.go:1:13: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Expression2: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example80.go:1:20: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example80.go:1:17: LSH,
}
want:
--- FAIL: ExampleExpression_case17 (0.00s)
got:
&gc.Expression{
· Case: 17,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example81.go:1:13: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Expression2: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example81.go:1:20: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example81.go:1:17: NEQ,
}
want:
--- FAIL: ExampleExpression_case18 (0.00s)
got:
&gc.Expression{
· Case: 18,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example82.go:1:13: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Expression2: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example82.go:1:20: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example82.go:1:17: OROR,
}
want:
--- FAIL: ExampleExpression_case19 (0.00s)
got:
&gc.Expression{
· Case: 19,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example83.go:1:13: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Expression2: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example83.go:1:20: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example83.go:1:17: RSH,
}
want:
--- FAIL: ExampleExpression_case20 (0.00s)
got:
&gc.Expression{
· Case: 20,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example84.go:1:13: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Expression2: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example84.go:1:20: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example84.go:1:17: COMM,
}
want:
--- FAIL: ExampleExpressionList (0.00s)
got:
&gc.ExpressionList{
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example87.go:1:13: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
}
want:
--- FAIL: ExampleExpressionList_case1 (0.00s)
got:
&gc.ExpressionList{
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example88.go:1:13: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· ExpressionList: &gc.ExpressionList{
· · Case: 1,
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'c',
· · · · · · · Token: example88.go:1:19: CHAR_LIT "'c'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· · Token: example88.go:1:17: ',',
· },
}
want:
--- FAIL: ExampleExpressionListOpt (0.00s)
got:
true
want:
--- FAIL: ExampleExpressionListOpt_case1 (0.00s)
got:
&gc.ExpressionListOpt{
· ExpressionList: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'b',
· · · · · · · Token: example90.go:1:20: CHAR_LIT "'b'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
}
want:
--- FAIL: ExampleExpressionOpt (0.00s)
got:
true
want:
--- FAIL: ExampleExpressionOpt_case1 (0.00s)
got:
&gc.ExpressionOpt{
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example86.go:1:19: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
}
want:
--- FAIL: ExampleFile (0.00s)
got:
&gc.File{
· Scope: &gc.Scope{
· · Kind: FileScope,
· · Parent: &gc.Scope{
· · · Kind: PackageScope,
· · · Parent: &gc.Scope{
· · · · Bindings: gc.Bindings{
· · · · · "append": *gc.FuncDeclaration,
· · · · · "bool": *gc.TypeDeclaration,
· · · · · "byte": *gc.TypeDeclaration,
· · · · · "cap": *gc.FuncDeclaration,
· · · · · "close": *gc.FuncDeclaration,
· · · · · "complex": *gc.FuncDeclaration,
· · · · · "complex128": *gc.TypeDeclaration,
· · · · · "complex64": *gc.TypeDeclaration,
· · · · · "copy": *gc.FuncDeclaration,
· · · · · "delete": *gc.FuncDeclaration,
· · · · · "error": *gc.TypeDeclaration,
· · · · · "false": *gc.ConstDeclaration,
· · · · · "float32": *gc.TypeDeclaration,
· · · · · "float64": *gc.TypeDeclaration,
· · · · · "imag": *gc.FuncDeclaration,
· · · · · "int": *gc.TypeDeclaration,
· · · · · "int16": *gc.TypeDeclaration,
· · · · · "int32": *gc.TypeDeclaration,
· · · · · "int64": *gc.TypeDeclaration,
· · · · · "int8": *gc.TypeDeclaration,
· · · · · "iota": *gc.ConstDeclaration,
· · · · · "len": *gc.FuncDeclaration,
· · · · · "make": *gc.FuncDeclaration,
· · · · · "new": *gc.FuncDeclaration,
· · · · · "nil": *gc.VarDeclaration,
· · · · · "panic": *gc.FuncDeclaration,
· · · · · "print": *gc.FuncDeclaration,
· · · · · "println": *gc.FuncDeclaration,
· · · · · "real": *gc.FuncDeclaration,
· · · · · "recover": *gc.FuncDeclaration,
· · · · · "rune": *gc.TypeDeclaration,
· · · · · "string": *gc.TypeDeclaration,
· · · · · "true": *gc.ConstDeclaration,
· · · · · "uint": *gc.TypeDeclaration,
· · · · · "uint16": *gc.TypeDeclaration,
· · · · · "uint32": *gc.TypeDeclaration,
· · · · · "uint64": *gc.TypeDeclaration,
· · · · · "uint8": *gc.TypeDeclaration,
· · · · · "uintptr": *gc.TypeDeclaration,
· · · · },
· · · · Kind: UniverseScope,
· · · },
· · },
· },
· Path: "example1.go",
· Prologue: &gc.Prologue{
· · PackageClause: &gc.PackageClause{
· · · Token: example1.go:1:1: PACKAGE,
· · · Token2: example1.go:1:9: IDENTIFIER "a",
· · · Token3: example1.go:1:11: ';',
· · },
· },
}
want:
--- FAIL: ExampleForHeader (0.00s)
got:
&gc.ForHeader{
· Range: &gc.Range{
· · Case: 2,
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'b',
· · · · · · · Token: example91.go:1:23: CHAR_LIT "'b'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· · Token: example91.go:1:17: RANGE,
· },
}
want:
--- FAIL: ExampleForHeader_case1 (0.00s)
got:
&gc.ForHeader{
· Case: 1,
· Token: example92.go:1:17: ';',
· Token2: example92.go:1:19: ';',
}
want:
--- FAIL: ExampleForHeader_case2 (0.00s)
got:
&gc.ForHeader{
· Case: 2,
}
want:
--- FAIL: ExampleForStatement (0.00s)
got:
&gc.ForStatement{
· Body: &gc.Body{
· · Token: example94.go:1:17: '{',
· · Token2: example94.go:1:19: '}',
· },
· ForHeader: &gc.ForHeader{
· · Case: 2,
· },
· Token: example94.go:1:13: FOR,
}
want:
--- FAIL: ExampleFuncBodyOpt (0.00s)
got:
true
want:
--- FAIL: ExampleFuncBodyOpt_case1 (0.00s)
got:
&gc.FuncBodyOpt{
· Block: &gc.Block{
· · Token: example96.go:1:24: '{',
· · Token2: example96.go:1:26: '}',
· },
}
want:
--- FAIL: ExampleFuncDecl (0.00s)
got:
&gc.FuncDecl{
· Signature: &gc.Signature{
· · Parameters: &gc.Parameters{
· · · Token: example98.go:1:20: '(',
· · · Token2: example98.go:1:22: ')',
· · },
· },
· Token: example98.go:1:13: FUNC,
· Token2: example98.go:1:18: IDENTIFIER "b",
}
want:
--- FAIL: ExampleFuncType (0.00s)
got:
&gc.FuncType{
· Signature: &gc.Signature{
· · Parameters: &gc.Parameters{
· · · Token: example99.go:1:23: '(',
· · · Token2: example99.go:1:24: ')',
· · },
· },
· Token: example99.go:1:19: FUNC,
}
want:
--- FAIL: ExampleFuncType_case1 (0.00s)
got:
&gc.FuncType{
· Case: 1,
· IdentifierList: &gc.IdentifierList{
· · Token: example100.go:1:27: IDENTIFIER "b",
· },
· Signature: &gc.Signature{
· · Parameters: &gc.Parameters{
· · · Token: example100.go:1:32: '(',
· · · Token2: example100.go:1:34: ')',
· · },
· },
· Token: example100.go:1:19: FUNC,
· Token2: example100.go:1:24: LTLT,
· Token3: example100.go:1:29: GTGT,
}
want:
--- FAIL: ExampleGenericArgumentsOpt (0.00s)
got:
true
want:
--- FAIL: ExampleGenericArgumentsOpt_case1 (0.00s)
got:
&gc.GenericArgumentsOpt{
· Token: example102.go:1:15: LTLT,
· Token2: example102.go:1:20: GTGT,
· TypeList: &gc.TypeList{
· · Typ: &gc.Typ{
· · · Case: 7,
· · · QualifiedIdent: &gc.QualifiedIdent{
· · · · Token: example102.go:1:18: IDENTIFIER "c",
· · · },
· · },
· },
}
want:
--- FAIL: ExampleGenericParametersOpt (0.00s)
got:
true
want:
--- FAIL: ExampleGenericParametersOpt_case1 (0.00s)
got:
&gc.GenericParametersOpt{
· IdentifierList: &gc.IdentifierList{
· · Token: example104.go:1:23: IDENTIFIER "c",
· },
· Token: example104.go:1:20: LTLT,
· Token2: example104.go:1:25: GTGT,
}
want:
--- FAIL: ExampleIdentifierList (0.00s)
got:
&gc.IdentifierList{
· Token: example107.go:1:17: IDENTIFIER "b",
}
want:
--- FAIL: ExampleIdentifierList_case1 (0.00s)
got:
&gc.IdentifierList{
· IdentifierList: &gc.IdentifierList{
· · Case: 1,
· · Token: example108.go:1:19: ',',
· · Token2: example108.go:1:21: IDENTIFIER "c",
· },
· Token: example108.go:1:17: IDENTIFIER "b",
}
want:
--- FAIL: ExampleIdentifierOpt (0.00s)
got:
true
want:
--- FAIL: ExampleIdentifierOpt_case1 (0.00s)
got:
&gc.IdentifierOpt{
· Token: example106.go:1:20: IDENTIFIER "b",
}
want:
--- FAIL: ExampleIfHeader (0.00s)
got:
&gc.IfHeader{
· SimpleStatementOpt: &gc.SimpleStatementOpt{
· · SimpleStatement: &gc.SimpleStatement{
· · · Case: 1,
· · · Expression: &gc.Expression{
· · · · UnaryExpression: &gc.UnaryExpression{
· · · · · Case: 7,
· · · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · · Operand: &gc.Operand{
· · · · · · · Case: 4,
· · · · · · · Token: example109.go:1:16: IDENTIFIER "b",
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
}
want:
--- FAIL: ExampleIfHeader_case1 (0.00s)
got:
&gc.IfHeader{
· Case: 1,
· Token: example110.go:1:16: ';',
}
want:
--- FAIL: ExampleIfStatement (0.00s)
got:
&gc.IfStatement{
· Body: &gc.Body{
· · Token: example111.go:1:16: '{',
· · Token2: example111.go:1:18: '}',
· },
· Token: example111.go:1:13: IF,
}
want:
--- FAIL: ExampleImportDecl (0.00s)
got:
&gc.ImportDecl{
· Token: example112.go:1:13: IMPORT,
· Token2: example112.go:1:20: '(',
· Token3: example112.go:1:22: ')',
}
want:
--- FAIL: ExampleImportDecl_case1 (0.00s)
got:
&gc.ImportDecl{
· Case: 1,
· ImportSpecList: &gc.ImportSpecList{
· · ImportSpec: &gc.ImportSpec{
· · · BasicLiteral: &gc.BasicLiteral{
· · · · Value: 'b',
· · · · Token: example113.go:1:22: CHAR_LIT "'b'",
· · · },
· · · Case: 1,
· · },
· },
· Token: example113.go:1:13: IMPORT,
· Token2: example113.go:1:20: '(',
· Token3: example113.go:1:26: ')',
}
want:
--- FAIL: ExampleImportDecl_case2 (0.00s)
got:
&gc.ImportDecl{
· Case: 2,
· ImportSpec: &gc.ImportSpec{
· · BasicLiteral: &gc.BasicLiteral{
· · · Value: 'b',
· · · Token: example114.go:1:20: CHAR_LIT "'b'",
· · },
· · Case: 1,
· },
· Token: example114.go:1:13: IMPORT,
}
want:
--- FAIL: ExampleImportList (0.00s)
got:
true
want:
--- FAIL: ExampleImportList_case1 (0.00s)
got:
&gc.ImportList{
· ImportDecl: &gc.ImportDecl{
· · Case: 2,
· · ImportSpec: &gc.ImportSpec{
· · · BasicLiteral: &gc.BasicLiteral{
· · · · Value: 'b',
· · · · Token: example122.go:1:20: CHAR_LIT "'b'",
· · · },
· · · Case: 1,
· · },
· · Token: example122.go:1:13: IMPORT,
· },
· Token: example122.go:1:24: ';',
}
want:
--- FAIL: ExampleImportSpec (0.00s)
got:
&gc.ImportSpec{
· BasicLiteral: &gc.BasicLiteral{
· · Value: 'b',
· · Token: example115.go:1:22: CHAR_LIT "'b'",
· },
· Token: example115.go:1:20: '.',
}
want:
--- FAIL: ExampleImportSpec_case1 (0.00s)
got:
&gc.ImportSpec{
· BasicLiteral: &gc.BasicLiteral{
· · Value: 'b',
· · Token: example116.go:1:20: CHAR_LIT "'b'",
· },
· Case: 1,
}
want:
--- FAIL: ExampleImportSpecList (0.00s)
got:
&gc.ImportSpecList{
· ImportSpec: &gc.ImportSpec{
· · BasicLiteral: &gc.BasicLiteral{
· · · Value: 'b',
· · · Token: example119.go:1:22: CHAR_LIT "'b'",
· · },
· · Case: 1,
· },
}
want:
--- FAIL: ExampleImportSpecList_case1 (0.00s)
got:
&gc.ImportSpecList{
· ImportSpec: &gc.ImportSpec{
· · BasicLiteral: &gc.BasicLiteral{
· · · Value: 'b',
· · · Token: example120.go:1:22: CHAR_LIT "'b'",
· · },
· · Case: 1,
· },
· ImportSpecList: &gc.ImportSpecList{
· · Case: 1,
· · ImportSpec: &gc.ImportSpec{
· · · BasicLiteral: &gc.BasicLiteral{
· · · · Value: 'c',
· · · · Token: example120.go:1:28: CHAR_LIT "'c'",
· · · },
· · · Case: 1,
· · },
· · Token: example120.go:1:26: ';',
· },
}
want:
--- FAIL: ExampleInterfaceMethodDecl (0.00s)
got:
&gc.InterfaceMethodDecl{
· Signature: &gc.Signature{
· · Parameters: &gc.Parameters{
· · · Token: example127.go:1:27: '(',
· · · Token2: example127.go:1:29: ')',
· · },
· },
· Token: example127.go:1:25: IDENTIFIER "b",
}
want:
--- FAIL: ExampleInterfaceMethodDecl_case1 (0.00s)
got:
&gc.InterfaceMethodDecl{
· Case: 1,
· QualifiedIdent: &gc.QualifiedIdent{
· · Token: example128.go:1:25: IDENTIFIER "b",
· },
}
want:
--- FAIL: ExampleInterfaceMethodDeclList (0.00s)
got:
&gc.InterfaceMethodDeclList{
· InterfaceMethodDecl: &gc.InterfaceMethodDecl{
· · Case: 1,
· · QualifiedIdent: &gc.QualifiedIdent{
· · · Token: example129.go:1:25: IDENTIFIER "b",
· · },
· },
}
want:
--- FAIL: ExampleInterfaceMethodDeclList_case1 (0.00s)
got:
&gc.InterfaceMethodDeclList{
· InterfaceMethodDecl: &gc.InterfaceMethodDecl{
· · Case: 1,
· · QualifiedIdent: &gc.QualifiedIdent{
· · · Token: example130.go:1:25: IDENTIFIER "b",
· · },
· },
· InterfaceMethodDeclList: &gc.InterfaceMethodDeclList{
· · Case: 1,
· · InterfaceMethodDecl: &gc.InterfaceMethodDecl{
· · · Case: 1,
· · · QualifiedIdent: &gc.QualifiedIdent{
· · · · Token: example130.go:1:29: IDENTIFIER "c",
· · · },
· · },
· · Token: example130.go:1:27: ';',
· },
}
want:
--- FAIL: ExampleInterfaceType (0.00s)
got:
&gc.InterfaceType{
· LBrace: &gc.LBrace{
· · Case: 1,
· · Token: example123.go:1:23: '{',
· },
· Token: example123.go:1:13: INTERFACE,
· Token2: example123.go:1:25: '}',
}
want:
--- FAIL: ExampleInterfaceType_case1 (0.00s)
got:
&gc.InterfaceType{
· Case: 1,
· InterfaceMethodDeclList: &gc.InterfaceMethodDeclList{
· · InterfaceMethodDecl: &gc.InterfaceMethodDecl{
· · · Case: 1,
· · · QualifiedIdent: &gc.QualifiedIdent{
· · · · Token: example125.go:1:25: IDENTIFIER "b",
· · · },
· · },
· },
· LBrace: &gc.LBrace{
· · Case: 1,
· · Token: example125.go:1:23: '{',
· },
· Token: example125.go:1:13: INTERFACE,
· Token2: example125.go:1:27: '}',
}
want:
--- FAIL: ExampleLBrace (0.00s)
got:
&gc.LBrace{
· Token: example131.go:1:26: '{',
}
want:
--- FAIL: ExampleLBrace_case1 (0.00s)
got:
&gc.LBrace{
· Case: 1,
· Token: example132.go:1:23: '{',
}
want:
--- FAIL: ExampleLBraceCompLitItem (0.00s)
got:
&gc.LBraceCompLitItem{
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example133.go:1:21: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
}
want:
--- FAIL: ExampleLBraceCompLitItem_case1 (0.00s)
got:
&gc.LBraceCompLitItem{
· Case: 1,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example134.go:1:21: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Expression2: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'd',
· · · · · · Token: example134.go:1:27: CHAR_LIT "'d'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example134.go:1:25: ':',
}
want:
--- FAIL: ExampleLBraceCompLitItem_case2 (0.00s)
got:
&gc.LBraceCompLitItem{
· Case: 2,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example135.go:1:21: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· LBraceCompLitValue: &gc.LBraceCompLitValue{
· · LBrace: &gc.LBrace{
· · · Case: 1,
· · · Token: example135.go:1:27: '{',
· · },
· · Token: example135.go:1:29: '}',
· },
· Token: example135.go:1:25: ':',
}
want:
--- FAIL: ExampleLBraceCompLitItem_case3 (0.00s)
got:
&gc.LBraceCompLitItem{
· Case: 3,
· LBraceCompLitValue: &gc.LBraceCompLitValue{
· · LBrace: &gc.LBrace{
· · · Case: 1,
· · · Token: example136.go:1:21: '{',
· · },
· · Token: example136.go:1:23: '}',
· },
}
want:
--- FAIL: ExampleLBraceCompLitItem_case4 (0.00s)
got:
&gc.LBraceCompLitItem{
· Case: 4,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example137.go:1:27: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· LBraceCompLitValue: &gc.LBraceCompLitValue{
· · LBrace: &gc.LBrace{
· · · Case: 1,
· · · Token: example137.go:1:21: '{',
· · },
· · Token: example137.go:1:23: '}',
· },
· Token: example137.go:1:25: ':',
}
want:
--- FAIL: ExampleLBraceCompLitItem_case5 (0.00s)
got:
&gc.LBraceCompLitItem{
· Case: 5,
· LBraceCompLitValue: &gc.LBraceCompLitValue{
· · LBrace: &gc.LBrace{
· · · Case: 1,
· · · Token: example138.go:1:21: '{',
· · },
· · Token: example138.go:1:23: '}',
· },
· LBraceCompLitValue2: &gc.LBraceCompLitValue{
· · LBrace: &gc.LBrace{
· · · Case: 1,
· · · Token: example138.go:1:27: '{',
· · },
· · Token: example138.go:1:29: '}',
· },
· Token: example138.go:1:25: ':',
}
want:
--- FAIL: ExampleLBraceCompLitItemList (0.00s)
got:
&gc.LBraceCompLitItemList{
· LBraceCompLitItem: &gc.LBraceCompLitItem{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'c',
· · · · · · · Token: example139.go:1:21: CHAR_LIT "'c'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
}
want:
--- FAIL: ExampleLBraceCompLitItemList_case1 (0.00s)
got:
&gc.LBraceCompLitItemList{
· LBraceCompLitItem: &gc.LBraceCompLitItem{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'c',
· · · · · · · Token: example140.go:1:21: CHAR_LIT "'c'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· LBraceCompLitItemList: &gc.LBraceCompLitItemList{
· · Case: 1,
· · LBraceCompLitItem: &gc.LBraceCompLitItem{
· · · Expression: &gc.Expression{
· · · · UnaryExpression: &gc.UnaryExpression{
· · · · · Case: 7,
· · · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · · Operand: &gc.Operand{
· · · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · · Value: 'd',
· · · · · · · · Token: example140.go:1:27: CHAR_LIT "'d'",
· · · · · · · },
· · · · · · · Case: 2,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · Token: example140.go:1:25: ',',
· },
}
want:
--- FAIL: ExampleLBraceCompLitValue (0.00s)
got:
&gc.LBraceCompLitValue{
· LBrace: &gc.LBrace{
· · Case: 1,
· · Token: example141.go:1:19: '{',
· },
· Token: example141.go:1:21: '}',
}
want:
--- FAIL: ExampleLBraceCompLitValue_case1 (0.00s)
got:
&gc.LBraceCompLitValue{
· Case: 1,
· LBrace: &gc.LBrace{
· · Case: 1,
· · Token: example142.go:1:19: '{',
· },
· LBraceCompLitItemList: &gc.LBraceCompLitItemList{
· · LBraceCompLitItem: &gc.LBraceCompLitItem{
· · · Expression: &gc.Expression{
· · · · UnaryExpression: &gc.UnaryExpression{
· · · · · Case: 7,
· · · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · · Operand: &gc.Operand{
· · · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · · Value: 'c',
· · · · · · · · Token: example142.go:1:21: CHAR_LIT "'c'",
· · · · · · · },
· · · · · · · Case: 2,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example142.go:1:25: '}',
}
want:
--- FAIL: ExampleMapType (0.00s)
got:
&gc.MapType{
· Token: example143.go:1:13: MAP,
· Token2: example143.go:1:17: '[',
· Token3: example143.go:1:21: ']',
· Typ: &gc.Typ{
· · Case: 7,
· · QualifiedIdent: &gc.QualifiedIdent{
· · · Token: example143.go:1:19: IDENTIFIER "b",
· · },
· },
· Typ2: &gc.Typ{
· · Case: 7,
· · QualifiedIdent: &gc.QualifiedIdent{
· · · Token: example143.go:1:23: IDENTIFIER "c",
· · },
· },
}
want:
--- FAIL: ExampleOperand (0.00s)
got:
&gc.Operand{
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example144.go:1:15: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example144.go:1:13: '(',
· Token2: example144.go:1:19: ')',
}
want:
--- FAIL: ExampleOperand_case1 (0.00s)
got:
&gc.Operand{
· Case: 1,
· Token: example145.go:1:13: '(',
· Token2: example145.go:1:22: ')',
· TypeLiteral: &gc.TypeLiteral{
· · Case: 2,
· · ChanType: &gc.ChanType{
· · · Token: example145.go:1:15: CHAN,
· · · Typ: &gc.Typ{
· · · · Case: 7,
· · · · QualifiedIdent: &gc.QualifiedIdent{
· · · · · Token: example145.go:1:20: IDENTIFIER "b",
· · · · },
· · · },
· · },
· },
}
want:
--- FAIL: ExampleOperand_case2 (0.00s)
got:
&gc.Operand{
· BasicLiteral: &gc.BasicLiteral{
· · Value: 'b',
· · Token: example146.go:1:13: CHAR_LIT "'b'",
· },
· Case: 2,
}
want:
--- FAIL: ExampleOperand_case3 (0.00s)
got:
&gc.Operand{
· Case: 3,
· FuncType: &gc.FuncType{
· · Signature: &gc.Signature{
· · · Parameters: &gc.Parameters{
· · · · Token: example148.go:1:18: '(',
· · · · Token2: example148.go:1:20: ')',
· · · },
· · },
· · Token: example148.go:1:13: FUNC,
· },
· LBrace: &gc.LBrace{
· · Case: 1,
· · Token: example148.go:1:22: '{',
· },
· Token: example148.go:1:24: '}',
}
want:
--- FAIL: ExampleOperand_case4 (0.00s)
got:
&gc.Operand{
· Case: 4,
· Token: example149.go:1:13: IDENTIFIER "b",
}
want:
--- FAIL: ExamplePackageClause (0.00s)
got:
&gc.PackageClause{
· Token: example150.go:1:1: PACKAGE,
· Token2: example150.go:1:9: IDENTIFIER "a",
· Token3: example150.go:1:11: ';',
}
want:
--- FAIL: ExampleParameterDecl (0.00s)
got:
&gc.ParameterDecl{
· Token: example151.go:1:20: DDD,
· Typ: &gc.Typ{
· · Case: 7,
· · QualifiedIdent: &gc.QualifiedIdent{
· · · Token: example151.go:1:24: IDENTIFIER "b",
· · },
· },
}
want:
--- FAIL: ExampleParameterDecl_case1 (0.00s)
got:
&gc.ParameterDecl{
· Case: 1,
· Token: example152.go:1:20: IDENTIFIER "b",
· Token2: example152.go:1:22: DDD,
· Typ: &gc.Typ{
· · Case: 7,
· · QualifiedIdent: &gc.QualifiedIdent{
· · · Token: example152.go:1:26: IDENTIFIER "c",
· · },
· },
}
want:
--- FAIL: ExampleParameterDecl_case2 (0.00s)
got:
&gc.ParameterDecl{
· Case: 2,
· Token: example153.go:1:20: IDENTIFIER "b",
· Typ: &gc.Typ{
· · Case: 7,
· · QualifiedIdent: &gc.QualifiedIdent{
· · · Token: example153.go:1:22: IDENTIFIER "c",
· · },
· },
}
want:
--- FAIL: ExampleParameterDecl_case3 (0.00s)
got:
&gc.ParameterDecl{
· Case: 3,
· Typ: &gc.Typ{
· · Case: 7,
· · QualifiedIdent: &gc.QualifiedIdent{
· · · Token: example154.go:1:24: IDENTIFIER "b",
· · },
· },
}
want:
--- FAIL: ExampleParameterDeclList (0.00s)
got:
&gc.ParameterDeclList{
· ParameterDecl: &gc.ParameterDecl{
· · Case: 3,
· · Typ: &gc.Typ{
· · · Case: 7,
· · · QualifiedIdent: &gc.QualifiedIdent{
· · · · Token: example155.go:1:20: IDENTIFIER "b",
· · · },
· · },
· },
}
want:
--- FAIL: ExampleParameterDeclList_case1 (0.00s)
got:
&gc.ParameterDeclList{
· ParameterDecl: &gc.ParameterDecl{
· · Case: 3,
· · Typ: &gc.Typ{
· · · Case: 7,
· · · QualifiedIdent: &gc.QualifiedIdent{
· · · · Token: example156.go:1:20: IDENTIFIER "b",
· · · },
· · },
· },
· ParameterDeclList: &gc.ParameterDeclList{
· · Case: 1,
· · ParameterDecl: &gc.ParameterDecl{
· · · Case: 3,
· · · Typ: &gc.Typ{
· · · · Case: 7,
· · · · QualifiedIdent: &gc.QualifiedIdent{
· · · · · Token: example156.go:1:24: IDENTIFIER "c",
· · · · },
· · · },
· · },
· · Token: example156.go:1:22: ',',
· },
}
want:
--- FAIL: ExampleParameters (0.00s)
got:
&gc.Parameters{
· Token: example157.go:1:18: '(',
· Token2: example157.go:1:20: ')',
}
want:
--- FAIL: ExampleParameters_case1 (0.00s)
got:
&gc.Parameters{
· Case: 1,
· ParameterDeclList: &gc.ParameterDeclList{
· · ParameterDecl: &gc.ParameterDecl{
· · · Case: 3,
· · · Typ: &gc.Typ{
· · · · Case: 7,
· · · · QualifiedIdent: &gc.QualifiedIdent{
· · · · · Token: example158.go:1:20: IDENTIFIER "b",
· · · · },
· · · },
· · },
· },
· Token: example158.go:1:18: '(',
· Token2: example158.go:1:22: ')',
}
want:
--- FAIL: ExamplePrimaryExpression (0.00s)
got:
&gc.PrimaryExpression{
· Operand: &gc.Operand{
· · BasicLiteral: &gc.BasicLiteral{
· · · Value: 'b',
· · · Token: example159.go:1:13: CHAR_LIT "'b'",
· · },
· · Case: 2,
· },
}
want:
--- FAIL: ExamplePrimaryExpression_case01 (0.00s)
got:
&gc.PrimaryExpression{
· Case: 1,
· CompLitType: &gc.CompLitType{
· · Case: 2,
· · SliceType: &gc.SliceType{
· · · Token: example160.go:1:13: '[',
· · · Token2: example160.go:1:15: ']',
· · · Typ: &gc.Typ{
· · · · Case: 7,
· · · · QualifiedIdent: &gc.QualifiedIdent{
· · · · · Token: example160.go:1:17: IDENTIFIER "b",
· · · · },
· · · },
· · },
· },
· LBraceCompLitValue: &gc.LBraceCompLitValue{
· · LBrace: &gc.LBrace{
· · · Case: 1,
· · · Token: example160.go:1:19: '{',
· · },
· · Token: example160.go:1:21: '}',
· },
}
want:
--- FAIL: ExamplePrimaryExpression_case02 (0.00s)
got:
&gc.PrimaryExpression{
· Case: 2,
· PrimaryExpression: &gc.PrimaryExpression{
· · Operand: &gc.Operand{
· · · BasicLiteral: &gc.BasicLiteral{
· · · · Value: 'c',
· · · · Token: example161.go:1:27: CHAR_LIT "'c'",
· · · },
· · · Case: 2,
· · },
· },
· Token: example161.go:1:31: '.',
· Token2: example161.go:1:33: '(',
· Token3: example161.go:1:35: TYPE,
· Token4: example161.go:1:40: ')',
}
want:
--- FAIL: ExamplePrimaryExpression_case03 (0.00s)
got:
&gc.PrimaryExpression{
· Case: 3,
· PrimaryExpression: &gc.PrimaryExpression{
· · Operand: &gc.Operand{
· · · BasicLiteral: &gc.BasicLiteral{
· · · · Value: 'b',
· · · · Token: example162.go:1:13: CHAR_LIT "'b'",
· · · },
· · · Case: 2,
· · },
· },
· Token: example162.go:1:17: '.',
· Token2: example162.go:1:19: '(',
· Token3: example162.go:1:23: ')',
· Typ: &gc.Typ{
· · Case: 7,
· · QualifiedIdent: &gc.QualifiedIdent{
· · · Token: example162.go:1:21: IDENTIFIER "c",
· · },
· },
}
want:
--- FAIL: ExamplePrimaryExpression_case04 (0.00s)
got:
&gc.PrimaryExpression{
· Case: 4,
· PrimaryExpression: &gc.PrimaryExpression{
· · Operand: &gc.Operand{
· · · BasicLiteral: &gc.BasicLiteral{
· · · · Value: 'b',
· · · · Token: example163.go:1:13: CHAR_LIT "'b'",
· · · },
· · · Case: 2,
· · },
· },
· Token: example163.go:1:17: '.',
· Token2: example163.go:1:19: IDENTIFIER "c",
}
want:
--- FAIL: ExamplePrimaryExpression_case05 (0.00s)
got:
&gc.PrimaryExpression{
· Case: 5,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example164.go:1:19: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· PrimaryExpression: &gc.PrimaryExpression{
· · Operand: &gc.Operand{
· · · BasicLiteral: &gc.BasicLiteral{
· · · · Value: 'b',
· · · · Token: example164.go:1:13: CHAR_LIT "'b'",
· · · },
· · · Case: 2,
· · },
· },
· Token: example164.go:1:17: '[',
· Token2: example164.go:1:23: ']',
}
want:
--- FAIL: ExamplePrimaryExpression_case06 (0.00s)
got:
&gc.PrimaryExpression{
· Case: 6,
· PrimaryExpression: &gc.PrimaryExpression{
· · Operand: &gc.Operand{
· · · BasicLiteral: &gc.BasicLiteral{
· · · · Value: 'b',
· · · · Token: example165.go:1:13: CHAR_LIT "'b'",
· · · },
· · · Case: 2,
· · },
· },
· Token: example165.go:1:17: '[',
· Token2: example165.go:1:19: ':',
· Token3: example165.go:1:21: ':',
· Token4: example165.go:1:23: ']',
}
want:
--- FAIL: ExamplePrimaryExpression_case07 (0.00s)
got:
&gc.PrimaryExpression{
· Case: 7,
· PrimaryExpression: &gc.PrimaryExpression{
· · Operand: &gc.Operand{
· · · BasicLiteral: &gc.BasicLiteral{
· · · · Value: 'b',
· · · · Token: example166.go:1:13: CHAR_LIT "'b'",
· · · },
· · · Case: 2,
· · },
· },
· Token: example166.go:1:17: '[',
· Token2: example166.go:1:19: ':',
· Token3: example166.go:1:21: ']',
}
want:
--- FAIL: ExamplePrimaryExpression_case08 (0.00s)
got:
&gc.PrimaryExpression{
· Call: &gc.Call{
· · Token: example167.go:1:17: '(',
· · Token2: example167.go:1:19: ')',
· },
· Case: 8,
· PrimaryExpression: &gc.PrimaryExpression{
· · Operand: &gc.Operand{
· · · BasicLiteral: &gc.BasicLiteral{
· · · · Value: 'b',
· · · · Token: example167.go:1:13: CHAR_LIT "'b'",
· · · },
· · · Case: 2,
· · },
· },
}
want:
--- FAIL: ExamplePrimaryExpression_case09 (0.00s)
got:
&gc.PrimaryExpression{
· Case: 9,
· CompLitValue: &gc.CompLitValue{
· · Token: example168.go:1:17: '{',
· · Token2: example168.go:1:19: '}',
· },
· PrimaryExpression: &gc.PrimaryExpression{
· · Operand: &gc.Operand{
· · · BasicLiteral: &gc.BasicLiteral{
· · · · Value: 'b',
· · · · Token: example168.go:1:13: CHAR_LIT "'b'",
· · · },
· · · Case: 2,
· · },
· },
}
want:
--- FAIL: ExamplePrimaryExpression_case10 (0.00s)
got:
&gc.PrimaryExpression{
· Case: 10,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example169.go:1:22: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example169.go:1:20: '(',
· Token2: example169.go:1:26: ')',
· TypeLiteral: &gc.TypeLiteral{
· · Case: 2,
· · ChanType: &gc.ChanType{
· · · Token: example169.go:1:13: CHAN,
· · · Typ: &gc.Typ{
· · · · Case: 7,
· · · · QualifiedIdent: &gc.QualifiedIdent{
· · · · · Token: example169.go:1:18: IDENTIFIER "b",
· · · · },
· · · },
· · },
· },
}
want:
--- FAIL: ExamplePrologue (0.00s)
got:
&gc.Prologue{
· PackageClause: &gc.PackageClause{
· · Token: example170.go:1:1: PACKAGE,
· · Token2: example170.go:1:9: IDENTIFIER "a",
· · Token3: example170.go:1:11: ';',
· },
}
want:
--- FAIL: ExampleQualifiedIdent (0.00s)
got:
&gc.QualifiedIdent{
· Token: example171.go:1:18: IDENTIFIER "b",
}
want:
--- FAIL: ExampleQualifiedIdent_case1 (0.00s)
got:
&gc.QualifiedIdent{
· Case: 1,
· Token: example172.go:1:18: IDENTIFIER "b",
· Token2: example172.go:1:20: '.',
· Token3: example172.go:1:22: IDENTIFIER "c",
}
want:
--- FAIL: ExampleRange (0.00s)
got:
&gc.Range{
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example173.go:1:29: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· ExpressionList: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'b',
· · · · · · · Token: example173.go:1:17: CHAR_LIT "'b'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example173.go:1:21: '=',
· Token2: example173.go:1:23: RANGE,
}
want:
--- FAIL: ExampleRange_case1 (0.00s)
got:
&gc.Range{
· Case: 1,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example174.go:1:30: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· ExpressionList: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'b',
· · · · · · · Token: example174.go:1:17: CHAR_LIT "'b'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example174.go:1:21: COLAS,
· Token2: example174.go:1:24: RANGE,
}
want:
--- FAIL: ExampleRange_case2 (0.00s)
got:
&gc.Range{
· Case: 2,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example175.go:1:23: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example175.go:1:17: RANGE,
}
want:
--- FAIL: ExampleReceiverOpt (0.00s)
got:
true
want:
--- FAIL: ExampleReceiverOpt_case1 (0.00s)
got:
&gc.ReceiverOpt{
· Parameters: &gc.Parameters{
· · Token: example177.go:1:18: '(',
· · Token2: example177.go:1:20: ')',
· },
}
want:
--- FAIL: ExampleResultOpt (0.00s)
got:
true
want:
--- FAIL: ExampleResultOpt_case1 (0.00s)
got:
&gc.ResultOpt{
· Case: 1,
· Parameters: &gc.Parameters{
· · Token: example179.go:1:22: '(',
· · Token2: example179.go:1:24: ')',
· },
}
want:
--- FAIL: ExampleResultOpt_case2 (0.00s)
got:
&gc.ResultOpt{
· Case: 2,
· Typ: &gc.Typ{
· · Case: 8,
· · SliceType: &gc.SliceType{
· · · Token: example180.go:1:22: '[',
· · · Token2: example180.go:1:23: ']',
· · · Typ: &gc.Typ{
· · · · Case: 7,
· · · · QualifiedIdent: &gc.QualifiedIdent{
· · · · · Token: example180.go:1:24: IDENTIFIER "b",
· · · · },
· · · },
· · },
· },
}
want:
--- FAIL: ExampleSelectStatement (0.00s)
got:
&gc.SelectStatement{
· SwitchBody: &gc.SwitchBody{
· · Token: example182.go:1:20: '{',
· · Token2: example182.go:1:22: '}',
· },
· Token: example182.go:1:13: SELECT,
}
want:
--- FAIL: ExampleSemicolonOpt (0.00s)
got:
true
want:
--- FAIL: ExampleSemicolonOpt_case1 (0.00s)
got:
&gc.SemicolonOpt{
· Token: example184.go:1:26: ';',
}
want:
--- FAIL: ExampleSignature (0.00s)
got:
&gc.Signature{
· Parameters: &gc.Parameters{
· · Token: example185.go:1:24: '(',
· · Token2: example185.go:1:26: ')',
· },
}
want:
--- FAIL: ExampleSimpleStatement (0.00s)
got:
&gc.SimpleStatement{
· Assignment: &gc.Assignment{
· · ExpressionList: &gc.ExpressionList{
· · · Expression: &gc.Expression{
· · · · UnaryExpression: &gc.UnaryExpression{
· · · · · Case: 7,
· · · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · · Operand: &gc.Operand{
· · · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · · Value: 'b',
· · · · · · · · Token: example186.go:1:13: CHAR_LIT "'b'",
· · · · · · · },
· · · · · · · Case: 2,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · ExpressionList2: &gc.ExpressionList{
· · · Expression: &gc.Expression{
· · · · UnaryExpression: &gc.UnaryExpression{
· · · · · Case: 7,
· · · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · · Operand: &gc.Operand{
· · · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · · Value: 'c',
· · · · · · · · Token: example186.go:1:19: CHAR_LIT "'c'",
· · · · · · · },
· · · · · · · Case: 2,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· · Token: example186.go:1:17: '=',
· },
}
want:
--- FAIL: ExampleSimpleStatement_case1 (0.00s)
got:
&gc.SimpleStatement{
· Case: 1,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example187.go:1:13: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
}
want:
--- FAIL: ExampleSimpleStatement_case2 (0.00s)
got:
&gc.SimpleStatement{
· Case: 2,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example188.go:1:13: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example188.go:1:17: DEC,
}
want:
--- FAIL: ExampleSimpleStatement_case3 (0.00s)
got:
&gc.SimpleStatement{
· Case: 3,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example189.go:1:13: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example189.go:1:17: INC,
}
want:
--- FAIL: ExampleSimpleStatement_case4 (0.00s)
got:
&gc.SimpleStatement{
· Case: 4,
· ExpressionList: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'b',
· · · · · · · Token: example190.go:1:13: CHAR_LIT "'b'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· ExpressionList2: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'c',
· · · · · · · Token: example190.go:1:20: CHAR_LIT "'c'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example190.go:1:17: COLAS,
}
want:
--- FAIL: ExampleSimpleStatementOpt (0.00s)
got:
true
want:
--- FAIL: ExampleSimpleStatementOpt_case1 (0.00s)
got:
&gc.SimpleStatementOpt{
· SimpleStatement: &gc.SimpleStatement{
· · Case: 1,
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'b',
· · · · · · · Token: example192.go:1:16: CHAR_LIT "'b'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
}
want:
--- FAIL: ExampleSliceType (0.00s)
got:
&gc.SliceType{
· Token: example193.go:1:13: '[',
· Token2: example193.go:1:15: ']',
· Typ: &gc.Typ{
· · Case: 7,
· · QualifiedIdent: &gc.QualifiedIdent{
· · · Token: example193.go:1:17: IDENTIFIER "b",
· · },
· },
}
want:
--- FAIL: ExampleStatement (0.00s)
got:
true
want:
--- FAIL: ExampleStatement_case1 (0.00s)
got:
&gc.Statement{
· Block: &gc.Block{
· · Token: example195.go:1:17: '{',
· · Token2: example195.go:1:19: '}',
· },
· Case: 1,
}
want:
--- FAIL: ExampleStatement_case2 (0.00s)
got:
&gc.Statement{
· Case: 2,
· ConstDecl: &gc.ConstDecl{
· · Case: 2,
· · ConstSpec: &gc.ConstSpec{
· · · IdentifierList: &gc.IdentifierList{
· · · · Token: example196.go:1:24: IDENTIFIER "b",
· · · },
· · },
· · Token: example196.go:1:18: CONST,
· },
}
want:
--- FAIL: ExampleStatement_case3 (0.00s)
got:
&gc.Statement{
· Case: 3,
· TypeDecl: &gc.TypeDecl{
· · Token: example197.go:1:17: TYPE,
· · Token2: example197.go:1:22: '(',
· · Token3: example197.go:1:24: ')',
· },
}
want:
--- FAIL: ExampleStatement_case4 (0.00s)
got:
&gc.Statement{
· Case: 4,
· VarDecl: &gc.VarDecl{
· · Token: example198.go:1:17: VAR,
· · Token2: example198.go:1:21: '(',
· · Token3: example198.go:1:23: ')',
· },
}
want:
--- FAIL: ExampleStatement_case5 (0.00s)
got:
&gc.Statement{
· Case: 5,
· StatementNonDecl: &gc.StatementNonDecl{
· · Token: example199.go:1:17: BREAK,
· },
}
want:
--- FAIL: ExampleStatementList (0.00s)
got:
&gc.StatementList{
· Statement: &gc.Statement{
· · Case: 5,
· · StatementNonDecl: &gc.StatementNonDecl{
· · · Case: 11,
· · · SimpleStatement: &gc.SimpleStatement{
· · · · Case: 1,
· · · · Expression: &gc.Expression{
· · · · · UnaryExpression: &gc.UnaryExpression{
· · · · · · Case: 7,
· · · · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · · · Operand: &gc.Operand{
· · · · · · · · Case: 4,
· · · · · · · · Token: example201.go:1:18: IDENTIFIER "b",
· · · · · · · },
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
}
want:
--- FAIL: ExampleStatementList_case1 (0.00s)
got:
&gc.StatementList{
· StatementList: &gc.StatementList{
· · Case: 1,
· · Token: example202.go:1:18: ';',
· },
}
want:
--- FAIL: ExampleStatementNonDecl (0.00s)
got:
&gc.StatementNonDecl{
· Token: example203.go:1:13: BREAK,
}
want:
--- FAIL: ExampleStatementNonDecl_case01 (0.00s)
got:
&gc.StatementNonDecl{
· Case: 1,
· Token: example204.go:1:13: CONTINUE,
}
want:
--- FAIL: ExampleStatementNonDecl_case02 (0.00s)
got:
&gc.StatementNonDecl{
· Case: 2,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example205.go:1:19: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example205.go:1:13: DEFER,
}
want:
--- FAIL: ExampleStatementNonDecl_case03 (0.00s)
got:
&gc.StatementNonDecl{
· Case: 3,
· Token: example206.go:1:13: FALLTHROUGH,
}
want:
--- FAIL: ExampleStatementNonDecl_case04 (0.00s)
got:
&gc.StatementNonDecl{
· Case: 4,
· ForStatement: &gc.ForStatement{
· · Body: &gc.Body{
· · · Token: example207.go:1:17: '{',
· · · Token2: example207.go:1:19: '}',
· · },
· · ForHeader: &gc.ForHeader{
· · · Case: 2,
· · },
· · Token: example207.go:1:13: FOR,
· },
}
want:
--- FAIL: ExampleStatementNonDecl_case05 (0.00s)
got:
&gc.StatementNonDecl{
· Case: 5,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example208.go:1:16: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example208.go:1:13: GO,
}
want:
--- FAIL: ExampleStatementNonDecl_case06 (0.00s)
got:
&gc.StatementNonDecl{
· Case: 6,
· Token: example209.go:1:13: GOTO,
· Token2: example209.go:1:18: IDENTIFIER "b",
}
want:
--- FAIL: ExampleStatementNonDecl_case07 (0.00s)
got:
&gc.StatementNonDecl{
· Case: 7,
· Token: example210.go:1:13: IDENTIFIER "b",
· Token2: example210.go:1:15: ':',
}
want:
--- FAIL: ExampleStatementNonDecl_case08 (0.00s)
got:
&gc.StatementNonDecl{
· Case: 8,
· IfStatement: &gc.IfStatement{
· · Body: &gc.Body{
· · · Token: example211.go:1:16: '{',
· · · Token2: example211.go:1:18: '}',
· · },
· · Token: example211.go:1:13: IF,
· },
}
want:
--- FAIL: ExampleStatementNonDecl_case09 (0.00s)
got:
&gc.StatementNonDecl{
· Case: 9,
· Token: example212.go:1:13: RETURN,
}
want:
--- FAIL: ExampleStatementNonDecl_case10 (0.00s)
got:
&gc.StatementNonDecl{
· Case: 10,
· SelectStatement: &gc.SelectStatement{
· · SwitchBody: &gc.SwitchBody{
· · · Token: example213.go:1:20: '{',
· · · Token2: example213.go:1:22: '}',
· · },
· · Token: example213.go:1:13: SELECT,
· },
}
want:
--- FAIL: ExampleStatementNonDecl_case11 (0.00s)
got:
&gc.StatementNonDecl{
· Case: 11,
· SimpleStatement: &gc.SimpleStatement{
· · Case: 1,
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'b',
· · · · · · · Token: example214.go:1:13: CHAR_LIT "'b'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
}
want:
--- FAIL: ExampleStatementNonDecl_case12 (0.00s)
got:
&gc.StatementNonDecl{
· Case: 12,
· SwitchStatement: &gc.SwitchStatement{
· · SwitchBody: &gc.SwitchBody{
· · · Token: example215.go:1:20: '{',
· · · Token2: example215.go:1:22: '}',
· · },
· · Token: example215.go:1:13: SWITCH,
· },
}
want:
--- FAIL: ExampleStructFieldDecl (0.00s)
got:
&gc.StructFieldDecl{
· QualifiedIdent: &gc.QualifiedIdent{
· · Token: example216.go:1:24: IDENTIFIER "b",
· },
· Token: example216.go:1:22: '*',
}
want:
--- FAIL: ExampleStructFieldDecl_case1 (0.00s)
got:
&gc.StructFieldDecl{
· Case: 1,
· IdentifierList: &gc.IdentifierList{
· · Token: example217.go:1:22: IDENTIFIER "b",
· },
· Typ: &gc.Typ{
· · Case: 7,
· · QualifiedIdent: &gc.QualifiedIdent{
· · · Token: example217.go:1:24: IDENTIFIER "c",
· · },
· },
}
want:
--- FAIL: ExampleStructFieldDecl_case2 (0.00s)
got:
&gc.StructFieldDecl{
· Case: 2,
· QualifiedIdent: &gc.QualifiedIdent{
· · Token: example218.go:1:22: IDENTIFIER "b",
· },
}
want:
--- FAIL: ExampleStructFieldDecl_case3 (0.00s)
got:
&gc.StructFieldDecl{
· Case: 3,
· QualifiedIdent: &gc.QualifiedIdent{
· · Token: example219.go:1:24: IDENTIFIER "b",
· },
· Token: example219.go:1:22: '(',
· Token2: example219.go:1:26: ')',
}
want:
--- FAIL: ExampleStructFieldDecl_case4 (0.00s)
got:
&gc.StructFieldDecl{
· Case: 4,
· QualifiedIdent: &gc.QualifiedIdent{
· · Token: example220.go:1:26: IDENTIFIER "b",
· },
· Token: example220.go:1:22: '(',
· Token2: example220.go:1:24: '*',
· Token3: example220.go:1:28: ')',
}
want:
--- FAIL: ExampleStructFieldDecl_case5 (0.00s)
got:
&gc.StructFieldDecl{
· Case: 5,
· QualifiedIdent: &gc.QualifiedIdent{
· · Token: example221.go:1:26: IDENTIFIER "b",
· },
· Token: example221.go:1:22: '*',
· Token2: example221.go:1:24: '(',
· Token3: example221.go:1:28: ')',
}
want:
--- FAIL: ExampleStructFieldDeclList (0.00s)
got:
&gc.StructFieldDeclList{
· StructFieldDecl: &gc.StructFieldDecl{
· · Case: 2,
· · QualifiedIdent: &gc.QualifiedIdent{
· · · Token: example222.go:1:22: IDENTIFIER "b",
· · },
· },
}
want:
--- FAIL: ExampleStructFieldDeclList_case1 (0.00s)
got:
&gc.StructFieldDeclList{
· StructFieldDecl: &gc.StructFieldDecl{
· · Case: 2,
· · QualifiedIdent: &gc.QualifiedIdent{
· · · Token: example223.go:1:22: IDENTIFIER "b",
· · },
· },
· StructFieldDeclList: &gc.StructFieldDeclList{
· · Case: 1,
· · StructFieldDecl: &gc.StructFieldDecl{
· · · Case: 2,
· · · QualifiedIdent: &gc.QualifiedIdent{
· · · · Token: example223.go:1:26: IDENTIFIER "c",
· · · },
· · },
· · Token: example223.go:1:24: ';',
· },
}
want:
--- FAIL: ExampleStructType (0.00s)
got:
&gc.StructType{
· LBrace: &gc.LBrace{
· · Case: 1,
· · Token: example224.go:1:20: '{',
· },
· Token: example224.go:1:13: STRUCT,
· Token2: example224.go:1:22: '}',
}
want:
--- FAIL: ExampleStructType_case1 (0.00s)
got:
&gc.StructType{
· Case: 1,
· LBrace: &gc.LBrace{
· · Case: 1,
· · Token: example226.go:1:20: '{',
· },
· StructFieldDeclList: &gc.StructFieldDeclList{
· · StructFieldDecl: &gc.StructFieldDecl{
· · · Case: 2,
· · · QualifiedIdent: &gc.QualifiedIdent{
· · · · Token: example226.go:1:22: IDENTIFIER "b",
· · · },
· · },
· },
· Token: example226.go:1:13: STRUCT,
· Token2: example226.go:1:24: '}',
}
want:
--- FAIL: ExampleSwitchBody (0.00s)
got:
&gc.SwitchBody{
· Token: example227.go:1:20: '{',
· Token2: example227.go:1:22: '}',
}
want:
--- FAIL: ExampleSwitchBody_case1 (0.00s)
got:
&gc.SwitchBody{
· Case: 1,
· SwitchCaseList: &gc.SwitchCaseList{
· · SwitchCaseBlock: &gc.SwitchCaseBlock{
· · · SwitchCase: &gc.SwitchCase{
· · · · Case: 3,
· · · · Token: example229.go:1:22: DEFAULT,
· · · · Token2: example229.go:1:30: ':',
· · · },
· · },
· },
· Token: example229.go:1:20: '{',
· Token2: example229.go:1:32: '}',
}
want:
--- FAIL: ExampleSwitchCase (0.00s)
got:
&gc.SwitchCase{
· ArgumentList: &gc.ArgumentList{
· · Argument: &gc.Argument{
· · · Expression: &gc.Expression{
· · · · UnaryExpression: &gc.UnaryExpression{
· · · · · Case: 7,
· · · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · · Operand: &gc.Operand{
· · · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · · Value: 'b',
· · · · · · · · Token: example230.go:1:27: CHAR_LIT "'b'",
· · · · · · · },
· · · · · · · Case: 2,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Token: example230.go:1:22: CASE,
· Token2: example230.go:1:31: ':',
}
want:
--- FAIL: ExampleSwitchCase_case1 (0.00s)
got:
&gc.SwitchCase{
· ArgumentList: &gc.ArgumentList{
· · Argument: &gc.Argument{
· · · Expression: &gc.Expression{
· · · · UnaryExpression: &gc.UnaryExpression{
· · · · · Case: 7,
· · · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · · Operand: &gc.Operand{
· · · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · · Value: 'b',
· · · · · · · · Token: example231.go:1:27: CHAR_LIT "'b'",
· · · · · · · },
· · · · · · · Case: 2,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Case: 1,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example231.go:1:33: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example231.go:1:22: CASE,
· Token2: example231.go:1:31: '=',
· Token3: example231.go:1:37: ':',
}
want:
--- FAIL: ExampleSwitchCase_case2 (0.00s)
got:
&gc.SwitchCase{
· ArgumentList: &gc.ArgumentList{
· · Argument: &gc.Argument{
· · · Expression: &gc.Expression{
· · · · UnaryExpression: &gc.UnaryExpression{
· · · · · Case: 7,
· · · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · · Operand: &gc.Operand{
· · · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · · Value: 'b',
· · · · · · · · Token: example232.go:1:27: CHAR_LIT "'b'",
· · · · · · · },
· · · · · · · Case: 2,
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
· Case: 2,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'c',
· · · · · · Token: example232.go:1:34: CHAR_LIT "'c'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example232.go:1:22: CASE,
· Token2: example232.go:1:31: COLAS,
· Token3: example232.go:1:38: ':',
}
want:
--- FAIL: ExampleSwitchCase_case3 (0.00s)
got:
&gc.SwitchCase{
· Case: 3,
· Token: example233.go:1:22: DEFAULT,
· Token2: example233.go:1:30: ':',
}
want:
--- FAIL: ExampleSwitchCaseBlock (0.00s)
got:
&gc.SwitchCaseBlock{
· SwitchCase: &gc.SwitchCase{
· · Case: 3,
· · Token: example236.go:1:22: DEFAULT,
· · Token2: example236.go:1:30: ':',
· },
}
want:
--- FAIL: ExampleSwitchCaseList (0.00s)
got:
&gc.SwitchCaseList{
· SwitchCaseBlock: &gc.SwitchCaseBlock{
· · SwitchCase: &gc.SwitchCase{
· · · Case: 3,
· · · Token: example237.go:1:22: DEFAULT,
· · · Token2: example237.go:1:30: ':',
· · },
· },
}
want:
--- FAIL: ExampleSwitchCaseList_case1 (0.00s)
got:
&gc.SwitchCaseList{
· SwitchCaseBlock: &gc.SwitchCaseBlock{
· · SwitchCase: &gc.SwitchCase{
· · · Case: 3,
· · · Token: example238.go:1:22: DEFAULT,
· · · Token2: example238.go:1:30: ':',
· · },
· },
· SwitchCaseList: &gc.SwitchCaseList{
· · Case: 1,
· · SwitchCaseBlock: &gc.SwitchCaseBlock{
· · · SwitchCase: &gc.SwitchCase{
· · · · Case: 3,
· · · · Token: example238.go:1:32: DEFAULT,
· · · · Token2: example238.go:1:40: ':',
· · · },
· · },
· },
}
want:
--- FAIL: ExampleSwitchHeader (0.00s)
got:
&gc.SwitchHeader{
· SimpleStatementOpt: &gc.SimpleStatementOpt{
· · SimpleStatement: &gc.SimpleStatement{
· · · Case: 1,
· · · Expression: &gc.Expression{
· · · · UnaryExpression: &gc.UnaryExpression{
· · · · · Case: 7,
· · · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · · Operand: &gc.Operand{
· · · · · · · Case: 4,
· · · · · · · Token: example239.go:1:20: IDENTIFIER "b",
· · · · · · },
· · · · · },
· · · · },
· · · },
· · },
· },
}
want:
--- FAIL: ExampleSwitchHeader_case1 (0.00s)
got:
&gc.SwitchHeader{
· Case: 1,
· Token: example240.go:1:20: ';',
}
want:
--- FAIL: ExampleSwitchHeader_case2 (0.00s)
got:
&gc.SwitchHeader{
· Case: 2,
· Expression: &gc.Expression{
· · UnaryExpression: &gc.UnaryExpression{
· · · Case: 7,
· · · PrimaryExpression: &gc.PrimaryExpression{
· · · · Operand: &gc.Operand{
· · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · Value: 'b',
· · · · · · Token: example241.go:1:22: CHAR_LIT "'b'",
· · · · · },
· · · · · Case: 2,
· · · · },
· · · },
· · },
· },
· Token: example241.go:1:20: ';',
}
want:
--- FAIL: ExampleSwitchHeader_case3 (0.00s)
got:
&gc.SwitchHeader{
· Case: 3,
· PrimaryExpression: &gc.PrimaryExpression{
· · Operand: &gc.Operand{
· · · BasicLiteral: &gc.BasicLiteral{
· · · · Value: 'c',
· · · · Token: example242.go:1:27: CHAR_LIT "'c'",
· · · },
· · · Case: 2,
· · },
· },
· Token: example242.go:1:20: ';',
· Token2: example242.go:1:22: IDENTIFIER "b",
· Token3: example242.go:1:24: COLAS,
· Token4: example242.go:1:31: '.',
· Token5: example242.go:1:33: '(',
· Token6: example242.go:1:35: TYPE,
· Token7: example242.go:1:40: ')',
}
want:
--- FAIL: ExampleSwitchStatement (0.00s)
got:
&gc.SwitchStatement{
· SwitchBody: &gc.SwitchBody{
· · Token: example244.go:1:20: '{',
· · Token2: example244.go:1:22: '}',
· },
· Token: example244.go:1:13: SWITCH,
}
want:
--- FAIL: ExampleTagOpt (0.00s)
got:
true
want:
--- FAIL: ExampleTagOpt_case1 (0.00s)
got:
&gc.TagOpt{
· Token: example246.go:1:24: STRING_LIT "\"c\"",
}
want:
--- FAIL: ExampleTopLevelDecl (0.00s)
got:
&gc.TopLevelDecl{
· ConstDecl: &gc.ConstDecl{
· · Case: 2,
· · ConstSpec: &gc.ConstSpec{
· · · IdentifierList: &gc.IdentifierList{
· · · · Token: example247.go:1:19: IDENTIFIER "b",
· · · },
· · },
· · Token: example247.go:1:13: CONST,
· },
}
want:
--- FAIL: ExampleTopLevelDecl_case1 (0.00s)
got:
&gc.TopLevelDecl{
· Case: 1,
· FuncDecl: &gc.FuncDecl{
· · Signature: &gc.Signature{
· · · Parameters: &gc.Parameters{
· · · · Token: example248.go:1:20: '(',
· · · · Token2: example248.go:1:22: ')',
· · · },
· · },
· · Token: example248.go:1:13: FUNC,
· · Token2: example248.go:1:18: IDENTIFIER "b",
· },
}
want:
--- FAIL: ExampleTopLevelDecl_case2 (0.00s)
got:
&gc.TopLevelDecl{
· Case: 2,
· TypeDecl: &gc.TypeDecl{
· · Token: example249.go:1:13: TYPE,
· · Token2: example249.go:1:18: '(',
· · Token3: example249.go:1:20: ')',
· },
}
want:
--- FAIL: ExampleTopLevelDecl_case3 (0.00s)
got:
&gc.TopLevelDecl{
· Case: 3,
· VarDecl: &gc.VarDecl{
· · Token: example250.go:1:13: VAR,
· · Token2: example250.go:1:17: '(',
· · Token3: example250.go:1:19: ')',
· },
}
want:
--- FAIL: ExampleTopLevelDecl_case4 (0.00s)
got:
&gc.TopLevelDecl{
· Case: 4,
· StatementNonDecl: &gc.StatementNonDecl{
· · Token: example251.go:1:13: BREAK,
· },
}
want:
--- FAIL: ExampleTopLevelDeclList (0.00s)
got:
true
want:
--- FAIL: ExampleTopLevelDeclList_case1 (0.00s)
got:
&gc.TopLevelDeclList{
· Token: example254.go:1:19: ';',
· TopLevelDecl: &gc.TopLevelDecl{
· · Case: 4,
· · StatementNonDecl: &gc.StatementNonDecl{
· · · Token: example254.go:1:13: BREAK,
· · },
· },
}
want:
--- FAIL: ExampleTyp (0.00s)
got:
&gc.Typ{
· Token: example255.go:1:18: '(',
· Token2: example255.go:1:22: ')',
· Typ: &gc.Typ{
· · Case: 7,
· · QualifiedIdent: &gc.QualifiedIdent{
· · · Token: example255.go:1:20: IDENTIFIER "b",
· · },
· },
}
want:
--- FAIL: ExampleTyp_case01 (0.00s)
got:
&gc.Typ{
· Case: 1,
· Token: example256.go:1:18: '*',
· Typ: &gc.Typ{
· · Case: 7,
· · QualifiedIdent: &gc.QualifiedIdent{
· · · Token: example256.go:1:20: IDENTIFIER "b",
· · },
· },
}
want:
--- FAIL: ExampleTyp_case02 (0.00s)
got:
&gc.Typ{
· ArrayType: &gc.ArrayType{
· · Case: 1,
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'b',
· · · · · · · Token: example257.go:1:20: CHAR_LIT "'b'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· · Token: example257.go:1:18: '[',
· · Token2: example257.go:1:24: ']',
· · Typ: &gc.Typ{
· · · Case: 7,
· · · QualifiedIdent: &gc.QualifiedIdent{
· · · · Token: example257.go:1:26: IDENTIFIER "c",
· · · },
· · },
· },
· Case: 2,
}
want:
--- FAIL: ExampleTyp_case03 (0.00s)
got:
&gc.Typ{
· Case: 3,
· ChanType: &gc.ChanType{
· · Token: example258.go:1:18: CHAN,
· · Typ: &gc.Typ{
· · · Case: 7,
· · · QualifiedIdent: &gc.QualifiedIdent{
· · · · Token: example258.go:1:23: IDENTIFIER "b",
· · · },
· · },
· },
}
want:
--- FAIL: ExampleTyp_case04 (0.00s)
got:
&gc.Typ{
· Case: 4,
· FuncType: &gc.FuncType{
· · Signature: &gc.Signature{
· · · Parameters: &gc.Parameters{
· · · · Token: example259.go:1:24: '(',
· · · · Token2: example259.go:1:26: ')',
· · · },
· · },
· · Token: example259.go:1:19: FUNC,
· },
}
want:
--- FAIL: ExampleTyp_case05 (0.00s)
got:
&gc.Typ{
· Case: 5,
· InterfaceType: &gc.InterfaceType{
· · LBrace: &gc.LBrace{
· · · Case: 1,
· · · Token: example260.go:1:28: '{',
· · },
· · Token: example260.go:1:18: INTERFACE,
· · Token2: example260.go:1:30: '}',
· },
}
want:
--- FAIL: ExampleTyp_case06 (0.00s)
got:
&gc.Typ{
· Case: 6,
· MapType: &gc.MapType{
· · Token: example261.go:1:18: MAP,
· · Token2: example261.go:1:22: '[',
· · Token3: example261.go:1:26: ']',
· · Typ: &gc.Typ{
· · · Case: 7,
· · · QualifiedIdent: &gc.QualifiedIdent{
· · · · Token: example261.go:1:24: IDENTIFIER "b",
· · · },
· · },
· · Typ2: &gc.Typ{
· · · Case: 7,
· · · QualifiedIdent: &gc.QualifiedIdent{
· · · · Token: example261.go:1:28: IDENTIFIER "c",
· · · },
· · },
· },
}
want:
--- FAIL: ExampleTyp_case07 (0.00s)
got:
&gc.Typ{
· Case: 7,
· QualifiedIdent: &gc.QualifiedIdent{
· · Token: example262.go:1:18: IDENTIFIER "b",
· },
}
want:
--- FAIL: ExampleTyp_case08 (0.00s)
got:
&gc.Typ{
· Case: 8,
· SliceType: &gc.SliceType{
· · Token: example263.go:1:18: '[',
· · Token2: example263.go:1:20: ']',
· · Typ: &gc.Typ{
· · · Case: 7,
· · · QualifiedIdent: &gc.QualifiedIdent{
· · · · Token: example263.go:1:22: IDENTIFIER "b",
· · · },
· · },
· },
}
want:
--- FAIL: ExampleTyp_case09 (0.00s)
got:
&gc.Typ{
· Case: 9,
· StructType: &gc.StructType{
· · LBrace: &gc.LBrace{
· · · Case: 1,
· · · Token: example264.go:1:25: '{',
· · },
· · Token: example264.go:1:18: STRUCT,
· · Token2: example264.go:1:27: '}',
· },
}
want:
--- FAIL: ExampleTypeDecl (0.00s)
got:
&gc.TypeDecl{
· Token: example265.go:1:13: TYPE,
· Token2: example265.go:1:18: '(',
· Token3: example265.go:1:20: ')',
}
want:
--- FAIL: ExampleTypeDecl_case1 (0.00s)
got:
&gc.TypeDecl{
· Case: 1,
· Token: example266.go:1:13: TYPE,
· Token2: example266.go:1:18: '(',
· Token3: example266.go:1:24: ')',
· TypeSpecList: &gc.TypeSpecList{
· · TypeSpec: &gc.TypeSpec{
· · · Token: example266.go:1:20: IDENTIFIER "b",
· · · Typ: &gc.Typ{
· · · · Case: 7,
· · · · QualifiedIdent: &gc.QualifiedIdent{
· · · · · Token: example266.go:1:22: IDENTIFIER "c",
· · · · },
· · · },
· · },
· },
}
want:
--- FAIL: ExampleTypeDecl_case2 (0.00s)
got:
&gc.TypeDecl{
· Case: 2,
· Token: example267.go:1:13: TYPE,
· TypeSpec: &gc.TypeSpec{
· · Token: example267.go:1:18: IDENTIFIER "b",
· · Typ: &gc.Typ{
· · · Case: 7,
· · · QualifiedIdent: &gc.QualifiedIdent{
· · · · Token: example267.go:1:20: IDENTIFIER "c",
· · · },
· · },
· },
}
want:
--- FAIL: ExampleTypeList (0.00s)
got:
&gc.TypeList{
· Typ: &gc.Typ{
· · Case: 7,
· · QualifiedIdent: &gc.QualifiedIdent{
· · · Token: example268.go:1:18: IDENTIFIER "c",
· · },
· },
}
want:
--- FAIL: ExampleTypeList_case1 (0.00s)
got:
&gc.TypeList{
· Typ: &gc.Typ{
· · Case: 7,
· · QualifiedIdent: &gc.QualifiedIdent{
· · · Token: example269.go:1:18: IDENTIFIER "c",
· · },
· },
· TypeList: &gc.TypeList{
· · Case: 1,
· · Token: example269.go:1:20: ',',
· · Typ: &gc.Typ{
· · · Case: 7,
· · · QualifiedIdent: &gc.QualifiedIdent{
· · · · Token: example269.go:1:22: IDENTIFIER "d",
· · · },
· · },
· },
}
want:
--- FAIL: ExampleTypeLiteral (0.00s)
got:
&gc.TypeLiteral{
· Token: example270.go:1:13: '*',
· TypeLiteral: &gc.TypeLiteral{
· · Case: 2,
· · ChanType: &gc.ChanType{
· · · Token: example270.go:1:15: CHAN,
· · · Typ: &gc.Typ{
· · · · Case: 7,
· · · · QualifiedIdent: &gc.QualifiedIdent{
· · · · · Token: example270.go:1:20: IDENTIFIER "b",
· · · · },
· · · },
· · },
· },
}
want:
--- FAIL: ExampleTypeLiteral_case1 (0.00s)
got:
&gc.TypeLiteral{
· ArrayType: &gc.ArrayType{
· · Case: 1,
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'b',
· · · · · · · Token: example271.go:1:15: CHAR_LIT "'b'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· · Token: example271.go:1:13: '[',
· · Token2: example271.go:1:19: ']',
· · Typ: &gc.Typ{
· · · Case: 7,
· · · QualifiedIdent: &gc.QualifiedIdent{
· · · · Token: example271.go:1:21: IDENTIFIER "c",
· · · },
· · },
· },
· Case: 1,
}
want:
--- FAIL: ExampleTypeLiteral_case2 (0.00s)
got:
&gc.TypeLiteral{
· Case: 2,
· ChanType: &gc.ChanType{
· · Token: example272.go:1:13: CHAN,
· · Typ: &gc.Typ{
· · · Case: 7,
· · · QualifiedIdent: &gc.QualifiedIdent{
· · · · Token: example272.go:1:18: IDENTIFIER "b",
· · · },
· · },
· },
}
want:
--- FAIL: ExampleTypeLiteral_case3 (0.00s)
got:
&gc.TypeLiteral{
· Case: 3,
· FuncType: &gc.FuncType{
· · Signature: &gc.Signature{
· · · Parameters: &gc.Parameters{
· · · · Token: example273.go:1:19: '(',
· · · · Token2: example273.go:1:20: ')',
· · · },
· · },
· · Token: example273.go:1:15: FUNC,
· },
}
want:
--- FAIL: ExampleTypeLiteral_case4 (0.00s)
got:
&gc.TypeLiteral{
· Case: 4,
· InterfaceType: &gc.InterfaceType{
· · LBrace: &gc.LBrace{
· · · Case: 1,
· · · Token: example274.go:1:23: '{',
· · },
· · Token: example274.go:1:13: INTERFACE,
· · Token2: example274.go:1:25: '}',
· },
}
want:
--- FAIL: ExampleTypeLiteral_case5 (0.00s)
got:
&gc.TypeLiteral{
· Case: 5,
· MapType: &gc.MapType{
· · Token: example275.go:1:13: MAP,
· · Token2: example275.go:1:17: '[',
· · Token3: example275.go:1:21: ']',
· · Typ: &gc.Typ{
· · · Case: 7,
· · · QualifiedIdent: &gc.QualifiedIdent{
· · · · Token: example275.go:1:19: IDENTIFIER "b",
· · · },
· · },
· · Typ2: &gc.Typ{
· · · Case: 7,
· · · QualifiedIdent: &gc.QualifiedIdent{
· · · · Token: example275.go:1:23: IDENTIFIER "c",
· · · },
· · },
· },
}
want:
--- FAIL: ExampleTypeLiteral_case6 (0.00s)
got:
&gc.TypeLiteral{
· Case: 6,
· SliceType: &gc.SliceType{
· · Token: example276.go:1:13: '[',
· · Token2: example276.go:1:15: ']',
· · Typ: &gc.Typ{
· · · Case: 7,
· · · QualifiedIdent: &gc.QualifiedIdent{
· · · · Token: example276.go:1:17: IDENTIFIER "b",
· · · },
· · },
· },
}
want:
--- FAIL: ExampleTypeLiteral_case7 (0.00s)
got:
&gc.TypeLiteral{
· Case: 7,
· StructType: &gc.StructType{
· · LBrace: &gc.LBrace{
· · · Case: 1,
· · · Token: example277.go:1:20: '{',
· · },
· · Token: example277.go:1:13: STRUCT,
· · Token2: example277.go:1:22: '}',
· },
}
want:
--- FAIL: ExampleTypeSpec (0.00s)
got:
&gc.TypeSpec{
· Token: example278.go:1:18: IDENTIFIER "b",
· Typ: &gc.Typ{
· · Case: 7,
· · QualifiedIdent: &gc.QualifiedIdent{
· · · Token: example278.go:1:20: IDENTIFIER "c",
· · },
· },
}
want:
--- FAIL: ExampleTypeSpecList (0.00s)
got:
&gc.TypeSpecList{
· TypeSpec: &gc.TypeSpec{
· · Token: example279.go:1:20: IDENTIFIER "b",
· · Typ: &gc.Typ{
· · · Case: 7,
· · · QualifiedIdent: &gc.QualifiedIdent{
· · · · Token: example279.go:1:22: IDENTIFIER "c",
· · · },
· · },
· },
}
want:
--- FAIL: ExampleTypeSpecList_case1 (0.00s)
got:
&gc.TypeSpecList{
· TypeSpec: &gc.TypeSpec{
· · Token: example280.go:1:20: IDENTIFIER "b",
· · Typ: &gc.Typ{
· · · Case: 7,
· · · QualifiedIdent: &gc.QualifiedIdent{
· · · · Token: example280.go:1:22: IDENTIFIER "c",
· · · },
· · },
· },
· TypeSpecList: &gc.TypeSpecList{
· · Case: 1,
· · Token: example280.go:1:24: ';',
· · TypeSpec: &gc.TypeSpec{
· · · Token: example280.go:1:26: IDENTIFIER "d",
· · · Typ: &gc.Typ{
· · · · Case: 7,
· · · · QualifiedIdent: &gc.QualifiedIdent{
· · · · · Token: example280.go:1:28: IDENTIFIER "e",
· · · · },
· · · },
· · },
· },
}
want:
--- FAIL: ExampleUnaryExpression (0.00s)
got:
&gc.UnaryExpression{
· Token: example281.go:1:13: '!',
· UnaryExpression: &gc.UnaryExpression{
· · Case: 7,
· · PrimaryExpression: &gc.PrimaryExpression{
· · · Operand: &gc.Operand{
· · · · BasicLiteral: &gc.BasicLiteral{
· · · · · Value: 'b',
· · · · · Token: example281.go:1:15: CHAR_LIT "'b'",
· · · · },
· · · · Case: 2,
· · · },
· · },
· },
}
want:
--- FAIL: ExampleUnaryExpression_case1 (0.00s)
got:
&gc.UnaryExpression{
· Case: 1,
· Token: example282.go:1:13: '&',
· UnaryExpression: &gc.UnaryExpression{
· · Case: 7,
· · PrimaryExpression: &gc.PrimaryExpression{
· · · Operand: &gc.Operand{
· · · · BasicLiteral: &gc.BasicLiteral{
· · · · · Value: 'b',
· · · · · Token: example282.go:1:15: CHAR_LIT "'b'",
· · · · },
· · · · Case: 2,
· · · },
· · },
· },
}
want:
--- FAIL: ExampleUnaryExpression_case2 (0.00s)
got:
&gc.UnaryExpression{
· Case: 2,
· Token: example283.go:1:13: '*',
· UnaryExpression: &gc.UnaryExpression{
· · Case: 7,
· · PrimaryExpression: &gc.PrimaryExpression{
· · · Operand: &gc.Operand{
· · · · BasicLiteral: &gc.BasicLiteral{
· · · · · Value: 'b',
· · · · · Token: example283.go:1:15: CHAR_LIT "'b'",
· · · · },
· · · · Case: 2,
· · · },
· · },
· },
}
want:
--- FAIL: ExampleUnaryExpression_case3 (0.00s)
got:
&gc.UnaryExpression{
· Case: 3,
· Token: example284.go:1:13: '+',
· UnaryExpression: &gc.UnaryExpression{
· · Case: 7,
· · PrimaryExpression: &gc.PrimaryExpression{
· · · Operand: &gc.Operand{
· · · · BasicLiteral: &gc.BasicLiteral{
· · · · · Value: 'b',
· · · · · Token: example284.go:1:15: CHAR_LIT "'b'",
· · · · },
· · · · Case: 2,
· · · },
· · },
· },
}
want:
--- FAIL: ExampleUnaryExpression_case4 (0.00s)
got:
&gc.UnaryExpression{
· Case: 4,
· Token: example285.go:1:13: '-',
· UnaryExpression: &gc.UnaryExpression{
· · Case: 7,
· · PrimaryExpression: &gc.PrimaryExpression{
· · · Operand: &gc.Operand{
· · · · BasicLiteral: &gc.BasicLiteral{
· · · · · Value: 'b',
· · · · · Token: example285.go:1:15: CHAR_LIT "'b'",
· · · · },
· · · · Case: 2,
· · · },
· · },
· },
}
want:
--- FAIL: ExampleUnaryExpression_case5 (0.00s)
got:
&gc.UnaryExpression{
· Case: 5,
· Token: example286.go:1:13: '^',
· UnaryExpression: &gc.UnaryExpression{
· · Case: 7,
· · PrimaryExpression: &gc.PrimaryExpression{
· · · Operand: &gc.Operand{
· · · · BasicLiteral: &gc.BasicLiteral{
· · · · · Value: 'b',
· · · · · Token: example286.go:1:15: CHAR_LIT "'b'",
· · · · },
· · · · Case: 2,
· · · },
· · },
· },
}
want:
--- FAIL: ExampleUnaryExpression_case6 (0.00s)
got:
&gc.UnaryExpression{
· Case: 6,
· Token: example287.go:1:13: COMM,
· UnaryExpression: &gc.UnaryExpression{
· · Case: 7,
· · PrimaryExpression: &gc.PrimaryExpression{
· · · Operand: &gc.Operand{
· · · · BasicLiteral: &gc.BasicLiteral{
· · · · · Value: 'b',
· · · · · Token: example287.go:1:16: CHAR_LIT "'b'",
· · · · },
· · · · Case: 2,
· · · },
· · },
· },
}
want:
--- FAIL: ExampleUnaryExpression_case7 (0.00s)
got:
&gc.UnaryExpression{
· Case: 7,
· PrimaryExpression: &gc.PrimaryExpression{
· · Operand: &gc.Operand{
· · · BasicLiteral: &gc.BasicLiteral{
· · · · Value: 'b',
· · · · Token: example288.go:1:13: CHAR_LIT "'b'",
· · · },
· · · Case: 2,
· · },
· },
}
want:
--- FAIL: ExampleVarDecl (0.00s)
got:
&gc.VarDecl{
· Token: example289.go:1:13: VAR,
· Token2: example289.go:1:17: '(',
· Token3: example289.go:1:19: ')',
}
want:
--- FAIL: ExampleVarDecl_case1 (0.00s)
got:
&gc.VarDecl{
· Case: 1,
· Token: example290.go:1:13: VAR,
· Token2: example290.go:1:17: '(',
· Token3: example290.go:1:23: ')',
· VarSpecList: &gc.VarSpecList{
· · VarSpec: &gc.VarSpec{
· · · Case: 1,
· · · IdentifierList: &gc.IdentifierList{
· · · · Token: example290.go:1:19: IDENTIFIER "b",
· · · },
· · · Typ: &gc.Typ{
· · · · Case: 7,
· · · · QualifiedIdent: &gc.QualifiedIdent{
· · · · · Token: example290.go:1:21: IDENTIFIER "c",
· · · · },
· · · },
· · },
· },
}
want:
--- FAIL: ExampleVarDecl_case2 (0.00s)
got:
&gc.VarDecl{
· Case: 2,
· Token: example291.go:1:13: VAR,
· VarSpec: &gc.VarSpec{
· · Case: 1,
· · IdentifierList: &gc.IdentifierList{
· · · Token: example291.go:1:17: IDENTIFIER "b",
· · },
· · Typ: &gc.Typ{
· · · Case: 7,
· · · QualifiedIdent: &gc.QualifiedIdent{
· · · · Token: example291.go:1:19: IDENTIFIER "c",
· · · },
· · },
· },
}
want:
--- FAIL: ExampleVarSpec (0.00s)
got:
&gc.VarSpec{
· ExpressionList: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'c',
· · · · · · · Token: example292.go:1:21: CHAR_LIT "'c'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· IdentifierList: &gc.IdentifierList{
· · Token: example292.go:1:17: IDENTIFIER "b",
· },
· Token: example292.go:1:19: '=',
}
want:
--- FAIL: ExampleVarSpec_case1 (0.00s)
got:
&gc.VarSpec{
· Case: 1,
· IdentifierList: &gc.IdentifierList{
· · Token: example293.go:1:17: IDENTIFIER "b",
· },
· Typ: &gc.Typ{
· · Case: 7,
· · QualifiedIdent: &gc.QualifiedIdent{
· · · Token: example293.go:1:19: IDENTIFIER "c",
· · },
· },
}
want:
--- FAIL: ExampleVarSpec_case2 (0.00s)
got:
&gc.VarSpec{
· Case: 2,
· ExpressionList: &gc.ExpressionList{
· · Expression: &gc.Expression{
· · · UnaryExpression: &gc.UnaryExpression{
· · · · Case: 7,
· · · · PrimaryExpression: &gc.PrimaryExpression{
· · · · · Operand: &gc.Operand{
· · · · · · BasicLiteral: &gc.BasicLiteral{
· · · · · · · Value: 'd',
· · · · · · · Token: example294.go:1:23: CHAR_LIT "'d'",
· · · · · · },
· · · · · · Case: 2,
· · · · · },
· · · · },
· · · },
· · },
· },
· IdentifierList: &gc.IdentifierList{
· · Token: example294.go:1:17: IDENTIFIER "b",
· },
· Token: example294.go:1:21: '=',
· Typ: &gc.Typ{
· · Case: 7,
· · QualifiedIdent: &gc.QualifiedIdent{
· · · Token: example294.go:1:19: IDENTIFIER "c",
· · },
· },
}
want:
--- FAIL: ExampleVarSpecList (0.00s)
got:
&gc.VarSpecList{
· VarSpec: &gc.VarSpec{
· · Case: 1,
· · IdentifierList: &gc.IdentifierList{
· · · Token: example295.go:1:19: IDENTIFIER "b",
· · },
· · Typ: &gc.Typ{
· · · Case: 7,
· · · QualifiedIdent: &gc.QualifiedIdent{
· · · · Token: example295.go:1:21: IDENTIFIER "c",
· · · },
· · },
· },
}
want:
--- FAIL: ExampleVarSpecList_case1 (0.00s)
got:
&gc.VarSpecList{
· VarSpec: &gc.VarSpec{
· · Case: 1,
· · IdentifierList: &gc.IdentifierList{
· · · Token: example296.go:1:19: IDENTIFIER "b",
· · },
· · Typ: &gc.Typ{
· · · Case: 7,
· · · QualifiedIdent: &gc.QualifiedIdent{
· · · · Token: example296.go:1:21: IDENTIFIER "c",
· · · },
· · },
· },
· VarSpecList: &gc.VarSpecList{
· · Case: 1,
· · Token: example296.go:1:23: ';',
· · VarSpec: &gc.VarSpec{
· · · Case: 1,
· · · IdentifierList: &gc.IdentifierList{
· · · · Token: example296.go:1:25: IDENTIFIER "d",
· · · },
· · · Typ: &gc.Typ{
· · · · Case: 7,
· · · · QualifiedIdent: &gc.QualifiedIdent{
· · · · · Token: example296.go:1:27: IDENTIFIER "e",
· · · · },
· · · },
· · },
· },
}
want:
FAIL
exit status 1
FAIL github.com/cznic/gc 2.492s
grep -n 'extra error' test.log || true
422:[FAIL errorcheck: extra error] interface contains embedded non-interface I2 testdata/gc/fixedbugs/bug251.go:11:2
520:[FAIL errorcheck: extra error] cannot use 0 (type foo.T) as type foo.I in assignment testdata/gc/fixedbugs/bug374.go:16:11
534:[FAIL errorcheck: extra error] undefined: runtime.UintType testdata/gc/fixedbugs/bug388.go:13:21
536:[FAIL errorcheck: extra error] undefined: runtime.UintType testdata/gc/fixedbugs/bug388.go:18:18
538:[FAIL errorcheck: extra error] i undefined (type func() has no field or method i) testdata/gc/fixedbugs/bug388.go:23:15
540:[FAIL errorcheck: extra error] i undefined (type func() has no field or method i) testdata/gc/fixedbugs/bug388.go:28:15
542:[FAIL errorcheck: extra error] i undefined (type func(int, int) has no field or method i) testdata/gc/fixedbugs/bug388.go:33:14
621:[FAIL errorcheck: extra error] undefined: x testdata/gc/fixedbugs/issue13319.go:10:12
724:[FAIL errorcheck: extra error] label labelname already defined, previous declaration at testdata/gc/fixedbugs/issue14006.go:50:3 testdata/gc/fixedbugs/issue14006.go:56:3
725:[FAIL errorcheck: extra error] label labelname already defined, previous declaration at testdata/gc/fixedbugs/issue14006.go:50:3 testdata/gc/fixedbugs/issue14006.go:61:3
1285:[FAIL errorcheck: extra error] assignment count mismatch: 2 = 1 testdata/gc/named1.go:47:9
1286:[FAIL errorcheck: extra error] assignment count mismatch: 2 = 1 testdata/gc/named1.go:53:9
1741:[FAIL errorcheck: extra error] assignment count mismatch: 2 = 1 testdata/gc/typeswitch3.go:32:9
1752:[FAIL errorcheck: extra error] String undefined (type p.t has no field or method String) testdata/issue15292/0.go:207:10
1753:[FAIL errorcheck: extra error] Add undefined (type p.t has no field or method Add) testdata/issue15292/0.go:262:21
1754:[FAIL errorcheck: extra error] cannot use type *p.Pair297 as type p.Pair297 in return argument testdata/issue15292/0.go:311:2
1755:[FAIL errorcheck: extra error] Plus undefined (type p.t has no field or method Plus) testdata/issue15292/0.go:376:10
1756:[FAIL errorcheck: extra error] Divide undefined (type p.t has no field or method Divide) testdata/issue15292/0.go:378:12
1757:[FAIL errorcheck: extra error] cannot use type *p.List as type p.List in assignment testdata/issue15292/0.go:511:5
1758:[FAIL errorcheck: extra error] Less undefined (type p.t has no field or method Less) testdata/issue15292/0.go:534:15
grep -n 'xc\.Dict' *.go | grep -v global.go || true
git status test.log
On branch master
Your branch is up-to-date with 'origin/master'.
nothing to commit, working tree clean
go install
go vet 2>&1 | grep -v 'TODOOK\|parser\.go\|scanner\.go\|.*_string\.go' || true
exit status 1
golint 2>&1 | grep -v 'TODOOK\|parser\.go\|scanner\.go\|.*_string\.go' || true
make todo
make[1]: Entering directory '/home/guest/go/src/github.com/cznic/gc'
grep: testdata: Is a directory
ast2.go:239: todo(n, true)
ast2.go:262: todo(n, true)
ast2.go:307: todo(n)
ast2.go:314: todo(n)
ast2.go:346: todo(n)
ast2.go:369: todo(n)
ast2.go:371: todo(n)
ast2.go:373: todo(n)
ast2.go:375: todo(n)
ast2.go:377: todo(n)
ast2.go:379: todo(n)
ast2.go:381: todo(n)
ast2.go:403: todo(n)
ast2.go:405: todo(n)
ast2.go:407: todo(n)
ast2.go:667: todo(cv)
ast2.go:680: todo(cv)
ast2.go:682: todo(cv, true)
ast2.go:689: todo(key, true)
ast2.go:712: todo(e, true)
ast2.go:729: todo(key, true)
ast2.go:750: todo(e, true)
ast2.go:791: todo(n, true) // too large
ast2.go:796: todo(e)
ast2.go:799: case IntConst, RuneConst, StringConst: //TODO more types
ast2.go:884: todo(val, true) // dup index
ast2.go:897: todo(val, true)
ast2.go:904: todo(val, true)
ast2.go:943: todo(n)
ast2.go:956: todo(n, true) // invalid
ast2.go:1050:func (n *Expression) isIdentifier() (xc.Token, bool) { //TODO remove, use .ident()
ast2.go:1152: todo(n)
ast2.go:1165: todo(n)
ast2.go:1167: //TODO panic("internal error")
ast2.go:1232: todo(o, true)
ast2.go:1238: todo(o, true)
ast2.go:1254: todo(n, true) // need bool
ast2.go:1492: todo(n, true)
ast2.go:1509: todo(n, true)
ast2.go:1648: todo(n)
ast2.go:1691: //TODO generics todo(n)
ast2.go:1764: todo(n)
ast2.go:1848: //TODO generics todo(n)
ast2.go:1923: //TODO- case RuntimeValue:
ast2.go:1924: //TODO- if n.Value = arg.Convert(ctx.Context, t); n.Value == nil {
ast2.go:1925: //TODO- switch {
ast2.go:1926: //TODO- case t.Kind() == Interface:
ast2.go:1927: //TODO- arg.Type().implementsFailed(ctx, node, "cannot convert %s to type %s:", t)
ast2.go:1928: //TODO- default:
ast2.go:1929: //TODO- ctx.err(node, "1888: cannot convert %s to type %s", arg.Type(), t)
ast2.go:1930: //TODO- }
ast2.go:1931: //TODO- }
ast2.go:1940: todo(n)
ast2.go:1986: todo(n, true)
ast2.go:1996: todo(n)
ast2.go:1998: todo(n)
ast2.go:2002: todo(n, true)
ast2.go:2008: todo(n, true)
ast2.go:2014: todo(n, true)
ast2.go:2020: todo(n, true)
ast2.go:2029: //TODO- switch {
ast2.go:2030: //TODO- case ft.IsVariadic():
ast2.go:2031: //TODO- todo(n)
ast2.go:2032: //TODO- default:
ast2.go:2033: //TODO- if len(args) != ft.NumIn()-skip {
ast2.go:2034: //TODO- todo(n) //TODO special case single tuple arg.
ast2.go:2035: //TODO- }
ast2.go:2036: //TODO- if ddd {
ast2.go:2037: //TODO- todo(n)
ast2.go:2038: //TODO- }
ast2.go:2039: //TODO- for i, arg := range args {
ast2.go:2040: //TODO- if arg != nil && !arg.AssignableTo(ft.In(i+skip)) {
ast2.go:2041: //TODO- todo(n)
ast2.go:2042: //TODO- }
ast2.go:2043: //TODO- }
ast2.go:2044: //TODO- }
ast2.go:2074: panic("internal error") //TODO need inf. recursion protection.
ast2.go:2126: todo(n, true) // fail
ast2.go:2152: todo(n, true) // non-integer index
ast2.go:2160: todo(n)
ast2.go:2168: todo(n, true) // const index overflow
ast2.go:2235: todo(n, true) // not an interface
ast2.go:2239: todo(n)
ast2.go:2257: todo(n, true) // not an interface
ast2.go:2268: todo(n)
ast2.go:2285: if !isExported(nm.Val) { //TODO use d.IsExported()
ast2.go:2315: todo(n)
ast2.go:2365: todo(n, true)
ast2.go:2396: todo(n, true) // cannot use unexported method
ast2.go:2414: todo(n)
ast2.go:2476: todo(n.Expression, true) // < 0
ast2.go:2532: todo(n)
ast2.go:2569: todo(n)
ast2.go:2570: //TODO n.flags =
ast2.go:2606: todo(n, true) // cannot slice T
ast2.go:2610: todo(n)
ast2.go:2616: todo(n, true) // l >= h
ast2.go:2654: todo(n, true)
ast2.go:2667: todo(n)
ast2.go:2671: todo(n)
ast2.go:2673: todo(n)
ast2.go:2691: todo(n)
ast2.go:2725: todo(n, true)
ast2.go:2729: todo(n, true)
ast2.go:2733: todo(n, true)
ast2.go:2752: todo(n, true)
ast2.go:2880: todo(n)
ast2.go:2926: //TODO generics todo(n)
ast2.go:3081: todo(n, true) // unused value
ast2.go:3101: todo(n, true) // must be addressable or map index
ast2.go:3191: //TODO set n.flags
ast2.go:3219: //TODO verify valid context
ast2.go:3225: //TODO verify valid target
ast2.go:3228: todo(n)
ast2.go:3230: todo(n)
ast2.go:3232: //TODO check valid context
ast2.go:3236: todo(n)
ast2.go:3239: //TODO verify valid target
ast2.go:3274: todo(n, true)
ast2.go:3290: todo(n, true) // mismatch
ast2.go:3304: todo(n, true) // not enough
ast2.go:3310: todo(n, true) // mismatch
ast2.go:3315: todo(n, true) // not enough values to return
ast2.go:3318: todo(n, true) // too many values to return
ast2.go:3336: todo(n, true) // type mismatch
ast2.go:3342: todo(n, true) // too many values to return
ast2.go:3352: todo(n, true) // type mismatch
ast2.go:3547: todo(n)
ast2.go:3549: todo(n)
ast2.go:3551: //TODO check unique
ast2.go:3553: todo(n)
ast2.go:3555: todo(n)
ast2.go:3595: todo(n)
ast2.go:3597: todo(n)
ast2.go:3599: todo(n)
ast2.go:3669: //TODO generics todo(n)
ast2.go:3691: todo(n)
ast2.go:3731: todo(n)
ast2.go:3818: todo(n, true) // inv op
ast2.go:3822: todo(n)
ast2.go:3827: //TODO disallow taking address of a function (but not of a variable of a function type).
ast2.go:3831: todo(n)
ast2.go:3850: todo(n)
ast2.go:3870: todo(n)
ast2.go:3878: todo(n)
ast2.go:3886: todo(n, true) // need int
ast2.go:3893: todo(n)
ast2.go:3907: todo(n)
builtin.go:10: todo(call.ArgumentList, true) // not enough args
builtin.go:21: todo(call, true) // invalid arg
builtin.go:24: todo(call, true) // invalid arg
builtin.go:30: todo(call, true) // expected slice
builtin.go:41: todo(call)
builtin.go:49: todo(call, true) // type mismatch
builtin.go:60: todo(call.ArgumentList, true) // ... invalid
builtin.go:63: todo(call.ArgumentList, true) // not enough args
builtin.go:68: todo(call.ArgumentList, true) // too many args
builtin.go:81: todo(call, true) // Invalid
builtin.go:98: todo(call)
builtin.go:102: todo(call)
builtin.go:110: todo(call.ArgumentList, true) // ... invalid
builtin.go:113: todo(call.ArgumentList, true) // not enough args
builtin.go:118: todo(call.ArgumentList, true) // too many args
builtin.go:125: todo(call)
builtin.go:131: todo(call.ArgumentList, true) //
builtin.go:138: todo(call)
builtin.go:144: todo(call.ArgumentList, true) //
builtin.go:165: todo(call.ArgumentList, true) // ... invalid
builtin.go:168: todo(call.ArgumentList, true) // not enough args
builtin.go:173: todo(call.ArgumentList, true) // too many args
builtin.go:184: todo(call)
builtin.go:195: todo(call.ArgumentList, true) // not enough args
builtin.go:200: todo(call.ArgumentList, true) // too many args
builtin.go:215: todo(call)
builtin.go:221: todo(call, true) // Invalid
builtin.go:240: todo(call)
builtin.go:244: todo(call)
builtin.go:255: todo(call.ArgumentList, true) // not enough args
builtin.go:260: todo(call.ArgumentList.node(3), true) // too many args
builtin.go:271: todo(call, true)
builtin.go:279: todo(call, true) //TODO ctx.constConversionFail(call.ArgumentList.node(i), ctx.intType, v.Const())
builtin.go:286: todo(call)
builtin.go:300: todo(call.ArgumentList.node(2), true) // too many args
builtin.go:306: todo(call, true) // invalid key type
builtin.go:311: todo(call.ArgumentList.node(2), true) // too many args
builtin.go:316: todo(call) // check arg2 <= arg3
builtin.go:320: todo(call, true) // invalid arg
builtin.go:324: todo(call, true) // not a type
builtin.go:335: todo(call.ArgumentList, true) // not enough args
builtin.go:340: todo(call.ArgumentList.node(3), true) // too many args
builtin.go:352: todo(call, true) // not a type
builtin.go:360: todo(call.ArgumentList, true) // ... invalid
grep: testdatabuiltin.go:363: todo(call.ArgumentList, true) // not enough args
builtin.go:368: todo(call.ArgumentList.node(3), true) // too many args
builtin.go:374: //TODO args, _, ddd := call.args()
builtin.go:381: todo(call.ArgumentList, true) // ... invalid
builtin.go:384: todo(call.ArgumentList, true) // not enough args
builtin.go:389: todo(call.ArgumentList, true) // too many args
builtin.go:405: todo(call, true) // invalid arg
builtin.go:409: todo(call)
context.go:95: "mips": {8, 8}, //TODO ?
context.go:96: "mipsle": {8, 8}, //TODO ?
context.go:645: todo(n, true)
context.go:704: todo(n, true)
context.go:705: //TODO c.err(n, "constant %s overflows %s", d, d.Type())
context.go:750: todo(n, true) // need bool
context.go:755: todo(n, true) // need bool
context.go:765: todo(n)
context.go:768: todo(n)
context.go:770: todo(n)
context.go:787: todo(n, true) // invalid operand
context.go:796: todo(n, true) // invalid operand
context.go:799: todo(n, true) // invalid operand
context.go:825: todo(n, true) // type mismatch
decl.go:60: //TODO Exported() bool
decl.go:261: todo(t, true) // undefined label
decl.go:434: todo(n, true)
decl.go:436: todo(n, true)
decl.go:915: todo(n) // Merge method of the underlying type, must synthesize new method w/ receiver.
decl.go:920: //TODO-fallthrough
: Is a directorydecl.go:1518: todo(n)
decl.go:1554: todo(n, true)
decl.go:1563: todo(n, true) // not enough rhs values
decl.go:1582: todo(n, true)
etc.go:82: todoPanic bool // Dev hook.
etc.go:83: todoTrace bool // Dev hook.
etc.go:155:func todo(n Node, opt ...bool) { //TODO-
etc.go:156: if todoPanic {
etc.go:160: if len(opt) != 0 && todoTrace {
generate.go:128: //TODO remove dependency on pcregrep.
lexer.go:496: lx.declarationScope.declare(lx, newVarDeclaration(-1, t, nil, nil, lx.lookahead.Pos(), 0)) //TODO
type.go:284: //TODO
type.go:718: todo(n, true)
type.go:724: todo(n, true)
type.go:1240: node Node //TODO-
unsafe.go:14: todo(n, true)
unsafe.go:19: todo(n, true)
unsafe.go:24: todo(n, true)
unsafe.go:45: todo(n, true)
unsafe.go:50: todo(n, true)
unsafe.go:55: todo(n, true)
unsafe.go:66: todo(n, true)
unsafe.go:72: todo(n, true)
unsafe.go:129: todo(n, true)
unsafe.go:134: todo(n, true)
value.go:394: //TODO shrink runtimeValue size by introducing a payload field.
value.go:493: todo(n)
value.go:502: todo(n, true) // ctx.err(n, "invalid operation: mismatched types %s and %s", v.Type(), op.Type())
value.go:509: todo(n, true) // type mismatch
value.go:514: todo(n, true) // need int
value.go:520: todo(n)
value.go:526: todo(n)
value.go:582: todo(n)
value.go:615: todo(n)
value.go:634: todo(n, true) // type mismatch
value.go:639: todo(n, true) // not ordered
value.go:644: todo(n, true) // not ordered
value.go:651: todo(n)
value.go:666: todo(n, true) // not ordered
value.go:671: todo(n, true) // not ordered
value.go:678: todo(n)
value.go:705: todo(n)
value.go:732: todo(n)
value.go:738: //TODO non const shift rules
value.go:743: todo(n)
value.go:748: todo(n)
value.go:790: todo(n)
value.go:808: todo(n, true) // need int
value.go:813: todo(n, true) // type mismatch
value.go:818: todo(n, true) // invalid operation
value.go:825: todo(n, true) //ctx.err(n, "invalid operation: | (mismatched types %s and %s)", v.Type(), ot)
value.go:832: todo(n)
value.go:838: todo(n)
value.go:854: todo(n, true) // invalid operand
value.go:865: todo(n)
value.go:875: todo(n, true) // need int
value.go:879: if !op.Const().Untyped() && !ot.AssignableTo(v.Type()) { //TODO see .sub
value.go:880: todo(n, true) // type mismatch
value.go:899: todo(n)
value.go:1521: todo(n)
value.go:1543: todo(n)
value.go:1549: todo(n)
value.go:1554: todo(n)
value.go:1621: todo(n)
value.go:1626: todo(n)
value.go:1649: todo(n)
value.go:1708: todo(zeroNode)
value.go:1710: todo(zeroNode)
value.go:1712: todo(zeroNode)
value.go:1720: todo(n)
value.go:1725: todo(n)
value.go:1737: todo(n, true) // ctx.err(n, "constant multiplication overflow")
value.go:1754: todo(n)
value.go:1760: todo(n)
value.go:1765: todo(n)
value.go:1815: todo(zeroNode)
value.go:1830: todo(n, true) // {over,under}flow
value.go:1848: todo(n)
value.go:2008: todo(n)
value.go:2014: todo(n)
value.go:2019: todo(n)
value.go:2024: todo(n)
value.go:2037: //TODO non const shift rules
value.go:2040: todo(n)
value.go:2046: todo(n)
value.go:2051: todo(n)
value.go:2068: todo(n, true) // ctx.err(n, "constant multiplication overflow")
value.go:2086: todo(n)
value.go:2101: todo(n)
value.go:2106: todo(n)
value.go:2118: todo(n, true) // {over,under}flow
value.go:2136: todo(n)
value.go:2208: todo(n)
value.go:2233: todo(n)
value.go:2258: todo(n)
value.go:2311: todo(n)
value.go:2331: todo(n)
value.go:2351: todo(n)
value.go:2384: todo(n)
value.go:2404: todo(n)
value.go:2437: todo(n)
value.go:2484: todo(n, true) // need integer
value.go:2489: todo(n, true) // type/value mismatch
value.go:2496: todo(n)
value.go:2548: todo(zeroNode)
value.go:2598: todo(n, true) // invalid operand
value.go:2603: todo(n, true) // type mismatch
value.go:2610: todo(n)
value.go:2620: todo(n, true) // invalid shift count
value.go:2631: todo(n, true)
value.go:2636: todo(n, true)
value.go:2644: todo(n, true)
value.go:2669: //TODO non const shift rules
value.go:2672: todo(n)
value.go:2678: todo(n)
value.go:2706: todo(n)
value.go:2737: todo(n)
value.go:2772: todo(n, true)
value.go:2783: todo(n, true)
value.go:2788: todo(n, true)
value.go:2796: todo(n, true)
value.go:2822: todo(n)
value.go:2847: todo(n)
value.go:2878: todo(n, true) // type mismatch
value.go:2885: todo(n)
value.go:2979: todo(n)
value.go:3009: todo(n)
value.go:3015: todo(n)
value.go:3020: todo(n)
value.go:3025: todo(n)
value.go:3030: todo(n)
value.go:3049: todo(n)
value.go:3145: panic("TODO")
value.go:3153:func (s stringIDs) eq(v stringValue) bool { panic("TODO") }
grep: testdata: Is a directory
type.go:286: // BUG(rsc): FieldByName and related functions consider struct field
grep: testdatacontext.go:55:func println()
etc.go:67: idPrintln = dict.SID("println")
: Is a directory
make[1]: Leaving directory '/home/guest/go/src/github.com/cznic/gc'
unused . || true
misspell *.go
gosimple || true
/home/guest/go/src/github.com/cznic/gc/lexer.go:239:2: should replace this if statement with an unconditional bytes.TrimPrefix
/home/guest/go/src/github.com/cznic/gc/lexer.go:242:2: should replace this if statement with an unconditional bytes.TrimSuffix
guest@system:~/go/src/github.com/cznic/gc$ ls
all_test.go builtin.go decl.go GO-LICENSE log-generate parser.yy test.log xerrors
ast2.go chandir_string.go etc.go kind_string.go Makefile scanner.go type.go y.output
ast.go constkind_string.go gc.go lexer.go package.go scanner.l unsafe.go
ast_test.go context.go generate.go LICENSE parser.go scopekind_string.go value.go
AUTHORS CONTRIBUTORS global.go log parser.y testdata valuekind_string.go
guest@system:~/go/src/github.com/cznic/gc$
my os = ubuntu 16.10-64bit
my go : 1.8
how fix this?
Create fuzzing tests
Recommend Projects
-
React
A declarative, efficient, and flexible JavaScript library for building user interfaces.
-
Vue.js
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
-
Typescript
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
-
TensorFlow
An Open Source Machine Learning Framework for Everyone
-
Django
The Web framework for perfectionists with deadlines.
-
Laravel
A PHP framework for web artisans
-
D3
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
-
Recommend Topics
-
javascript
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
-
web
Some thing interesting about web. New door for the world.
-
server
A server is a program made to process requests and deliver data to clients.
-
Machine learning
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
-
Visualization
Some thing interesting about visualization, use data art
-
Game
Some thing interesting about game, make everyone happy.
Recommend Org
-
Facebook
We are working to build community through open source technology. NB: members must have two-factor auth.
-
Microsoft
Open source projects and samples from Microsoft.
-
Google
Google ❤️ Open Source for everyone.
-
Alibaba
Alibaba Open Source for everyone
-
D3
Data-Driven Documents codes.
-
Tencent
China tencent open source team.