mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-19 08:38:14 +01:00
155 lines
3.2 KiB
Go
155 lines
3.2 KiB
Go
// Use of this source code is governed by a BSD-style license that can be found
|
|
// in the LICENSE file.
|
|
|
|
package check
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"reflect"
|
|
"sort"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/google/puffs/lang/ast"
|
|
"github.com/google/puffs/lang/parse"
|
|
"github.com/google/puffs/lang/render"
|
|
"github.com/google/puffs/lang/token"
|
|
)
|
|
|
|
func compareToPuffsfmt(idMap *token.IDMap, tokens []token.Token, src string) error {
|
|
buf := &bytes.Buffer{}
|
|
if err := render.Render(buf, idMap, tokens, nil); err != nil {
|
|
return err
|
|
}
|
|
got := strings.Split(buf.String(), "\n")
|
|
want := strings.Split(src, "\n")
|
|
for line := 1; len(got) != 0 || len(want) != 0; line++ {
|
|
if len(got) == 0 {
|
|
w := strings.TrimSpace(want[0])
|
|
return fmt.Errorf("difference at line %d:\n%s\n%s", line, "", w)
|
|
}
|
|
if len(want) == 0 {
|
|
g := strings.TrimSpace(got[0])
|
|
return fmt.Errorf("difference at line %d:\n%s\n%s", line, g, "")
|
|
}
|
|
if g, w := strings.TrimSpace(got[0]), strings.TrimSpace(want[0]); g != w {
|
|
return fmt.Errorf("difference at line %d:\n%s\n%s", line, g, w)
|
|
}
|
|
got = got[1:]
|
|
want = want[1:]
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func TestCheck(t *testing.T) {
|
|
const filename = "foo.puffs"
|
|
src := strings.TrimSpace(`
|
|
func bar()() {
|
|
var x u8
|
|
var y i32 = +2
|
|
var z u64[:123]
|
|
var a[4] u8
|
|
var b bool
|
|
|
|
x = 0
|
|
y = -y
|
|
b = not true
|
|
|
|
y = x as i32
|
|
}
|
|
`) + "\n"
|
|
|
|
idMap := &token.IDMap{}
|
|
|
|
tokens, _, err := token.Tokenize(idMap, filename, []byte(src))
|
|
if err != nil {
|
|
t.Fatalf("Tokenize: %v", err)
|
|
}
|
|
|
|
file, err := parse.Parse(idMap, filename, tokens)
|
|
if err != nil {
|
|
t.Fatalf("Parse: %v", err)
|
|
}
|
|
|
|
if err := compareToPuffsfmt(idMap, tokens, src); err != nil {
|
|
t.Fatalf("compareToPuffsfmt: %v", err)
|
|
}
|
|
|
|
c, err := Check(idMap, file)
|
|
if err != nil {
|
|
t.Fatalf("Check: %v", err)
|
|
}
|
|
|
|
funcs := c.Funcs()
|
|
if len(funcs) != 1 {
|
|
t.Fatalf("Funcs: got %d elements, want 1", len(funcs))
|
|
}
|
|
bar := Func{}
|
|
for _, f := range funcs {
|
|
bar = f
|
|
break
|
|
}
|
|
|
|
if got, want := idMap.ByID(bar.QID[1]), "bar"; got != want {
|
|
t.Fatalf("Funcs[0] name: got %q, want %q", got, want)
|
|
}
|
|
|
|
got := [][2]string(nil)
|
|
for id, typ := range bar.LocalVars {
|
|
got = append(got, [2]string{
|
|
idMap.ByID(id),
|
|
typ.String(idMap),
|
|
})
|
|
}
|
|
sort.Slice(got, func(i, j int) bool {
|
|
return got[i][0] < got[j][0]
|
|
})
|
|
|
|
want := [][2]string{
|
|
{"a", "[4] u8"},
|
|
{"b", "bool"},
|
|
{"x", "u8"},
|
|
{"y", "i32"},
|
|
{"z", "u64[:123]"},
|
|
}
|
|
if !reflect.DeepEqual(got, want) {
|
|
t.Fatalf("\ngot %v\nwant %v", got, want)
|
|
}
|
|
|
|
walk(file.Node(), func(n *ast.Node) error {
|
|
if n.Kind() == ast.KExpr {
|
|
e := n.Expr()
|
|
if typ := e.MType(); typ == nil {
|
|
t.Errorf("expression node %q has no (implicit) type", n.Expr().String(idMap))
|
|
} else if typ == TypeExprIdealNumber && e.ConstValue() == nil {
|
|
t.Errorf("expression node %q has ideal number type but no const value", n.Expr().String(idMap))
|
|
}
|
|
}
|
|
return nil
|
|
})
|
|
}
|
|
|
|
func walk(n *ast.Node, f func(*ast.Node) error) error {
|
|
if err := f(n); err != nil {
|
|
return err
|
|
}
|
|
for _, m := range n.Raw().SubNodes() {
|
|
if m != nil {
|
|
if err := walk(m, f); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
for _, l := range n.Raw().SubLists() {
|
|
for _, m := range l {
|
|
if m != nil {
|
|
if err := walk(m, f); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|