mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 00:32:11 +01:00
First cut of a type checker.
This commit is contained in:
1 parent
6424985f0f
commit
f744089e9c
3 files changed
+373
-15
No files matched your search
+4
-2
@@ -34,8 +34,8 @@ const (
|
||||
// For associative operators, ID0 is the operator and List0 holds the
|
||||
// operands.
|
||||
//
|
||||
// The ID0 operator is in disambiguous form. For example, IDUnaryPlus,
|
||||
// IDBinaryPlus or IDAssociativePlus, not a bare IDPlus.
|
||||
// The ID0 operator is in disambiguous form. For example, IDXUnaryPlus,
|
||||
// IDXBinaryPlus or IDXAssociativePlus, not a bare IDPlus.
|
||||
//
|
||||
// For function calls, like "LHS(List0)", ID0 is IDOpenParen.
|
||||
//
|
||||
@@ -161,6 +161,8 @@ type Node struct {
|
||||
Kind Kind
|
||||
Flags Flags
|
||||
|
||||
Type *Node
|
||||
|
||||
Filename string
|
||||
Line uint32
|
||||
|
||||
|
||||
@@ -0,0 +1,348 @@
|
||||
// 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"
|
||||
"math/big"
|
||||
|
||||
a "github.com/google/puffs/lang/ast"
|
||||
t "github.com/google/puffs/lang/token"
|
||||
)
|
||||
|
||||
var (
|
||||
// DummyTypeFoo are dummy values for the a.Node.Type field:
|
||||
// - DummyTypeType means that n is itself a type.
|
||||
// - DummyTypeNumber means that n is an ideal numeric constant.
|
||||
DummyTypeType = &a.Node{}
|
||||
DummyTypeIdealNumber = &a.Node{}
|
||||
)
|
||||
|
||||
// scope maps from names to types.
|
||||
type scope map[t.ID]*a.Node
|
||||
|
||||
func Check(m *t.IDMap, files ...*a.Node) (*Checker, error) {
|
||||
for _, f := range files {
|
||||
if f == nil {
|
||||
return nil, errors.New("check: Check given a nil ast.Node")
|
||||
}
|
||||
if f.Kind != a.KFile {
|
||||
return nil, errors.New("check: Check given a non-file ast.Node")
|
||||
}
|
||||
}
|
||||
|
||||
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
|
||||
}
|
||||
}
|
||||
|
||||
c := &Checker{
|
||||
idMap: m,
|
||||
funcScopes: map[*a.Node]scope{},
|
||||
}
|
||||
for _, phase := range phases {
|
||||
for _, f := range files {
|
||||
for _, n := range f.List0 {
|
||||
if err := phase(c, n); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return c, nil
|
||||
}
|
||||
|
||||
var phases = [...]func(*Checker, *a.Node) error{
|
||||
(*Checker).checkUse,
|
||||
(*Checker).checkStruct,
|
||||
(*Checker).checkFuncSignature,
|
||||
(*Checker).checkFuncBody,
|
||||
}
|
||||
|
||||
type Checker struct {
|
||||
idMap *t.IDMap
|
||||
funcScopes map[*a.Node]scope
|
||||
}
|
||||
|
||||
func (c *Checker) checkUse(n *a.Node) error {
|
||||
if n.Kind != a.KUse {
|
||||
return nil
|
||||
}
|
||||
// TODO.
|
||||
return nil
|
||||
}
|
||||
|
||||
func (c *Checker) checkStruct(n *a.Node) error {
|
||||
if n.Kind != a.KStruct {
|
||||
return nil
|
||||
}
|
||||
// TODO.
|
||||
return nil
|
||||
}
|
||||
|
||||
func (c *Checker) checkFuncSignature(n *a.Node) error {
|
||||
if n.Kind != a.KFunc {
|
||||
return nil
|
||||
}
|
||||
// TODO.
|
||||
return nil
|
||||
}
|
||||
|
||||
func (c *Checker) checkFuncBody(n *a.Node) error {
|
||||
if n.Kind != a.KFunc {
|
||||
return nil
|
||||
}
|
||||
p := scope{}
|
||||
for _, m := range n.List2 {
|
||||
if err := c.checkStatement(m, p); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
c.funcScopes[n] = p
|
||||
return nil
|
||||
}
|
||||
|
||||
func (c *Checker) checkStatement(n *a.Node, p scope) error {
|
||||
if n == nil {
|
||||
return nil
|
||||
}
|
||||
|
||||
switch n.Kind {
|
||||
case a.KAssert:
|
||||
if err := c.checkExpr(n.RHS); err != nil {
|
||||
return err
|
||||
}
|
||||
// TODO: check that n.RHS has type bool.
|
||||
// TODO: check the actual assertion.
|
||||
return nil
|
||||
|
||||
case a.KAssign:
|
||||
if err := c.checkExpr(n.RHS); err != nil {
|
||||
return err
|
||||
}
|
||||
// TODO, look at the op (n.ID0).
|
||||
if id := isUserDefinedIdent(n.LHS); id != 0 {
|
||||
if previouslyInferredType, ok := p[id]; ok {
|
||||
// TODO: check that n.RHS.Type is assignable to previouslyInferredType.
|
||||
n.LHS.Type = previouslyInferredType
|
||||
} else {
|
||||
p[id] = n.RHS.Type
|
||||
n.LHS.Type = n.RHS.Type
|
||||
}
|
||||
} else {
|
||||
if err := c.checkExpr(n.LHS); err != nil {
|
||||
return err
|
||||
}
|
||||
// TODO: check that n.RHS.Type is assignable to n.LHS.Type.
|
||||
}
|
||||
return nil
|
||||
|
||||
case a.KFor:
|
||||
if err := c.checkExpr(n.LHS); err != nil {
|
||||
return err
|
||||
}
|
||||
// TODO: check n.LHS has type bool.
|
||||
for _, m := range n.List2 {
|
||||
if err := c.checkStatement(m, p); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
return nil
|
||||
|
||||
case a.KIf:
|
||||
for ; n != nil; n = n.RHS {
|
||||
if err := c.checkExpr(n.LHS); err != nil {
|
||||
return err
|
||||
}
|
||||
// TODO: check n.LHS has type bool.
|
||||
for _, m := range n.List1 {
|
||||
if err := c.checkStatement(m, p); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
for _, m := range n.List2 {
|
||||
if err := c.checkStatement(m, p); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
return nil
|
||||
|
||||
case a.KReturn:
|
||||
if err := c.checkExpr(n.LHS); err != nil {
|
||||
return err
|
||||
}
|
||||
// TODO: type-check that n.LHS is assignable to the return value. This
|
||||
// needs the context of what func we're in.
|
||||
return nil
|
||||
|
||||
case a.KBreak:
|
||||
// TODO: check that we're in a for loop.
|
||||
return nil
|
||||
|
||||
case a.KContinue:
|
||||
// TODO: check that we're in a for loop.
|
||||
return nil
|
||||
}
|
||||
|
||||
return fmt.Errorf("check: unrecognized ast.Kind (%d) for checkStatement", n.Kind)
|
||||
}
|
||||
|
||||
func (c *Checker) checkExpr(n *a.Node) error {
|
||||
if n == nil {
|
||||
return nil
|
||||
}
|
||||
if n.Kind != a.KExpr {
|
||||
return fmt.Errorf("check: unexpected ast.Kind (%d) for checkExpr", n.Kind)
|
||||
}
|
||||
switch n.ID0.Flags() & (t.FlagsUnaryOp | t.FlagsBinaryOp | t.FlagsAssociativeOp) {
|
||||
case 0:
|
||||
return c.checkExprOther(n)
|
||||
case t.FlagsUnaryOp:
|
||||
return c.checkExprUnaryOp(n)
|
||||
case t.FlagsBinaryOp:
|
||||
return c.checkExprBinaryOp(n)
|
||||
case t.FlagsAssociativeOp:
|
||||
return c.checkExprAssociativeOp(n)
|
||||
}
|
||||
return fmt.Errorf("check: unrecognized token.Key (0x%X) for checkExpr", n.ID0.Key())
|
||||
}
|
||||
|
||||
func (c *Checker) checkExprOther(n *a.Node) error {
|
||||
switch n.ID0 {
|
||||
case 0:
|
||||
// n is an identifier or a literal.
|
||||
if n.ID1.IsNumLiteral() {
|
||||
n.Type = DummyTypeIdealNumber
|
||||
return nil
|
||||
}
|
||||
// TODO.
|
||||
|
||||
case t.IDOpenParen:
|
||||
// n is a function call.
|
||||
// TODO.
|
||||
|
||||
case t.IDOpenBracket:
|
||||
// n is an index.
|
||||
// TODO.
|
||||
|
||||
case t.IDColon:
|
||||
// n is a slice.
|
||||
// TODO.
|
||||
|
||||
case t.IDDot:
|
||||
// n is a selector.
|
||||
// TODO.
|
||||
}
|
||||
return fmt.Errorf("check: unrecognized token.Key (0x%X) for checkExprOther", n.ID0.Key())
|
||||
}
|
||||
|
||||
func (c *Checker) checkExprUnaryOp(n *a.Node) error {
|
||||
// TODO.
|
||||
return fmt.Errorf("check: unrecognized token.Key (0x%X) for checkExprUnaryOp", n.ID0.Key())
|
||||
}
|
||||
|
||||
func (c *Checker) checkExprBinaryOp(n *a.Node) error {
|
||||
if err := c.checkExpr(n.LHS); err != nil {
|
||||
return err
|
||||
}
|
||||
if n.ID0 == t.IDXBinaryAs {
|
||||
if err := c.checkType(n.RHS); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := c.typeConvertible(n.LHS, n.RHS); err != nil {
|
||||
return err
|
||||
}
|
||||
n.Type = n.RHS
|
||||
return nil
|
||||
}
|
||||
if err := c.checkExpr(n.RHS); err != nil {
|
||||
return err
|
||||
}
|
||||
// TODO.
|
||||
return fmt.Errorf("check: unrecognized token.Key (0x%X) for checkExprBinaryOp", n.ID0.Key())
|
||||
}
|
||||
|
||||
func (c *Checker) checkExprAssociativeOp(n *a.Node) error {
|
||||
// TODO.
|
||||
return fmt.Errorf("check: unrecognized token.Key (0x%X) for checkExprAssociativeOp", n.ID0.Key())
|
||||
}
|
||||
|
||||
func (c *Checker) checkType(n *a.Node) error {
|
||||
for n != nil {
|
||||
if n.Kind != a.KType {
|
||||
return fmt.Errorf("check: unexpected ast.Kind (%d) for checkType", n.Kind)
|
||||
}
|
||||
|
||||
switch n.ID0 {
|
||||
case 0:
|
||||
if n.ID1.IsNumType() || n.ID1 == t.IDBool {
|
||||
n.Type = DummyTypeType
|
||||
return nil
|
||||
}
|
||||
// TODO: see if n.ID1 refers to a struct type.
|
||||
return fmt.Errorf("check: %q is not a type", c.idMap.ByKey(n.ID1.Key()))
|
||||
|
||||
case t.IDPtr:
|
||||
n = n.RHS
|
||||
|
||||
default:
|
||||
return fmt.Errorf("check: unrecognized node for checkType")
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (c *Checker) typeConvertible(val, typ *a.Node) error {
|
||||
if val.Type == nil {
|
||||
return fmt.Errorf("check: typeConvertible: no type for val %v", val)
|
||||
}
|
||||
if typ.Type == nil {
|
||||
return fmt.Errorf("check: typeConvertible: no type for typ %v", typ)
|
||||
}
|
||||
if typ.Type != DummyTypeType {
|
||||
typ = typ.Type
|
||||
if typ.Type != DummyTypeType {
|
||||
return fmt.Errorf("check: typeConvertible: invalid type for typ %v", typ)
|
||||
}
|
||||
}
|
||||
|
||||
if typ.ID0 == 0 && typ.ID1.IsBuiltIn() && typ.ID1.IsNumType() {
|
||||
if minMax := numTypeRanges[0xFF&(typ.ID1>>t.KeyShift)]; minMax[0] != nil {
|
||||
if val.Type == DummyTypeIdealNumber {
|
||||
// TODO: check that the val is in typ's bounds.
|
||||
return nil
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return fmt.Errorf("check: typeConvertible: cannot convert value %v to type %v", val, typ)
|
||||
}
|
||||
|
||||
var numTypeRanges = [256][2]*big.Int{
|
||||
t.IDI8 >> t.KeyShift: {big.NewInt(-1 << 7), big.NewInt(1<<7 - 1)},
|
||||
t.IDI16 >> t.KeyShift: {big.NewInt(-1 << 15), big.NewInt(1<<15 - 1)},
|
||||
t.IDI32 >> t.KeyShift: {big.NewInt(-1 << 31), big.NewInt(1<<31 - 1)},
|
||||
t.IDI64 >> t.KeyShift: {big.NewInt(-1 << 63), big.NewInt(1<<63 - 1)},
|
||||
t.IDU8 >> t.KeyShift: {zero, big.NewInt(0).SetUint64(1<<8 - 1)},
|
||||
t.IDU16 >> t.KeyShift: {zero, big.NewInt(0).SetUint64(1<<16 - 1)},
|
||||
t.IDU32 >> t.KeyShift: {zero, big.NewInt(0).SetUint64(1<<32 - 1)},
|
||||
t.IDU64 >> t.KeyShift: {zero, big.NewInt(0).SetUint64(1<<64 - 1)},
|
||||
t.IDUsize >> t.KeyShift: {zero, zero},
|
||||
}
|
||||
|
||||
var zero = big.NewInt(0)
|
||||
|
||||
func isUserDefinedIdent(n *a.Node) t.ID {
|
||||
if n != nil && n.Kind == a.KExpr && n.ID0 == 0 && n.ID1.IsIdent() && !n.ID1.IsBuiltIn() {
|
||||
return n.ID1
|
||||
}
|
||||
return 0
|
||||
}
|
||||
+21
-13
@@ -3,7 +3,7 @@
|
||||
|
||||
package token
|
||||
|
||||
// Flags are the low 14 bits of an ID. For example, they signify whether a
|
||||
// Flags are the low 16 bits of an ID. For example, they signify whether a
|
||||
// token is an operator, an identifier, etc.
|
||||
//
|
||||
// The flags are not exclusive. For example, the "+" token is both a unary and
|
||||
@@ -28,13 +28,15 @@ const (
|
||||
FlagsTightRight = Flags(0x0800)
|
||||
FlagsAssign = Flags(0x1000)
|
||||
FlagsImplicitSemicolon = Flags(0x2000)
|
||||
FlagsNumType = Flags(0x4000)
|
||||
flagsUnused = Flags(0x8000)
|
||||
)
|
||||
|
||||
// Key is the high 18 bits of an ID. It is the map key for an IDMap.
|
||||
// Key is the high 16 bits of an ID. It is the map key for an IDMap.
|
||||
type Key uint32
|
||||
|
||||
const (
|
||||
FlagsBits = 14
|
||||
FlagsBits = 16
|
||||
FlagsMask = 1<<FlagsBits - 1
|
||||
KeyBits = 32 - FlagsBits
|
||||
KeyShift = FlagsBits
|
||||
@@ -51,6 +53,8 @@ func (x ID) AssociativeForm() ID { return associativeForms[0xFF&(x>>KeyShift)] }
|
||||
func (x ID) Key() Key { return Key(x >> KeyShift) }
|
||||
func (x ID) Flags() Flags { return Flags(x & FlagsMask) }
|
||||
|
||||
func (x ID) IsBuiltIn() bool { return Key(x>>KeyShift) < nBuiltInKeys }
|
||||
|
||||
func (x ID) IsUnaryOp() bool { return Flags(x)&FlagsUnaryOp != 0 }
|
||||
func (x ID) IsBinaryOp() bool { return Flags(x)&FlagsBinaryOp != 0 }
|
||||
func (x ID) IsAssociativeOp() bool { return Flags(x)&FlagsAssociativeOp != 0 }
|
||||
@@ -64,6 +68,7 @@ func (x ID) IsTightLeft() bool { return Flags(x)&FlagsTightLeft != 0 }
|
||||
func (x ID) IsTightRight() bool { return Flags(x)&FlagsTightRight != 0 }
|
||||
func (x ID) IsAssign() bool { return Flags(x)&FlagsAssign != 0 }
|
||||
func (x ID) IsImplicitSemicolon() bool { return Flags(x)&FlagsImplicitSemicolon != 0 }
|
||||
func (x ID) IsNumType() bool { return Flags(x)&FlagsNumType != 0 }
|
||||
|
||||
// Token combines an ID and the line number it was seen.
|
||||
type Token struct {
|
||||
@@ -74,6 +79,8 @@ type Token struct {
|
||||
func (t Token) Key() Key { return Key(t.ID >> KeyShift) }
|
||||
func (t Token) Flags() Flags { return Flags(t.ID & FlagsMask) }
|
||||
|
||||
func (t Token) IsBuiltIn() bool { return Key(t.ID>>KeyShift) < nBuiltInKeys }
|
||||
|
||||
func (t Token) IsUnaryOp() bool { return Flags(t.ID)&FlagsUnaryOp != 0 }
|
||||
func (t Token) IsBinaryOp() bool { return Flags(t.ID)&FlagsBinaryOp != 0 }
|
||||
func (t Token) IsAssociativeOp() bool { return Flags(t.ID)&FlagsAssociativeOp != 0 }
|
||||
@@ -87,6 +94,7 @@ func (t Token) IsTightLeft() bool { return Flags(t.ID)&FlagsTightLeft !=
|
||||
func (t Token) IsTightRight() bool { return Flags(t.ID)&FlagsTightRight != 0 }
|
||||
func (t Token) IsAssign() bool { return Flags(t.ID)&FlagsAssign != 0 }
|
||||
func (t Token) IsImplicitSemicolon() bool { return Flags(t.ID)&FlagsImplicitSemicolon != 0 }
|
||||
func (t Token) IsNumType() bool { return Flags(t.ID)&FlagsNumType != 0 }
|
||||
|
||||
// nBuiltInKeys is the number of built-in Keys. The packing is:
|
||||
// - Zero is invalid.
|
||||
@@ -100,7 +108,7 @@ func (t Token) IsImplicitSemicolon() bool { return Flags(t.ID)&FlagsImplicitSemi
|
||||
//
|
||||
// "Squiggly" means a sequence of non-alpha-numeric characters, such as "+" and
|
||||
// "&=". Their Keys range in [0x01, 0x7F].
|
||||
const nBuiltInKeys = 256
|
||||
const nBuiltInKeys = Key(256)
|
||||
|
||||
const (
|
||||
IDInvalid = ID(0)
|
||||
@@ -170,15 +178,15 @@ const (
|
||||
IDFalse = ID(0x90<<KeyShift | FlagsLiteral | FlagsImplicitSemicolon)
|
||||
IDTrue = ID(0x91<<KeyShift | FlagsLiteral | FlagsImplicitSemicolon)
|
||||
|
||||
IDI8 = ID(0xA0<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
|
||||
IDI16 = ID(0xA1<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
|
||||
IDI32 = ID(0xA2<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
|
||||
IDI64 = ID(0xA3<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
|
||||
IDU8 = ID(0xA4<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
|
||||
IDU16 = ID(0xA5<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
|
||||
IDU32 = ID(0xA6<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
|
||||
IDU64 = ID(0xA7<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
|
||||
IDUsize = ID(0xA8<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
|
||||
IDI8 = ID(0xA0<<KeyShift | FlagsIdent | FlagsImplicitSemicolon | FlagsNumType)
|
||||
IDI16 = ID(0xA1<<KeyShift | FlagsIdent | FlagsImplicitSemicolon | FlagsNumType)
|
||||
IDI32 = ID(0xA2<<KeyShift | FlagsIdent | FlagsImplicitSemicolon | FlagsNumType)
|
||||
IDI64 = ID(0xA3<<KeyShift | FlagsIdent | FlagsImplicitSemicolon | FlagsNumType)
|
||||
IDU8 = ID(0xA4<<KeyShift | FlagsIdent | FlagsImplicitSemicolon | FlagsNumType)
|
||||
IDU16 = ID(0xA5<<KeyShift | FlagsIdent | FlagsImplicitSemicolon | FlagsNumType)
|
||||
IDU32 = ID(0xA6<<KeyShift | FlagsIdent | FlagsImplicitSemicolon | FlagsNumType)
|
||||
IDU64 = ID(0xA7<<KeyShift | FlagsIdent | FlagsImplicitSemicolon | FlagsNumType)
|
||||
IDUsize = ID(0xA8<<KeyShift | FlagsIdent | FlagsImplicitSemicolon | FlagsNumType)
|
||||
IDBool = ID(0xA9<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
|
||||
IDBuf1 = ID(0xAA<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
|
||||
IDBuf2 = ID(0xAB<<KeyShift | FlagsIdent | FlagsImplicitSemicolon)
|
||||
|
||||
Reference in new issue
Block a user