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,
}
}