Giter Club home page Giter Club logo

Comments (12)

cznic avatar cznic commented on June 30, 2024

This is a problem:

...
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
...

You need to update stringer to the version compiled by Go 1.8, yours is compiled by some older Go version:

$ go get -u golang.org/x/tools/cmd/stringer

from gc.

QuestionPython avatar QuestionPython commented on June 30, 2024

yes, i old have go 1.5 or 1.6.
but now have go 1.8.

also again say error!

from gc.

cznic avatar cznic commented on June 30, 2024

also again say error!

You have to be more specific, the above is not enough information to provide any help.

from gc.

QuestionPython avatar QuestionPython commented on June 30, 2024

after press make say this error.

from gc.

cznic avatar cznic commented on June 30, 2024

"after press make say this error" gives me no information of what/where/which/when the error is. Please post the command your're invoking and it's full output. Thank you.

from gc.

QuestionPython avatar QuestionPython commented on June 30, 2024

you not read my message? i write all output of make. go to up and read please.

from gc.

cznic avatar cznic commented on June 30, 2024

Your earlier message indicated a failure of stringer. You wrote you've fixed that.

Are you, by chance, getting a make unrelated error from go test instead? Because if so, you should have written that the failure is in go test, not make. That just confuses everything and that's why I asked to paste the full command and its output, which would have save us time and effort.

The gc package is clearly documented to be work in progress and even the tip commit message says that it passes about 40% of errorcheck tests. So go test reports the first 10 errors from the remaining errorcheck tests.

However, that's not a build error, which is the title is this issue. The package builds just fine. And you don't even need make to build it. It builds and installs fine just by using go get. Invoking make only recreates the files that are already in the repository. Do you have some other reason to run make?.

from gc.

QuestionPython avatar QuestionPython commented on June 30, 2024 
guest@system:~/go/src/github.com/cznic/gc$ go test
--- FAIL: TestLoad (1.08s)
	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.981s

tank you.

from gc.

cznic avatar cznic commented on June 30, 2024

--- FAIL: TestLoad (1.08s)

That's expected. Please read the package documentation:

Package gc is a Go compiler front end. Work in progess (40.09%).

from gc.

QuestionPython avatar QuestionPython commented on June 30, 2024

Do you have some other reason to run make?.

i love compiler,interpreter.
i want work with them on my project, and check bug and error of them. 馃憤

i just want a sample interpreter with golex + goyacc , both near of them.
example https://github.com/kumakichi/go-calculator this project just use goyacc.
also example https://github.com/golang-samples/yacc this just use yacc,(not golex)
but i want golex + goyacc(both in a project)

how can fix problem of gc Project, for make ?

from gc.

cznic avatar cznic commented on June 30, 2024

Hacking compilers and interpreters is a wonderful thing to work on 馃憤

However, the gc package is not finished and as such it cannot really help you above perhaps as possibly a source of some inspiration, sorry 馃槥

from gc.

cznic avatar cznic commented on June 30, 2024

Starting over.

from gc.

Related Issues (2)

Recommend Projects

  • React photo React

    A declarative, efficient, and flexible JavaScript library for building user interfaces.

  • Vue.js photo Vue.js

    馃枛 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo 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.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

    We are working to build community through open source technology. NB: members must have two-factor auth.

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google 鉂わ笍 Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.