Add type-safe wrappers for *ast.Node.

This means that code that uses nodes shouldn't have to fiddle with ID0,
LHS, List0 etc fields directly.
This commit is contained in:
Nigel Tao committed 2017-05-11 15:32:02 +10:00
1 parent 54567dbd47
commit e1c890907e
4 files changed
+565 -395

No files matched your search

+317 -24
View File
@@ -4,7 +4,7 @@
package ast
import (
"github.com/google/puffs/lang/token"
t "github.com/google/puffs/lang/token"
)
// Kind is what kind of node it is. For example, a top-level func or a numeric
@@ -12,6 +12,10 @@ import (
// in the programming language sense.
type Kind uint32
// XType is the explicit type, directly from the source code.
//
// MType is the implicit type, deduced for expressions during type checking.
const (
KInvalid = Kind(iota)
@@ -20,7 +24,7 @@ const (
// - ID1: <0|identifier name|literal>
// - LHS: <nil|KExpr>
// - MHS: <nil|KExpr>
// - RHS: <nil|KExpr|KType>
// - RHS: <nil|KExpr|KTypeExpr>
// - List0: <KExpr> function call arguments or associative op arguments
// - FlagsSuspendible is "f(x)" vs "f?(x)"
//
@@ -58,13 +62,13 @@ const (
// KVar is "var ID1 LHS" or "var ID1 LHS = RHS":
// - ID1: name
// - LHS: <KType>
// - LHS: <KTypeExpr>
// - RHS: <nil|KExpr>
KVar
// KParam is a "name type" parameter:
// - ID1: name
// - LHS: <KType>
// - LHS: <KTypeExpr>
KParam
// KFor is "for { List2 }" or "for LHS { List2 }":
@@ -91,22 +95,23 @@ const (
// TODO: label?
KContinue
// KType is a type, such as "u32", "pkg.foo", "ptr T" or "[8] T":
// - ID0: <0|package name|IDPtr>
// KTypeExpr is a type expression, such as "u32", "pkg.foo", "ptr T" or
// "[8] T":
// - ID0: <0|package name|IDPtr|IDOpenBracket>
// - ID1: <0|type name>
// - LHS: <nil|KExpr>
// - MHS: <nil|KExpr>
// - RHS: <nil|KExpr|KType>
// - RHS: <nil|KExpr|KTypeExpr>
//
// An IDPtr ID0 means "ptr RHS". RHS is a KType.
// An IDPtr ID0 means "ptr RHS". RHS is a KTypeExpr.
//
// An IDOpenBracket ID0 means "[LHS] RHS". RHS is a KType.
// An IDOpenBracket ID0 means "[LHS] RHS". RHS is a KTypeExpr.
//
// Other ID0 values mean a (possibly package-qualified) type like "pkg.foo"
// or "foo". ID0 is the "pkg" or zero, ID1 is the "foo". Such a type can be
// refined as "pkg.foo[MHS:RHS]". MHS and RHS are KExpr's, possibly nil.
// For example, the MHS for "u32[:4096]" is nil.
KType
KTypeExpr
// KFunc is "func ID0.ID1(List0) (List1) { List2 }":
// - ID0: <0|receiver>
@@ -153,7 +158,7 @@ var kindStrings = [...]string{
KParam: "KParam",
KReturn: "KReturn",
KStruct: "KStruct",
KType: "KType",
KTypeExpr: "KTypeExpr",
KUse: "KUse",
KVar: "KVar",
}
@@ -165,20 +170,308 @@ const (
)
type Node struct {
Kind Kind
Flags Flags
kind Kind
flags Flags
Type *Node
mType *TypeExpr
Filename string
Line uint32
filename string
line uint32
ID0 token.ID
ID1 token.ID
LHS *Node // Left Hand Side.
MHS *Node // Middle Hand Side.
RHS *Node // Right Hand Side.
List0 []*Node
List1 []*Node
List2 []*Node
id0 t.ID
id1 t.ID
lhs *Node // Left Hand Side.
mhs *Node // Middle Hand Side.
rhs *Node // Right Hand Side.
list0 []*Node
list1 []*Node
list2 []*Node
}
func (n *Node) Kind() Kind { return n.kind }
func (n *Node) Assert() *Assert { return (*Assert)(n) }
func (n *Node) Assign() *Assign { return (*Assign)(n) }
func (n *Node) Break() *Break { return (*Break)(n) }
func (n *Node) Continue() *Continue { return (*Continue)(n) }
func (n *Node) Expr() *Expr { return (*Expr)(n) }
func (n *Node) File() *File { return (*File)(n) }
func (n *Node) For() *For { return (*For)(n) }
func (n *Node) Func() *Func { return (*Func)(n) }
func (n *Node) If() *If { return (*If)(n) }
func (n *Node) Param() *Param { return (*Param)(n) }
func (n *Node) Raw() *Raw { return (*Raw)(n) }
func (n *Node) Return() *Return { return (*Return)(n) }
func (n *Node) Struct() *Struct { return (*Struct)(n) }
func (n *Node) TypeExpr() *TypeExpr { return (*TypeExpr)(n) }
func (n *Node) Use() *Use { return (*Use)(n) }
func (n *Node) Var() *Var { return (*Var)(n) }
type Raw Node
func (n *Raw) Node() *Node { return (*Node)(n) }
func (n *Raw) Kind() Kind { return n.kind }
func (n *Raw) Flags() Flags { return n.flags }
func (n *Raw) MType() *TypeExpr { return n.mType }
func (n *Raw) FilenameLine() (string, uint32) { return n.filename, n.line }
func (n *Raw) Filename() string { return n.filename }
func (n *Raw) Line() uint32 { return n.line }
func (n *Raw) ID0() t.ID { return n.id0 }
func (n *Raw) ID1() t.ID { return n.id1 }
func (n *Raw) SubNodes() [3]*Node { return [3]*Node{n.lhs, n.mhs, n.rhs} }
func (n *Raw) LHS() *Node { return n.lhs }
func (n *Raw) MHS() *Node { return n.mhs }
func (n *Raw) RHS() *Node { return n.rhs }
func (n *Raw) SubLists() [3][]*Node { return [3][]*Node{n.list0, n.list1, n.list2} }
func (n *Raw) List0() []*Node { return n.list0 }
func (n *Raw) List1() []*Node { return n.list1 }
func (n *Raw) List2() []*Node { return n.list2 }
func (n *Raw) SetFilenameLine(f string, l uint32) { n.filename, n.line = f, l }
type Expr Node
func (n *Expr) Node() *Node { return (*Node)(n) }
func (n *Expr) MType() *TypeExpr { return n.mType }
func (n *Expr) ID0() t.ID { return n.id0 }
func (n *Expr) ID1() t.ID { return n.id1 }
func (n *Expr) LHS() *Node { return n.lhs }
func (n *Expr) MHS() *Node { return n.mhs }
func (n *Expr) RHS() *Node { return n.rhs }
func (n *Expr) List() []*Node { return n.list0 }
func (n *Expr) SetMType(x *TypeExpr) { n.mType = x }
func NewExpr(flags Flags, operator t.ID, nameLiteralSelector t.ID, lhs *Node, mhs *Node, rhs *Node, args []*Node) *Expr {
return &Expr{
kind: KExpr,
flags: flags,
id0: operator,
id1: nameLiteralSelector,
lhs: lhs,
mhs: mhs,
rhs: rhs,
list0: args,
}
}
type Assert Node
func (n *Assert) Node() *Node { return (*Node)(n) }
func (n *Assert) Condition() *Expr { return n.rhs.Expr() }
func NewAssert(condition *Expr) *Assert {
return &Assert{
kind: KAssert,
lhs: condition.Node(),
}
}
type Assign Node
func (n *Assign) Node() *Node { return (*Node)(n) }
func (n *Assign) Operator() t.ID { return n.id0 }
func (n *Assign) LHS() *Expr { return n.lhs.Expr() }
func (n *Assign) RHS() *Expr { return n.rhs.Expr() }
func NewAssign(operator t.ID, lhs *Expr, rhs *Expr) *Assign {
return &Assign{
kind: KAssign,
id0: operator,
lhs: lhs.Node(),
rhs: rhs.Node(),
}
}
type Var Node
func (n *Var) Node() *Node { return (*Node)(n) }
func (n *Var) Name() t.ID { return n.id1 }
func (n *Var) XType() *TypeExpr { return n.lhs.TypeExpr() }
func (n *Var) Value() *Expr { return n.rhs.Expr() }
func NewVar(name t.ID, xType *TypeExpr, value *Expr) *Var {
return &Var{
kind: KVar,
id1: name,
lhs: xType.Node(),
rhs: value.Node(),
}
}
type Param Node
func (n *Param) Node() *Node { return (*Node)(n) }
func (n *Param) Name() t.ID { return n.id1 }
func (n *Param) XType() *TypeExpr { return n.lhs.TypeExpr() }
func NewParam(name t.ID, xType *TypeExpr) *Param {
return &Param{
kind: KParam,
id1: name,
lhs: xType.Node(),
}
}
type For Node
func (n *For) Node() *Node { return (*Node)(n) }
func (n *For) Condition() *Expr { return n.lhs.Expr() }
func (n *For) Body() []*Node { return n.list2 }
func NewFor(condition *Expr, body []*Node) *For {
return &For{
kind: KFor,
lhs: condition.Node(),
list2: body,
}
}
type If Node
func (n *If) Node() *Node { return (*Node)(n) }
func (n *If) Condition() *Expr { return n.lhs.Expr() }
func (n *If) ElseIf() *If { return n.rhs.If() }
func (n *If) BodyIfTrue() []*Node { return n.list1 }
func (n *If) BodyIfFalse() []*Node { return n.list2 }
func NewIf(condition *Expr, elseIf *If, bodyIfTrue []*Node, bodyIfFalse []*Node) *If {
return &If{
kind: KIf,
lhs: condition.Node(),
rhs: elseIf.Node(),
list1: bodyIfTrue,
list2: bodyIfFalse,
}
}
type Return Node
func (n *Return) Node() *Node { return (*Node)(n) }
func (n *Return) Value() *Expr { return n.lhs.Expr() }
func NewReturn(value *Expr) *Return {
return &Return{
kind: KReturn,
lhs: value.Node(),
}
}
type Break Node
func (n *Break) Node() *Node { return (*Node)(n) }
func NewBreak() *Break {
return &Break{
kind: KBreak,
}
}
type Continue Node
func (n *Continue) Node() *Node { return (*Node)(n) }
func NewContinue() *Continue {
return &Continue{
kind: KContinue,
}
}
type TypeExpr Node
func (n *TypeExpr) Node() *Node { return (*Node)(n) }
func (n *TypeExpr) PackageOrDecorator() t.ID { return n.id0 }
func (n *TypeExpr) Name() t.ID { return n.id1 }
func (n *TypeExpr) LHS() *Node { return n.lhs }
func (n *TypeExpr) MHS() *Node { return n.mhs }
func (n *TypeExpr) RHS() *Node { return n.rhs }
// TODO: tighten the types here.
func NewTypeExpr(pkgOrDec t.ID, name t.ID, lhs *Node, mhs *Node, rhs *Node) *TypeExpr {
return &TypeExpr{
kind: KTypeExpr,
id0: pkgOrDec,
id1: name,
lhs: lhs,
mhs: mhs,
rhs: rhs,
}
}
type Func Node
func (n *Func) Node() *Node { return (*Node)(n) }
func (n *Func) Suspendible() bool { return n.flags&FlagsSuspendible != 0 }
func (n *Func) Filename() string { return n.filename }
func (n *Func) Line() uint32 { return n.line }
func (n *Func) QID() t.QID { return t.QID{n.id0, n.id1} }
func (n *Func) Receiver() t.ID { return n.id0 }
func (n *Func) Name() t.ID { return n.id1 }
func (n *Func) InParams() []*Node { return n.list0 }
func (n *Func) OutParams() []*Node { return n.list1 }
func (n *Func) Body() []*Node { return n.list2 }
func NewFunc(flags Flags, filename string, line uint32, receiver t.ID, name t.ID, inParams []*Node, outParams []*Node, body []*Node) *Func {
return &Func{
kind: KFunc,
flags: flags,
filename: filename,
line: line,
id0: receiver,
id1: name,
list0: inParams,
list1: outParams,
list2: body,
}
}
type Struct Node
func (n *Struct) Node() *Node { return (*Node)(n) }
func (n *Struct) Suspendible() bool { return n.flags&FlagsSuspendible != 0 }
func (n *Struct) Filename() string { return n.filename }
func (n *Struct) Line() uint32 { return n.line }
func (n *Struct) Name() t.ID { return n.id1 }
func (n *Struct) Fields() []*Node { return n.list0 }
func NewStruct(flags Flags, filename string, line uint32, name t.ID, fields []*Node) *Struct {
return &Struct{
kind: KStruct,
flags: flags,
filename: filename,
line: line,
id1: name,
list0: fields,
}
}
type Use Node
func (n *Use) Node() *Node { return (*Node)(n) }
func (n *Use) Filename() string { return n.filename }
func (n *Use) Line() uint32 { return n.line }
func (n *Use) Path() t.ID { return n.id1 }
func NewUse(filename string, line uint32, path t.ID) *Use {
return &Use{
kind: KUse,
filename: filename,
line: line,
id1: path,
}
}
type File Node
func (n *File) Node() *Node { return (*Node)(n) }
func (n *File) Filename() string { return n.filename }
func (n *File) TopLevelDecls() []*Node { return n.list0 }
func NewFile(filename string, topLevelDecls []*Node) *File {
return &File{
kind: KFile,
filename: filename,
list0: topLevelDecls,
}
}
+135 -162
View File
@@ -12,67 +12,55 @@ import (
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{Kind: a.KType}
DummyTypeIdealNumber = &a.Node{Kind: a.KType}
)
// DummyTypeIdealNumber is an a.Node.MType field that means that n is an ideal
// numeric constant.
//
// TODO: change 1 to a named constant.
var DummyTypeIdealNumber = a.NewTypeExpr(0, 1, nil, nil, nil)
// TypeString returns a string form of the type n.
func TypeString(m *t.IDMap, n *a.Node) string {
if n == nil {
return "!nil!"
}
if n.Kind != a.KType {
return "!not_a_type!"
}
switch n {
case DummyTypeType:
return "!invalid_type!"
case DummyTypeIdealNumber:
return "!ideal!"
}
switch n.ID0 {
case 0:
return m.ByID(n.ID1)
case t.IDPtr:
return "ptr " + TypeString(m, n.RHS)
case t.IDOpenBracket:
// TODO.
default:
return m.ByID(n.ID0) + "." + m.ByID(n.ID1)
func TypeString(m *t.IDMap, n *a.TypeExpr) string {
if n != nil {
if n == DummyTypeIdealNumber {
return "!ideal!"
}
switch n.PackageOrDecorator() {
case 0:
return m.ByID(n.Name())
case t.IDPtr:
return "ptr " + TypeString(m, n.RHS().TypeExpr())
case t.IDOpenBracket:
// TODO.
default:
return m.ByID(n.PackageOrDecorator()) + "." + m.ByID(n.Name())
}
}
return "!invalid_type!"
}
// TypeMap maps from variable names (as token IDs) to types.
type TypeMap map[t.ID]*a.Node
type TypeMap map[t.ID]*a.TypeExpr
type Func struct {
QID t.QID
Node *a.Node
Func *a.Func
LocalVars TypeMap
}
func Check(m *t.IDMap, files ...*a.Node) (*Checker, error) {
func Check(m *t.IDMap, files ...*a.File) (*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")
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)
if m[f.Filename()] {
return nil, fmt.Errorf("check: Check given duplicate filename %q", f.Filename())
}
m[f.Filename] = true
m[f.Filename()] = true
}
}
@@ -82,8 +70,11 @@ func Check(m *t.IDMap, files ...*a.Node) (*Checker, error) {
}
for _, phase := range phases {
for _, f := range files {
for _, n := range f.List0 {
if err := phase(c, n); err != nil {
for _, n := range f.TopLevelDecls() {
if n.Kind() != phase.kind {
continue
}
if err := phase.check(c, n); err != nil {
return nil, err
}
}
@@ -92,11 +83,14 @@ func Check(m *t.IDMap, files ...*a.Node) (*Checker, error) {
return c, nil
}
var phases = [...]func(*Checker, *a.Node) error{
(*Checker).checkUse,
(*Checker).checkStruct,
(*Checker).checkFuncSignature,
(*Checker).checkFuncBody,
var phases = [...]struct {
kind a.Kind
check func(*Checker, *a.Node) error
}{
{a.KUse, (*Checker).checkUse},
{a.KStruct, (*Checker).checkStruct},
{a.KFunc, (*Checker).checkFuncSignature},
{a.KFunc, (*Checker).checkFuncBody},
}
type Checker struct {
@@ -107,47 +101,36 @@ type Checker struct {
func (c *Checker) Funcs() map[t.QID]Func { return c.funcs }
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
}
f := n.Func()
p := TypeMap{}
for _, m := range n.List2 {
for _, m := range f.Body() {
if err := c.checkVars(m, p); err != nil {
return fmt.Errorf("%v at %s:%d", err, m.Filename, m.Line)
return fmt.Errorf("%v at %s:%d", err, m.Raw().Filename(), m.Raw().Line())
}
}
for _, m := range n.List2 {
for _, m := range f.Body() {
if err := c.checkStatement(m, p); err != nil {
return fmt.Errorf("%v at %s:%d", err, m.Filename, m.Line)
return fmt.Errorf("%v at %s:%d", err, m.Raw().Filename(), m.Raw().Line())
}
}
qid := t.QID{n.ID0, n.ID1}
qid := f.QID()
if _, ok := c.funcs[qid]; ok {
if qid[0] == 0 {
return fmt.Errorf(`check: duplicate function "%s"`, c.idMap.ByID(qid[1]))
@@ -157,30 +140,29 @@ func (c *Checker) checkFuncBody(n *a.Node) error {
}
c.funcs[qid] = Func{
QID: qid,
Node: n,
Func: f,
LocalVars: p,
}
return nil
}
func (c *Checker) checkVars(n *a.Node, p TypeMap) error {
if n == nil {
return nil
}
if n.Kind == a.KVar {
if _, ok := p[n.ID1]; ok {
return fmt.Errorf("check: duplicate var %q", c.idMap.ByID(n.ID1))
if n.Kind() == a.KVar {
v := n.Var()
name := v.Name()
if _, ok := p[name]; ok {
return fmt.Errorf("check: duplicate var %q", c.idMap.ByID(name))
}
if err := c.checkType(n.LHS); err != nil {
if err := c.checkTypeExpr(v.XType()); err != nil {
return err
}
if n.RHS != nil {
// TODO: check that n.RHS doesn't mention the variable itself.
if value := v.Value(); value != nil {
// TODO: check that value doesn't mention the variable itself.
}
p[n.ID1] = n.LHS
p[name] = v.XType()
return nil
}
for _, l := range [...][]*a.Node{n.List0, n.List1, n.List2} {
for _, l := range n.Raw().SubLists() {
for _, m := range l {
if err := c.checkVars(m, p); err != nil {
return err
@@ -191,45 +173,47 @@ func (c *Checker) checkVars(n *a.Node, p TypeMap) error {
}
func (c *Checker) checkStatement(n *a.Node, p TypeMap) error {
if n == nil {
return nil
}
switch n.Kind {
switch n.Kind() {
case a.KAssert:
if err := c.checkExpr(n.RHS); err != nil {
o := n.Assert()
if err := c.checkExpr(o.Condition()); err != nil {
return err
}
// TODO: check that n.RHS has type bool.
// TODO: check that o.Condition() has type bool.
// TODO: check the actual assertion.
return nil
case a.KAssign:
if err := c.checkExpr(n.LHS); err != nil {
o := n.Assign()
if err := c.checkExpr(o.LHS()); err != nil {
return err
}
if err := c.checkExpr(n.RHS); err != nil {
if err := c.checkExpr(o.RHS()); err != nil {
return err
}
// TODO: check that n.RHS.Type is assignable to n.LHS.Type.
// TODO, look at the op (n.ID0).
// TODO: check that o.RHS().Type is assignable to o.LHS().Type.
// TODO, look at o.Operator().
return nil
case a.KVar:
if n.RHS != nil {
if err := c.checkExpr(n.RHS); err != nil {
o := n.Var()
if value := o.Value(); value != nil {
if err := c.checkExpr(value); err != nil {
return err
}
// TODO: check that n.RHS.Type is assignable to n.LHS.
// TODO: check that value.Type is assignable to o.TypeExpr().
}
return nil
case a.KFor:
if err := c.checkExpr(n.LHS); err != nil {
return err
o := n.For()
if cond := o.Condition(); cond != nil {
if err := c.checkExpr(cond); err != nil {
return err
}
// TODO: check cond has type bool.
}
// TODO: check n.LHS has type bool.
for _, m := range n.List2 {
for _, m := range o.Body() {
if err := c.checkStatement(m, p); err != nil {
return err
}
@@ -237,17 +221,17 @@ func (c *Checker) checkStatement(n *a.Node, p TypeMap) error {
return nil
case a.KIf:
for ; n != nil; n = n.RHS {
if err := c.checkExpr(n.LHS); err != nil {
for o := n.If(); o != nil; o = o.ElseIf() {
if err := c.checkExpr(o.Condition()); err != nil {
return err
}
// TODO: check n.LHS has type bool.
for _, m := range n.List1 {
// TODO: check o.Condition() has type bool.
for _, m := range o.BodyIfTrue() {
if err := c.checkStatement(m, p); err != nil {
return err
}
}
for _, m := range n.List2 {
for _, m := range o.BodyIfFalse() {
if err := c.checkStatement(m, p); err != nil {
return err
}
@@ -256,11 +240,14 @@ func (c *Checker) checkStatement(n *a.Node, p TypeMap) error {
return nil
case a.KReturn:
if err := c.checkExpr(n.LHS); err != nil {
return err
o := n.Return()
if value := o.Value(); value != nil {
if err := c.checkExpr(value); 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.
}
// 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:
@@ -272,17 +259,11 @@ func (c *Checker) checkStatement(n *a.Node, p TypeMap) error {
return nil
}
return fmt.Errorf("check: unrecognized ast.Kind (%d) for checkStatement", n.Kind)
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) {
func (c *Checker) checkExpr(n *a.Expr) error {
switch n.ID0().Flags() & (t.FlagsUnaryOp | t.FlagsBinaryOp | t.FlagsAssociativeOp) {
case 0:
return c.checkExprOther(n)
case t.FlagsUnaryOp:
@@ -292,15 +273,15 @@ func (c *Checker) checkExpr(n *a.Node) error {
case t.FlagsAssociativeOp:
return c.checkExprAssociativeOp(n)
}
return fmt.Errorf("check: unrecognized token.Key (0x%X) for checkExpr", n.ID0.Key())
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 {
func (c *Checker) checkExprOther(n *a.Expr) error {
switch n.ID0() {
case 0:
// n is an identifier or a literal.
if n.ID1.IsNumLiteral() {
n.Type = DummyTypeIdealNumber
if n.ID1().IsNumLiteral() {
n.SetMType(DummyTypeIdealNumber)
return nil
}
// TODO.
@@ -321,89 +302,81 @@ func (c *Checker) checkExprOther(n *a.Node) error {
// n is a selector.
// TODO.
}
return fmt.Errorf("check: unrecognized token.Key (0x%X) for checkExprOther", n.ID0.Key())
return fmt.Errorf("check: unrecognized token.Key (0x%X) for checkExprOther", n.ID0().Key())
}
func (c *Checker) checkExprUnaryOp(n *a.Node) error {
func (c *Checker) checkExprUnaryOp(n *a.Expr) error {
// TODO.
return fmt.Errorf("check: unrecognized token.Key (0x%X) for checkExprUnaryOp", n.ID0.Key())
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 {
func (c *Checker) checkExprBinaryOp(n *a.Expr) error {
if err := c.checkExpr(n.LHS().Expr()); err != nil {
return err
}
if n.ID0 == t.IDXBinaryAs {
if err := c.checkType(n.RHS); err != nil {
if n.ID0() == t.IDXBinaryAs {
lhs := n.LHS().Expr()
rhs := n.RHS().TypeExpr()
if err := c.checkTypeExpr(rhs); err != nil {
return err
}
if err := c.typeConvertible(n.LHS, n.RHS); err != nil {
if err := c.typeConvertible(lhs, rhs); err != nil {
return err
}
n.Type = n.RHS
n.SetMType(rhs)
return nil
}
if err := c.checkExpr(n.RHS); err != nil {
if err := c.checkExpr(n.RHS().Expr()); err != nil {
return err
}
// TODO.
return fmt.Errorf("check: unrecognized token.Key (0x%X) for checkExprBinaryOp", n.ID0.Key())
// TODO: check lhs and rhs have compatible types, then call n.SetMType.
// TODO: other checks.
return fmt.Errorf("check: unrecognized token.Key (0x%X) for checkExprBinaryOp", n.ID0().Key())
}
func (c *Checker) checkExprAssociativeOp(n *a.Node) error {
func (c *Checker) checkExprAssociativeOp(n *a.Expr) error {
// TODO.
return fmt.Errorf("check: unrecognized token.Key (0x%X) for checkExprAssociativeOp", n.ID0.Key())
return fmt.Errorf("check: unrecognized token.Key (0x%X) for checkExprAssociativeOp", n.ID0().Key())
}
func (c *Checker) checkType(n *a.Node) error {
func (c *Checker) checkTypeExpr(n *a.TypeExpr) error {
for n != nil {
if n.Kind != a.KType {
return fmt.Errorf("check: unexpected ast.Kind (%d) for checkType", n.Kind)
}
switch n.ID0 {
switch n.PackageOrDecorator() {
case 0:
if n.ID1.IsNumType() || n.ID1 == t.IDBool {
n.Type = DummyTypeType
name := n.Name()
if name.IsNumType() || name == t.IDBool {
return nil
}
// TODO: see if n.ID1 refers to a struct type.
return fmt.Errorf("check: %q is not a type", c.idMap.ByID(n.ID1))
// TODO: see if name refers to a struct type.
return fmt.Errorf("check: %q is not a type", c.idMap.ByID(name))
case t.IDPtr:
n = n.RHS
n = n.RHS().TypeExpr()
case t.IDOpenBracket:
// TODO.
fallthrough
default:
return fmt.Errorf("check: unrecognized node for checkType")
return fmt.Errorf("check: unrecognized node for checkTypeExpr")
}
}
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
func (c *Checker) typeConvertible(e *a.Expr, typ *a.TypeExpr) error {
if typ.PackageOrDecorator() == 0 {
if name := typ.Name(); name.IsBuiltIn() && name.IsNumType() {
if minMax := numTypeRanges[0xFF&(name>>t.KeyShift)]; minMax[0] != nil {
if e.MType() == 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)
return fmt.Errorf("check: typeConvertible: cannot convert expression %v to type %v", e, typ)
}
var numTypeRanges = [256][2]*big.Int{
+16 -15
View File
@@ -29,12 +29,12 @@ func TestCheck(t *testing.T) {
t.Fatalf("Tokenize: %v", err)
}
node, err := parse.Parse(idMap, filename, tokens)
file, err := parse.Parse(idMap, filename, tokens)
if err != nil {
t.Fatalf("Parse: %v", err)
}
c, err := Check(idMap, node)
c, err := Check(idMap, file)
if err != nil {
t.Fatalf("Check: %v", err)
}
@@ -72,32 +72,33 @@ func TestCheck(t *testing.T) {
t.Fatalf("\ngot %v\nwant %v", got, want)
}
walk(node, func(n *ast.Node) error {
if n.Kind == ast.KExpr && n.Type == nil {
t.Errorf("expression node has no type: n=%v", n)
walk(file.Node(), func(n *ast.Node) error {
if n.Kind() == ast.KExpr && n.Expr().MType() == nil {
t.Errorf("expression node has no (implicit) type: n=%v", n)
}
return nil
})
}
func walk(n *ast.Node, f func(*ast.Node) error) error {
if n == nil {
return nil
}
if err := f(n); err != nil {
return err
}
for _, m := range [...]*ast.Node{n.LHS, n.MHS, n.RHS} {
if err := walk(m, f); err != nil {
return err
}
}
for _, l := range [...][]*ast.Node{n.List0, n.List1, n.List2} {
for _, m := range l {
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
}
+97 -194
View File
@@ -12,7 +12,7 @@ import (
t "github.com/google/puffs/lang/token"
)
func Parse(m *t.IDMap, filename string, src []t.Token) (*a.Node, error) {
func Parse(m *t.IDMap, filename string, src []t.Token) (*a.File, error) {
p := &parser{
src: src,
m: m,
@@ -45,20 +45,16 @@ func (p *parser) peekID() t.ID {
return 0
}
func (p *parser) parseFile() (*a.Node, error) {
decls := []*a.Node(nil)
func (p *parser) parseFile() (*a.File, error) {
topLevelDecls := []*a.Node(nil)
for len(p.src) > 0 {
d, err := p.parseTopLevelDecl()
if err != nil {
return nil, err
}
decls = append(decls, d)
topLevelDecls = append(topLevelDecls, d)
}
return &a.Node{
Kind: a.KFile,
Filename: p.filename,
List0: decls,
}, nil
return a.NewFile(p.filename, topLevelDecls), nil
}
func (p *parser) parseTopLevelDecl() (*a.Node, error) {
@@ -75,15 +71,15 @@ func (p *parser) parseTopLevelDecl() (*a.Node, error) {
flags |= a.FlagsSuspendible
p.src = p.src[1:]
}
inParams, err := p.parseList((*parser).parseParam)
inParams, err := p.parseList((*parser).parseParamNode)
if err != nil {
return nil, err
}
outParams, err := p.parseList((*parser).parseParam)
outParams, err := p.parseList((*parser).parseParamNode)
if err != nil {
return nil, err
}
block, err := p.parseBlock()
body, err := p.parseBlock()
if err != nil {
return nil, err
}
@@ -92,22 +88,12 @@ func (p *parser) parseTopLevelDecl() (*a.Node, error) {
return nil, fmt.Errorf("parse: expected (implicit) \";\", got %q at %s:%d", got, p.filename, p.line())
}
p.src = p.src[1:]
return &a.Node{
Kind: a.KFunc,
Flags: flags,
Filename: p.filename,
Line: line,
ID0: id0,
ID1: id1,
List0: inParams,
List1: outParams,
List2: block,
}, nil
return a.NewFunc(flags, p.filename, line, id0, id1, inParams, outParams, body).Node(), nil
case t.IDStruct:
flags := a.Flags(0)
p.src = p.src[1:]
id1, err := p.parseIdent()
name, err := p.parseIdent()
if err != nil {
return nil, err
}
@@ -115,7 +101,7 @@ func (p *parser) parseTopLevelDecl() (*a.Node, error) {
flags |= a.FlagsSuspendible
p.src = p.src[1:]
}
list0, err := p.parseList((*parser).parseParam)
fields, err := p.parseList((*parser).parseParamNode)
if err != nil {
return nil, err
}
@@ -124,20 +110,13 @@ func (p *parser) parseTopLevelDecl() (*a.Node, error) {
return nil, fmt.Errorf("parse: expected (implicit) \";\", got %q at %s:%d", got, p.filename, p.line())
}
p.src = p.src[1:]
return &a.Node{
Kind: a.KStruct,
Flags: flags,
Filename: p.filename,
Line: line,
ID1: id1,
List0: list0,
}, nil
return a.NewStruct(flags, p.filename, line, name, fields).Node(), nil
case t.IDUse:
p.src = p.src[1:]
id1 := p.peekID()
if !id1.IsStrLiteral() {
got := p.m.ByID(id1)
path := p.peekID()
if !path.IsStrLiteral() {
got := p.m.ByID(path)
return nil, fmt.Errorf("parse: expected string literal, got %q at %s:%d", got, p.filename, p.line())
}
p.src = p.src[1:]
@@ -146,12 +125,7 @@ func (p *parser) parseTopLevelDecl() (*a.Node, error) {
return nil, fmt.Errorf("parse: expected (implicit) \";\", got %q at %s:%d", got, p.filename, p.line())
}
p.src = p.src[1:]
return &a.Node{
Kind: a.KUse,
Filename: p.filename,
Line: line,
ID1: id1,
}, nil
return a.NewUse(p.filename, line, path).Node(), nil
}
return nil, fmt.Errorf("parse: unrecognized top level declaration at %s:%d", p.filename, p.src[0].Line)
@@ -189,7 +163,7 @@ func (p *parser) parseIdent() (t.ID, error) {
return x.ID, nil
}
func (p *parser) parseList(parseFunc func(*parser) (*a.Node, error)) ([]*a.Node, error) {
func (p *parser) parseList(parseElem func(*parser) (*a.Node, error)) ([]*a.Node, error) {
if x := p.peekID(); x != t.IDOpenParen {
got := p.m.ByID(x)
return nil, fmt.Errorf("parse: expected \"(\", got %q at %s:%d", got, p.filename, p.line())
@@ -203,7 +177,7 @@ func (p *parser) parseList(parseFunc func(*parser) (*a.Node, error)) ([]*a.Node,
return ret, nil
}
elem, err := parseFunc(p)
elem, err := parseElem(p)
if err != nil {
return nil, err
}
@@ -223,35 +197,27 @@ func (p *parser) parseList(parseFunc func(*parser) (*a.Node, error)) ([]*a.Node,
return nil, fmt.Errorf("parse: expected \")\" at %s:%d", p.filename, p.line())
}
func (p *parser) parseParam() (*a.Node, error) {
id, err := p.parseIdent()
func (p *parser) parseParamNode() (*a.Node, error) {
name, err := p.parseIdent()
if err != nil {
return nil, err
}
lhs, err := p.parseType()
typ, err := p.parseTypeExpr()
if err != nil {
return nil, err
}
return &a.Node{
Kind: a.KParam,
ID1: id,
LHS: lhs,
}, nil
return a.NewParam(name, typ).Node(), nil
}
func (p *parser) parseType() (*a.Node, error) {
func (p *parser) parseTypeExpr() (*a.TypeExpr, error) {
switch p.peekID() {
case t.IDPtr:
p.src = p.src[1:]
rhs, err := p.parseType()
rhs, err := p.parseTypeExpr()
if err != nil {
return nil, err
}
return &a.Node{
Kind: a.KType,
ID0: t.IDPtr,
RHS: rhs,
}, nil
return a.NewTypeExpr(t.IDPtr, 0, nil, nil, rhs.Node()), nil
}
if x := p.peekID(); x == t.IDOpenBracket {
@@ -265,24 +231,19 @@ func (p *parser) parseType() (*a.Node, error) {
return nil, fmt.Errorf("parse: expected \"]\", got %q at %s:%d", got, p.filename, p.line())
}
p.src = p.src[1:]
rhs, err := p.parseType()
rhs, err := p.parseTypeExpr()
if err != nil {
return nil, err
}
return &a.Node{
Kind: a.KType,
ID0: t.IDOpenBracket,
LHS: lhs,
RHS: rhs,
}, nil
return a.NewTypeExpr(t.IDOpenBracket, 0, lhs.Node(), nil, rhs.Node()), nil
}
id0, id1, err := p.parseQualifiedIdent()
pkg, name, err := p.parseQualifiedIdent()
if err != nil {
return nil, err
}
mhs, rhs := (*a.Node)(nil), (*a.Node)(nil)
mhs, rhs := (*a.Expr)(nil), (*a.Expr)(nil)
if x := p.peekID(); x == t.IDOpenBracket {
_, mhs, rhs, err = p.parseRangeOrIndex(false)
if err != nil {
@@ -290,19 +251,13 @@ func (p *parser) parseType() (*a.Node, error) {
}
}
return &a.Node{
Kind: a.KType,
ID0: id0,
ID1: id1,
MHS: mhs,
RHS: rhs,
}, nil
return a.NewTypeExpr(pkg, name, nil, mhs.Node(), rhs.Node()), nil
}
// parseRangeOrIndex parses "[i:j]", "[i:]", "[:j]" and "[:]". If allowIndex,
// it also parses "[x]". The returned op is t.IDColon for a range and
// t.IDOpenBracket for an index.
func (p *parser) parseRangeOrIndex(allowIndex bool) (op t.ID, mhs *a.Node, rhs *a.Node, err error) {
func (p *parser) parseRangeOrIndex(allowIndex bool) (op t.ID, mhs *a.Expr, rhs *a.Expr, err error) {
if x := p.peekID(); x != t.IDOpenBracket {
got := p.m.ByID(x)
return 0, nil, nil, fmt.Errorf("parse: expected \"[\", got %q at %s:%d", got, p.filename, p.line())
@@ -385,8 +340,7 @@ func (p *parser) parseStatement() (*a.Node, error) {
}
n, err := p.parseStatement1()
if n != nil {
n.Filename = p.filename
n.Line = line
n.Raw().SetFilenameLine(p.filename, line)
}
return n, err
}
@@ -399,58 +353,45 @@ func (p *parser) parseStatement1() (*a.Node, error) {
if err != nil {
return nil, err
}
return &a.Node{
Kind: a.KAssert,
RHS: rhs,
}, nil
return a.NewAssert(rhs).Node(), nil
case t.IDBreak:
p.src = p.src[1:]
return &a.Node{
Kind: a.KBreak,
}, nil
return a.NewBreak().Node(), nil
case t.IDContinue:
p.src = p.src[1:]
return &a.Node{
Kind: a.KContinue,
}, nil
return a.NewContinue().Node(), nil
case t.IDFor:
p.src = p.src[1:]
lhs, err := (*a.Node)(nil), error(nil)
condition, err := (*a.Expr)(nil), error(nil)
if p.peekID() != t.IDOpenCurly {
lhs, err = p.parseExpr()
condition, err = p.parseExpr()
if err != nil {
return nil, err
}
}
block, err := p.parseBlock()
body, err := p.parseBlock()
if err != nil {
return nil, err
}
return &a.Node{
Kind: a.KFor,
LHS: lhs,
List2: block,
}, nil
return a.NewFor(condition, body).Node(), nil
case t.IDIf:
return p.parseIf()
o, err := p.parseIf()
return o.Node(), err
case t.IDReturn:
p.src = p.src[1:]
lhs, err := (*a.Node)(nil), error(nil)
value, err := (*a.Expr)(nil), error(nil)
if p.peekID() != t.IDSemicolon {
lhs, err = p.parseExpr()
value, err = p.parseExpr()
if err != nil {
return nil, err
}
}
return &a.Node{
Kind: a.KReturn,
LHS: lhs,
}, nil
return a.NewReturn(value).Node(), nil
case t.IDVar:
p.src = p.src[1:]
@@ -458,24 +399,19 @@ func (p *parser) parseStatement1() (*a.Node, error) {
if err != nil {
return nil, err
}
lhs, err := p.parseType()
typ, err := p.parseTypeExpr()
if err != nil {
return nil, err
}
rhs := (*a.Node)(nil)
value := (*a.Expr)(nil)
if p.peekID() == t.IDEq {
p.src = p.src[1:]
rhs, err = p.parseExpr()
value, err = p.parseExpr()
if err != nil {
return nil, err
}
}
return &a.Node{
Kind: a.KVar,
ID1: id,
LHS: lhs,
RHS: rhs,
}, nil
return a.NewVar(id, typ, value).Node(), nil
}
lhs, err := p.parseExpr()
@@ -489,107 +425,98 @@ func (p *parser) parseStatement1() (*a.Node, error) {
if err != nil {
return nil, err
}
return &a.Node{
Kind: a.KAssign,
ID0: op,
LHS: lhs,
RHS: rhs,
}, nil
return a.NewAssign(op, lhs, rhs).Node(), nil
}
return lhs, nil
return lhs.Node(), nil
}
func (p *parser) parseIf() (*a.Node, error) {
func (p *parser) parseIf() (*a.If, error) {
if x := p.peekID(); x != t.IDIf {
got := p.m.ByID(x)
return nil, fmt.Errorf("parse: expected \"if\", got %q at %s:%d", got, p.filename, p.line())
}
p.src = p.src[1:]
lhs, err := p.parseExpr()
condition, err := p.parseExpr()
if err != nil {
return nil, err
}
list1, err := p.parseBlock()
bodyIfTrue, err := p.parseBlock()
if err != nil {
return nil, err
}
rhs, list2 := (*a.Node)(nil), ([]*a.Node)(nil)
elseIf, bodyIfFalse := (*a.If)(nil), ([]*a.Node)(nil)
if p.peekID() == t.IDElse {
p.src = p.src[1:]
if p.peekID() == t.IDIf {
rhs, err = p.parseIf()
elseIf, err = p.parseIf()
if err != nil {
return nil, err
}
} else {
list2, err = p.parseBlock()
bodyIfFalse, err = p.parseBlock()
if err != nil {
return nil, err
}
}
}
return &a.Node{
Kind: a.KIf,
LHS: lhs,
RHS: rhs,
List1: list1,
List2: list2,
}, nil
return a.NewIf(condition, elseIf, bodyIfTrue, bodyIfFalse), nil
}
func (p *parser) parseExpr() (*a.Node, error) {
func (p *parser) parseExprNode() (*a.Node, error) {
n, err := p.parseExpr()
return n.Node(), err
}
func (p *parser) parseExpr() (*a.Expr, error) {
lhs, err := p.parseOperand()
if err != nil {
return nil, err
}
if x := p.peekID(); x.IsBinaryOp() {
p.src = p.src[1:]
parseFunc := (*parser).parseOperand
rhs := (*a.Node)(nil)
if x == t.IDAs {
parseFunc = (*parser).parseType
}
rhs, err := parseFunc(p)
if err != nil {
return nil, err
o, err := p.parseTypeExpr()
if err != nil {
return nil, err
}
rhs = o.Node()
} else {
o, err := p.parseOperand()
if err != nil {
return nil, err
}
rhs = o.Node()
}
if !x.IsAssociativeOp() || x != p.peekID() {
id0 := x.BinaryForm()
if id0 == 0 {
op := x.BinaryForm()
if op == 0 {
return nil, fmt.Errorf("parse: internal error: no binary form for token.Key 0x%#02x", x.Key())
}
return &a.Node{
Kind: a.KExpr,
ID0: id0,
LHS: lhs,
RHS: rhs,
}, nil
return a.NewExpr(0, op, 0, lhs.Node(), nil, rhs, nil), nil
}
list0 := []*a.Node{lhs, rhs}
args := []*a.Node{lhs.Node(), rhs}
for p.peekID() == x {
p.src = p.src[1:]
arg, err := p.parseOperand()
if err != nil {
return nil, err
}
list0 = append(list0, arg)
args = append(args, arg.Node())
}
id0 := x.AssociativeForm()
if id0 == 0 {
op := x.AssociativeForm()
if op == 0 {
return nil, fmt.Errorf("parse: internal error: no associative form for token.Key 0x%#02x", x.Key())
}
return &a.Node{
Kind: a.KExpr,
ID0: id0,
List0: list0,
}, nil
return a.NewExpr(0, op, 0, nil, nil, nil, args), nil
}
return lhs, nil
}
func (p *parser) parseOperand() (*a.Node, error) {
func (p *parser) parseOperand() (*a.Expr, error) {
switch x := p.peekID(); {
case x == t.IDOpenParen:
p.src = p.src[1:]
@@ -610,32 +537,22 @@ func (p *parser) parseOperand() (*a.Node, error) {
if err != nil {
return nil, err
}
id0 := x.UnaryForm()
if id0 == 0 {
op := x.UnaryForm()
if op == 0 {
return nil, fmt.Errorf("parse: internal error: no unary form for token.Key 0x%#02x", x.Key())
}
return &a.Node{
Kind: a.KExpr,
ID0: id0,
RHS: rhs,
}, nil
return a.NewExpr(0, op, 0, nil, nil, rhs.Node(), nil), nil
case x.IsLiteral():
p.src = p.src[1:]
return &a.Node{
Kind: a.KExpr,
ID1: x,
}, nil
return a.NewExpr(0, 0, x, nil, nil, nil, nil), nil
}
id, err := p.parseIdent()
if err != nil {
return nil, err
}
lhs := &a.Node{
Kind: a.KExpr,
ID1: id,
}
lhs := a.NewExpr(0, 0, id, nil, nil, nil, nil)
for {
flags := a.Flags(0)
@@ -649,43 +566,29 @@ func (p *parser) parseOperand() (*a.Node, error) {
fallthrough
case t.IDOpenParen:
list0, err := p.parseList((*parser).parseExpr)
args, err := p.parseList(func(p *parser) (*a.Node, error) {
n, err := p.parseExpr()
return n.Node(), err
})
if err != nil {
return nil, err
}
lhs = &a.Node{
Kind: a.KExpr,
Flags: flags,
ID0: t.IDOpenParen,
LHS: lhs,
List0: list0,
}
return a.NewExpr(flags, t.IDOpenParen, 0, lhs.Node(), nil, nil, args), nil
case t.IDOpenBracket:
id0, mhs, rhs, err := p.parseRangeOrIndex(true)
if err != nil {
return nil, err
}
lhs = &a.Node{
Kind: a.KExpr,
ID0: id0,
LHS: lhs,
MHS: mhs,
RHS: rhs,
}
lhs = a.NewExpr(0, id0, 0, lhs.Node(), mhs.Node(), rhs.Node(), nil)
case t.IDDot:
p.src = p.src[1:]
id, err := p.parseIdent()
selector, err := p.parseIdent()
if err != nil {
return nil, err
}
lhs = &a.Node{
Kind: a.KExpr,
ID0: t.IDDot,
ID1: id,
LHS: lhs,
}
lhs = a.NewExpr(0, t.IDDot, selector, lhs.Node(), nil, nil, nil)
}
}
}