mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
424 lines
9.7 KiB
Go
424 lines
9.7 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 (
|
|
"errors"
|
|
"fmt"
|
|
|
|
a "github.com/google/puffs/lang/ast"
|
|
t "github.com/google/puffs/lang/token"
|
|
)
|
|
|
|
type Flags uint32
|
|
|
|
const (
|
|
FlagsOnlyTypeCheck = Flags(0x0001)
|
|
)
|
|
|
|
type Error struct {
|
|
Err error
|
|
Filename string
|
|
Line uint32
|
|
OtherFilename string
|
|
OtherLine uint32
|
|
|
|
TMap *t.Map
|
|
Facts []*a.Expr
|
|
}
|
|
|
|
func (e *Error) Error() string {
|
|
s := ""
|
|
if e.OtherFilename != "" || e.OtherLine != 0 {
|
|
s = fmt.Sprintf("%s at %s:%d and %s:%d",
|
|
e.Err, e.Filename, e.Line, e.OtherFilename, e.OtherLine)
|
|
} else {
|
|
s = fmt.Sprintf("%s at %s:%d", e.Err, e.Filename, e.Line)
|
|
}
|
|
if e.TMap == nil {
|
|
return s
|
|
}
|
|
b := append([]byte(s), ". Facts:\n"...)
|
|
for _, f := range e.Facts {
|
|
b = append(b, '\t')
|
|
b = append(b, f.String(e.TMap)...)
|
|
b = append(b, '\n')
|
|
}
|
|
return string(b)
|
|
}
|
|
|
|
func trimQuotes(s string) string {
|
|
if len(s) >= 2 && s[0] == '"' && s[len(s)-1] == '"' {
|
|
return s[1 : len(s)-1]
|
|
}
|
|
return s
|
|
}
|
|
|
|
// typeExprFoo is an *ast.Node MType (implicit type).
|
|
var (
|
|
typeExprBool = a.NewTypeExpr(0, t.IDBool, nil, nil, nil)
|
|
typeExprIdeal = a.NewTypeExpr(0, t.IDDoubleZ, nil, nil, nil)
|
|
typeExprU8 = a.NewTypeExpr(0, t.IDU8, nil, nil, nil)
|
|
)
|
|
|
|
// TypeMap maps from variable names (as token IDs) to types.
|
|
type TypeMap map[t.ID]*a.TypeExpr
|
|
|
|
type Func struct {
|
|
QID t.QID // Qualified ID of the func name.
|
|
Func *a.Func
|
|
LocalVars TypeMap
|
|
}
|
|
|
|
type Status struct {
|
|
ID t.ID // ID of the status message.
|
|
Status *a.Status
|
|
}
|
|
|
|
type Struct struct {
|
|
ID t.ID // ID of the struct name.
|
|
Struct *a.Struct
|
|
}
|
|
|
|
func Check(tm *t.Map, flags Flags, files ...*a.File) (*Checker, error) {
|
|
for _, f := range files {
|
|
if f == nil {
|
|
return nil, errors.New("check: Check given a nil *ast.File")
|
|
}
|
|
}
|
|
|
|
if len(files) > 1 {
|
|
m := map[string]bool{}
|
|
for _, f := range files {
|
|
if m[f.Filename()] {
|
|
return nil, fmt.Errorf("check: Check given duplicate filename %q", f.Filename())
|
|
}
|
|
m[f.Filename()] = true
|
|
}
|
|
}
|
|
|
|
rMap := reasonMap{}
|
|
for _, r := range reasons {
|
|
if id := tm.ByName(r.s); id != 0 {
|
|
rMap[id.Key()] = r.r
|
|
}
|
|
}
|
|
c := &Checker{
|
|
flags: flags,
|
|
tm: tm,
|
|
reasonMap: rMap,
|
|
funcs: map[t.QID]Func{},
|
|
statuses: map[t.ID]Status{},
|
|
structs: map[t.ID]Struct{},
|
|
}
|
|
|
|
for _, phase := range phases {
|
|
for _, f := range files {
|
|
for _, n := range f.TopLevelDecls() {
|
|
if n.Kind() != phase.kind {
|
|
continue
|
|
}
|
|
if err := phase.check(c, n); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
f.Node().SetTypeChecked()
|
|
}
|
|
}
|
|
return c, nil
|
|
}
|
|
|
|
var phases = [...]struct {
|
|
kind a.Kind
|
|
check func(*Checker, *a.Node) error
|
|
}{
|
|
{a.KUse, (*Checker).checkUse},
|
|
{a.KStatus, (*Checker).checkStatus},
|
|
{a.KStruct, (*Checker).checkStruct},
|
|
{a.KFunc, (*Checker).checkFuncSignature},
|
|
{a.KFunc, (*Checker).checkFuncContract},
|
|
{a.KFunc, (*Checker).checkFuncBody},
|
|
}
|
|
|
|
type Checker struct {
|
|
flags Flags
|
|
tm *t.Map
|
|
reasonMap reasonMap
|
|
funcs map[t.QID]Func
|
|
statuses map[t.ID]Status
|
|
structs map[t.ID]Struct
|
|
}
|
|
|
|
func (c *Checker) Funcs() map[t.QID]Func { return c.funcs }
|
|
func (c *Checker) Statuses() map[t.ID]Status { return c.statuses }
|
|
func (c *Checker) Structs() map[t.ID]Struct { return c.structs }
|
|
|
|
func (c *Checker) checkUse(node *a.Node) error {
|
|
// TODO.
|
|
return nil
|
|
}
|
|
|
|
func (c *Checker) checkStatus(node *a.Node) error {
|
|
n := node.Status()
|
|
id := n.Message()
|
|
if other, ok := c.statuses[id]; ok {
|
|
return &Error{
|
|
Err: fmt.Errorf("check: duplicate status %q", trimQuotes(id.String(c.tm))),
|
|
Filename: n.Filename(),
|
|
Line: n.Line(),
|
|
OtherFilename: other.Status.Filename(),
|
|
OtherLine: other.Status.Line(),
|
|
}
|
|
}
|
|
c.statuses[id] = Status{
|
|
ID: id,
|
|
Status: n,
|
|
}
|
|
n.Node().SetTypeChecked()
|
|
return nil
|
|
}
|
|
|
|
func (c *Checker) checkFields(fields []*a.Node, banPtrTypes bool) error {
|
|
if len(fields) == 0 {
|
|
return nil
|
|
}
|
|
|
|
q := &checker{
|
|
c: c,
|
|
tm: c.tm,
|
|
}
|
|
fieldNames := map[t.ID]bool{}
|
|
for _, n := range fields {
|
|
f := n.Field()
|
|
if _, ok := fieldNames[f.Name()]; ok {
|
|
return fmt.Errorf("check: duplicate field %q", f.Name().String(c.tm))
|
|
}
|
|
if err := q.tcheckTypeExpr(f.XType(), 0); err != nil {
|
|
return fmt.Errorf("%v in field %q", err, f.Name().String(c.tm))
|
|
}
|
|
if banPtrTypes {
|
|
for x := f.XType(); x.Inner() != nil; x = x.Inner() {
|
|
if x.Decorator().Key() == t.KeyPtr {
|
|
// TODO: implement nptr (nullable pointer) types.
|
|
return fmt.Errorf("check: ptr type %q not allowed for field %q; use nptr instead",
|
|
x.String(c.tm), f.Name().String(c.tm))
|
|
}
|
|
}
|
|
}
|
|
if dv := f.DefaultValue(); dv != nil {
|
|
if f.XType().Decorator() != 0 {
|
|
return fmt.Errorf("check: cannot set default value for qualified type %q for field %q",
|
|
f.XType().String(c.tm), f.Name().String(c.tm))
|
|
}
|
|
if err := q.tcheckExpr(dv, 0); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if c.flags&FlagsOnlyTypeCheck == 0 {
|
|
if err := bcheckField(c.tm, f); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
fieldNames[f.Name()] = true
|
|
f.Node().SetTypeChecked()
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (c *Checker) checkStruct(node *a.Node) error {
|
|
n := node.Struct()
|
|
if err := c.checkFields(n.Fields(), true); err != nil {
|
|
return &Error{
|
|
Err: fmt.Errorf("%v in struct %q", err, n.Name().String(c.tm)),
|
|
Filename: n.Filename(),
|
|
Line: n.Line(),
|
|
}
|
|
}
|
|
id := n.Name()
|
|
if other, ok := c.structs[id]; ok {
|
|
return &Error{
|
|
Err: fmt.Errorf("check: duplicate struct %q", id.String(c.tm)),
|
|
Filename: n.Filename(),
|
|
Line: n.Line(),
|
|
OtherFilename: other.Struct.Filename(),
|
|
OtherLine: other.Struct.Line(),
|
|
}
|
|
}
|
|
c.structs[id] = Struct{
|
|
ID: id,
|
|
Struct: n,
|
|
}
|
|
n.Node().SetTypeChecked()
|
|
return nil
|
|
}
|
|
|
|
func (c *Checker) checkFuncSignature(node *a.Node) error {
|
|
n := node.Func()
|
|
if err := c.checkFields(n.In().Fields(), false); err != nil {
|
|
return &Error{
|
|
Err: fmt.Errorf("%v in in-params for func %q", err, n.Name().String(c.tm)),
|
|
Filename: n.Filename(),
|
|
Line: n.Line(),
|
|
}
|
|
}
|
|
n.In().Node().SetTypeChecked()
|
|
if err := c.checkFields(n.Out().Fields(), false); err != nil {
|
|
return &Error{
|
|
Err: fmt.Errorf("%v in out-params for func %q", err, n.Name().String(c.tm)),
|
|
Filename: n.Filename(),
|
|
Line: n.Line(),
|
|
}
|
|
}
|
|
n.Out().Node().SetTypeChecked()
|
|
|
|
qid := n.QID()
|
|
if other, ok := c.funcs[qid]; ok {
|
|
return &Error{
|
|
Err: fmt.Errorf("check: duplicate function %q", qid.String(c.tm)),
|
|
Filename: n.Filename(),
|
|
Line: n.Line(),
|
|
OtherFilename: other.Func.Filename(),
|
|
OtherLine: other.Func.Line(),
|
|
}
|
|
}
|
|
|
|
inTyp := a.NewTypeExpr(0, n.In().Name(), nil, nil, nil)
|
|
inTyp.Node().SetTypeChecked()
|
|
outTyp := a.NewTypeExpr(0, n.Out().Name(), nil, nil, nil)
|
|
outTyp.Node().SetTypeChecked()
|
|
localVars := TypeMap{
|
|
t.IDIn: inTyp,
|
|
t.IDOut: outTyp,
|
|
}
|
|
if qid[0] != 0 {
|
|
if _, ok := c.structs[qid[0]]; !ok {
|
|
return &Error{
|
|
Err: fmt.Errorf("check: no receiver struct defined for function %q", qid.String(c.tm)),
|
|
Filename: n.Filename(),
|
|
Line: n.Line(),
|
|
}
|
|
}
|
|
sTyp := a.NewTypeExpr(0, qid[0], nil, nil, nil)
|
|
sTyp.Node().SetTypeChecked()
|
|
pTyp := a.NewTypeExpr(t.IDPtr, 0, nil, nil, sTyp)
|
|
pTyp.Node().SetTypeChecked()
|
|
localVars[t.IDThis] = pTyp
|
|
}
|
|
c.funcs[qid] = Func{
|
|
QID: qid,
|
|
Func: n,
|
|
LocalVars: localVars,
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (c *Checker) checkFuncContract(node *a.Node) error {
|
|
n := node.Func()
|
|
if len(n.Asserts()) == 0 {
|
|
return nil
|
|
}
|
|
q := &checker{
|
|
c: c,
|
|
tm: c.tm,
|
|
}
|
|
for _, o := range n.Asserts() {
|
|
if err := q.tcheckAssert(o.Assert()); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (c *Checker) checkFuncBody(node *a.Node) error {
|
|
n := node.Func()
|
|
q := &checker{
|
|
c: c,
|
|
tm: c.tm,
|
|
reasonMap: c.reasonMap,
|
|
f: c.funcs[n.QID()],
|
|
}
|
|
|
|
// Fill in the TypeMap with all local variables. Note that they have
|
|
// function scope and can be hoisted, JavaScript style, a la
|
|
// https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/var
|
|
if err := q.tcheckVars(n.Body()); err != nil {
|
|
return &Error{
|
|
Err: err,
|
|
Filename: q.errFilename,
|
|
Line: q.errLine,
|
|
}
|
|
}
|
|
|
|
// TODO: check that variables are never used before they're initialized.
|
|
|
|
// Assign ConstValue's (if applicable) and MType's to each Expr.
|
|
for _, o := range n.Body() {
|
|
if err := q.tcheckStatement(o); err != nil {
|
|
return &Error{
|
|
Err: err,
|
|
Filename: q.errFilename,
|
|
Line: q.errLine,
|
|
}
|
|
}
|
|
}
|
|
|
|
// Run bounds checks.
|
|
if c.flags&FlagsOnlyTypeCheck == 0 {
|
|
if err := q.bcheckBlock(n.Body()); err != nil {
|
|
return &Error{
|
|
Err: err,
|
|
Filename: q.errFilename,
|
|
Line: q.errLine,
|
|
TMap: c.tm,
|
|
Facts: q.facts,
|
|
}
|
|
}
|
|
}
|
|
|
|
n.Node().SetTypeChecked()
|
|
if err := n.Node().Walk(func(o *a.Node) error {
|
|
if !o.TypeChecked() {
|
|
switch o.Kind() {
|
|
case a.KExpr:
|
|
return fmt.Errorf("check: internal error: unchecked %s node %q",
|
|
o.Kind(), o.Expr().String(q.tm))
|
|
case a.KTypeExpr:
|
|
return fmt.Errorf("check: internal error: unchecked %s node %q",
|
|
o.Kind(), o.TypeExpr().String(q.tm))
|
|
}
|
|
return fmt.Errorf("check: internal error: unchecked %s node", o.Kind())
|
|
}
|
|
if o.Kind() == a.KExpr {
|
|
o := o.Expr()
|
|
if typ := o.MType(); typ == nil {
|
|
return fmt.Errorf("check: internal error: expression %q has no (implicit) type",
|
|
o.String(q.tm))
|
|
} else if typ.IsIdeal() && o.ConstValue() == nil {
|
|
return fmt.Errorf("check: internal error: expression %q has ideal number type "+
|
|
"but no const value", o.String(q.tm))
|
|
}
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return err
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
type checker struct {
|
|
c *Checker
|
|
tm *t.Map
|
|
reasonMap reasonMap
|
|
f Func
|
|
|
|
errFilename string
|
|
errLine uint32
|
|
|
|
jumpTargets []*a.While
|
|
|
|
facts facts
|
|
}
|