mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
1090 lines
30 KiB
Go
1090 lines
30 KiB
Go
// Copyright 2017 The Wuffs Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package check
|
|
|
|
import (
|
|
"fmt"
|
|
"math/big"
|
|
|
|
"github.com/google/wuffs/lang/builtin"
|
|
|
|
a "github.com/google/wuffs/lang/ast"
|
|
t "github.com/google/wuffs/lang/token"
|
|
)
|
|
|
|
func (q *checker) tcheckVars(block []*a.Node) error {
|
|
for _, o := range block {
|
|
q.errFilename, q.errLine = o.Raw().FilenameLine()
|
|
|
|
switch o.Kind() {
|
|
case a.KIf:
|
|
for o := o.If(); o != nil; o = o.ElseIf() {
|
|
if err := q.tcheckVars(o.BodyIfTrue()); err != nil {
|
|
return err
|
|
}
|
|
if err := q.tcheckVars(o.BodyIfFalse()); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
case a.KIterate:
|
|
if err := q.tcheckVars(o.Iterate().Variables()); err != nil {
|
|
return err
|
|
}
|
|
if err := q.tcheckVars(o.Iterate().Body()); err != nil {
|
|
return err
|
|
}
|
|
|
|
case a.KVar:
|
|
o := o.Var()
|
|
name := o.Name()
|
|
if _, ok := q.localVars[name]; ok {
|
|
return fmt.Errorf("check: duplicate var %q", name.Str(q.tm))
|
|
}
|
|
if err := q.tcheckTypeExpr(o.XType(), 0); err != nil {
|
|
return err
|
|
}
|
|
q.localVars[name] = o.XType()
|
|
|
|
case a.KWhile:
|
|
if err := q.tcheckVars(o.While().Body()); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (q *checker) tcheckStatement(n *a.Node) error {
|
|
q.errFilename, q.errLine = n.Raw().FilenameLine()
|
|
|
|
switch n.Kind() {
|
|
case a.KAssert:
|
|
if err := q.tcheckAssert(n.Assert()); err != nil {
|
|
return err
|
|
}
|
|
|
|
case a.KAssign:
|
|
if err := q.tcheckAssign(n.Assign()); err != nil {
|
|
return err
|
|
}
|
|
|
|
case a.KExpr:
|
|
return q.tcheckExpr(n.Expr(), 0)
|
|
|
|
case a.KIf:
|
|
for n := n.If(); n != nil; n = n.ElseIf() {
|
|
cond := n.Condition()
|
|
if err := q.tcheckExpr(cond, 0); err != nil {
|
|
return err
|
|
}
|
|
if !cond.MType().IsBool() {
|
|
return fmt.Errorf("check: if condition %q, of type %q, does not have a boolean type",
|
|
cond.Str(q.tm), cond.MType().Str(q.tm))
|
|
}
|
|
for _, o := range n.BodyIfTrue() {
|
|
if err := q.tcheckStatement(o); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
for _, o := range n.BodyIfFalse() {
|
|
if err := q.tcheckStatement(o); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
for n := n.If(); n != nil; n = n.ElseIf() {
|
|
n.Node().SetTypeChecked()
|
|
}
|
|
return nil
|
|
|
|
case a.KIterate:
|
|
n := n.Iterate()
|
|
unroll := n.UnrollCount()
|
|
if err := q.tcheckExpr(unroll, 0); err != nil {
|
|
return err
|
|
}
|
|
if cv := unroll.ConstValue(); cv == nil {
|
|
return fmt.Errorf("check: unroll count %q is not constant", unroll.Str(q.tm))
|
|
}
|
|
for _, o := range n.Variables() {
|
|
if err := q.tcheckStatement(o); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if err := q.tcheckLoop(n); err != nil {
|
|
return err
|
|
}
|
|
|
|
case a.KJump:
|
|
n := n.Jump()
|
|
jumpTarget := (a.Loop)(nil)
|
|
if id := n.Label(); id != 0 {
|
|
for i := len(q.jumpTargets) - 1; i >= 0; i-- {
|
|
if w := q.jumpTargets[i]; w.Label() == id {
|
|
jumpTarget = w
|
|
break
|
|
}
|
|
}
|
|
} else if nj := len(q.jumpTargets); nj > 0 {
|
|
jumpTarget = q.jumpTargets[nj-1]
|
|
}
|
|
if jumpTarget == nil {
|
|
sepStr, labelStr := "", ""
|
|
if id := n.Label(); id != 0 {
|
|
sepStr, labelStr = ":", id.Str(q.tm)
|
|
}
|
|
return fmt.Errorf("no matching while/iterate statement for %s%s%s",
|
|
n.Keyword().Str(q.tm), sepStr, labelStr)
|
|
}
|
|
if n.Keyword().Key() == t.KeyBreak {
|
|
jumpTarget.SetHasBreak()
|
|
} else {
|
|
jumpTarget.SetHasContinue()
|
|
}
|
|
n.SetJumpTarget(jumpTarget)
|
|
|
|
case a.KRet:
|
|
n := n.Ret()
|
|
if value := n.Value(); value != nil {
|
|
if err := q.tcheckExpr(value, 0); err != nil {
|
|
return err
|
|
}
|
|
// TODO: type-check that value is assignable to the return value.
|
|
// This needs the context of what func we're in.
|
|
}
|
|
|
|
case a.KVar:
|
|
n := n.Var()
|
|
if !n.XType().Node().TypeChecked() {
|
|
return fmt.Errorf("check: internal error: unchecked type expression %q", n.XType().Str(q.tm))
|
|
}
|
|
if value := n.Value(); value != nil {
|
|
if err := q.tcheckExpr(value, 0); err != nil {
|
|
return err
|
|
}
|
|
lTyp := n.XType()
|
|
rTyp := value.MType()
|
|
if n.IterateVariable() {
|
|
if lTyp.Decorator().Key() != t.KeyPtr {
|
|
return fmt.Errorf("check: iterate variable %q, of type %q, does not have a pointer type",
|
|
n.Name().Str(q.tm), lTyp.Str(q.tm))
|
|
}
|
|
if !rTyp.IsSliceType() {
|
|
return fmt.Errorf("check: iterate range %q, of type %q, does not have a slice type",
|
|
value.Str(q.tm), rTyp.Str(q.tm))
|
|
}
|
|
if !lTyp.Inner().Eq(rTyp.Inner()) {
|
|
return fmt.Errorf("check: cannot iterate %q of type %q over %q of type %q "+
|
|
"as their inner types don't match",
|
|
n.Name().Str(q.tm), lTyp.Str(q.tm), value.Str(q.tm), rTyp.Str(q.tm))
|
|
}
|
|
} else if err := q.tcheckEq(n.Name(), nil, lTyp, value, rTyp); err != nil {
|
|
return err
|
|
}
|
|
|
|
} else {
|
|
// TODO: check that the default zero value is assignable to n.XType().
|
|
}
|
|
|
|
case a.KWhile:
|
|
n := n.While()
|
|
cond := n.Condition()
|
|
if err := q.tcheckExpr(cond, 0); err != nil {
|
|
return err
|
|
}
|
|
if !cond.MType().IsBool() {
|
|
return fmt.Errorf("check: for-loop condition %q, of type %q, does not have a boolean type",
|
|
cond.Str(q.tm), cond.MType().Str(q.tm))
|
|
}
|
|
if err := q.tcheckLoop(n); err != nil {
|
|
return err
|
|
}
|
|
|
|
default:
|
|
return fmt.Errorf("check: unrecognized ast.Kind (%s) for tcheckStatement", n.Kind())
|
|
}
|
|
|
|
n.SetTypeChecked()
|
|
return nil
|
|
}
|
|
|
|
func (q *checker) tcheckAssert(n *a.Assert) error {
|
|
cond := n.Condition()
|
|
if err := q.tcheckExpr(cond, 0); err != nil {
|
|
return err
|
|
}
|
|
if !cond.MType().IsBool() {
|
|
return fmt.Errorf("check: assert condition %q, of type %q, does not have a boolean type",
|
|
cond.Str(q.tm), cond.MType().Str(q.tm))
|
|
}
|
|
for _, o := range n.Args() {
|
|
if err := q.tcheckExpr(o.Arg().Value(), 0); err != nil {
|
|
return err
|
|
}
|
|
o.SetTypeChecked()
|
|
}
|
|
// TODO: check that there are no side effects.
|
|
return nil
|
|
}
|
|
|
|
func (q *checker) tcheckEq(lID t.ID, lhs *a.Expr, lTyp *a.TypeExpr, rhs *a.Expr, rTyp *a.TypeExpr) error {
|
|
if (rTyp.IsIdeal() && lTyp.IsNumType()) || lTyp.EqIgnoringRefinements(rTyp) {
|
|
return nil
|
|
}
|
|
lStr := "???"
|
|
if lID != 0 {
|
|
lStr = lID.Str(q.tm)
|
|
} else if lhs != nil {
|
|
lStr = lhs.Str(q.tm)
|
|
}
|
|
return fmt.Errorf("check: cannot assign %q of type %q to %q of type %q",
|
|
rhs.Str(q.tm), rTyp.Str(q.tm), lStr, lTyp.Str(q.tm))
|
|
}
|
|
|
|
func (q *checker) tcheckAssign(n *a.Assign) error {
|
|
lhs := n.LHS()
|
|
rhs := n.RHS()
|
|
if err := q.tcheckExpr(lhs, 0); err != nil {
|
|
return err
|
|
}
|
|
if err := q.tcheckExpr(rhs, 0); err != nil {
|
|
return err
|
|
}
|
|
lTyp := lhs.MType()
|
|
rTyp := rhs.MType()
|
|
|
|
if n.Operator().Key() == t.KeyEq {
|
|
return q.tcheckEq(0, lhs, lTyp, rhs, rTyp)
|
|
}
|
|
|
|
if !lTyp.IsNumType() {
|
|
return fmt.Errorf("check: assignment %q: assignee %q, of type %q, does not have numeric type",
|
|
n.Operator().Str(q.tm), lhs.Str(q.tm), lTyp.Str(q.tm))
|
|
}
|
|
|
|
switch n.Operator().Key() {
|
|
case t.KeyShiftLEq, t.KeyShiftREq:
|
|
if !rTyp.IsNumTypeOrIdeal() {
|
|
return fmt.Errorf("check: assignment %q: shift %q, of type %q, does not have numeric type",
|
|
n.Operator().Str(q.tm), rhs.Str(q.tm), rTyp.Str(q.tm))
|
|
}
|
|
return nil
|
|
case t.KeyTildePlusEq:
|
|
if !lTyp.IsUnsignedInteger() {
|
|
return fmt.Errorf("check: assignment %q: %q, of type %q, does not have unsigned integer type",
|
|
n.Operator().Str(q.tm), lhs.Str(q.tm), lTyp.Str(q.tm))
|
|
}
|
|
}
|
|
|
|
if rTyp.IsIdeal() || lTyp.EqIgnoringRefinements(rTyp) {
|
|
return nil
|
|
}
|
|
return fmt.Errorf("check: assignment %q: %q and %q, of types %q and %q, do not have compatible types",
|
|
n.Operator().Str(q.tm),
|
|
lhs.Str(q.tm), rhs.Str(q.tm),
|
|
lTyp.Str(q.tm), rTyp.Str(q.tm),
|
|
)
|
|
}
|
|
|
|
func (q *checker) tcheckArg(n *a.Arg, inField *a.Field, genericType *a.TypeExpr, depth uint32) error {
|
|
if err := q.tcheckExpr(n.Value(), depth); err != nil {
|
|
return err
|
|
}
|
|
|
|
if inField == nil {
|
|
// TODO: panic.
|
|
n.Node().SetTypeChecked()
|
|
return nil
|
|
}
|
|
|
|
if n.Name() != inField.Name() {
|
|
return fmt.Errorf("check: argument name: got %q, want %q", n.Name().Str(q.tm), inField.Name().Str(q.tm))
|
|
}
|
|
inFieldTyp := inField.XType()
|
|
if genericType != nil && inFieldTyp.Eq(typeExprGeneric) {
|
|
inFieldTyp = genericType
|
|
}
|
|
if err := q.tcheckEq(inField.Name(), nil, inFieldTyp, n.Value(), n.Value().MType()); err != nil {
|
|
return err
|
|
}
|
|
n.Node().SetTypeChecked()
|
|
return nil
|
|
}
|
|
|
|
func (q *checker) tcheckLoop(n a.Loop) error {
|
|
for _, o := range n.Asserts() {
|
|
if err := q.tcheckAssert(o.Assert()); err != nil {
|
|
return err
|
|
}
|
|
o.SetTypeChecked()
|
|
}
|
|
q.jumpTargets = append(q.jumpTargets, n)
|
|
defer func() {
|
|
q.jumpTargets = q.jumpTargets[:len(q.jumpTargets)-1]
|
|
}()
|
|
for _, o := range n.Body() {
|
|
if err := q.tcheckStatement(o); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (q *checker) tcheckExpr(n *a.Expr, depth uint32) error {
|
|
if depth > a.MaxExprDepth {
|
|
return fmt.Errorf("check: expression recursion depth too large")
|
|
}
|
|
depth++
|
|
|
|
switch n.Operator().Flags() & (t.FlagsUnaryOp | t.FlagsBinaryOp | t.FlagsAssociativeOp) {
|
|
case 0:
|
|
if err := q.tcheckExprOther(n, depth); err != nil {
|
|
return err
|
|
}
|
|
case t.FlagsUnaryOp:
|
|
if err := q.tcheckExprUnaryOp(n, depth); err != nil {
|
|
return err
|
|
}
|
|
case t.FlagsBinaryOp:
|
|
if err := q.tcheckExprBinaryOp(n, depth); err != nil {
|
|
return err
|
|
}
|
|
case t.FlagsAssociativeOp:
|
|
if err := q.tcheckExprAssociativeOp(n, depth); err != nil {
|
|
return err
|
|
}
|
|
default:
|
|
return fmt.Errorf("check: unrecognized token.Key (0x%X) for tcheckExpr", n.Operator().Key())
|
|
}
|
|
n.Node().SetTypeChecked()
|
|
return nil
|
|
}
|
|
|
|
func (q *checker) tcheckExprOther(n *a.Expr, depth uint32) error {
|
|
switch n.Operator().Key() {
|
|
case 0:
|
|
id1 := n.Ident()
|
|
if id1.IsNumLiteral() {
|
|
z := big.NewInt(0)
|
|
s := id1.Str(q.tm)
|
|
if _, ok := z.SetString(s, 0); !ok {
|
|
return fmt.Errorf("check: invalid numeric literal %q", s)
|
|
}
|
|
n.SetConstValue(z)
|
|
n.SetMType(typeExprIdeal)
|
|
return nil
|
|
|
|
} else if id1.IsIdent() {
|
|
if q.localVars != nil {
|
|
if typ, ok := q.localVars[id1]; ok {
|
|
n.SetMType(typ)
|
|
return nil
|
|
}
|
|
}
|
|
if c, ok := q.c.consts[t.QID{0, id1}]; ok {
|
|
// TODO: check somewhere that a global ident (i.e. a const) is
|
|
// not directly in the LHS of an assignment.
|
|
n.SetGlobalIdent()
|
|
n.SetMType(c.XType())
|
|
return nil
|
|
}
|
|
// TODO: look for other (global) names: consts, funcs, statuses,
|
|
// structs from used packages.
|
|
return fmt.Errorf("check: unrecognized identifier %q", id1.Str(q.tm))
|
|
}
|
|
switch id1.Key() {
|
|
case t.KeyFalse:
|
|
n.SetConstValue(zero)
|
|
n.SetMType(typeExprBool)
|
|
return nil
|
|
|
|
case t.KeyTrue:
|
|
n.SetConstValue(one)
|
|
n.SetMType(typeExprBool)
|
|
return nil
|
|
|
|
case t.KeyUnderscore:
|
|
// TODO.
|
|
|
|
case t.KeyThis:
|
|
// TODO.
|
|
}
|
|
|
|
case t.KeyOpenParen, t.KeyTry:
|
|
// n is a function call.
|
|
|
|
// TODO: be consistent about type-checking n.LHS().Expr() or
|
|
// n.LHS().Expr().LHS().Expr(). Doing this properly will probably
|
|
// require a TypeExpr being able to express function and method types.
|
|
|
|
// TODO: delete this hack that only matches "foo.decode(etc)".
|
|
if isThatMethod(q.tm, n, q.tm.ByName("decode").Key(), 3) {
|
|
foo := n.LHS().Expr().LHS().Expr()
|
|
if err := q.tcheckExpr(foo, depth); err != nil {
|
|
return err
|
|
}
|
|
n.LHS().SetTypeChecked()
|
|
n.LHS().Expr().SetMType(typeExprPlaceholder) // HACK.
|
|
for _, o := range n.Args() {
|
|
if err := q.tcheckArg(o.Arg(), nil, nil, depth); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if n.Operator().Key() == t.KeyTry {
|
|
// TODO: be more principled about inferring "try etc"'s type.
|
|
n.SetMType(typeExprStatus)
|
|
} else {
|
|
n.SetMType(typeExprPlaceholder) // HACK.
|
|
}
|
|
return nil
|
|
}
|
|
|
|
return q.tcheckExprCall(n, depth)
|
|
|
|
case t.KeyOpenBracket:
|
|
// n is an index.
|
|
lhs := n.LHS().Expr()
|
|
if err := q.tcheckExpr(lhs, depth); err != nil {
|
|
return err
|
|
}
|
|
rhs := n.RHS().Expr()
|
|
if err := q.tcheckExpr(rhs, depth); err != nil {
|
|
return err
|
|
}
|
|
lTyp := lhs.MType()
|
|
if key := lTyp.Decorator().Key(); key != t.KeyOpenBracket && key != t.KeyColon {
|
|
return fmt.Errorf("check: %s is an index expression but %s has type %s, not an array or slice type",
|
|
n.Str(q.tm), lhs.Str(q.tm), lTyp.Str(q.tm))
|
|
}
|
|
rTyp := rhs.MType()
|
|
if !rTyp.IsNumTypeOrIdeal() {
|
|
return fmt.Errorf("check: %s is an index expression but %s has type %s, not a numeric type",
|
|
n.Str(q.tm), rhs.Str(q.tm), rTyp.Str(q.tm))
|
|
}
|
|
n.SetMType(lTyp.Inner())
|
|
return nil
|
|
|
|
case t.KeyColon:
|
|
// n is a slice.
|
|
// TODO: require that the i and j in a[i:j] are *unsigned* (or
|
|
// non-negative constants)?
|
|
if mhs := n.MHS().Expr(); mhs != nil {
|
|
if err := q.tcheckExpr(mhs, depth); err != nil {
|
|
return err
|
|
}
|
|
mTyp := mhs.MType()
|
|
if !mTyp.IsNumTypeOrIdeal() {
|
|
return fmt.Errorf("check: %s is a slice expression but %s has type %s, not a numeric type",
|
|
n.Str(q.tm), mhs.Str(q.tm), mTyp.Str(q.tm))
|
|
}
|
|
}
|
|
if rhs := n.RHS().Expr(); rhs != nil {
|
|
if err := q.tcheckExpr(rhs, depth); err != nil {
|
|
return err
|
|
}
|
|
rTyp := rhs.MType()
|
|
if !rTyp.IsNumTypeOrIdeal() {
|
|
return fmt.Errorf("check: %s is a slice expression but %s has type %s, not a numeric type",
|
|
n.Str(q.tm), rhs.Str(q.tm), rTyp.Str(q.tm))
|
|
}
|
|
}
|
|
lhs := n.LHS().Expr()
|
|
if err := q.tcheckExpr(lhs, depth); err != nil {
|
|
return err
|
|
}
|
|
lTyp := lhs.MType()
|
|
switch lTyp.Decorator().Key() {
|
|
default:
|
|
return fmt.Errorf("check: %s is a slice expression but %s has type %s, not an array or slice type",
|
|
n.Str(q.tm), lhs.Str(q.tm), lTyp.Str(q.tm))
|
|
case t.KeyOpenBracket:
|
|
n.SetMType(a.NewTypeExpr(t.IDColon, 0, 0, nil, nil, lTyp.Inner()))
|
|
case t.KeyColon:
|
|
n.SetMType(lTyp)
|
|
}
|
|
return nil
|
|
|
|
case t.KeyDot:
|
|
return q.tcheckDot(n, depth)
|
|
|
|
case t.KeyError, t.KeyStatus, t.KeySuspension:
|
|
nominalKeyword := n.Operator()
|
|
declaredKeyword := t.ID(0)
|
|
if s, ok := q.c.statuses[n.StatusQID()]; ok {
|
|
declaredKeyword = s.Keyword()
|
|
} else {
|
|
msg, _ := t.Unescape(n.Ident().Str(q.tm))
|
|
z, ok := builtin.StatusMap[msg]
|
|
if !ok {
|
|
return fmt.Errorf("check: no error or status with message %q", msg)
|
|
}
|
|
declaredKeyword = z.Keyword
|
|
}
|
|
if nominalKeyword != declaredKeyword {
|
|
return fmt.Errorf("check: status literal says %q but declaration says %q",
|
|
nominalKeyword.Str(q.tm), declaredKeyword.Str(q.tm))
|
|
}
|
|
n.SetMType(typeExprStatus)
|
|
return nil
|
|
|
|
case t.KeyDollar:
|
|
for _, o := range n.Args() {
|
|
o := o.Expr()
|
|
if err := q.tcheckExpr(o, depth); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
n.SetMType(typeExprList)
|
|
return nil
|
|
}
|
|
|
|
return fmt.Errorf("check: unrecognized token.Key (0x%X) in expression %q for tcheckExprOther",
|
|
n.Operator().Key(), n.Str(q.tm))
|
|
}
|
|
|
|
func (q *checker) tcheckExprCall(n *a.Expr, depth uint32) error {
|
|
lhs := n.LHS().Expr()
|
|
if err := q.tcheckExpr(lhs, depth); err != nil {
|
|
return err
|
|
}
|
|
f, err := q.c.resolveFunc(lhs.MType())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if ne, fe := n.Effect(), f.Effect(); ne != fe {
|
|
return fmt.Errorf("check: %q has effect %q but %q has effect %q",
|
|
n.Str(q.tm), ne, f.QQID().Str(q.tm), fe)
|
|
}
|
|
|
|
genericType := (*a.TypeExpr)(nil)
|
|
if f.Receiver() == (t.QID{0, t.IDDiamond}) {
|
|
genericType = lhs.MType().Receiver()
|
|
}
|
|
|
|
// Check that the func's in type matches the arguments.
|
|
inFields := f.In().Fields()
|
|
if len(inFields) != len(n.Args()) {
|
|
return fmt.Errorf("check: %q has %d arguments but %d were given",
|
|
lhs.MType().Str(q.tm), len(inFields), len(n.Args()))
|
|
}
|
|
for i, o := range n.Args() {
|
|
// TODO: inline tcheckArg here, after removing the special-cased hacks
|
|
// in tcheckExprOther.
|
|
if err := q.tcheckArg(o.Arg(), inFields[i].Field(), genericType, depth); err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
// TODO: distinguish t.KeyOpenParen vs t.KeyTry in a more principled way?
|
|
//
|
|
// TODO: figure out calls with and without "?" should interact with the out
|
|
// type.
|
|
if n.Operator().Key() == t.KeyTry {
|
|
n.SetMType(typeExprStatus)
|
|
} else {
|
|
outFields := f.Out().Fields()
|
|
switch len(outFields) {
|
|
default:
|
|
// TODO: figure out how to translate f.Out(), which is an
|
|
// *ast.Struct, to an *ast.TypeExpr we can pass to n.SetMType.
|
|
return fmt.Errorf("TODO: translate an *ast.Struct to an *ast.TypeExpr")
|
|
case 0:
|
|
// TODO: use a "unit", "void" or "empty struct" type.
|
|
n.SetMType(typeExprPlaceholder)
|
|
case 1:
|
|
oTyp := outFields[0].Field().XType()
|
|
if genericType != nil && oTyp.Eq(typeExprGeneric) {
|
|
n.SetMType(genericType)
|
|
} else {
|
|
n.SetMType(oTyp)
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func isInSrc(tm *t.Map, n *a.Expr, methodName t.Key, nArgs int) bool {
|
|
callSuspendible := methodName != t.KeySinceMark &&
|
|
methodName != t.KeyMark &&
|
|
methodName != t.KeyLimit
|
|
if n.Operator().Key() != t.KeyOpenParen || n.CallSuspendible() != callSuspendible || len(n.Args()) != nArgs {
|
|
return false
|
|
}
|
|
n = n.LHS().Expr()
|
|
if n.Operator().Key() != t.KeyDot || n.Ident().Key() != methodName {
|
|
return false
|
|
}
|
|
n = n.LHS().Expr()
|
|
if n.Operator().Key() != t.KeyDot || n.Ident() != tm.ByName("src") {
|
|
return false
|
|
}
|
|
n = n.LHS().Expr()
|
|
return n.Operator() == 0 && n.Ident().Key() == t.KeyIn
|
|
}
|
|
|
|
func isInDst(tm *t.Map, n *a.Expr, methodName t.Key, nArgs int) bool {
|
|
callSuspendible := methodName != t.KeyCopyFromReader32 &&
|
|
methodName != t.KeyCopyFromHistory32 &&
|
|
methodName != t.KeyCopyFromSlice32 &&
|
|
methodName != t.KeyCopyFromSlice &&
|
|
methodName != t.KeySinceMark &&
|
|
methodName != t.KeyIsMarked &&
|
|
methodName != t.KeyMark &&
|
|
methodName != t.KeyLimit
|
|
// TODO: check that n.Args() is "(x:bar)".
|
|
if n.Operator().Key() != t.KeyOpenParen || n.CallSuspendible() != callSuspendible || len(n.Args()) != nArgs {
|
|
return false
|
|
}
|
|
n = n.LHS().Expr()
|
|
if n.Operator().Key() != t.KeyDot || n.Ident().Key() != methodName {
|
|
return false
|
|
}
|
|
n = n.LHS().Expr()
|
|
if n.Operator().Key() != t.KeyDot || n.Ident() != tm.ByName("dst") {
|
|
return false
|
|
}
|
|
n = n.LHS().Expr()
|
|
return n.Operator() == 0 && n.Ident().Key() == t.KeyIn
|
|
}
|
|
|
|
// isThatMethod matches foo.methodName(etc) where etc has nArgs elements.
|
|
func isThatMethod(tm *t.Map, n *a.Expr, methodName t.Key, nArgs int) bool {
|
|
if k := n.Operator().Key(); k != t.KeyOpenParen && k != t.KeyTry {
|
|
return false
|
|
}
|
|
if len(n.Args()) != nArgs {
|
|
return false
|
|
}
|
|
n = n.LHS().Expr()
|
|
if n.Operator().Key() != t.KeyDot || n.Ident().Key() != methodName {
|
|
return false
|
|
}
|
|
n = n.LHS().Expr()
|
|
if n.Operator().Key() == t.KeyDot &&
|
|
(n.Ident() == tm.ByName("src") || n.Ident() == tm.ByName("dst")) {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func (q *checker) tcheckDot(n *a.Expr, depth uint32) error {
|
|
lhs := n.LHS().Expr()
|
|
if err := q.tcheckExpr(lhs, depth); err != nil {
|
|
return err
|
|
}
|
|
lTyp := lhs.MType().Pointee()
|
|
lQID := lTyp.QID()
|
|
qqid := t.QQID{lQID[0], lQID[1], n.Ident()}
|
|
|
|
if key := lTyp.Decorator().Key(); key == t.KeyColon {
|
|
// lTyp is a slice.
|
|
qqid[0] = 0
|
|
qqid[1] = t.IDDiamond
|
|
if f, err := q.c.builtInSliceFunc(qqid); err != nil {
|
|
return err
|
|
} else if f == nil {
|
|
return fmt.Errorf("check: no slice method %q", n.Ident().Str(q.tm))
|
|
}
|
|
n.SetMType(a.NewTypeExpr(t.IDOpenParen, 0, n.Ident(), lTyp.Node(), nil, nil))
|
|
return nil
|
|
} else if key != 0 {
|
|
return fmt.Errorf("check: invalid type %q for dot-expression LHS %q", lTyp.Str(q.tm), lhs.Str(q.tm))
|
|
}
|
|
|
|
f, err := q.c.builtInFunc(qqid)
|
|
if err != nil {
|
|
return err
|
|
} else if f == nil {
|
|
f = q.c.funcs[qqid]
|
|
}
|
|
if f != nil {
|
|
n.SetMType(a.NewTypeExpr(t.IDOpenParen, 0, n.Ident(), lTyp.Node(), nil, nil))
|
|
return nil
|
|
}
|
|
|
|
s := (*a.Struct)(nil)
|
|
if q.astFunc != nil && lQID[0] == 0 {
|
|
switch lQID[1].Key() {
|
|
case t.KeyIn:
|
|
s = q.astFunc.In()
|
|
case t.KeyOut:
|
|
s = q.astFunc.Out()
|
|
}
|
|
}
|
|
if s == nil {
|
|
s = q.c.structs[lQID]
|
|
if s == nil && builtInTypeMap[lQID[1]] == nil {
|
|
return fmt.Errorf("check: no struct type %q found for expression %q", lTyp.Str(q.tm), lhs.Str(q.tm))
|
|
}
|
|
}
|
|
|
|
if s != nil {
|
|
for _, field := range s.Fields() {
|
|
f := field.Field()
|
|
if f.Name() == n.Ident() {
|
|
n.SetMType(f.XType())
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
|
|
return fmt.Errorf("check: no field or method named %q found in type %q for expression %q",
|
|
n.Ident().Str(q.tm), lTyp.Str(q.tm), n.Str(q.tm))
|
|
}
|
|
|
|
func (q *checker) tcheckExprUnaryOp(n *a.Expr, depth uint32) error {
|
|
rhs := n.RHS().Expr()
|
|
if err := q.tcheckExpr(rhs, depth); err != nil {
|
|
return err
|
|
}
|
|
rTyp := rhs.MType()
|
|
|
|
switch n.Operator().Key() {
|
|
case t.KeyXUnaryPlus, t.KeyXUnaryMinus:
|
|
if !rTyp.IsNumTypeOrIdeal() {
|
|
return fmt.Errorf("check: unary %q: %q, of type %q, does not have a numeric type",
|
|
n.Operator().AmbiguousForm().Str(q.tm), rhs.Str(q.tm), rTyp.Str(q.tm))
|
|
}
|
|
if cv := rhs.ConstValue(); cv != nil {
|
|
if n.Operator().Key() == t.KeyXUnaryMinus {
|
|
cv = neg(cv)
|
|
}
|
|
n.SetConstValue(cv)
|
|
}
|
|
n.SetMType(rTyp.Unrefined())
|
|
return nil
|
|
|
|
case t.KeyXUnaryNot:
|
|
if !rTyp.IsBool() {
|
|
return fmt.Errorf("check: unary %q: %q, of type %q, does not have a boolean type",
|
|
n.Operator().AmbiguousForm().Str(q.tm), rhs.Str(q.tm), rTyp.Str(q.tm))
|
|
}
|
|
if cv := rhs.ConstValue(); cv != nil {
|
|
n.SetConstValue(btoi(cv.Sign() == 0))
|
|
}
|
|
n.SetMType(typeExprBool)
|
|
return nil
|
|
|
|
case t.KeyXUnaryRef:
|
|
// TODO.
|
|
|
|
case t.KeyXUnaryDeref:
|
|
if rTyp.Decorator().Key() != t.KeyPtr { // TODO: t.KeyNptr?
|
|
return fmt.Errorf("check: %q is a dereference of a non-pointer type %q",
|
|
n.Str(q.tm), rTyp.Str(q.tm))
|
|
}
|
|
n.SetMType(rTyp.Inner())
|
|
return nil
|
|
}
|
|
return fmt.Errorf("check: unrecognized token.Key (0x%X) for tcheckExprUnaryOp", n.Operator().Key())
|
|
}
|
|
|
|
func (q *checker) tcheckExprBinaryOp(n *a.Expr, depth uint32) error {
|
|
lhs := n.LHS().Expr()
|
|
if err := q.tcheckExpr(lhs, depth); err != nil {
|
|
return err
|
|
}
|
|
lTyp := lhs.MType()
|
|
op := n.Operator()
|
|
if op.Key() == t.KeyXBinaryAs {
|
|
rhs := n.RHS().TypeExpr()
|
|
if err := q.tcheckTypeExpr(rhs, 0); err != nil {
|
|
return err
|
|
}
|
|
if lTyp.IsNumTypeOrIdeal() && rhs.IsNumType() {
|
|
n.SetMType(rhs)
|
|
return nil
|
|
}
|
|
return fmt.Errorf("check: cannot convert expression %q, of type %q, as type %q",
|
|
lhs.Str(q.tm), lTyp.Str(q.tm), rhs.Str(q.tm))
|
|
}
|
|
rhs := n.RHS().Expr()
|
|
if err := q.tcheckExpr(rhs, depth); err != nil {
|
|
return err
|
|
}
|
|
rTyp := rhs.MType()
|
|
|
|
switch op.Key() {
|
|
default:
|
|
if !lTyp.IsNumTypeOrIdeal() {
|
|
return fmt.Errorf("check: binary %q: %q, of type %q, does not have a numeric type",
|
|
op.AmbiguousForm().Str(q.tm), lhs.Str(q.tm), lTyp.Str(q.tm))
|
|
}
|
|
if !rTyp.IsNumTypeOrIdeal() {
|
|
return fmt.Errorf("check: binary %q: %q, of type %q, does not have a numeric type",
|
|
op.AmbiguousForm().Str(q.tm), rhs.Str(q.tm), rTyp.Str(q.tm))
|
|
}
|
|
case t.KeyXBinaryNotEq, t.KeyXBinaryEqEq:
|
|
// No-op.
|
|
case t.KeyXBinaryAnd, t.KeyXBinaryOr:
|
|
if !lTyp.IsBool() {
|
|
return fmt.Errorf("check: binary %q: %q, of type %q, does not have a boolean type",
|
|
op.AmbiguousForm().Str(q.tm), lhs.Str(q.tm), lTyp.Str(q.tm))
|
|
}
|
|
if !rTyp.IsBool() {
|
|
return fmt.Errorf("check: binary %q: %q, of type %q, does not have a boolean type",
|
|
op.AmbiguousForm().Str(q.tm), rhs.Str(q.tm), rTyp.Str(q.tm))
|
|
}
|
|
}
|
|
|
|
switch op.Key() {
|
|
default:
|
|
if !lTyp.EqIgnoringRefinements(rTyp) && !lTyp.IsIdeal() && !rTyp.IsIdeal() {
|
|
return fmt.Errorf("check: binary %q: %q and %q, of types %q and %q, do not have compatible types",
|
|
op.AmbiguousForm().Str(q.tm),
|
|
lhs.Str(q.tm), rhs.Str(q.tm),
|
|
lTyp.Str(q.tm), rTyp.Str(q.tm),
|
|
)
|
|
}
|
|
case t.KeyXBinaryShiftL, t.KeyXBinaryShiftR:
|
|
if lTyp.IsIdeal() && !rTyp.IsIdeal() {
|
|
return fmt.Errorf("check: binary %q: %q and %q, of types %q and %q; "+
|
|
"cannot shift an ideal number by a non-ideal number",
|
|
op.AmbiguousForm().Str(q.tm),
|
|
lhs.Str(q.tm), rhs.Str(q.tm),
|
|
lTyp.Str(q.tm), rTyp.Str(q.tm),
|
|
)
|
|
}
|
|
}
|
|
|
|
switch op.Key() {
|
|
case t.KeyXBinaryTildePlus:
|
|
typ := lTyp
|
|
if typ.IsIdeal() {
|
|
typ = rTyp
|
|
if typ.IsIdeal() {
|
|
return fmt.Errorf("check: binary %q: %q and %q, of types %q and %q, do not have non-ideal types",
|
|
op.AmbiguousForm().Str(q.tm),
|
|
lhs.Str(q.tm), rhs.Str(q.tm),
|
|
lTyp.Str(q.tm), rTyp.Str(q.tm),
|
|
)
|
|
}
|
|
}
|
|
if !typ.IsUnsignedInteger() {
|
|
return fmt.Errorf("check: binary %q: %q and %q, of types %q and %q, do not have unsigned integer types",
|
|
op.AmbiguousForm().Str(q.tm),
|
|
lhs.Str(q.tm), rhs.Str(q.tm),
|
|
lTyp.Str(q.tm), rTyp.Str(q.tm),
|
|
)
|
|
}
|
|
}
|
|
|
|
if lcv, rcv := lhs.ConstValue(), rhs.ConstValue(); lcv != nil && rcv != nil {
|
|
ncv, err := evalConstValueBinaryOp(q.tm, n, lcv, rcv)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
n.SetConstValue(ncv)
|
|
}
|
|
|
|
if comparisonOps[0xFF&op.Key()] {
|
|
n.SetMType(typeExprBool)
|
|
} else if !lTyp.IsIdeal() {
|
|
n.SetMType(lTyp.Unrefined())
|
|
} else {
|
|
n.SetMType(rTyp.Unrefined())
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func evalConstValueBinaryOp(tm *t.Map, n *a.Expr, l *big.Int, r *big.Int) (*big.Int, error) {
|
|
switch n.Operator().Key() {
|
|
case t.KeyXBinaryPlus:
|
|
return big.NewInt(0).Add(l, r), nil
|
|
case t.KeyXBinaryMinus:
|
|
return big.NewInt(0).Sub(l, r), nil
|
|
case t.KeyXBinaryStar:
|
|
return big.NewInt(0).Mul(l, r), nil
|
|
case t.KeyXBinarySlash:
|
|
if r.Sign() == 0 {
|
|
return nil, fmt.Errorf("check: division by zero in const expression %q", n.Str(tm))
|
|
}
|
|
// TODO: decide on Euclidean division vs other definitions. See "go doc
|
|
// math/big int.divmod" for details.
|
|
return big.NewInt(0).Div(l, r), nil
|
|
case t.KeyXBinaryShiftL:
|
|
if r.Sign() < 0 || r.Cmp(ffff) > 0 {
|
|
return nil, fmt.Errorf("check: shift %q out of range in const expression %q",
|
|
n.RHS().Expr().Str(tm), n.Str(tm))
|
|
}
|
|
return big.NewInt(0).Lsh(l, uint(r.Uint64())), nil
|
|
case t.KeyXBinaryShiftR:
|
|
if r.Sign() < 0 || r.Cmp(ffff) > 0 {
|
|
return nil, fmt.Errorf("check: shift %q out of range in const expression %q",
|
|
n.RHS().Expr().Str(tm), n.Str(tm))
|
|
}
|
|
return big.NewInt(0).Rsh(l, uint(r.Uint64())), nil
|
|
case t.KeyXBinaryAmp:
|
|
return big.NewInt(0).And(l, r), nil
|
|
case t.KeyXBinaryAmpHat:
|
|
return big.NewInt(0).AndNot(l, r), nil
|
|
case t.KeyXBinaryPipe:
|
|
return big.NewInt(0).Or(l, r), nil
|
|
case t.KeyXBinaryHat:
|
|
return big.NewInt(0).Xor(l, r), nil
|
|
case t.KeyXBinaryPercent:
|
|
if r.Sign() == 0 {
|
|
return nil, fmt.Errorf("check: division by zero in const expression %q", n.Str(tm))
|
|
}
|
|
return big.NewInt(0).Mod(l, r), nil
|
|
case t.KeyXBinaryNotEq:
|
|
return btoi(l.Cmp(r) != 0), nil
|
|
case t.KeyXBinaryLessThan:
|
|
return btoi(l.Cmp(r) < 0), nil
|
|
case t.KeyXBinaryLessEq:
|
|
return btoi(l.Cmp(r) <= 0), nil
|
|
case t.KeyXBinaryEqEq:
|
|
return btoi(l.Cmp(r) == 0), nil
|
|
case t.KeyXBinaryGreaterEq:
|
|
return btoi(l.Cmp(r) >= 0), nil
|
|
case t.KeyXBinaryGreaterThan:
|
|
return btoi(l.Cmp(r) > 0), nil
|
|
case t.KeyXBinaryAnd:
|
|
return btoi((l.Sign() != 0) && (r.Sign() != 0)), nil
|
|
case t.KeyXBinaryOr:
|
|
return btoi((l.Sign() != 0) || (r.Sign() != 0)), nil
|
|
case t.KeyXBinaryTildePlus:
|
|
return nil, fmt.Errorf("check: cannot apply ~+ operator to ideal numbers")
|
|
}
|
|
return nil, fmt.Errorf("check: unrecognized token.Key (0x%02X) for evalConstValueBinaryOp", n.Operator().Key())
|
|
}
|
|
|
|
func (q *checker) tcheckExprAssociativeOp(n *a.Expr, depth uint32) error {
|
|
switch n.Operator().Key() {
|
|
case t.KeyXAssociativePlus, t.KeyXAssociativeStar,
|
|
t.KeyXAssociativeAmp, t.KeyXAssociativePipe, t.KeyXAssociativeHat:
|
|
|
|
expr, typ := (*a.Expr)(nil), (*a.TypeExpr)(nil)
|
|
for _, o := range n.Args() {
|
|
o := o.Expr()
|
|
if err := q.tcheckExpr(o, depth); err != nil {
|
|
return err
|
|
}
|
|
oTyp := o.MType()
|
|
if oTyp.IsIdeal() {
|
|
continue
|
|
}
|
|
if !oTyp.IsNumType() {
|
|
return fmt.Errorf("check: associative %q: %q, of type %q, does not have a numeric type",
|
|
n.Operator().AmbiguousForm().Str(q.tm), o.Str(q.tm), oTyp.Str(q.tm))
|
|
}
|
|
if typ == nil {
|
|
expr, typ = o, oTyp.Unrefined()
|
|
continue
|
|
}
|
|
if !typ.EqIgnoringRefinements(oTyp) {
|
|
return fmt.Errorf("check: associative %q: %q and %q, of types %q and %q, "+
|
|
"do not have compatible types",
|
|
n.Operator().AmbiguousForm().Str(q.tm),
|
|
expr.Str(q.tm), o.Str(q.tm),
|
|
expr.MType().Str(q.tm), o.MType().Str(q.tm))
|
|
}
|
|
}
|
|
if typ == nil {
|
|
typ = typeExprIdeal
|
|
}
|
|
n.SetMType(typ)
|
|
return nil
|
|
|
|
case t.KeyXAssociativeAnd, t.KeyXAssociativeOr:
|
|
for _, o := range n.Args() {
|
|
o := o.Expr()
|
|
if err := q.tcheckExpr(o, depth); err != nil {
|
|
return err
|
|
}
|
|
if !o.MType().IsBool() {
|
|
return fmt.Errorf("check: associative %q: %q, of type %q, does not have a boolean type",
|
|
n.Operator().AmbiguousForm().Str(q.tm), o.Str(q.tm), o.MType().Str(q.tm))
|
|
}
|
|
}
|
|
n.SetMType(typeExprBool)
|
|
return nil
|
|
}
|
|
|
|
return fmt.Errorf("check: unrecognized token.Key (0x%X) for tcheckExprAssociativeOp", n.Operator().Key())
|
|
}
|
|
|
|
func (q *checker) tcheckTypeExpr(typ *a.TypeExpr, depth uint32) error {
|
|
if depth > a.MaxTypeExprDepth {
|
|
return fmt.Errorf("check: type expression recursion depth too large")
|
|
}
|
|
depth++
|
|
|
|
swtch:
|
|
switch typ.Decorator().Key() {
|
|
// TODO: also check t.KeyOpenParen.
|
|
case 0:
|
|
qid := typ.QID()
|
|
if qid[1].IsNumType() {
|
|
for _, b := range typ.Bounds() {
|
|
if b == nil {
|
|
continue
|
|
}
|
|
if err := q.tcheckExpr(b, 0); err != nil {
|
|
return err
|
|
}
|
|
if b.ConstValue() == nil {
|
|
return fmt.Errorf("check: %q is not constant", b.Str(q.tm))
|
|
}
|
|
}
|
|
break
|
|
}
|
|
if typ.Min() != nil || typ.Max() != nil {
|
|
// TODO: reject. You can only refine numeric types.
|
|
}
|
|
if _, ok := builtInTypeMap[qid[1]]; ok {
|
|
break swtch
|
|
}
|
|
for _, s := range q.c.structs {
|
|
if s.QID() == qid {
|
|
break swtch
|
|
}
|
|
}
|
|
return fmt.Errorf("check: %q is not a type", typ.Str(q.tm))
|
|
|
|
case t.KeyOpenBracket:
|
|
aLen := typ.ArrayLength()
|
|
if err := q.tcheckExpr(aLen, 0); err != nil {
|
|
return err
|
|
}
|
|
if aLen.ConstValue() == nil {
|
|
return fmt.Errorf("check: %q is not constant", aLen.Str(q.tm))
|
|
}
|
|
fallthrough
|
|
|
|
// TODO: also check t.KeyNptr? Where else should we look for nptr?
|
|
case t.KeyPtr, t.KeyColon:
|
|
if err := q.tcheckTypeExpr(typ.Inner(), depth); err != nil {
|
|
return err
|
|
}
|
|
|
|
default:
|
|
return fmt.Errorf("check: %q is not a type", typ.Str(q.tm))
|
|
}
|
|
typ.Node().SetTypeChecked()
|
|
return nil
|
|
}
|
|
|
|
var comparisonOps = [256]bool{
|
|
t.KeyXBinaryNotEq: true,
|
|
t.KeyXBinaryLessThan: true,
|
|
t.KeyXBinaryLessEq: true,
|
|
t.KeyXBinaryEqEq: true,
|
|
t.KeyXBinaryGreaterEq: true,
|
|
t.KeyXBinaryGreaterThan: true,
|
|
}
|