diff --git a/lang/ast/ast.go b/lang/ast/ast.go index 7dcdbe15..5182a77e 100644 --- a/lang/ast/ast.go +++ b/lang/ast/ast.go @@ -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: // - MHS: - // - RHS: + // - RHS: // - List0: 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: + // - LHS: // - RHS: KVar // KParam is a "name type" parameter: // - ID1: name - // - LHS: + // - LHS: 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: // - MHS: - // - RHS: + // - RHS: // - // 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, + } } diff --git a/lang/check/check.go b/lang/check/check.go index 36f5f8fd..c4cfee76 100644 --- a/lang/check/check.go +++ b/lang/check/check.go @@ -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{ diff --git a/lang/check/check_test.go b/lang/check/check_test.go index 60d52438..f2fa11ae 100644 --- a/lang/check/check_test.go +++ b/lang/check/check_test.go @@ -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 } diff --git a/lang/parse/parse.go b/lang/parse/parse.go index b69fc18b..2a39044c 100644 --- a/lang/parse/parse.go +++ b/lang/parse/parse.go @@ -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) } } }