mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 08:32:11 +01:00
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:
1 parent
54567dbd47
commit
e1c890907e
4 files changed
+565
-395
No files matched your search
+317
-24
@@ -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
@@ -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
@@ -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
@@ -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)
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user