mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-18 08:32:11 +01:00
Rename ast.Node methods from Foo to AsFoo
This commit is contained in:
1 parent
12773ce74a
commit
ccb78f5db7
21 files changed
+461
-458
No files matched your search
@@ -28,8 +28,8 @@ func (g *gen) writeBuiltinCall(b *buffer, n *a.Expr, rp replacementPolicy, depth
|
||||
if n.Operator() != t.IDOpenParen {
|
||||
return errNoSuchBuiltin
|
||||
}
|
||||
method := n.LHS().Expr()
|
||||
recv := method.LHS().Expr()
|
||||
method := n.LHS().AsExpr()
|
||||
recv := method.LHS().AsExpr()
|
||||
recvTyp := recv.MType()
|
||||
|
||||
switch recvTyp.Decorator() {
|
||||
@@ -44,7 +44,7 @@ func (g *gen) writeBuiltinCall(b *buffer, n *a.Expr, rp replacementPolicy, depth
|
||||
b.printf("wuffs_base__image_config__initialize(a_dst")
|
||||
for _, o := range n.Args() {
|
||||
b.writeb(',')
|
||||
if err := g.writeExpr(b, o.Arg().Value(), rp, depth); err != nil {
|
||||
if err := g.writeExpr(b, o.AsArg().Value(), rp, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
@@ -142,7 +142,7 @@ func (g *gen) writeBuiltinIOReader(b *buffer, recv *a.Expr, method t.ID, args []
|
||||
// call (to a static inline function) instead of a struct literal, to
|
||||
// avoid a "expression result unused" compiler error.
|
||||
b.writes("(ioptr_src += ")
|
||||
if err := g.writeExpr(b, args[1].Arg().Value(), rp, depth); err != nil {
|
||||
if err := g.writeExpr(b, args[1].AsArg().Value(), rp, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
b.writes(", wuffs_base__return_empty_struct())")
|
||||
@@ -175,7 +175,7 @@ func (g *gen) writeBuiltinIOWriter(b *buffer, recv *a.Expr, method t.ID, args []
|
||||
bco, aPrefix)
|
||||
for _, o := range args {
|
||||
b.writeb(',')
|
||||
if err := g.writeExpr(b, o.Arg().Value(), rp, depth); err != nil {
|
||||
if err := g.writeExpr(b, o.AsArg().Value(), rp, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
@@ -224,7 +224,7 @@ func (g *gen) writeBuiltinNumType(b *buffer, recv *a.Expr, method t.ID, args []*
|
||||
return err
|
||||
}
|
||||
b.writes(") & ((1 << (")
|
||||
if err := g.writeExpr(b, args[0].Arg().Value(), rp, depth); err != nil {
|
||||
if err := g.writeExpr(b, args[0].AsArg().Value(), rp, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
b.writes(")) - 1))")
|
||||
@@ -243,7 +243,7 @@ func (g *gen) writeBuiltinNumType(b *buffer, recv *a.Expr, method t.ID, args []*
|
||||
b.printf("%d", 8*sz)
|
||||
}
|
||||
b.writes(" - (")
|
||||
if err := g.writeExpr(b, args[0].Arg().Value(), rp, depth); err != nil {
|
||||
if err := g.writeExpr(b, args[0].AsArg().Value(), rp, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
b.writes(")))")
|
||||
@@ -261,7 +261,7 @@ func (g *gen) writeBuiltinNumType(b *buffer, recv *a.Expr, method t.ID, args []*
|
||||
return err
|
||||
}
|
||||
b.writes(",")
|
||||
if err := g.writeExpr(b, args[0].Arg().Value(), rp, depth); err != nil {
|
||||
if err := g.writeExpr(b, args[0].AsArg().Value(), rp, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
b.writes(")")
|
||||
@@ -279,7 +279,7 @@ func (g *gen) writeBuiltinNumType(b *buffer, recv *a.Expr, method t.ID, args []*
|
||||
return err
|
||||
}
|
||||
b.writes(",")
|
||||
if err := g.writeExpr(b, args[0].Arg().Value(), rp, depth); err != nil {
|
||||
if err := g.writeExpr(b, args[0].AsArg().Value(), rp, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
b.writes(")")
|
||||
@@ -376,7 +376,7 @@ func (g *gen) writeArgs(b *buffer, args []*a.Node, rp replacementPolicy, depth u
|
||||
if i > 0 {
|
||||
b.writeb(',')
|
||||
}
|
||||
if err := g.writeExpr(b, o.Arg().Value(), rp, depth); err != nil {
|
||||
if err := g.writeExpr(b, o.AsArg().Value(), rp, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
@@ -389,8 +389,8 @@ func (g *gen) writeBuiltinCallSuspendibles(b *buffer, n *a.Expr, depth uint32) e
|
||||
if n.Operator() != t.IDOpenParen {
|
||||
return errNoSuchBuiltin
|
||||
}
|
||||
method := n.LHS().Expr()
|
||||
recv := method.LHS().Expr()
|
||||
method := n.LHS().AsExpr()
|
||||
recv := method.LHS().AsExpr()
|
||||
recvTyp := recv.MType()
|
||||
if !recvTyp.IsIOType() {
|
||||
return errNoSuchBuiltin
|
||||
@@ -459,7 +459,7 @@ func (g *gen) writeBuiltinCallSuspendibles(b *buffer, n *a.Expr, depth uint32) e
|
||||
cPrefix, g.currFunk.astFunc.FuncName().Str(g.tm))
|
||||
|
||||
b.printf("%s = ", scratchName)
|
||||
x := n.Args()[0].Arg().Value()
|
||||
x := n.Args()[0].AsArg().Value()
|
||||
if err := g.writeExpr(b, x, replaceCallSuspendibles, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -488,7 +488,7 @@ func (g *gen) writeBuiltinCallSuspendibles(b *buffer, n *a.Expr, depth uint32) e
|
||||
}
|
||||
|
||||
b.printf("*ioptr_dst++ = ")
|
||||
x := n.Args()[0].Arg().Value()
|
||||
x := n.Args()[0].AsArg().Value()
|
||||
if err := g.writeExpr(b, x, replaceCallSuspendibles, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
@@ -283,7 +283,7 @@ func (g *gen) generate() ([]byte, error) {
|
||||
for _, file := range g.files {
|
||||
for _, tld := range file.TopLevelDecls() {
|
||||
if tld.Kind() == a.KStruct {
|
||||
unsortedStructs = append(unsortedStructs, tld.Struct())
|
||||
unsortedStructs = append(unsortedStructs, tld.AsStruct())
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -453,11 +453,11 @@ func (g *gen) forEachConst(b *buffer, v visibility, f func(*gen, *buffer, *a.Con
|
||||
for _, file := range g.files {
|
||||
for _, tld := range file.TopLevelDecls() {
|
||||
if tld.Kind() != a.KConst ||
|
||||
(v == pubOnly && tld.Raw().Flags()&a.FlagsPublic == 0) ||
|
||||
(v == priOnly && tld.Raw().Flags()&a.FlagsPublic != 0) {
|
||||
(v == pubOnly && tld.AsRaw().Flags()&a.FlagsPublic == 0) ||
|
||||
(v == priOnly && tld.AsRaw().Flags()&a.FlagsPublic != 0) {
|
||||
continue
|
||||
}
|
||||
if err := f(g, b, tld.Const()); err != nil {
|
||||
if err := f(g, b, tld.AsConst()); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
@@ -469,11 +469,11 @@ func (g *gen) forEachFunc(b *buffer, v visibility, f func(*gen, *buffer, *a.Func
|
||||
for _, file := range g.files {
|
||||
for _, tld := range file.TopLevelDecls() {
|
||||
if tld.Kind() != a.KFunc ||
|
||||
(v == pubOnly && tld.Raw().Flags()&a.FlagsPublic == 0) ||
|
||||
(v == priOnly && tld.Raw().Flags()&a.FlagsPublic != 0) {
|
||||
(v == pubOnly && tld.AsRaw().Flags()&a.FlagsPublic == 0) ||
|
||||
(v == priOnly && tld.AsRaw().Flags()&a.FlagsPublic != 0) {
|
||||
continue
|
||||
}
|
||||
if err := f(g, b, tld.Func()); err != nil {
|
||||
if err := f(g, b, tld.AsFunc()); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
@@ -485,11 +485,11 @@ func (g *gen) forEachStatus(b *buffer, v visibility, f func(*gen, *buffer, *a.St
|
||||
for _, file := range g.files {
|
||||
for _, tld := range file.TopLevelDecls() {
|
||||
if tld.Kind() != a.KStatus ||
|
||||
(v == pubOnly && tld.Raw().Flags()&a.FlagsPublic == 0) ||
|
||||
(v == priOnly && tld.Raw().Flags()&a.FlagsPublic != 0) {
|
||||
(v == pubOnly && tld.AsRaw().Flags()&a.FlagsPublic == 0) ||
|
||||
(v == priOnly && tld.AsRaw().Flags()&a.FlagsPublic != 0) {
|
||||
continue
|
||||
}
|
||||
if err := f(g, b, tld.Status()); err != nil {
|
||||
if err := f(g, b, tld.AsStatus()); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
@@ -503,7 +503,7 @@ func (g *gen) forEachUse(b *buffer, f func(*gen, *buffer, *a.Use) error) error {
|
||||
if tld.Kind() != a.KUse {
|
||||
continue
|
||||
}
|
||||
if err := f(g, b, tld.Use()); err != nil {
|
||||
if err := f(g, b, tld.AsUse()); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
@@ -606,7 +606,7 @@ func (g *gen) writeConstList(b *buffer, n *a.Expr) error {
|
||||
if n.Operator() == t.IDDollar {
|
||||
b.writeb('{')
|
||||
for _, o := range n.Args() {
|
||||
if err := g.writeConstList(b, o.Expr()); err != nil {
|
||||
if err := g.writeConstList(b, o.AsExpr()); err != nil {
|
||||
return err
|
||||
}
|
||||
b.writeb(',')
|
||||
@@ -643,7 +643,7 @@ func (g *gen) writeStruct(b *buffer, n *a.Struct) error {
|
||||
}
|
||||
|
||||
for _, o := range n.Fields() {
|
||||
o := o.Field()
|
||||
o := o.AsField()
|
||||
if err := g.writeCTypeName(b, o.XType(), fPrefix, o.Name().Str(g.tm)); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -657,7 +657,7 @@ func (g *gen) writeStruct(b *buffer, n *a.Struct) error {
|
||||
if tld.Kind() != a.KFunc {
|
||||
continue
|
||||
}
|
||||
o := tld.Func()
|
||||
o := tld.AsFunc()
|
||||
if o.Receiver() != n.QID() || !o.Suspendible() {
|
||||
continue
|
||||
}
|
||||
@@ -683,7 +683,7 @@ func (g *gen) writeStruct(b *buffer, n *a.Struct) error {
|
||||
}
|
||||
b.writes("} private_impl;\n\n")
|
||||
|
||||
if n.Node().Raw().Flags()&a.FlagsPublic != 0 {
|
||||
if n.AsNode().AsRaw().Flags()&a.FlagsPublic != 0 {
|
||||
if err := g.writeCppPrototypes(b, n); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -700,10 +700,10 @@ func (g *gen) writeCppPrototypes(b *buffer, n *a.Struct) error {
|
||||
structID := n.QID()[1]
|
||||
for _, file := range g.files {
|
||||
for _, tld := range file.TopLevelDecls() {
|
||||
if (tld.Kind() != a.KFunc) || (tld.Raw().Flags()&a.FlagsPublic == 0) {
|
||||
if (tld.Kind() != a.KFunc) || (tld.AsRaw().Flags()&a.FlagsPublic == 0) {
|
||||
continue
|
||||
}
|
||||
f := tld.Func()
|
||||
f := tld.AsFunc()
|
||||
qqid := f.QQID()
|
||||
if qqid[1] != structID {
|
||||
continue
|
||||
@@ -727,10 +727,10 @@ func (g *gen) writeCppImpls(b *buffer) error {
|
||||
|
||||
for _, file := range g.files {
|
||||
for _, tld := range file.TopLevelDecls() {
|
||||
if (tld.Kind() != a.KStruct) || (tld.Raw().Flags()&a.FlagsPublic == 0) {
|
||||
if (tld.Kind() != a.KStruct) || (tld.AsRaw().Flags()&a.FlagsPublic == 0) {
|
||||
continue
|
||||
}
|
||||
n := tld.Struct()
|
||||
n := tld.AsStruct()
|
||||
|
||||
structID := n.QID()[1]
|
||||
structName := structID.Str(g.tm)
|
||||
@@ -746,10 +746,10 @@ func (g *gen) writeCppImpls(b *buffer) error {
|
||||
|
||||
for _, file := range g.files {
|
||||
for _, tld := range file.TopLevelDecls() {
|
||||
if (tld.Kind() != a.KFunc) || (tld.Raw().Flags()&a.FlagsPublic == 0) {
|
||||
if (tld.Kind() != a.KFunc) || (tld.AsRaw().Flags()&a.FlagsPublic == 0) {
|
||||
continue
|
||||
}
|
||||
n := tld.Func()
|
||||
n := tld.AsFunc()
|
||||
if !publicStructs[n.QQID()[1]] {
|
||||
continue
|
||||
}
|
||||
@@ -763,7 +763,7 @@ func (g *gen) writeCppImpls(b *buffer) error {
|
||||
for _, o := range n.In().Fields() {
|
||||
b.writeb(',')
|
||||
b.writes(aPrefix)
|
||||
b.writes(o.Field().Name().Str(g.tm))
|
||||
b.writes(o.AsField().Name().Str(g.tm))
|
||||
}
|
||||
b.writes(");}\n\n")
|
||||
}
|
||||
@@ -880,7 +880,7 @@ func (g *gen) writeInitializerImpl(b *buffer, n *a.Struct) error {
|
||||
|
||||
// Call any ctors on sub-structs.
|
||||
for _, f := range n.Fields() {
|
||||
f := f.Field()
|
||||
f := f.AsField()
|
||||
x := f.XType()
|
||||
if x != x.Innermost() {
|
||||
// TODO: arrays of sub-structs.
|
||||
|
||||
@@ -89,9 +89,9 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, rp replacementPolicy, depth u
|
||||
return err
|
||||
}
|
||||
|
||||
if n.LHS().Expr().Ident() == t.IDReset {
|
||||
method := n.LHS().Expr()
|
||||
recv := method.LHS().Expr()
|
||||
if n.LHS().AsExpr().Ident() == t.IDReset {
|
||||
method := n.LHS().AsExpr()
|
||||
recv := method.LHS().AsExpr()
|
||||
recvTyp, addr := recv.MType(), "&"
|
||||
if recvTyp.Decorator() == t.IDPtr {
|
||||
recvTyp, addr = recvTyp.Inner(), ""
|
||||
@@ -129,15 +129,15 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, rp replacementPolicy, depth u
|
||||
|
||||
case t.IDOpenBracket:
|
||||
// n is an index.
|
||||
if err := g.writeExpr(b, n.LHS().Expr(), rp, depth); err != nil {
|
||||
if err := g.writeExpr(b, n.LHS().AsExpr(), rp, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
if lTyp := n.LHS().Expr().MType(); lTyp.IsSliceType() {
|
||||
if lTyp := n.LHS().AsExpr().MType(); lTyp.IsSliceType() {
|
||||
// TODO: don't assume that the slice is a slice of base.u8.
|
||||
b.writes(".ptr")
|
||||
}
|
||||
b.writeb('[')
|
||||
if err := g.writeExpr(b, n.RHS().Expr(), rp, depth); err != nil {
|
||||
if err := g.writeExpr(b, n.RHS().AsExpr(), rp, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
b.writeb(']')
|
||||
@@ -145,9 +145,9 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, rp replacementPolicy, depth u
|
||||
|
||||
case t.IDColon:
|
||||
// n is a slice.
|
||||
lhs := n.LHS().Expr()
|
||||
mhs := n.MHS().Expr()
|
||||
rhs := n.RHS().Expr()
|
||||
lhs := n.LHS().AsExpr()
|
||||
mhs := n.MHS().AsExpr()
|
||||
rhs := n.RHS().AsExpr()
|
||||
switch {
|
||||
case mhs != nil && rhs == nil:
|
||||
b.writes("wuffs_base__slice_u8__subslice_i(")
|
||||
@@ -187,7 +187,7 @@ func (g *gen) writeExprOther(b *buffer, n *a.Expr, rp replacementPolicy, depth u
|
||||
return nil
|
||||
|
||||
case t.IDDot:
|
||||
lhs := n.LHS().Expr()
|
||||
lhs := n.LHS().AsExpr()
|
||||
if lhs.Ident() == t.IDIn {
|
||||
b.writes(aPrefix)
|
||||
b.writes(n.Ident().Str(g.tm))
|
||||
@@ -230,7 +230,7 @@ func (g *gen) writeExprUnaryOp(b *buffer, n *a.Expr, rp replacementPolicy, depth
|
||||
}
|
||||
|
||||
b.writes(opName)
|
||||
return g.writeExpr(b, n.RHS().Expr(), rp, depth)
|
||||
return g.writeExpr(b, n.RHS().AsExpr(), rp, depth)
|
||||
}
|
||||
|
||||
func (g *gen) writeExprBinaryOp(b *buffer, n *a.Expr, rp replacementPolicy, depth uint32) error {
|
||||
@@ -251,7 +251,7 @@ func (g *gen) writeExprBinaryOp(b *buffer, n *a.Expr, rp replacementPolicy, dept
|
||||
opName = ","
|
||||
|
||||
case t.IDXBinaryAs:
|
||||
return g.writeExprAs(b, n.LHS().Expr(), n.RHS().TypeExpr(), rp, depth)
|
||||
return g.writeExprAs(b, n.LHS().AsExpr(), n.RHS().AsTypeExpr(), rp, depth)
|
||||
|
||||
default:
|
||||
opName = cOpName(op)
|
||||
@@ -261,11 +261,11 @@ func (g *gen) writeExprBinaryOp(b *buffer, n *a.Expr, rp replacementPolicy, dept
|
||||
}
|
||||
|
||||
b.writeb('(')
|
||||
if err := g.writeExpr(b, n.LHS().Expr(), rp, depth); err != nil {
|
||||
if err := g.writeExpr(b, n.LHS().AsExpr(), rp, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
b.writes(opName)
|
||||
if err := g.writeExpr(b, n.RHS().Expr(), rp, depth); err != nil {
|
||||
if err := g.writeExpr(b, n.RHS().AsExpr(), rp, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
b.writeb(')')
|
||||
@@ -299,7 +299,7 @@ func (g *gen) writeExprAssociativeOp(b *buffer, n *a.Expr, rp replacementPolicy,
|
||||
if i != 0 {
|
||||
b.writes(opName)
|
||||
}
|
||||
if err := g.writeExpr(b, o.Expr(), rp, depth); err != nil {
|
||||
if err := g.writeExpr(b, o.AsExpr(), rp, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
@@ -308,8 +308,8 @@ func (g *gen) writeExprAssociativeOp(b *buffer, n *a.Expr, rp replacementPolicy,
|
||||
}
|
||||
|
||||
func (g *gen) writeExprUserDefinedCall(b *buffer, n *a.Expr, rp replacementPolicy, depth uint32) error {
|
||||
method := n.LHS().Expr()
|
||||
recv := method.LHS().Expr()
|
||||
method := n.LHS().AsExpr()
|
||||
recv := method.LHS().AsExpr()
|
||||
recvTyp, addr := recv.MType(), "&"
|
||||
if recvTyp.Decorator() == t.IDPtr {
|
||||
recvTyp, addr = recvTyp.Inner(), ""
|
||||
|
||||
@@ -90,7 +90,7 @@ func (g *gen) writeFuncSignature(b *buffer, n *a.Func, cpp uint32) error {
|
||||
b.writes("void ")
|
||||
} else if len(outFields) == 1 {
|
||||
// TODO: does this generate the right C if the XType is an array?
|
||||
if err := g.writeCTypeName(b, outFields[0].Field().XType(), "", ""); err != nil {
|
||||
if err := g.writeCTypeName(b, outFields[0].AsField().XType(), "", ""); err != nil {
|
||||
return err
|
||||
}
|
||||
} else {
|
||||
@@ -123,7 +123,7 @@ func (g *gen) writeFuncSignature(b *buffer, n *a.Func, cpp uint32) error {
|
||||
b.writeb(',')
|
||||
}
|
||||
comma = true
|
||||
o := o.Field()
|
||||
o := o.AsField()
|
||||
if err := g.writeCTypeName(b, o.XType(), aPrefix, o.Name().Str(g.tm)); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -200,7 +200,7 @@ func (g *gen) writeOutFieldsZeroValue(b *buffer, outFields []*a.Node) error {
|
||||
case 0:
|
||||
// No-op.
|
||||
case 1:
|
||||
if typ := outFields[0].Field().XType(); typ.IsNumType() {
|
||||
if typ := outFields[0].AsField().XType(); typ.IsNumType() {
|
||||
b.writes("0")
|
||||
} else {
|
||||
b.writes("((")
|
||||
@@ -262,7 +262,7 @@ func (g *gen) writeFuncImplHeader(b *buffer) error {
|
||||
if g.currFunk.suspendible {
|
||||
g.findDerivedVars()
|
||||
for _, o := range g.currFunk.astFunc.In().Fields() {
|
||||
o := o.Field()
|
||||
o := o.AsField()
|
||||
if err := g.writeLoadDerivedVar(b, "", o.Name(), o.XType(), true); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -331,7 +331,7 @@ func (g *gen) writeFuncImplFooter(b *buffer) error {
|
||||
b.writes("goto exit;exit:") // The goto avoids the "unused label" warning.
|
||||
|
||||
for _, o := range g.currFunk.astFunc.In().Fields() {
|
||||
o := o.Field()
|
||||
o := o.AsField()
|
||||
if err := g.writeSaveDerivedVar(b, "", o.Name(), o.XType()); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -363,7 +363,7 @@ func (g *gen) writeFuncImplArgChecks(b *buffer, n *a.Func) error {
|
||||
checks := []string(nil)
|
||||
|
||||
for _, o := range n.In().Fields() {
|
||||
o := o.Field()
|
||||
o := o.AsField()
|
||||
oTyp := o.XType()
|
||||
if oTyp.Decorator() != t.IDPtr && !oTyp.IsRefined() {
|
||||
// TODO: Also check elements, for array-typed arguments.
|
||||
|
||||
@@ -43,10 +43,10 @@ func (g *gen) writeStatement(b *buffer, n *a.Node, depth uint32) error {
|
||||
mightIntroduceTemporaries := false
|
||||
switch n.Kind() {
|
||||
case a.KAssign:
|
||||
n := n.Assign()
|
||||
n := n.AsAssign()
|
||||
mightIntroduceTemporaries = n.LHS().Suspendible() || n.RHS().Suspendible()
|
||||
case a.KVar:
|
||||
v := n.Var().Value()
|
||||
v := n.AsVar().Value()
|
||||
mightIntroduceTemporaries = v != nil && v.Suspendible()
|
||||
}
|
||||
if mightIntroduceTemporaries {
|
||||
@@ -59,7 +59,7 @@ func (g *gen) writeStatement(b *buffer, n *a.Node, depth uint32) error {
|
||||
}
|
||||
|
||||
if genFilenameLineComments {
|
||||
filename, line := n.Raw().FilenameLine()
|
||||
filename, line := n.AsRaw().FilenameLine()
|
||||
if i := strings.LastIndexByte(filename, '/'); i >= 0 {
|
||||
filename = filename[i+1:]
|
||||
}
|
||||
@@ -71,23 +71,23 @@ func (g *gen) writeStatement(b *buffer, n *a.Node, depth uint32) error {
|
||||
|
||||
switch n.Kind() {
|
||||
case a.KAssign:
|
||||
return g.writeStatementAssign(b, n.Assign(), depth)
|
||||
return g.writeStatementAssign(b, n.AsAssign(), depth)
|
||||
case a.KExpr:
|
||||
return g.writeStatementExpr(b, n.Expr(), depth)
|
||||
return g.writeStatementExpr(b, n.AsExpr(), depth)
|
||||
case a.KIOBind:
|
||||
return g.writeStatementIOBind(b, n.IOBind(), depth)
|
||||
return g.writeStatementIOBind(b, n.AsIOBind(), depth)
|
||||
case a.KIf:
|
||||
return g.writeStatementIf(b, n.If(), depth)
|
||||
return g.writeStatementIf(b, n.AsIf(), depth)
|
||||
case a.KIterate:
|
||||
return g.writeStatementIterate(b, n.Iterate(), depth)
|
||||
return g.writeStatementIterate(b, n.AsIterate(), depth)
|
||||
case a.KJump:
|
||||
return g.writeStatementJump(b, n.Jump(), depth)
|
||||
return g.writeStatementJump(b, n.AsJump(), depth)
|
||||
case a.KRet:
|
||||
return g.writeStatementRet(b, n.Ret(), depth)
|
||||
return g.writeStatementRet(b, n.AsRet(), depth)
|
||||
case a.KVar:
|
||||
return g.writeStatementVar(b, n.Var(), depth)
|
||||
return g.writeStatementVar(b, n.AsVar(), depth)
|
||||
case a.KWhile:
|
||||
return g.writeStatementWhile(b, n.While(), depth)
|
||||
return g.writeStatementWhile(b, n.AsWhile(), depth)
|
||||
}
|
||||
return fmt.Errorf("unrecognized ast.Kind (%s) for writeStatement", n.Kind())
|
||||
}
|
||||
@@ -164,7 +164,7 @@ func (g *gen) writeStatementIOBind(b *buffer, n *a.IOBind, depth uint32) error {
|
||||
// switch can jump past this initialization??
|
||||
b.writes("{\n")
|
||||
for i := 0; i < len(inFields); i++ {
|
||||
e := inFields[i].Expr()
|
||||
e := inFields[i].AsExpr()
|
||||
prefix := vPrefix
|
||||
if e.Operator() != 0 {
|
||||
prefix = aPrefix
|
||||
@@ -195,7 +195,7 @@ func (g *gen) writeStatementIOBind(b *buffer, n *a.IOBind, depth uint32) error {
|
||||
}
|
||||
|
||||
for i := len(inFields) - 1; i >= 0; i-- {
|
||||
e := inFields[i].Expr()
|
||||
e := inFields[i].AsExpr()
|
||||
prefix := vPrefix
|
||||
if e.Operator() != 0 {
|
||||
prefix = aPrefix
|
||||
@@ -273,7 +273,7 @@ func (g *gen) writeStatementIterate(b *buffer, n *a.Iterate, depth uint32) error
|
||||
if len(vars) != 1 {
|
||||
return fmt.Errorf("TODO: iterate over more than one variable")
|
||||
}
|
||||
v := vars[0].Var()
|
||||
v := vars[0].AsVar()
|
||||
name := v.Name().Str(g.tm)
|
||||
b.writes("{\n")
|
||||
|
||||
@@ -515,16 +515,16 @@ func (g *gen) mightActuallySuspend(n *a.Expr, depth uint32) error {
|
||||
// The evaluation order for suspendible calls (which can have side effects)
|
||||
// is important here: LHS, MHS, RHS, Args and finally the node itself.
|
||||
if !n.CallSuspendible() {
|
||||
for _, o := range n.Node().Raw().SubNodes() {
|
||||
for _, o := range n.AsNode().AsRaw().SubNodes() {
|
||||
if o != nil && o.Kind() == a.KExpr {
|
||||
if err := g.mightActuallySuspend(o.Expr(), depth); err != nil {
|
||||
if err := g.mightActuallySuspend(o.AsExpr(), depth); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
for _, o := range n.Args() {
|
||||
if o != nil && o.Kind() == a.KExpr {
|
||||
if err := g.mightActuallySuspend(o.Expr(), depth); err != nil {
|
||||
if err := g.mightActuallySuspend(o.AsExpr(), depth); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
@@ -547,16 +547,16 @@ func (g *gen) writeCallSuspendibles(b *buffer, n *a.Expr, depth uint32) error {
|
||||
// The evaluation order for suspendible calls (which can have side effects)
|
||||
// is important here: LHS, MHS, RHS, Args and finally the node itself.
|
||||
if !n.CallSuspendible() {
|
||||
for _, o := range n.Node().Raw().SubNodes() {
|
||||
for _, o := range n.AsNode().AsRaw().SubNodes() {
|
||||
if o != nil && o.Kind() == a.KExpr {
|
||||
if err := g.writeCallSuspendibles(b, o.Expr(), depth); err != nil {
|
||||
if err := g.writeCallSuspendibles(b, o.AsExpr(), depth); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
for _, o := range n.Args() {
|
||||
if o != nil && o.Kind() == a.KExpr {
|
||||
if err := g.writeCallSuspendibles(b, o.Expr(), depth); err != nil {
|
||||
if err := g.writeCallSuspendibles(b, o.AsExpr(), depth); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
@@ -31,19 +31,19 @@ func (g *gen) needDerivedVar(name t.ID) bool {
|
||||
if p.Kind() != a.KExpr {
|
||||
return nil
|
||||
}
|
||||
q := p.Expr()
|
||||
q := p.AsExpr()
|
||||
if q.Operator() != t.IDOpenParen {
|
||||
return nil
|
||||
}
|
||||
q = q.LHS().Expr()
|
||||
q = q.LHS().AsExpr()
|
||||
if q.Operator() != t.IDDot {
|
||||
return nil
|
||||
}
|
||||
q = q.LHS().Expr()
|
||||
q = q.LHS().AsExpr()
|
||||
if q.Operator() != t.IDDot || q.Ident() != name {
|
||||
return nil
|
||||
}
|
||||
q = q.LHS().Expr()
|
||||
q = q.LHS().AsExpr()
|
||||
if q.Operator() != 0 || q.Ident() != t.IDIn {
|
||||
return nil
|
||||
}
|
||||
@@ -58,7 +58,7 @@ func (g *gen) needDerivedVar(name t.ID) bool {
|
||||
|
||||
func (g *gen) findDerivedVars() {
|
||||
for _, o := range g.currFunk.astFunc.In().Fields() {
|
||||
o := o.Field()
|
||||
o := o.AsField()
|
||||
oTyp := o.XType()
|
||||
if oTyp.Decorator() != 0 {
|
||||
continue
|
||||
@@ -182,7 +182,7 @@ func (g *gen) writeLoadExprDerivedVars(b *buffer, n *a.Expr) error {
|
||||
return nil
|
||||
}
|
||||
for _, o := range n.Args() {
|
||||
o := o.Arg()
|
||||
o := o.AsArg()
|
||||
// TODO: don't hard-code these.
|
||||
hack := ""
|
||||
if s := o.Value().Str(g.tm); s != "in.dst" && s != "in.src" && s != "w" {
|
||||
@@ -205,7 +205,7 @@ func (g *gen) writeSaveExprDerivedVars(b *buffer, n *a.Expr) error {
|
||||
return nil
|
||||
}
|
||||
for _, o := range n.Args() {
|
||||
o := o.Arg()
|
||||
o := o.AsArg()
|
||||
// TODO: don't hard-code these.
|
||||
hack := ""
|
||||
if s := o.Value().Str(g.tm); s != "in.dst" && s != "in.src" && s != "w" {
|
||||
@@ -229,7 +229,7 @@ func (g *gen) visitVars(b *buffer, block []*a.Node, depth uint32, f func(*gen, *
|
||||
for _, o := range block {
|
||||
switch o.Kind() {
|
||||
case a.KIf:
|
||||
for o := o.If(); o != nil; o = o.ElseIf() {
|
||||
for o := o.AsIf(); o != nil; o = o.ElseIf() {
|
||||
if err := g.visitVars(b, o.BodyIfTrue(), depth, f); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -239,25 +239,25 @@ func (g *gen) visitVars(b *buffer, block []*a.Node, depth uint32, f func(*gen, *
|
||||
}
|
||||
|
||||
case a.KIOBind:
|
||||
if err := g.visitVars(b, o.IOBind().Body(), depth, f); err != nil {
|
||||
if err := g.visitVars(b, o.AsIOBind().Body(), depth, f); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
case a.KIterate:
|
||||
if err := g.visitVars(b, o.Iterate().Variables(), depth, f); err != nil {
|
||||
if err := g.visitVars(b, o.AsIterate().Variables(), depth, f); err != nil {
|
||||
return err
|
||||
}
|
||||
if err := g.visitVars(b, o.Iterate().Body(), depth, f); err != nil {
|
||||
if err := g.visitVars(b, o.AsIterate().Body(), depth, f); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
case a.KVar:
|
||||
if err := f(g, b, o.Var()); err != nil {
|
||||
if err := f(g, b, o.AsVar()); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
case a.KWhile:
|
||||
if err := g.visitVars(b, o.While().Body(), depth, f); err != nil {
|
||||
if err := g.visitVars(b, o.AsWhile().Body(), depth, f); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
+7
-7
@@ -213,7 +213,7 @@ func (h *genHelper) genDirDependencies(qualifiedFilenames []string) error {
|
||||
if n.Kind() != a.KUse {
|
||||
continue
|
||||
}
|
||||
useDirname := h.tm.ByID(n.Use().Path())
|
||||
useDirname := h.tm.ByID(n.AsUse().Path())
|
||||
useDirname, _ = t.Unescape(useDirname)
|
||||
if err := h.gen(useDirname, false); err != nil {
|
||||
return err
|
||||
@@ -241,7 +241,7 @@ func (h *genHelper) genWuffs(dirname string, qualifiedFilenames []string) error
|
||||
for _, f := range files {
|
||||
for _, n := range f.TopLevelDecls() {
|
||||
if n.Kind() == a.KPackageID {
|
||||
pkgIDNode = n.PackageID()
|
||||
pkgIDNode = n.AsPackageID()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -261,14 +261,14 @@ func (h *genHelper) genWuffs(dirname string, qualifiedFilenames []string) error
|
||||
for _, n := range f.TopLevelDecls() {
|
||||
switch n.Kind() {
|
||||
case a.KConst:
|
||||
n := n.Const()
|
||||
n := n.AsConst()
|
||||
if !n.Public() {
|
||||
continue
|
||||
}
|
||||
return fmt.Errorf("TODO: genWuffs for consts")
|
||||
|
||||
case a.KFunc:
|
||||
n := n.Func()
|
||||
n := n.AsFunc()
|
||||
if !n.Public() {
|
||||
continue
|
||||
}
|
||||
@@ -288,7 +288,7 @@ func (h *genHelper) genWuffs(dirname string, qualifiedFilenames []string) error
|
||||
fmt.Fprintf(out, ")(")
|
||||
}
|
||||
for j, field := range param.Fields() {
|
||||
field := field.Field()
|
||||
field := field.AsField()
|
||||
if j > 0 {
|
||||
fmt.Fprintf(out, ", ")
|
||||
}
|
||||
@@ -300,7 +300,7 @@ func (h *genHelper) genWuffs(dirname string, qualifiedFilenames []string) error
|
||||
fmt.Fprintf(out, ") { }\n")
|
||||
|
||||
case a.KStatus:
|
||||
n := n.Status()
|
||||
n := n.AsStatus()
|
||||
if !n.Public() {
|
||||
continue
|
||||
}
|
||||
@@ -308,7 +308,7 @@ func (h *genHelper) genWuffs(dirname string, qualifiedFilenames []string) error
|
||||
n.Keyword().Str(&h.tm), n.Value().Str(&h.tm), n.QID().Str(&h.tm))
|
||||
|
||||
case a.KStruct:
|
||||
n := n.Struct()
|
||||
n := n.AsStruct()
|
||||
if !n.Public() {
|
||||
continue
|
||||
}
|
||||
|
||||
+89
-89
@@ -193,39 +193,39 @@ func (n *Node) Kind() Kind { return n.kind }
|
||||
func (n *Node) MType() *TypeExpr { return n.mType }
|
||||
func (n *Node) SetMType(x *TypeExpr) { n.mType = x }
|
||||
|
||||
func (n *Node) Arg() *Arg { return (*Arg)(n) }
|
||||
func (n *Node) Assert() *Assert { return (*Assert)(n) }
|
||||
func (n *Node) Assign() *Assign { return (*Assign)(n) }
|
||||
func (n *Node) Const() *Const { return (*Const)(n) }
|
||||
func (n *Node) Expr() *Expr { return (*Expr)(n) }
|
||||
func (n *Node) Field() *Field { return (*Field)(n) }
|
||||
func (n *Node) File() *File { return (*File)(n) }
|
||||
func (n *Node) Func() *Func { return (*Func)(n) }
|
||||
func (n *Node) IOBind() *IOBind { return (*IOBind)(n) }
|
||||
func (n *Node) If() *If { return (*If)(n) }
|
||||
func (n *Node) Iterate() *Iterate { return (*Iterate)(n) }
|
||||
func (n *Node) Jump() *Jump { return (*Jump)(n) }
|
||||
func (n *Node) PackageID() *PackageID { return (*PackageID)(n) }
|
||||
func (n *Node) Raw() *Raw { return (*Raw)(n) }
|
||||
func (n *Node) Ret() *Ret { return (*Ret)(n) }
|
||||
func (n *Node) Status() *Status { return (*Status)(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) }
|
||||
func (n *Node) While() *While { return (*While)(n) }
|
||||
func (n *Node) AsArg() *Arg { return (*Arg)(n) }
|
||||
func (n *Node) AsAssert() *Assert { return (*Assert)(n) }
|
||||
func (n *Node) AsAssign() *Assign { return (*Assign)(n) }
|
||||
func (n *Node) AsConst() *Const { return (*Const)(n) }
|
||||
func (n *Node) AsExpr() *Expr { return (*Expr)(n) }
|
||||
func (n *Node) AsField() *Field { return (*Field)(n) }
|
||||
func (n *Node) AsFile() *File { return (*File)(n) }
|
||||
func (n *Node) AsFunc() *Func { return (*Func)(n) }
|
||||
func (n *Node) AsIOBind() *IOBind { return (*IOBind)(n) }
|
||||
func (n *Node) AsIf() *If { return (*If)(n) }
|
||||
func (n *Node) AsIterate() *Iterate { return (*Iterate)(n) }
|
||||
func (n *Node) AsJump() *Jump { return (*Jump)(n) }
|
||||
func (n *Node) AsPackageID() *PackageID { return (*PackageID)(n) }
|
||||
func (n *Node) AsRaw() *Raw { return (*Raw)(n) }
|
||||
func (n *Node) AsRet() *Ret { return (*Ret)(n) }
|
||||
func (n *Node) AsStatus() *Status { return (*Status)(n) }
|
||||
func (n *Node) AsStruct() *Struct { return (*Struct)(n) }
|
||||
func (n *Node) AsTypeExpr() *TypeExpr { return (*TypeExpr)(n) }
|
||||
func (n *Node) AsUse() *Use { return (*Use)(n) }
|
||||
func (n *Node) AsVar() *Var { return (*Var)(n) }
|
||||
func (n *Node) AsWhile() *While { return (*While)(n) }
|
||||
|
||||
func (n *Node) Walk(f func(*Node) error) error {
|
||||
if n != nil {
|
||||
if err := f(n); err != nil {
|
||||
return err
|
||||
}
|
||||
for _, o := range n.Raw().SubNodes() {
|
||||
for _, o := range n.AsRaw().SubNodes() {
|
||||
if err := o.Walk(f); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
for _, l := range n.Raw().SubLists() {
|
||||
for _, l := range n.AsRaw().SubLists() {
|
||||
for _, o := range l {
|
||||
if err := o.Walk(f); err != nil {
|
||||
return err
|
||||
@@ -237,7 +237,7 @@ func (n *Node) Walk(f func(*Node) error) error {
|
||||
}
|
||||
|
||||
type Loop interface {
|
||||
Node() *Node
|
||||
AsNode() *Node
|
||||
HasBreak() bool
|
||||
HasContinue() bool
|
||||
Label() t.ID
|
||||
@@ -249,7 +249,7 @@ type Loop interface {
|
||||
|
||||
type Raw Node
|
||||
|
||||
func (n *Raw) Node() *Node { return (*Node)(n) }
|
||||
func (n *Raw) AsNode() *Node { return (*Node)(n) }
|
||||
func (n *Raw) Flags() Flags { return n.flags }
|
||||
func (n *Raw) FilenameLine() (string, uint32) { return n.filename, n.line }
|
||||
func (n *Raw) SubNodes() [3]*Node { return [3]*Node{n.lhs, n.mhs, n.rhs} }
|
||||
@@ -258,7 +258,7 @@ func (n *Raw) SubLists() [3][]*Node { return [3][]*Node{n.list0, n.lis
|
||||
func (n *Raw) SetFilenameLine(f string, l uint32) { n.filename, n.line = f, l }
|
||||
|
||||
func (n *Raw) SetPackage(tm *t.Map, pkg t.ID) error {
|
||||
return n.Node().Walk(func(o *Node) error {
|
||||
return n.AsNode().Walk(func(o *Node) error {
|
||||
switch o.Kind() {
|
||||
default:
|
||||
return nil
|
||||
@@ -335,7 +335,7 @@ const MaxExprDepth = 255
|
||||
// keyword, ID1 is the package and ID2 is the message.
|
||||
type Expr Node
|
||||
|
||||
func (n *Expr) Node() *Node { return (*Node)(n) }
|
||||
func (n *Expr) AsNode() *Node { return (*Node)(n) }
|
||||
func (n *Expr) Effect() Effect { return Effect(n.flags & flagEffect) }
|
||||
func (n *Expr) Pure() bool { return n.flags&FlagsImpure == 0 }
|
||||
func (n *Expr) Impure() bool { return n.flags&FlagsImpure != 0 }
|
||||
@@ -395,10 +395,10 @@ func NewExpr(flags Flags, operator t.ID, statusPkg t.ID, ident t.ID, lhs *Node,
|
||||
// - List0: <Arg> reason arguments
|
||||
type Assert Node
|
||||
|
||||
func (n *Assert) Node() *Node { return (*Node)(n) }
|
||||
func (n *Assert) AsNode() *Node { return (*Node)(n) }
|
||||
func (n *Assert) Keyword() t.ID { return n.id0 }
|
||||
func (n *Assert) Reason() t.ID { return n.id2 }
|
||||
func (n *Assert) Condition() *Expr { return n.rhs.Expr() }
|
||||
func (n *Assert) Condition() *Expr { return n.rhs.AsExpr() }
|
||||
func (n *Assert) Args() []*Node { return n.list0 }
|
||||
|
||||
func NewAssert(keyword t.ID, condition *Expr, reason t.ID, args []*Node) *Assert {
|
||||
@@ -406,7 +406,7 @@ func NewAssert(keyword t.ID, condition *Expr, reason t.ID, args []*Node) *Assert
|
||||
kind: KAssert,
|
||||
id0: keyword,
|
||||
id2: reason,
|
||||
rhs: condition.Node(),
|
||||
rhs: condition.AsNode(),
|
||||
list0: args,
|
||||
}
|
||||
}
|
||||
@@ -416,15 +416,15 @@ func NewAssert(keyword t.ID, condition *Expr, reason t.ID, args []*Node) *Assert
|
||||
// - RHS: <Expr> value
|
||||
type Arg Node
|
||||
|
||||
func (n *Arg) Node() *Node { return (*Node)(n) }
|
||||
func (n *Arg) Name() t.ID { return n.id2 }
|
||||
func (n *Arg) Value() *Expr { return n.rhs.Expr() }
|
||||
func (n *Arg) AsNode() *Node { return (*Node)(n) }
|
||||
func (n *Arg) Name() t.ID { return n.id2 }
|
||||
func (n *Arg) Value() *Expr { return n.rhs.AsExpr() }
|
||||
|
||||
func NewArg(name t.ID, value *Expr) *Arg {
|
||||
return &Arg{
|
||||
kind: KArg,
|
||||
id2: name,
|
||||
rhs: value.Node(),
|
||||
rhs: value.AsNode(),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -434,17 +434,17 @@ func NewArg(name t.ID, value *Expr) *Arg {
|
||||
// - RHS: <Expr>
|
||||
type Assign Node
|
||||
|
||||
func (n *Assign) Node() *Node { return (*Node)(n) }
|
||||
func (n *Assign) AsNode() *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 (n *Assign) LHS() *Expr { return n.lhs.AsExpr() }
|
||||
func (n *Assign) RHS() *Expr { return n.rhs.AsExpr() }
|
||||
|
||||
func NewAssign(operator t.ID, lhs *Expr, rhs *Expr) *Assign {
|
||||
return &Assign{
|
||||
kind: KAssign,
|
||||
id0: operator,
|
||||
lhs: lhs.Node(),
|
||||
rhs: rhs.Node(),
|
||||
lhs: lhs.AsNode(),
|
||||
rhs: rhs.AsNode(),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -456,19 +456,19 @@ func NewAssign(operator t.ID, lhs *Expr, rhs *Expr) *Assign {
|
||||
// - RHS: <nil|Expr>
|
||||
type Var Node
|
||||
|
||||
func (n *Var) Node() *Node { return (*Node)(n) }
|
||||
func (n *Var) AsNode() *Node { return (*Node)(n) }
|
||||
func (n *Var) IterateVariable() bool { return n.id0 == t.IDEqColon }
|
||||
func (n *Var) Name() t.ID { return n.id2 }
|
||||
func (n *Var) XType() *TypeExpr { return n.lhs.TypeExpr() }
|
||||
func (n *Var) Value() *Expr { return n.rhs.Expr() }
|
||||
func (n *Var) XType() *TypeExpr { return n.lhs.AsTypeExpr() }
|
||||
func (n *Var) Value() *Expr { return n.rhs.AsExpr() }
|
||||
|
||||
func NewVar(op t.ID, name t.ID, xType *TypeExpr, value *Expr) *Var {
|
||||
return &Var{
|
||||
kind: KVar,
|
||||
id0: op,
|
||||
id2: name,
|
||||
lhs: xType.Node(),
|
||||
rhs: value.Node(),
|
||||
lhs: xType.AsNode(),
|
||||
rhs: value.AsNode(),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -477,15 +477,15 @@ func NewVar(op t.ID, name t.ID, xType *TypeExpr, value *Expr) *Var {
|
||||
// - LHS: <TypeExpr>
|
||||
type Field Node
|
||||
|
||||
func (n *Field) Node() *Node { return (*Node)(n) }
|
||||
func (n *Field) AsNode() *Node { return (*Node)(n) }
|
||||
func (n *Field) Name() t.ID { return n.id2 }
|
||||
func (n *Field) XType() *TypeExpr { return n.lhs.TypeExpr() }
|
||||
func (n *Field) XType() *TypeExpr { return n.lhs.AsTypeExpr() }
|
||||
|
||||
func NewField(name t.ID, xType *TypeExpr) *Field {
|
||||
return &Field{
|
||||
kind: KField,
|
||||
id2: name,
|
||||
lhs: xType.Node(),
|
||||
lhs: xType.AsNode(),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -496,7 +496,7 @@ func NewField(name t.ID, xType *TypeExpr) *Field {
|
||||
// TODO: in_fields and "in.something" isn't right.
|
||||
type IOBind Node
|
||||
|
||||
func (n *IOBind) Node() *Node { return (*Node)(n) }
|
||||
func (n *IOBind) AsNode() *Node { return (*Node)(n) }
|
||||
func (n *IOBind) InFields() []*Node { return n.list0 }
|
||||
func (n *IOBind) Body() []*Node { return n.list2 }
|
||||
|
||||
@@ -521,13 +521,13 @@ func NewIOBind(in_fields []*Node, body []*Node) *IOBind {
|
||||
// - List2: <Statement> body
|
||||
type Iterate Node
|
||||
|
||||
func (n *Iterate) Node() *Node { return (*Node)(n) }
|
||||
func (n *Iterate) AsNode() *Node { return (*Node)(n) }
|
||||
func (n *Iterate) HasBreak() bool { return n.flags&FlagsHasBreak != 0 }
|
||||
func (n *Iterate) HasContinue() bool { return n.flags&FlagsHasContinue != 0 }
|
||||
func (n *Iterate) Unroll() t.ID { return n.id0 }
|
||||
func (n *Iterate) Label() t.ID { return n.id1 }
|
||||
func (n *Iterate) Length() t.ID { return n.id2 }
|
||||
func (n *Iterate) ElseIterate() *Iterate { return n.rhs.Iterate() }
|
||||
func (n *Iterate) ElseIterate() *Iterate { return n.rhs.AsIterate() }
|
||||
func (n *Iterate) Variables() []*Node { return n.list0 }
|
||||
func (n *Iterate) Asserts() []*Node { return n.list1 }
|
||||
func (n *Iterate) Body() []*Node { return n.list2 }
|
||||
@@ -541,7 +541,7 @@ func NewIterate(label t.ID, vars []*Node, length t.ID, unroll t.ID, asserts []*N
|
||||
id0: unroll,
|
||||
id1: label,
|
||||
id2: length,
|
||||
rhs: elseIterate.Node(),
|
||||
rhs: elseIterate.AsNode(),
|
||||
list0: vars,
|
||||
list1: asserts,
|
||||
list2: body,
|
||||
@@ -559,11 +559,11 @@ func NewIterate(label t.ID, vars []*Node, length t.ID, unroll t.ID, asserts []*N
|
||||
// TODO: should we be able to unroll while loops too?
|
||||
type While Node
|
||||
|
||||
func (n *While) Node() *Node { return (*Node)(n) }
|
||||
func (n *While) AsNode() *Node { return (*Node)(n) }
|
||||
func (n *While) HasBreak() bool { return n.flags&FlagsHasBreak != 0 }
|
||||
func (n *While) HasContinue() bool { return n.flags&FlagsHasContinue != 0 }
|
||||
func (n *While) Label() t.ID { return n.id1 }
|
||||
func (n *While) Condition() *Expr { return n.mhs.Expr() }
|
||||
func (n *While) Condition() *Expr { return n.mhs.AsExpr() }
|
||||
func (n *While) Asserts() []*Node { return n.list1 }
|
||||
func (n *While) Body() []*Node { return n.list2 }
|
||||
|
||||
@@ -574,7 +574,7 @@ func NewWhile(label t.ID, condition *Expr, asserts []*Node, body []*Node) *While
|
||||
return &While{
|
||||
kind: KWhile,
|
||||
id1: label,
|
||||
mhs: condition.Node(),
|
||||
mhs: condition.AsNode(),
|
||||
list1: asserts,
|
||||
list2: body,
|
||||
}
|
||||
@@ -587,17 +587,17 @@ func NewWhile(label t.ID, condition *Expr, asserts []*Node, body []*Node) *While
|
||||
// - List2: <Statement> if-true body
|
||||
type If Node
|
||||
|
||||
func (n *If) Node() *Node { return (*Node)(n) }
|
||||
func (n *If) Condition() *Expr { return n.mhs.Expr() }
|
||||
func (n *If) ElseIf() *If { return n.rhs.If() }
|
||||
func (n *If) AsNode() *Node { return (*Node)(n) }
|
||||
func (n *If) Condition() *Expr { return n.mhs.AsExpr() }
|
||||
func (n *If) ElseIf() *If { return n.rhs.AsIf() }
|
||||
func (n *If) BodyIfTrue() []*Node { return n.list2 }
|
||||
func (n *If) BodyIfFalse() []*Node { return n.list1 }
|
||||
|
||||
func NewIf(condition *Expr, bodyIfTrue []*Node, bodyIfFalse []*Node, elseIf *If) *If {
|
||||
return &If{
|
||||
kind: KIf,
|
||||
mhs: condition.Node(),
|
||||
rhs: elseIf.Node(),
|
||||
mhs: condition.AsNode(),
|
||||
rhs: elseIf.AsNode(),
|
||||
list1: bodyIfFalse,
|
||||
list2: bodyIfTrue,
|
||||
}
|
||||
@@ -608,15 +608,15 @@ func NewIf(condition *Expr, bodyIfTrue []*Node, bodyIfFalse []*Node, elseIf *If)
|
||||
// - LHS: <nil|Expr>
|
||||
type Ret Node
|
||||
|
||||
func (n *Ret) Node() *Node { return (*Node)(n) }
|
||||
func (n *Ret) AsNode() *Node { return (*Node)(n) }
|
||||
func (n *Ret) Keyword() t.ID { return n.id0 }
|
||||
func (n *Ret) Value() *Expr { return n.lhs.Expr() }
|
||||
func (n *Ret) Value() *Expr { return n.lhs.AsExpr() }
|
||||
|
||||
func NewRet(keyword t.ID, value *Expr) *Ret {
|
||||
return &Ret{
|
||||
kind: KRet,
|
||||
id0: keyword,
|
||||
lhs: value.Node(),
|
||||
lhs: value.AsNode(),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -625,7 +625,7 @@ func NewRet(keyword t.ID, value *Expr) *Ret {
|
||||
// - ID1: <0|label>
|
||||
type Jump Node
|
||||
|
||||
func (n *Jump) Node() *Node { return (*Node)(n) }
|
||||
func (n *Jump) AsNode() *Node { return (*Node)(n) }
|
||||
func (n *Jump) JumpTarget() Loop { return n.jumpTarget }
|
||||
func (n *Jump) Keyword() t.ID { return n.id0 }
|
||||
func (n *Jump) Label() t.ID { return n.id1 }
|
||||
@@ -675,16 +675,16 @@ const MaxTypeExprDepth = 63
|
||||
// TODO: struct types, list types, nptr vs ptr.
|
||||
type TypeExpr Node
|
||||
|
||||
func (n *TypeExpr) Node() *Node { return (*Node)(n) }
|
||||
func (n *TypeExpr) AsNode() *Node { return (*Node)(n) }
|
||||
func (n *TypeExpr) Decorator() t.ID { return n.id0 }
|
||||
func (n *TypeExpr) QID() t.QID { return t.QID{n.id1, n.id2} }
|
||||
func (n *TypeExpr) FuncName() t.ID { return n.id2 }
|
||||
func (n *TypeExpr) ArrayLength() *Expr { return n.lhs.Expr() }
|
||||
func (n *TypeExpr) Receiver() *TypeExpr { return n.lhs.TypeExpr() }
|
||||
func (n *TypeExpr) Bounds() [2]*Expr { return [2]*Expr{n.lhs.Expr(), n.mhs.Expr()} }
|
||||
func (n *TypeExpr) Min() *Expr { return n.lhs.Expr() }
|
||||
func (n *TypeExpr) Max() *Expr { return n.mhs.Expr() }
|
||||
func (n *TypeExpr) Inner() *TypeExpr { return n.rhs.TypeExpr() }
|
||||
func (n *TypeExpr) ArrayLength() *Expr { return n.lhs.AsExpr() }
|
||||
func (n *TypeExpr) Receiver() *TypeExpr { return n.lhs.AsTypeExpr() }
|
||||
func (n *TypeExpr) Bounds() [2]*Expr { return [2]*Expr{n.lhs.AsExpr(), n.mhs.AsExpr()} }
|
||||
func (n *TypeExpr) Min() *Expr { return n.lhs.AsExpr() }
|
||||
func (n *TypeExpr) Max() *Expr { return n.mhs.AsExpr() }
|
||||
func (n *TypeExpr) Inner() *TypeExpr { return n.rhs.AsTypeExpr() }
|
||||
|
||||
func (n *TypeExpr) Innermost() *TypeExpr {
|
||||
for ; n != nil && n.Inner() != nil; n = n.Inner() {
|
||||
@@ -773,8 +773,8 @@ func NewTypeExpr(decorator t.ID, pkg t.ID, name t.ID, alenRecvMin *Node, max *Ex
|
||||
id1: pkg,
|
||||
id2: name,
|
||||
lhs: alenRecvMin,
|
||||
mhs: max.Node(),
|
||||
rhs: inner.Node(),
|
||||
mhs: max.AsNode(),
|
||||
rhs: inner.AsNode(),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -806,7 +806,7 @@ const MaxBodyDepth = 255
|
||||
// - While
|
||||
type Func Node
|
||||
|
||||
func (n *Func) Node() *Node { return (*Node)(n) }
|
||||
func (n *Func) AsNode() *Node { return (*Node)(n) }
|
||||
func (n *Func) Effect() Effect { return Effect(n.flags & flagEffect) }
|
||||
func (n *Func) Pure() bool { return n.flags&FlagsImpure == 0 }
|
||||
func (n *Func) Impure() bool { return n.flags&FlagsImpure != 0 }
|
||||
@@ -817,8 +817,8 @@ func (n *Func) Line() uint32 { return n.line }
|
||||
func (n *Func) QQID() t.QQID { return t.QQID{n.id1, n.id2, n.id0} }
|
||||
func (n *Func) Receiver() t.QID { return t.QID{n.id1, n.id2} }
|
||||
func (n *Func) FuncName() t.ID { return n.id0 }
|
||||
func (n *Func) In() *Struct { return n.lhs.Struct() }
|
||||
func (n *Func) Out() *Struct { return n.rhs.Struct() }
|
||||
func (n *Func) In() *Struct { return n.lhs.AsStruct() }
|
||||
func (n *Func) Out() *Struct { return n.rhs.AsStruct() }
|
||||
func (n *Func) Asserts() []*Node { return n.list1 }
|
||||
func (n *Func) Body() []*Node { return n.list2 }
|
||||
|
||||
@@ -830,8 +830,8 @@ func NewFunc(flags Flags, filename string, line uint32, receiverName t.ID, funcN
|
||||
line: line,
|
||||
id0: funcName,
|
||||
id2: receiverName,
|
||||
lhs: in.Node(),
|
||||
rhs: out.Node(),
|
||||
lhs: in.AsNode(),
|
||||
rhs: out.AsNode(),
|
||||
list1: asserts,
|
||||
list2: body,
|
||||
}
|
||||
@@ -844,13 +844,13 @@ func NewFunc(flags Flags, filename string, line uint32, receiverName t.ID, funcN
|
||||
// - ID2: message
|
||||
type Status Node
|
||||
|
||||
func (n *Status) Node() *Node { return (*Node)(n) }
|
||||
func (n *Status) AsNode() *Node { return (*Node)(n) }
|
||||
func (n *Status) Public() bool { return n.flags&FlagsPublic != 0 }
|
||||
func (n *Status) Filename() string { return n.filename }
|
||||
func (n *Status) Line() uint32 { return n.line }
|
||||
func (n *Status) Keyword() t.ID { return n.id0 }
|
||||
func (n *Status) QID() t.QID { return t.QID{n.id1, n.id2} }
|
||||
func (n *Status) Value() *Expr { return n.rhs.Expr() }
|
||||
func (n *Status) Value() *Expr { return n.rhs.AsExpr() }
|
||||
|
||||
func NewStatus(flags Flags, filename string, line uint32, keyword t.ID, value *Expr, message t.ID) *Status {
|
||||
return &Status{
|
||||
@@ -860,7 +860,7 @@ func NewStatus(flags Flags, filename string, line uint32, keyword t.ID, value *E
|
||||
line: line,
|
||||
id0: keyword,
|
||||
id2: message,
|
||||
rhs: value.Node(),
|
||||
rhs: value.AsNode(),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -872,13 +872,13 @@ func NewStatus(flags Flags, filename string, line uint32, keyword t.ID, value *E
|
||||
// - RHS: <Expr>
|
||||
type Const Node
|
||||
|
||||
func (n *Const) Node() *Node { return (*Node)(n) }
|
||||
func (n *Const) AsNode() *Node { return (*Node)(n) }
|
||||
func (n *Const) Public() bool { return n.flags&FlagsPublic != 0 }
|
||||
func (n *Const) Filename() string { return n.filename }
|
||||
func (n *Const) Line() uint32 { return n.line }
|
||||
func (n *Const) QID() t.QID { return t.QID{n.id1, n.id2} }
|
||||
func (n *Const) XType() *TypeExpr { return n.lhs.TypeExpr() }
|
||||
func (n *Const) Value() *Expr { return n.rhs.Expr() }
|
||||
func (n *Const) XType() *TypeExpr { return n.lhs.AsTypeExpr() }
|
||||
func (n *Const) Value() *Expr { return n.rhs.AsExpr() }
|
||||
|
||||
func NewConst(flags Flags, filename string, line uint32, name t.ID, xType *TypeExpr, value *Expr) *Const {
|
||||
return &Const{
|
||||
@@ -887,8 +887,8 @@ func NewConst(flags Flags, filename string, line uint32, name t.ID, xType *TypeE
|
||||
filename: filename,
|
||||
line: line,
|
||||
id2: name,
|
||||
lhs: xType.Node(),
|
||||
rhs: value.Node(),
|
||||
lhs: xType.AsNode(),
|
||||
rhs: value.AsNode(),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -900,7 +900,7 @@ func NewConst(flags Flags, filename string, line uint32, name t.ID, xType *TypeE
|
||||
// - List0: <Field> fields
|
||||
type Struct Node
|
||||
|
||||
func (n *Struct) Node() *Node { return (*Node)(n) }
|
||||
func (n *Struct) AsNode() *Node { return (*Node)(n) }
|
||||
func (n *Struct) Suspendible() bool { return n.flags&FlagsSuspendible != 0 }
|
||||
func (n *Struct) Public() bool { return n.flags&FlagsPublic != 0 }
|
||||
func (n *Struct) Filename() string { return n.filename }
|
||||
@@ -923,7 +923,7 @@ func NewStruct(flags Flags, filename string, line uint32, name t.ID, fields []*N
|
||||
// - ID2: <string literal> package ID
|
||||
type PackageID Node
|
||||
|
||||
func (n *PackageID) Node() *Node { return (*Node)(n) }
|
||||
func (n *PackageID) AsNode() *Node { return (*Node)(n) }
|
||||
func (n *PackageID) Filename() string { return n.filename }
|
||||
func (n *PackageID) Line() uint32 { return n.line }
|
||||
func (n *PackageID) ID() t.ID { return n.id2 }
|
||||
@@ -941,7 +941,7 @@ func NewPackageID(filename string, line uint32, id t.ID) *PackageID {
|
||||
// - ID2: <string literal> package path
|
||||
type Use Node
|
||||
|
||||
func (n *Use) Node() *Node { return (*Node)(n) }
|
||||
func (n *Use) AsNode() *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.id2 }
|
||||
@@ -959,7 +959,7 @@ func NewUse(filename string, line uint32, path t.ID) *Use {
|
||||
// - List0: <Const|Func|PackageID|Status|Struct|Use> top-level declarations
|
||||
type File Node
|
||||
|
||||
func (n *File) Node() *Node { return (*Node)(n) }
|
||||
func (n *File) AsNode() *Node { return (*Node)(n) }
|
||||
func (n *File) Filename() string { return n.filename }
|
||||
func (n *File) TopLevelDecls() []*Node { return n.list0 }
|
||||
|
||||
|
||||
+12
-12
@@ -39,18 +39,18 @@ func (n *Expr) Eq(o *Expr) bool {
|
||||
n.id0 != o.id0 || n.id1 != o.id1 || n.id2 != o.id2 {
|
||||
return false
|
||||
}
|
||||
if !n.lhs.Expr().Eq(o.lhs.Expr()) {
|
||||
if !n.lhs.AsExpr().Eq(o.lhs.AsExpr()) {
|
||||
return false
|
||||
}
|
||||
if !n.mhs.Expr().Eq(o.mhs.Expr()) {
|
||||
if !n.mhs.AsExpr().Eq(o.mhs.AsExpr()) {
|
||||
return false
|
||||
}
|
||||
|
||||
if n.id0 == t.IDXBinaryAs {
|
||||
if !n.rhs.TypeExpr().Eq(o.rhs.TypeExpr()) {
|
||||
if !n.rhs.AsTypeExpr().Eq(o.rhs.AsTypeExpr()) {
|
||||
return false
|
||||
}
|
||||
} else if !n.rhs.Expr().Eq(o.rhs.Expr()) {
|
||||
} else if !n.rhs.AsExpr().Eq(o.rhs.AsExpr()) {
|
||||
return false
|
||||
}
|
||||
|
||||
@@ -58,7 +58,7 @@ func (n *Expr) Eq(o *Expr) bool {
|
||||
return false
|
||||
}
|
||||
for i, x := range n.list0 {
|
||||
if !x.Expr().Eq(o.list0[i].Expr()) {
|
||||
if !x.AsExpr().Eq(o.list0[i].AsExpr()) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
@@ -70,13 +70,13 @@ func (n *Expr) Mentions(o *Expr) bool {
|
||||
return false
|
||||
}
|
||||
if n.Eq(o) ||
|
||||
n.lhs.Expr().Mentions(o) ||
|
||||
n.mhs.Expr().Mentions(o) ||
|
||||
(n.id0 != t.IDXBinaryAs && n.rhs.Expr().Mentions(o)) {
|
||||
n.lhs.AsExpr().Mentions(o) ||
|
||||
n.mhs.AsExpr().Mentions(o) ||
|
||||
(n.id0 != t.IDXBinaryAs && n.rhs.AsExpr().Mentions(o)) {
|
||||
return true
|
||||
}
|
||||
for _, x := range n.list0 {
|
||||
if x.Expr().Mentions(o) {
|
||||
if x.AsExpr().Mentions(o) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
@@ -106,14 +106,14 @@ func (n *TypeExpr) eq(o *TypeExpr, ignoreRefinements bool) bool {
|
||||
return false
|
||||
}
|
||||
if n.IsArrayType() || !ignoreRefinements {
|
||||
if !n.lhs.Expr().Eq(o.lhs.Expr()) || !n.mhs.Expr().Eq(o.mhs.Expr()) {
|
||||
if !n.lhs.AsExpr().Eq(o.lhs.AsExpr()) || !n.mhs.AsExpr().Eq(o.mhs.AsExpr()) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
if n.rhs == nil && o.rhs == nil {
|
||||
return true
|
||||
}
|
||||
n = n.rhs.TypeExpr()
|
||||
o = o.rhs.TypeExpr()
|
||||
n = n.rhs.AsTypeExpr()
|
||||
o = o.rhs.AsTypeExpr()
|
||||
}
|
||||
}
|
||||
+1
-1
@@ -53,7 +53,7 @@ func tssVisit(dst []*Struct, n *Struct, byQID map[t.QID]*Struct, marks map[*Stru
|
||||
marks[n] = temporary
|
||||
|
||||
for _, f := range n.Fields() {
|
||||
x := f.Field().XType().Innermost()
|
||||
x := f.AsField().XType().Innermost()
|
||||
if o := byQID[x.QID()]; o != nil {
|
||||
var ok bool
|
||||
dst, ok = tssVisit(dst, o, byQID, marks)
|
||||
|
||||
+15
-15
@@ -43,18 +43,18 @@ func (n *Expr) appendStr(buf []byte, tm *t.Map, parenthesize bool, depth uint32)
|
||||
switch {
|
||||
case n.id0.IsXUnaryOp():
|
||||
buf = append(buf, opString(n.id0)...)
|
||||
buf = n.rhs.Expr().appendStr(buf, tm, true, depth)
|
||||
buf = n.rhs.AsExpr().appendStr(buf, tm, true, depth)
|
||||
|
||||
case n.id0.IsXBinaryOp():
|
||||
if parenthesize {
|
||||
buf = append(buf, '(')
|
||||
}
|
||||
buf = n.lhs.Expr().appendStr(buf, tm, true, depth)
|
||||
buf = n.lhs.AsExpr().appendStr(buf, tm, true, depth)
|
||||
buf = append(buf, opString(n.id0)...)
|
||||
if n.id0 == t.IDXBinaryAs {
|
||||
buf = append(buf, n.rhs.TypeExpr().Str(tm)...)
|
||||
buf = append(buf, n.rhs.AsTypeExpr().Str(tm)...)
|
||||
} else {
|
||||
buf = n.rhs.Expr().appendStr(buf, tm, true, depth)
|
||||
buf = n.rhs.AsExpr().appendStr(buf, tm, true, depth)
|
||||
}
|
||||
if parenthesize {
|
||||
buf = append(buf, ')')
|
||||
@@ -69,7 +69,7 @@ func (n *Expr) appendStr(buf []byte, tm *t.Map, parenthesize bool, depth uint32)
|
||||
if i != 0 {
|
||||
buf = append(buf, op...)
|
||||
}
|
||||
buf = o.Expr().appendStr(buf, tm, true, depth)
|
||||
buf = o.AsExpr().appendStr(buf, tm, true, depth)
|
||||
}
|
||||
if parenthesize {
|
||||
buf = append(buf, ')')
|
||||
@@ -101,7 +101,7 @@ func (n *Expr) appendStr(buf []byte, tm *t.Map, parenthesize bool, depth uint32)
|
||||
fallthrough
|
||||
|
||||
case t.IDOpenParen:
|
||||
buf = n.lhs.Expr().appendStr(buf, tm, true, depth)
|
||||
buf = n.lhs.AsExpr().appendStr(buf, tm, true, depth)
|
||||
if n.flags&FlagsSuspendible != 0 {
|
||||
buf = append(buf, '?')
|
||||
} else if n.flags&FlagsImpure != 0 {
|
||||
@@ -112,28 +112,28 @@ func (n *Expr) appendStr(buf []byte, tm *t.Map, parenthesize bool, depth uint32)
|
||||
if i != 0 {
|
||||
buf = append(buf, ", "...)
|
||||
}
|
||||
buf = append(buf, tm.ByID(o.Arg().Name())...)
|
||||
buf = append(buf, tm.ByID(o.AsArg().Name())...)
|
||||
buf = append(buf, ':')
|
||||
buf = o.Arg().Value().appendStr(buf, tm, false, depth)
|
||||
buf = o.AsArg().Value().appendStr(buf, tm, false, depth)
|
||||
}
|
||||
buf = append(buf, ')')
|
||||
|
||||
case t.IDOpenBracket:
|
||||
buf = n.lhs.Expr().appendStr(buf, tm, true, depth)
|
||||
buf = n.lhs.AsExpr().appendStr(buf, tm, true, depth)
|
||||
buf = append(buf, '[')
|
||||
buf = n.rhs.Expr().appendStr(buf, tm, false, depth)
|
||||
buf = n.rhs.AsExpr().appendStr(buf, tm, false, depth)
|
||||
buf = append(buf, ']')
|
||||
|
||||
case t.IDColon:
|
||||
buf = n.lhs.Expr().appendStr(buf, tm, true, depth)
|
||||
buf = n.lhs.AsExpr().appendStr(buf, tm, true, depth)
|
||||
buf = append(buf, '[')
|
||||
buf = n.mhs.Expr().appendStr(buf, tm, false, depth)
|
||||
buf = n.mhs.AsExpr().appendStr(buf, tm, false, depth)
|
||||
buf = append(buf, ':')
|
||||
buf = n.rhs.Expr().appendStr(buf, tm, false, depth)
|
||||
buf = n.rhs.AsExpr().appendStr(buf, tm, false, depth)
|
||||
buf = append(buf, ']')
|
||||
|
||||
case t.IDDot:
|
||||
buf = n.lhs.Expr().appendStr(buf, tm, true, depth)
|
||||
buf = n.lhs.AsExpr().appendStr(buf, tm, true, depth)
|
||||
buf = append(buf, '.')
|
||||
buf = append(buf, tm.ByID(n.id2)...)
|
||||
|
||||
@@ -143,7 +143,7 @@ func (n *Expr) appendStr(buf []byte, tm *t.Map, parenthesize bool, depth uint32)
|
||||
if i != 0 {
|
||||
buf = append(buf, ", "...)
|
||||
}
|
||||
buf = o.Expr().appendStr(buf, tm, false, depth)
|
||||
buf = o.AsExpr().appendStr(buf, tm, false, depth)
|
||||
}
|
||||
buf = append(buf, ')')
|
||||
}
|
||||
|
||||
+15
-15
@@ -46,11 +46,11 @@ func otherHandSide(n *a.Expr, thisHS *a.Expr) (op t.ID, thatHS *a.Expr) {
|
||||
}
|
||||
|
||||
if reverseOp != 0 {
|
||||
if thisHS.Eq(n.LHS().Expr()) {
|
||||
return op, n.RHS().Expr()
|
||||
if thisHS.Eq(n.LHS().AsExpr()) {
|
||||
return op, n.RHS().AsExpr()
|
||||
}
|
||||
if thisHS.Eq(n.RHS().Expr()) {
|
||||
return reverseOp, n.LHS().Expr()
|
||||
if thisHS.Eq(n.RHS().AsExpr()) {
|
||||
return reverseOp, n.LHS().AsExpr()
|
||||
}
|
||||
}
|
||||
return 0, nil
|
||||
@@ -74,12 +74,12 @@ func (z *facts) appendFact(fact *a.Expr) {
|
||||
}
|
||||
}
|
||||
case t.IDXBinaryAnd:
|
||||
z.appendFact(fact.LHS().Expr())
|
||||
z.appendFact(fact.RHS().Expr())
|
||||
z.appendFact(fact.LHS().AsExpr())
|
||||
z.appendFact(fact.RHS().AsExpr())
|
||||
return
|
||||
case t.IDXAssociativeAnd:
|
||||
for _, a := range fact.Args() {
|
||||
z.appendFact(a.Expr())
|
||||
z.appendFact(a.AsExpr())
|
||||
}
|
||||
return
|
||||
}
|
||||
@@ -217,7 +217,7 @@ func simplify(tm *t.Map, n *a.Expr) (*a.Expr, error) {
|
||||
return nil, err
|
||||
}
|
||||
if l != lhs || r != rhs {
|
||||
o := a.NewExpr(0, op, 0, 0, l.Node(), nil, r.Node(), nil)
|
||||
o := a.NewExpr(0, op, 0, 0, l.AsNode(), nil, r.AsNode(), nil)
|
||||
o.SetConstValue(n.ConstValue())
|
||||
o.SetMType(n.MType())
|
||||
return o, nil
|
||||
@@ -229,8 +229,8 @@ func simplify(tm *t.Map, n *a.Expr) (*a.Expr, error) {
|
||||
func argValue(tm *t.Map, args []*a.Node, name string) *a.Expr {
|
||||
if x := tm.ByName(name); x != 0 {
|
||||
for _, a := range args {
|
||||
if a.Arg().Name() == x {
|
||||
return a.Arg().Value()
|
||||
if a.AsArg().Name() == x {
|
||||
return a.AsArg().Value()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -246,7 +246,7 @@ func parseBinaryOp(n *a.Expr) (op t.ID, lhs *a.Expr, rhs *a.Expr) {
|
||||
if op == t.IDAs {
|
||||
return 0, nil, nil
|
||||
}
|
||||
return op, n.LHS().Expr(), n.RHS().Expr()
|
||||
return op, n.LHS().AsExpr(), n.RHS().AsExpr()
|
||||
}
|
||||
|
||||
func proveBinaryOpConstValues(op t.ID, lMin *big.Int, lMax *big.Int, rMin *big.Int, rMax *big.Int) (ok bool) {
|
||||
@@ -290,16 +290,16 @@ func (q *checker) proveBinaryOp(op t.ID, lhs *a.Expr, rhs *a.Expr) error {
|
||||
}
|
||||
|
||||
for _, x := range q.facts {
|
||||
if !x.LHS().Expr().Eq(lhs) {
|
||||
if !x.LHS().AsExpr().Eq(lhs) {
|
||||
continue
|
||||
}
|
||||
factOp := x.Operator()
|
||||
if opImpliesOp(factOp, op) && x.RHS().Expr().Eq(rhs) {
|
||||
if opImpliesOp(factOp, op) && x.RHS().AsExpr().Eq(rhs) {
|
||||
return nil
|
||||
}
|
||||
|
||||
if factOp == t.IDXBinaryEqEq && rcv != nil {
|
||||
if factCV := x.RHS().Expr().ConstValue(); factCV != nil {
|
||||
if factCV := x.RHS().AsExpr().ConstValue(); factCV != nil {
|
||||
switch op {
|
||||
case t.IDXBinaryNotEq:
|
||||
return errFailedOrNil(factCV.Cmp(rcv) != 0)
|
||||
@@ -350,7 +350,7 @@ func proveReasonRequirement(q *checker, op t.ID, lhs *a.Expr, rhs *a.Expr) error
|
||||
"check: internal error: proveReasonRequirement token (0x%02X) is not an XBinaryOp", op)
|
||||
}
|
||||
if err := q.proveBinaryOp(op, lhs, rhs); err != nil {
|
||||
n := a.NewExpr(0, op, 0, 0, lhs.Node(), nil, rhs.Node(), nil)
|
||||
n := a.NewExpr(0, op, 0, 0, lhs.AsNode(), nil, rhs.AsNode(), nil)
|
||||
return fmt.Errorf("cannot prove %q: %v", n.Str(q.tm), err)
|
||||
}
|
||||
return nil
|
||||
|
||||
+68
-66
@@ -121,7 +121,7 @@ func invert(tm *t.Map, n *a.Expr) (*a.Expr, error) {
|
||||
if cv := n.ConstValue(); cv != nil {
|
||||
return nil, fmt.Errorf("check: invert(%q) called on constant expression", n.Str(tm))
|
||||
}
|
||||
op, lhs, rhs, args := n.Operator(), n.LHS().Expr(), n.RHS().Expr(), []*a.Node(nil)
|
||||
op, lhs, rhs, args := n.Operator(), n.LHS().AsExpr(), n.RHS().AsExpr(), []*a.Node(nil)
|
||||
switch op {
|
||||
case t.IDXUnaryNot:
|
||||
return rhs, nil
|
||||
@@ -155,11 +155,11 @@ func invert(tm *t.Map, n *a.Expr) (*a.Expr, error) {
|
||||
case t.IDXAssociativeAnd, t.IDXAssociativeOr:
|
||||
args = make([]*a.Node, 0, len(n.Args()))
|
||||
for _, a := range n.Args() {
|
||||
v, err := invert(tm, a.Expr())
|
||||
v, err := invert(tm, a.AsExpr())
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
args = append(args, v.Node())
|
||||
args = append(args, v.AsNode())
|
||||
}
|
||||
if op == t.IDXAssociativeAnd {
|
||||
op = t.IDXAssociativeOr
|
||||
@@ -169,7 +169,7 @@ func invert(tm *t.Map, n *a.Expr) (*a.Expr, error) {
|
||||
default:
|
||||
op, lhs, rhs = t.IDXUnaryNot, nil, n
|
||||
}
|
||||
o := a.NewExpr(n.Node().Raw().Flags(), op, 0, 0, lhs.Node(), nil, rhs.Node(), args)
|
||||
o := a.NewExpr(n.AsNode().AsRaw().Flags(), op, 0, 0, lhs.AsNode(), nil, rhs.AsNode(), args)
|
||||
o.SetMType(n.MType())
|
||||
return o, nil
|
||||
}
|
||||
@@ -211,7 +211,7 @@ loop:
|
||||
case a.KJump:
|
||||
break loop
|
||||
case a.KRet:
|
||||
if o.Ret().Keyword() == t.IDReturn {
|
||||
if o.AsRet().Keyword() == t.IDReturn {
|
||||
break loop
|
||||
}
|
||||
// o is a yield statement.
|
||||
@@ -232,7 +232,7 @@ loop:
|
||||
}
|
||||
|
||||
func (q *checker) bcheckStatement(n *a.Node) error {
|
||||
q.errFilename, q.errLine = n.Raw().FilenameLine()
|
||||
q.errFilename, q.errLine = n.AsRaw().FilenameLine()
|
||||
|
||||
// TODO: be principled about checking for provenNotToSuspend. Should we
|
||||
// call optimizeSuspendible only for assignments, for var statements too,
|
||||
@@ -240,14 +240,14 @@ func (q *checker) bcheckStatement(n *a.Node) error {
|
||||
|
||||
switch n.Kind() {
|
||||
case a.KAssert:
|
||||
return q.bcheckAssert(n.Assert())
|
||||
return q.bcheckAssert(n.AsAssert())
|
||||
|
||||
case a.KAssign:
|
||||
n := n.Assign()
|
||||
n := n.AsAssign()
|
||||
return q.bcheckAssignment(n.LHS(), n.Operator(), n.RHS())
|
||||
|
||||
case a.KExpr:
|
||||
n := n.Expr()
|
||||
n := n.AsExpr()
|
||||
if _, _, err := q.bcheckExpr(n, 0); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -259,7 +259,7 @@ func (q *checker) bcheckStatement(n *a.Node) error {
|
||||
return nil
|
||||
|
||||
case a.KIOBind:
|
||||
n := n.IOBind()
|
||||
n := n.AsIOBind()
|
||||
if err := q.bcheckBlock(n.Body()); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -267,12 +267,12 @@ func (q *checker) bcheckStatement(n *a.Node) error {
|
||||
return nil
|
||||
|
||||
case a.KIf:
|
||||
return q.bcheckIf(n.If())
|
||||
return q.bcheckIf(n.AsIf())
|
||||
|
||||
case a.KIterate:
|
||||
n := n.Iterate()
|
||||
n := n.AsIterate()
|
||||
for _, o := range n.Variables() {
|
||||
if err := q.bcheckVar(o.Var(), true); err != nil {
|
||||
if err := q.bcheckVar(o.AsVar(), true); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
@@ -284,7 +284,7 @@ func (q *checker) bcheckStatement(n *a.Node) error {
|
||||
for ; n != nil; n = n.ElseIterate() {
|
||||
q.facts = q.facts[:0]
|
||||
for _, o := range variables {
|
||||
v := o.Var()
|
||||
v := o.AsVar()
|
||||
q.facts = append(q.facts, makeSliceLengthEqEq(v.Name(), v.XType(), n.Length()))
|
||||
}
|
||||
for _, o := range n.Body() {
|
||||
@@ -298,16 +298,16 @@ func (q *checker) bcheckStatement(n *a.Node) error {
|
||||
return nil
|
||||
|
||||
case a.KJump:
|
||||
n := n.Jump()
|
||||
n := n.AsJump()
|
||||
skip := t.IDPost
|
||||
if n.Keyword() == t.IDBreak {
|
||||
skip = t.IDPre
|
||||
}
|
||||
for _, o := range n.JumpTarget().Asserts() {
|
||||
if o.Assert().Keyword() == skip {
|
||||
if o.AsAssert().Keyword() == skip {
|
||||
continue
|
||||
}
|
||||
if err := q.bcheckAssert(o.Assert()); err != nil {
|
||||
if err := q.bcheckAssert(o.AsAssert()); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
@@ -318,10 +318,10 @@ func (q *checker) bcheckStatement(n *a.Node) error {
|
||||
// TODO.
|
||||
|
||||
case a.KVar:
|
||||
return q.bcheckVar(n.Var(), false)
|
||||
return q.bcheckVar(n.AsVar(), false)
|
||||
|
||||
case a.KWhile:
|
||||
return q.bcheckWhile(n.While())
|
||||
return q.bcheckWhile(n.AsWhile())
|
||||
|
||||
default:
|
||||
return fmt.Errorf("check: unrecognized ast.Kind (%s) for bcheckStatement", n.Kind())
|
||||
@@ -351,7 +351,8 @@ func (q *checker) bcheckAssert(n *a.Assert) error {
|
||||
err = fmt.Errorf("no such reason %s", reasonID.Str(q.tm))
|
||||
}
|
||||
} else if condition.Operator().IsBinaryOp() && condition.Operator() != t.IDAs {
|
||||
err = q.proveBinaryOp(condition.Operator(), condition.LHS().Expr(), condition.RHS().Expr())
|
||||
err = q.proveBinaryOp(condition.Operator(),
|
||||
condition.LHS().AsExpr(), condition.RHS().AsExpr())
|
||||
}
|
||||
|
||||
if err != nil {
|
||||
@@ -385,7 +386,7 @@ func (q *checker) bcheckAssignment(lhs *a.Expr, op t.ID, rhs *a.Expr) error {
|
||||
}
|
||||
|
||||
if lhs.Pure() && rhs.Pure() && lhs.MType().IsNumType() {
|
||||
o := a.NewExpr(0, t.IDXBinaryEqEq, 0, 0, lhs.Node(), nil, rhs.Node(), nil)
|
||||
o := a.NewExpr(0, t.IDXBinaryEqEq, 0, 0, lhs.AsNode(), nil, rhs.AsNode(), nil)
|
||||
o.SetMType(lhs.MType())
|
||||
q.facts.appendFact(o)
|
||||
}
|
||||
@@ -404,13 +405,13 @@ func (q *checker) bcheckAssignment(lhs *a.Expr, op t.ID, rhs *a.Expr) error {
|
||||
}
|
||||
switch op {
|
||||
case t.IDPlusEq, t.IDMinusEq:
|
||||
oRHS := a.NewExpr(0, op.BinaryForm(), 0, 0, xRHS.Node(), nil, rhs.Node(), nil)
|
||||
oRHS := a.NewExpr(0, op.BinaryForm(), 0, 0, xRHS.AsNode(), nil, rhs.AsNode(), nil)
|
||||
oRHS.SetMType(xRHS.MType())
|
||||
oRHS, err := simplify(q.tm, oRHS)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
o := a.NewExpr(0, xOp, 0, 0, xLHS.Node(), nil, oRHS.Node(), nil)
|
||||
o := a.NewExpr(0, xOp, 0, 0, xLHS.AsNode(), nil, oRHS.AsNode(), nil)
|
||||
o.SetMType(x.MType())
|
||||
return o, nil
|
||||
}
|
||||
@@ -506,7 +507,7 @@ func terminates(body []*a.Node) bool {
|
||||
n := body[len(body)-1]
|
||||
switch n.Kind() {
|
||||
case a.KIf:
|
||||
n := n.If()
|
||||
n := n.AsIf()
|
||||
for {
|
||||
if !terminates(n.BodyIfTrue()) {
|
||||
return false
|
||||
@@ -523,7 +524,7 @@ func terminates(body []*a.Node) bool {
|
||||
case a.KJump:
|
||||
return true
|
||||
case a.KRet:
|
||||
return n.Ret().Keyword() == t.IDReturn
|
||||
return n.AsRet().Keyword() == t.IDReturn
|
||||
}
|
||||
return false
|
||||
}
|
||||
@@ -614,10 +615,10 @@ func (q *checker) bcheckIf(n *a.If) error {
|
||||
func (q *checker) bcheckWhile(n *a.While) error {
|
||||
// Check the pre and inv conditions on entry.
|
||||
for _, o := range n.Asserts() {
|
||||
if o.Assert().Keyword() == t.IDPost {
|
||||
if o.AsAssert().Keyword() == t.IDPost {
|
||||
continue
|
||||
}
|
||||
if err := q.bcheckAssert(o.Assert()); err != nil {
|
||||
if err := q.bcheckAssert(o.AsAssert()); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
@@ -643,10 +644,10 @@ func (q *checker) bcheckWhile(n *a.While) error {
|
||||
} else {
|
||||
q.facts = q.facts[:0]
|
||||
for _, o := range n.Asserts() {
|
||||
if o.Assert().Keyword() == t.IDPost {
|
||||
if o.AsAssert().Keyword() == t.IDPost {
|
||||
continue
|
||||
}
|
||||
q.facts.appendFact(o.Assert().Condition())
|
||||
q.facts.appendFact(o.AsAssert().Condition())
|
||||
}
|
||||
if inverse, err := invert(q.tm, n.Condition()); err != nil {
|
||||
return err
|
||||
@@ -654,8 +655,8 @@ func (q *checker) bcheckWhile(n *a.While) error {
|
||||
q.facts.appendFact(inverse)
|
||||
}
|
||||
for _, o := range n.Asserts() {
|
||||
if o.Assert().Keyword() == t.IDPost {
|
||||
if err := q.bcheckAssert(o.Assert()); err != nil {
|
||||
if o.AsAssert().Keyword() == t.IDPost {
|
||||
if err := q.bcheckAssert(o.AsAssert()); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
@@ -669,10 +670,10 @@ func (q *checker) bcheckWhile(n *a.While) error {
|
||||
// Assume the pre and inv conditions...
|
||||
q.facts = q.facts[:0]
|
||||
for _, o := range n.Asserts() {
|
||||
if o.Assert().Keyword() == t.IDPost {
|
||||
if o.AsAssert().Keyword() == t.IDPost {
|
||||
continue
|
||||
}
|
||||
q.facts.appendFact(o.Assert().Condition())
|
||||
q.facts.appendFact(o.AsAssert().Condition())
|
||||
}
|
||||
// ...and the while condition, unless it is the redundant "true".
|
||||
if cv == nil {
|
||||
@@ -686,10 +687,10 @@ func (q *checker) bcheckWhile(n *a.While) error {
|
||||
// body.
|
||||
if !terminates(n.Body()) {
|
||||
for _, o := range n.Asserts() {
|
||||
if o.Assert().Keyword() == t.IDPost {
|
||||
if o.AsAssert().Keyword() == t.IDPost {
|
||||
continue
|
||||
}
|
||||
if err := q.bcheckAssert(o.Assert()); err != nil {
|
||||
if err := q.bcheckAssert(o.AsAssert()); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
@@ -699,10 +700,10 @@ func (q *checker) bcheckWhile(n *a.While) error {
|
||||
// Assume the inv and post conditions.
|
||||
q.facts = q.facts[:0]
|
||||
for _, o := range n.Asserts() {
|
||||
if o.Assert().Keyword() == t.IDPre {
|
||||
if o.AsAssert().Keyword() == t.IDPre {
|
||||
continue
|
||||
}
|
||||
q.facts.appendFact(o.Assert().Condition())
|
||||
q.facts.appendFact(o.AsAssert().Condition())
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -767,9 +768,9 @@ func (q *checker) bcheckExpr1(n *a.Expr, depth uint32) (*big.Int, *big.Int, erro
|
||||
return q.bcheckExprUnaryOp(n, depth)
|
||||
case op.IsXBinaryOp():
|
||||
if op == t.IDXBinaryAs {
|
||||
return q.bcheckExpr(n.LHS().Expr(), depth)
|
||||
return q.bcheckExpr(n.LHS().AsExpr(), depth)
|
||||
}
|
||||
return q.bcheckExprBinaryOp(op, n.LHS().Expr(), n.RHS().Expr(), depth)
|
||||
return q.bcheckExprBinaryOp(op, n.LHS().AsExpr(), n.RHS().AsExpr(), depth)
|
||||
case op.IsXAssociativeOp():
|
||||
return q.bcheckExprAssociativeOp(n, depth)
|
||||
}
|
||||
@@ -793,7 +794,7 @@ func (q *checker) bcheckExprOther(n *a.Expr, depth uint32) (*big.Int, *big.Int,
|
||||
}
|
||||
|
||||
case t.IDOpenParen, t.IDTry:
|
||||
lhs := n.LHS().Expr()
|
||||
lhs := n.LHS().AsExpr()
|
||||
if _, _, err := q.bcheckExpr(lhs, depth); err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
@@ -807,11 +808,11 @@ func (q *checker) bcheckExprOther(n *a.Expr, depth uint32) (*big.Int, *big.Int,
|
||||
}
|
||||
|
||||
case t.IDOpenBracket:
|
||||
lhs := n.LHS().Expr()
|
||||
lhs := n.LHS().AsExpr()
|
||||
if _, _, err := q.bcheckExpr(lhs, depth); err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
rhs := n.RHS().Expr()
|
||||
rhs := n.RHS().AsExpr()
|
||||
if _, _, err := q.bcheckExpr(rhs, depth); err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
@@ -831,17 +832,17 @@ func (q *checker) bcheckExprOther(n *a.Expr, depth uint32) (*big.Int, *big.Int,
|
||||
}
|
||||
|
||||
case t.IDColon:
|
||||
lhs := n.LHS().Expr()
|
||||
lhs := n.LHS().AsExpr()
|
||||
if _, _, err := q.bcheckExpr(lhs, depth); err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
mhs := n.MHS().Expr()
|
||||
mhs := n.MHS().AsExpr()
|
||||
if mhs != nil {
|
||||
if _, _, err := q.bcheckExpr(mhs, depth); err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
}
|
||||
rhs := n.RHS().Expr()
|
||||
rhs := n.RHS().AsExpr()
|
||||
if rhs != nil {
|
||||
if _, _, err := q.bcheckExpr(rhs, depth); err != nil {
|
||||
return nil, nil, err
|
||||
@@ -883,19 +884,19 @@ func (q *checker) bcheckExprOther(n *a.Expr, depth uint32) (*big.Int, *big.Int,
|
||||
|
||||
case t.IDDot:
|
||||
// TODO: delete this hack that only matches "in".
|
||||
if n.LHS().Expr().Ident() == t.IDIn {
|
||||
if n.LHS().AsExpr().Ident() == t.IDIn {
|
||||
for _, o := range q.astFunc.In().Fields() {
|
||||
o := o.Field()
|
||||
o := o.AsField()
|
||||
if o.Name() == n.Ident() {
|
||||
return q.bcheckTypeExpr(o.XType())
|
||||
}
|
||||
}
|
||||
lTyp := n.LHS().Expr().MType()
|
||||
lTyp := n.LHS().AsExpr().MType()
|
||||
return nil, nil, fmt.Errorf("check: no field named %q found in struct type %q for expression %q",
|
||||
n.Ident().Str(q.tm), lTyp.QID().Str(q.tm), n.Str(q.tm))
|
||||
}
|
||||
|
||||
if _, _, err := q.bcheckExpr(n.LHS().Expr(), depth); err != nil {
|
||||
if _, _, err := q.bcheckExpr(n.LHS().AsExpr(), depth); err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
|
||||
@@ -912,7 +913,7 @@ func (q *checker) bcheckExprCall(n *a.Expr, depth uint32) error {
|
||||
// TODO: handle func pre/post conditions.
|
||||
//
|
||||
// TODO: bcheck the receiver, e.g. ptr vs nptr.
|
||||
lhs := n.LHS().Expr()
|
||||
lhs := n.LHS().AsExpr()
|
||||
f, err := q.c.resolveFunc(lhs.MType())
|
||||
if err != nil {
|
||||
return err
|
||||
@@ -923,7 +924,7 @@ func (q *checker) bcheckExprCall(n *a.Expr, depth uint32) error {
|
||||
lhs.MType().Str(q.tm), len(inFields), len(n.Args()))
|
||||
}
|
||||
for i, o := range n.Args() {
|
||||
if err := q.bcheckAssignment2(nil, inFields[i].Field().XType(), t.IDEq, o.Arg().Value()); err != nil {
|
||||
if err := q.bcheckAssignment2(nil, inFields[i].AsField().XType(), t.IDEq, o.AsArg().Value()); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
@@ -931,8 +932,8 @@ func (q *checker) bcheckExprCall(n *a.Expr, depth uint32) error {
|
||||
}
|
||||
|
||||
func (q *checker) bcheckExprCallSpecialCases(n *a.Expr, depth uint32) (*big.Int, *big.Int, error) {
|
||||
lhs := n.LHS().Expr()
|
||||
recv := lhs.LHS().Expr()
|
||||
lhs := n.LHS().AsExpr()
|
||||
recv := lhs.LHS().AsExpr()
|
||||
method := lhs.Ident()
|
||||
|
||||
if recvTyp := recv.MType(); recvTyp == nil {
|
||||
@@ -944,7 +945,7 @@ func (q *checker) bcheckExprCallSpecialCases(n *a.Expr, depth uint32) (*big.Int,
|
||||
// isn't expressible in Wuffs' function syntax and type system.
|
||||
switch method {
|
||||
case t.IDLowBits, t.IDHighBits:
|
||||
_, aMax, err := q.bcheckExpr(n.Args()[0].Arg().Value(), depth)
|
||||
_, aMax, err := q.bcheckExpr(n.Args()[0].AsArg().Value(), depth)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
@@ -953,11 +954,11 @@ func (q *checker) bcheckExprCallSpecialCases(n *a.Expr, depth uint32) (*big.Int,
|
||||
case t.IDMin, t.IDMax:
|
||||
// TODO: lhs has already been bcheck'ed. There should be no
|
||||
// need to bcheck lhs.LHS().Expr() twice.
|
||||
lMin, lMax, err := q.bcheckExpr(lhs.LHS().Expr(), depth)
|
||||
lMin, lMax, err := q.bcheckExpr(lhs.LHS().AsExpr(), depth)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
aMin, aMax, err := q.bcheckExpr(n.Args()[0].Arg().Value(), depth)
|
||||
aMin, aMax, err := q.bcheckExpr(n.Args()[0].AsArg().Value(), depth)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
@@ -976,8 +977,8 @@ func (q *checker) bcheckExprCallSpecialCases(n *a.Expr, depth uint32) (*big.Int,
|
||||
if len(args) != 2 {
|
||||
return nil, nil, fmt.Errorf("check: internal error: bad skip32_fast arguments")
|
||||
}
|
||||
actual := args[0].Arg().Value()
|
||||
worstCase := args[1].Arg().Value()
|
||||
actual := args[0].AsArg().Value()
|
||||
worstCase := args[1].AsArg().Value()
|
||||
if err := q.proveBinaryOp(t.IDXBinaryLessEq, actual, worstCase); err == errFailed {
|
||||
return nil, nil, fmt.Errorf("check: could not prove skip32_fast precondition: %s <= %s",
|
||||
actual.Str(q.tm), worstCase.Str(q.tm))
|
||||
@@ -1028,9 +1029,9 @@ var ioMethodAdvances = [...]*big.Int{
|
||||
|
||||
// makeSliceLength returns "x.length()".
|
||||
func makeSliceLength(slice *a.Expr) *a.Expr {
|
||||
x := a.NewExpr(0, t.IDDot, 0, t.IDLength, slice.Node(), nil, nil, nil)
|
||||
x.SetMType(a.NewTypeExpr(t.IDFunc, 0, t.IDLength, slice.MType().Node(), nil, nil))
|
||||
x = a.NewExpr(0, t.IDOpenParen, 0, 0, x.Node(), nil, nil, nil)
|
||||
x := a.NewExpr(0, t.IDDot, 0, t.IDLength, slice.AsNode(), nil, nil, nil)
|
||||
x.SetMType(a.NewTypeExpr(t.IDFunc, 0, t.IDLength, slice.MType().AsNode(), nil, nil))
|
||||
x = a.NewExpr(0, t.IDOpenParen, 0, 0, x.AsNode(), nil, nil, nil)
|
||||
x.SetMType(typeExprU64)
|
||||
return x
|
||||
}
|
||||
@@ -1052,13 +1053,13 @@ func makeSliceLengthEqEq(x t.ID, xTyp *a.TypeExpr, n t.ID) *a.Expr {
|
||||
rhs.SetConstValue(big.NewInt(int64(nValue)))
|
||||
rhs.SetMType(typeExprIdeal)
|
||||
|
||||
ret := a.NewExpr(0, t.IDXBinaryEqEq, 0, 0, lhs.Node(), nil, rhs.Node(), nil)
|
||||
ret := a.NewExpr(0, t.IDXBinaryEqEq, 0, 0, lhs.AsNode(), nil, rhs.AsNode(), nil)
|
||||
ret.SetMType(typeExprBool)
|
||||
return ret
|
||||
}
|
||||
|
||||
func (q *checker) bcheckExprUnaryOp(n *a.Expr, depth uint32) (*big.Int, *big.Int, error) {
|
||||
rMin, rMax, err := q.bcheckExpr(n.RHS().Expr(), depth)
|
||||
rMin, rMax, err := q.bcheckExpr(n.RHS().AsExpr(), depth)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
@@ -1267,7 +1268,7 @@ func (q *checker) bcheckExprAssociativeOp(n *a.Expr, depth uint32) (*big.Int, *b
|
||||
if len(args) < 1 {
|
||||
return nil, nil, fmt.Errorf("check: associative op has no arguments")
|
||||
}
|
||||
lMin, lMax, err := q.bcheckExpr(args[0].Expr(), depth)
|
||||
lMin, lMax, err := q.bcheckExpr(args[0].AsExpr(), depth)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
@@ -1275,8 +1276,9 @@ func (q *checker) bcheckExprAssociativeOp(n *a.Expr, depth uint32) (*big.Int, *b
|
||||
if i == 0 {
|
||||
continue
|
||||
}
|
||||
lhs := a.NewExpr(n.Node().Raw().Flags(), n.Operator(), 0, n.Ident(), n.LHS(), n.MHS(), n.RHS(), args[:i])
|
||||
lMin, lMax, err = q.bcheckExprBinaryOp1(op, lhs, lMin, lMax, o.Expr(), depth)
|
||||
lhs := a.NewExpr(n.AsNode().AsRaw().Flags(),
|
||||
n.Operator(), 0, n.Ident(), n.LHS(), n.MHS(), n.RHS(), args[:i])
|
||||
lMin, lMax, err = q.bcheckExprBinaryOp1(op, lhs, lMin, lMax, o.AsExpr(), depth)
|
||||
if err != nil {
|
||||
return nil, nil, err
|
||||
}
|
||||
|
||||
+41
-41
@@ -126,7 +126,7 @@ func Check(tm *t.Map, files []*a.File, resolveUse func(usePath string) ([]byte,
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
f.Node().SetMType(typeExprPlaceholder)
|
||||
f.AsNode().SetMType(typeExprPlaceholder)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -185,7 +185,7 @@ type Checker struct {
|
||||
func (c *Checker) PackageID() uint32 { return c.packageID }
|
||||
|
||||
func (c *Checker) checkPackageID(node *a.Node) error {
|
||||
n := node.PackageID()
|
||||
n := node.AsPackageID()
|
||||
if c.otherPackageID != nil {
|
||||
return &Error{
|
||||
Err: fmt.Errorf("check: multiple packageid declarations"),
|
||||
@@ -214,7 +214,7 @@ func (c *Checker) checkPackageID(node *a.Node) error {
|
||||
}
|
||||
c.packageID = u
|
||||
c.otherPackageID = n
|
||||
n.Node().SetMType(typeExprPlaceholder)
|
||||
n.AsNode().SetMType(typeExprPlaceholder)
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -226,7 +226,7 @@ func (c *Checker) checkPackageIDExists(node *a.Node) error {
|
||||
}
|
||||
|
||||
func (c *Checker) checkUse(node *a.Node) error {
|
||||
usePath := node.Use().Path()
|
||||
usePath := node.AsUse().Path()
|
||||
filename, ok := t.Unescape(usePath.Str(c.tm))
|
||||
if !ok {
|
||||
return fmt.Errorf("check: cannot resolve `use %s`", usePath.Str(c.tm))
|
||||
@@ -259,7 +259,7 @@ func (c *Checker) checkUse(node *a.Node) error {
|
||||
}
|
||||
|
||||
for _, n := range f.TopLevelDecls() {
|
||||
if err := n.Raw().SetPackage(c.tm, baseName); err != nil {
|
||||
if err := n.AsRaw().SetPackage(c.tm, baseName); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
@@ -286,7 +286,7 @@ func (c *Checker) checkUse(node *a.Node) error {
|
||||
}
|
||||
|
||||
func (c *Checker) checkStatus(node *a.Node) error {
|
||||
n := node.Status()
|
||||
n := node.AsStatus()
|
||||
qid := n.QID()
|
||||
if other, ok := c.statuses[qid]; ok {
|
||||
return &Error{
|
||||
@@ -322,12 +322,12 @@ func (c *Checker) checkStatus(node *a.Node) error {
|
||||
c.statusByValue[x] = n.QID()[1]
|
||||
}
|
||||
|
||||
n.Node().SetMType(typeExprPlaceholder)
|
||||
n.AsNode().SetMType(typeExprPlaceholder)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (c *Checker) checkConst(node *a.Node) error {
|
||||
n := node.Const()
|
||||
n := node.AsConst()
|
||||
qid := n.QID()
|
||||
if other, ok := c.consts[qid]; ok {
|
||||
return &Error{
|
||||
@@ -373,7 +373,7 @@ func (c *Checker) checkConst(node *a.Node) error {
|
||||
if err := c.checkConstElement(n.Value(), nMin, nMax, nLists); err != nil {
|
||||
return fmt.Errorf("check: %v for %s", err, qid.Str(c.tm))
|
||||
}
|
||||
n.Node().SetMType(typeExprPlaceholder)
|
||||
n.AsNode().SetMType(typeExprPlaceholder)
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -384,7 +384,7 @@ func (c *Checker) checkConstElement(n *a.Expr, nMin *big.Int, nMax *big.Int, nLi
|
||||
return fmt.Errorf("invalid const value %q", n.Str(c.tm))
|
||||
}
|
||||
for _, o := range n.Args() {
|
||||
if err := c.checkConstElement(o.Expr(), nMin, nMax, nLists); err != nil {
|
||||
if err := c.checkConstElement(o.AsExpr(), nMin, nMax, nLists); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
@@ -397,7 +397,7 @@ func (c *Checker) checkConstElement(n *a.Expr, nMin *big.Int, nMax *big.Int, nLi
|
||||
}
|
||||
|
||||
func (c *Checker) checkStructDecl(node *a.Node) error {
|
||||
n := node.Struct()
|
||||
n := node.AsStruct()
|
||||
qid := n.QID()
|
||||
if other, ok := c.structs[qid]; ok {
|
||||
return &Error{
|
||||
@@ -410,16 +410,16 @@ func (c *Checker) checkStructDecl(node *a.Node) error {
|
||||
}
|
||||
c.structs[qid] = n
|
||||
c.unsortedStructs = append(c.unsortedStructs, n)
|
||||
n.Node().SetMType(typeExprPlaceholder)
|
||||
n.AsNode().SetMType(typeExprPlaceholder)
|
||||
|
||||
// A struct declaration implies a reset method.
|
||||
in := a.NewStruct(0, n.Filename(), n.Line(), t.IDIn, nil)
|
||||
out := a.NewStruct(0, n.Filename(), n.Line(), t.IDOut, nil)
|
||||
f := a.NewFunc(0, n.Filename(), n.Line(), qid[1], t.IDReset, in, out, nil, nil)
|
||||
if qid[0] != 0 {
|
||||
f.Node().Raw().SetPackage(c.tm, qid[0])
|
||||
f.AsNode().AsRaw().SetPackage(c.tm, qid[0])
|
||||
}
|
||||
return c.checkFuncSignature(f.Node())
|
||||
return c.checkFuncSignature(f.AsNode())
|
||||
}
|
||||
|
||||
func (c *Checker) checkStructCycles(_ *a.Node) error {
|
||||
@@ -430,7 +430,7 @@ func (c *Checker) checkStructCycles(_ *a.Node) error {
|
||||
}
|
||||
|
||||
func (c *Checker) checkStructFields(node *a.Node) error {
|
||||
n := node.Struct()
|
||||
n := node.AsStruct()
|
||||
if err := c.checkFields(n.Fields(), true, true); err != nil {
|
||||
return &Error{
|
||||
Err: fmt.Errorf("%v in struct %s", err, n.QID().Str(c.tm)),
|
||||
@@ -452,7 +452,7 @@ func (c *Checker) checkFields(fields []*a.Node, banPtrTypes bool, checkDefaultZe
|
||||
}
|
||||
fieldNames := map[t.ID]bool{}
|
||||
for _, n := range fields {
|
||||
f := n.Field()
|
||||
f := n.AsField()
|
||||
if _, ok := fieldNames[f.Name()]; ok {
|
||||
return fmt.Errorf("check: duplicate field %q", f.Name().Str(c.tm))
|
||||
}
|
||||
@@ -477,14 +477,14 @@ func (c *Checker) checkFields(fields []*a.Node, banPtrTypes bool, checkDefaultZe
|
||||
}
|
||||
|
||||
fieldNames[f.Name()] = true
|
||||
f.Node().SetMType(typeExprPlaceholder)
|
||||
f.AsNode().SetMType(typeExprPlaceholder)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (c *Checker) checkFuncSignature(node *a.Node) error {
|
||||
n := node.Func()
|
||||
n := node.AsFunc()
|
||||
if err := c.checkFields(n.In().Fields(), false, false); err != nil {
|
||||
return &Error{
|
||||
Err: fmt.Errorf("%v in in-params for func %s", err, n.QQID().Str(c.tm)),
|
||||
@@ -492,7 +492,7 @@ func (c *Checker) checkFuncSignature(node *a.Node) error {
|
||||
Line: n.Line(),
|
||||
}
|
||||
}
|
||||
n.In().Node().SetMType(typeExprPlaceholder)
|
||||
n.In().AsNode().SetMType(typeExprPlaceholder)
|
||||
if err := c.checkFields(n.Out().Fields(), false, true); err != nil {
|
||||
return &Error{
|
||||
Err: fmt.Errorf("%v in out-params for func %s", err, n.QQID().Str(c.tm)),
|
||||
@@ -500,8 +500,8 @@ func (c *Checker) checkFuncSignature(node *a.Node) error {
|
||||
Line: n.Line(),
|
||||
}
|
||||
}
|
||||
n.Out().Node().SetMType(typeExprPlaceholder)
|
||||
n.Node().SetMType(typeExprPlaceholder)
|
||||
n.Out().AsNode().SetMType(typeExprPlaceholder)
|
||||
n.AsNode().SetMType(typeExprPlaceholder)
|
||||
|
||||
// TODO: check somewhere that, if n.Out() is non-empty (or we are
|
||||
// suspendible), that we end with a return statement? Or is that an
|
||||
@@ -528,10 +528,10 @@ func (c *Checker) checkFuncSignature(node *a.Node) error {
|
||||
|
||||
iQID := n.In().QID()
|
||||
inTyp := a.NewTypeExpr(0, iQID[0], iQID[1], nil, nil, nil)
|
||||
inTyp.Node().SetMType(typeExprPlaceholder)
|
||||
inTyp.AsNode().SetMType(typeExprPlaceholder)
|
||||
oQID := n.Out().QID()
|
||||
outTyp := a.NewTypeExpr(0, oQID[0], oQID[1], nil, nil, nil)
|
||||
outTyp.Node().SetMType(typeExprPlaceholder)
|
||||
outTyp.AsNode().SetMType(typeExprPlaceholder)
|
||||
localVars := typeMap{
|
||||
t.IDIn: inTyp,
|
||||
t.IDOut: outTyp,
|
||||
@@ -545,9 +545,9 @@ func (c *Checker) checkFuncSignature(node *a.Node) error {
|
||||
}
|
||||
}
|
||||
sTyp := a.NewTypeExpr(0, qqid[0], qqid[1], nil, nil, nil)
|
||||
sTyp.Node().SetMType(typeExprPlaceholder)
|
||||
sTyp.AsNode().SetMType(typeExprPlaceholder)
|
||||
pTyp := a.NewTypeExpr(t.IDPtr, 0, 0, nil, nil, sTyp)
|
||||
pTyp.Node().SetMType(typeExprPlaceholder)
|
||||
pTyp.AsNode().SetMType(typeExprPlaceholder)
|
||||
localVars[t.IDThis] = pTyp
|
||||
}
|
||||
c.localVars[qqid] = localVars
|
||||
@@ -555,7 +555,7 @@ func (c *Checker) checkFuncSignature(node *a.Node) error {
|
||||
}
|
||||
|
||||
func (c *Checker) checkFuncContract(node *a.Node) error {
|
||||
n := node.Func()
|
||||
n := node.AsFunc()
|
||||
if len(n.Asserts()) == 0 {
|
||||
return nil
|
||||
}
|
||||
@@ -564,7 +564,7 @@ func (c *Checker) checkFuncContract(node *a.Node) error {
|
||||
tm: c.tm,
|
||||
}
|
||||
for _, o := range n.Asserts() {
|
||||
if err := q.tcheckAssert(o.Assert()); err != nil {
|
||||
if err := q.tcheckAssert(o.AsAssert()); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
@@ -572,7 +572,7 @@ func (c *Checker) checkFuncContract(node *a.Node) error {
|
||||
}
|
||||
|
||||
func (c *Checker) checkFuncBody(node *a.Node) error {
|
||||
n := node.Func()
|
||||
n := node.AsFunc()
|
||||
if len(n.Body()) == 0 {
|
||||
return nil
|
||||
}
|
||||
@@ -622,10 +622,10 @@ func (c *Checker) checkFuncBody(node *a.Node) error {
|
||||
}
|
||||
|
||||
func (c *Checker) checkFieldMethodCollisions(node *a.Node) error {
|
||||
n := node.Struct()
|
||||
n := node.AsStruct()
|
||||
for _, o := range n.Fields() {
|
||||
nQID := n.QID()
|
||||
qqid := t.QQID{nQID[0], nQID[1], o.Field().Name()}
|
||||
qqid := t.QQID{nQID[0], nQID[1], o.AsField().Name()}
|
||||
if _, ok := c.funcs[qqid]; ok {
|
||||
return fmt.Errorf("check: struct %q has both a field and method named %q",
|
||||
nQID.Str(c.tm), qqid[2].Str(c.tm))
|
||||
@@ -636,22 +636,22 @@ func (c *Checker) checkFieldMethodCollisions(node *a.Node) error {
|
||||
|
||||
func (c *Checker) checkAllTypeChecked(node *a.Node) error {
|
||||
for _, v := range c.consts {
|
||||
if err := allTypeChecked(c.tm, v.Node()); err != nil {
|
||||
if err := allTypeChecked(c.tm, v.AsNode()); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
for _, v := range c.funcs {
|
||||
if err := allTypeChecked(c.tm, v.Node()); err != nil {
|
||||
if err := allTypeChecked(c.tm, v.AsNode()); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
for _, v := range c.statuses {
|
||||
if err := allTypeChecked(c.tm, v.Node()); err != nil {
|
||||
if err := allTypeChecked(c.tm, v.AsNode()); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
for _, v := range c.structs {
|
||||
if err := allTypeChecked(c.tm, v.Node()); err != nil {
|
||||
if err := allTypeChecked(c.tm, v.AsNode()); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
@@ -665,27 +665,27 @@ func allTypeChecked(tm *t.Map, n *a.Node) error {
|
||||
switch o.Kind() {
|
||||
case a.KConst:
|
||||
return fmt.Errorf("check: internal error: unchecked %s node %q",
|
||||
o.Kind(), o.Const().QID().Str(tm))
|
||||
o.Kind(), o.AsConst().QID().Str(tm))
|
||||
case a.KExpr:
|
||||
return fmt.Errorf("check: internal error: unchecked %s node %q",
|
||||
o.Kind(), o.Expr().Str(tm))
|
||||
o.Kind(), o.AsExpr().Str(tm))
|
||||
case a.KFunc:
|
||||
return fmt.Errorf("check: internal error: unchecked %s node %q",
|
||||
o.Kind(), o.Func().QQID().Str(tm))
|
||||
o.Kind(), o.AsFunc().QQID().Str(tm))
|
||||
case a.KTypeExpr:
|
||||
return fmt.Errorf("check: internal error: unchecked %s node %q",
|
||||
o.Kind(), o.TypeExpr().Str(tm))
|
||||
o.Kind(), o.AsTypeExpr().Str(tm))
|
||||
case a.KStatus:
|
||||
return fmt.Errorf("check: internal error: unchecked %s node %q",
|
||||
o.Kind(), o.Status().QID().Str(tm))
|
||||
o.Kind(), o.AsStatus().QID().Str(tm))
|
||||
case a.KStruct:
|
||||
return fmt.Errorf("check: internal error: unchecked %s node %q",
|
||||
o.Kind(), o.Struct().QID().Str(tm))
|
||||
o.Kind(), o.AsStruct().QID().Str(tm))
|
||||
}
|
||||
return fmt.Errorf("check: internal error: unchecked %s node", o.Kind())
|
||||
}
|
||||
if o.Kind() == a.KExpr {
|
||||
o := o.Expr()
|
||||
o := o.AsExpr()
|
||||
if typ.IsIdeal() && o.ConstValue() == nil {
|
||||
return fmt.Errorf("check: internal error: expression %q has ideal number type "+
|
||||
"but no const value", o.Str(tm))
|
||||
|
||||
@@ -253,7 +253,7 @@ func TestConstValues(tt *testing.T) {
|
||||
continue
|
||||
}
|
||||
|
||||
got := body[0].Var().Value().ConstValue()
|
||||
got := body[0].AsVar().Value().ConstValue()
|
||||
want := big.NewInt(wantInt64)
|
||||
if got == nil || want == nil || got.Cmp(want) != 0 {
|
||||
tt.Errorf("%q: got %v, want %v", s, got, want)
|
||||
|
||||
+2
-2
@@ -248,7 +248,7 @@ var reasons = [...]struct {
|
||||
if xc0 == nil {
|
||||
return errFailed
|
||||
}
|
||||
t1 := a.NewExpr(0, t.IDXBinaryPlus, 0, 0, xb0.Node(), nil, xc0.Node(), nil)
|
||||
t1 := a.NewExpr(0, t.IDXBinaryPlus, 0, 0, xb0.AsNode(), nil, xc0.AsNode(), nil)
|
||||
if err := proveReasonRequirement(q, t.IDXBinaryLessThan, xa, t1); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -273,7 +273,7 @@ var reasons = [...]struct {
|
||||
return errFailed
|
||||
}
|
||||
// a <= (c - b)
|
||||
t1 := a.NewExpr(0, t.IDXBinaryMinus, 0, 0, xc.Node(), nil, xb.Node(), nil)
|
||||
t1 := a.NewExpr(0, t.IDXBinaryMinus, 0, 0, xc.AsNode(), nil, xb.AsNode(), nil)
|
||||
if err := proveReasonRequirement(q, t.IDXBinaryLessEq, xa, t1); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
+1
-1
@@ -203,7 +203,7 @@ func genProveReasonRequirement(n *node, name string) error {
|
||||
fmt.Fprintf(&out, "if err := proveReasonRequirement(q, t.ID%s, %s, %s); err != nil { return err }\n",
|
||||
key, l, r)
|
||||
} else {
|
||||
fmt.Fprintf(&out, "%s := a.NewExpr(0, t.ID%s, 0, 0, %s.Node(), nil, %s.Node(), nil)\n",
|
||||
fmt.Fprintf(&out, "%s := a.NewExpr(0, t.ID%s, 0, 0, %s.AsNode(), nil, %s.AsNode(), nil)\n",
|
||||
name, key, l, r)
|
||||
}
|
||||
return nil
|
||||
|
||||
+21
-20
@@ -38,11 +38,11 @@ func splitReceiverMethodArgs(n *a.Expr) (receiver *a.Expr, method t.ID, args []*
|
||||
return nil, 0, nil
|
||||
}
|
||||
args = n.Args()
|
||||
n = n.LHS().Expr()
|
||||
n = n.LHS().AsExpr()
|
||||
if n.Operator() != t.IDDot {
|
||||
return nil, 0, nil
|
||||
}
|
||||
return n.LHS().Expr(), n.Ident(), args
|
||||
return n.LHS().AsExpr(), n.Ident(), args
|
||||
}
|
||||
|
||||
// TODO: should optimizeNonSuspendible be optimizeExpr and check both
|
||||
@@ -82,8 +82,8 @@ func (q *checker) optimizeCopyFromHistory32(n *a.Expr) error {
|
||||
if len(args) != 2 {
|
||||
return nil
|
||||
}
|
||||
d := args[0].Arg().Value()
|
||||
l := args[1].Arg().Value()
|
||||
d := args[0].AsArg().Value()
|
||||
l := args[1].AsArg().Value()
|
||||
|
||||
// Check "distance > 0".
|
||||
check0:
|
||||
@@ -92,10 +92,10 @@ check0:
|
||||
if x.Operator() != t.IDXBinaryGreaterThan {
|
||||
continue
|
||||
}
|
||||
if lhs := x.LHS().Expr(); !lhs.Eq(d) {
|
||||
if lhs := x.LHS().AsExpr(); !lhs.Eq(d) {
|
||||
continue
|
||||
}
|
||||
if rcv := x.RHS().Expr().ConstValue(); rcv == nil || rcv.Sign() != 0 {
|
||||
if rcv := x.RHS().AsExpr().ConstValue(); rcv == nil || rcv.Sign() != 0 {
|
||||
continue
|
||||
}
|
||||
break check0
|
||||
@@ -112,17 +112,17 @@ check1:
|
||||
}
|
||||
|
||||
// Check that the LHS is "d as base.u64".
|
||||
lhs := x.LHS().Expr()
|
||||
lhs := x.LHS().AsExpr()
|
||||
if lhs.Operator() != t.IDXBinaryAs {
|
||||
continue
|
||||
}
|
||||
llhs, lrhs := lhs.LHS().Expr(), lhs.RHS().TypeExpr()
|
||||
llhs, lrhs := lhs.LHS().AsExpr(), lhs.RHS().AsTypeExpr()
|
||||
if !llhs.Eq(d) || !lrhs.Eq(typeExprU64) {
|
||||
continue
|
||||
}
|
||||
|
||||
// Check that the RHS is "nReceiver.since_mark().length()".
|
||||
y, method, yArgs := splitReceiverMethodArgs(x.RHS().Expr())
|
||||
y, method, yArgs := splitReceiverMethodArgs(x.RHS().AsExpr())
|
||||
if method != t.IDLength || len(yArgs) != 0 {
|
||||
continue
|
||||
}
|
||||
@@ -148,17 +148,17 @@ check2:
|
||||
}
|
||||
|
||||
// Check that the LHS is "l as base.u64".
|
||||
lhs := x.LHS().Expr()
|
||||
lhs := x.LHS().AsExpr()
|
||||
if lhs.Operator() != t.IDXBinaryAs {
|
||||
continue
|
||||
}
|
||||
llhs, lrhs := lhs.LHS().Expr(), lhs.RHS().TypeExpr()
|
||||
llhs, lrhs := lhs.LHS().AsExpr(), lhs.RHS().AsTypeExpr()
|
||||
if !llhs.Eq(l) || !lrhs.Eq(typeExprU64) {
|
||||
continue
|
||||
}
|
||||
|
||||
// Check that the RHS is "nReceiver.available()".
|
||||
y, method, yArgs := splitReceiverMethodArgs(x.RHS().Expr())
|
||||
y, method, yArgs := splitReceiverMethodArgs(x.RHS().AsExpr())
|
||||
if method != t.IDAvailable || len(yArgs) != 0 {
|
||||
continue
|
||||
}
|
||||
@@ -182,16 +182,16 @@ func (q *checker) optimizeSuspendible(n *a.Expr, depth uint32) error {
|
||||
depth++
|
||||
|
||||
if !n.CallSuspendible() {
|
||||
for _, o := range n.Node().Raw().SubNodes() {
|
||||
for _, o := range n.AsNode().AsRaw().SubNodes() {
|
||||
if o != nil && o.Kind() == a.KExpr {
|
||||
if err := q.optimizeSuspendible(o.Expr(), depth); err != nil {
|
||||
if err := q.optimizeSuspendible(o.AsExpr(), depth); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
}
|
||||
for _, o := range n.Args() {
|
||||
if o != nil && o.Kind() == a.KExpr {
|
||||
if err := q.optimizeSuspendible(o.Expr(), depth); err != nil {
|
||||
if err := q.optimizeSuspendible(o.AsExpr(), depth); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
@@ -237,21 +237,21 @@ func (q *checker) optimizeIOMethodAdvance(receiver *a.Expr, advance *big.Int, up
|
||||
return x, nil
|
||||
}
|
||||
|
||||
rcv := x.RHS().Expr().ConstValue()
|
||||
rcv := x.RHS().AsExpr().ConstValue()
|
||||
if rcv == nil {
|
||||
return x, nil
|
||||
}
|
||||
|
||||
// Check that lhs is "receiver.available()".
|
||||
lhs := x.LHS().Expr()
|
||||
lhs := x.LHS().AsExpr()
|
||||
if lhs.Operator() != t.IDOpenParen || len(lhs.Args()) != 0 {
|
||||
return x, nil
|
||||
}
|
||||
lhs = lhs.LHS().Expr()
|
||||
lhs = lhs.LHS().AsExpr()
|
||||
if lhs.Operator() != t.IDDot || lhs.Ident() != t.IDAvailable {
|
||||
return x, nil
|
||||
}
|
||||
lhs = lhs.LHS().Expr()
|
||||
lhs = lhs.LHS().AsExpr()
|
||||
if !lhs.Eq(receiver) {
|
||||
return x, nil
|
||||
}
|
||||
@@ -290,7 +290,8 @@ func (q *checker) optimizeIOMethodAdvance(receiver *a.Expr, advance *big.Int, up
|
||||
o.SetConstValue(newRCV)
|
||||
o.SetMType(typeExprIdeal)
|
||||
|
||||
return a.NewExpr(x.Node().Raw().Flags(), t.IDXBinaryGreaterEq, 0, 0, x.LHS(), nil, o.Node(), nil), nil
|
||||
return a.NewExpr(x.AsNode().AsRaw().Flags(),
|
||||
t.IDXBinaryGreaterEq, 0, 0, x.LHS(), nil, o.AsNode(), nil), nil
|
||||
})
|
||||
return retOK, retErr
|
||||
}
|
||||
|
||||
@@ -132,9 +132,9 @@ func (c *Checker) parseBuiltInFuncs(ss []string, generic bool) (map[t.QQID]*a.Fu
|
||||
if len(tlds) != 1 || tlds[0].Kind() != a.KFunc {
|
||||
return nil, fmt.Errorf("check: parsing %q: got %d top level decls, want %d", s, len(tlds), 1)
|
||||
}
|
||||
f := tlds[0].Func()
|
||||
f.Node().Raw().SetPackage(c.tm, t.IDBase)
|
||||
if err := c.checkFuncSignature(f.Node()); err != nil {
|
||||
f := tlds[0].AsFunc()
|
||||
f.AsNode().AsRaw().SetPackage(c.tm, t.IDBase)
|
||||
if err := c.checkFuncSignature(f.AsNode()); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
|
||||
+52
-52
@@ -26,11 +26,11 @@ import (
|
||||
|
||||
func (q *checker) tcheckVars(block []*a.Node) error {
|
||||
for _, o := range block {
|
||||
q.errFilename, q.errLine = o.Raw().FilenameLine()
|
||||
q.errFilename, q.errLine = o.AsRaw().FilenameLine()
|
||||
|
||||
switch o.Kind() {
|
||||
case a.KIf:
|
||||
for o := o.If(); o != nil; o = o.ElseIf() {
|
||||
for o := o.AsIf(); o != nil; o = o.ElseIf() {
|
||||
if err := q.tcheckVars(o.BodyIfTrue()); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -40,12 +40,12 @@ func (q *checker) tcheckVars(block []*a.Node) error {
|
||||
}
|
||||
|
||||
case a.KIOBind:
|
||||
if err := q.tcheckVars(o.IOBind().Body()); err != nil {
|
||||
if err := q.tcheckVars(o.AsIOBind().Body()); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
case a.KIterate:
|
||||
for o := o.Iterate(); o != nil; o = o.ElseIterate() {
|
||||
for o := o.AsIterate(); o != nil; o = o.ElseIterate() {
|
||||
if err := q.tcheckVars(o.Variables()); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -55,7 +55,7 @@ func (q *checker) tcheckVars(block []*a.Node) error {
|
||||
}
|
||||
|
||||
case a.KVar:
|
||||
o := o.Var()
|
||||
o := o.AsVar()
|
||||
name := o.Name()
|
||||
if _, ok := q.localVars[name]; ok {
|
||||
return fmt.Errorf("check: duplicate var %q", name.Str(q.tm))
|
||||
@@ -66,7 +66,7 @@ func (q *checker) tcheckVars(block []*a.Node) error {
|
||||
q.localVars[name] = o.XType()
|
||||
|
||||
case a.KWhile:
|
||||
if err := q.tcheckVars(o.While().Body()); err != nil {
|
||||
if err := q.tcheckVars(o.AsWhile().Body()); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
@@ -75,24 +75,24 @@ func (q *checker) tcheckVars(block []*a.Node) error {
|
||||
}
|
||||
|
||||
func (q *checker) tcheckStatement(n *a.Node) error {
|
||||
q.errFilename, q.errLine = n.Raw().FilenameLine()
|
||||
q.errFilename, q.errLine = n.AsRaw().FilenameLine()
|
||||
|
||||
switch n.Kind() {
|
||||
case a.KAssert:
|
||||
if err := q.tcheckAssert(n.Assert()); err != nil {
|
||||
if err := q.tcheckAssert(n.AsAssert()); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
case a.KAssign:
|
||||
if err := q.tcheckAssign(n.Assign()); err != nil {
|
||||
if err := q.tcheckAssign(n.AsAssign()); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
case a.KExpr:
|
||||
return q.tcheckExpr(n.Expr(), 0)
|
||||
return q.tcheckExpr(n.AsExpr(), 0)
|
||||
|
||||
case a.KIf:
|
||||
for n := n.If(); n != nil; n = n.ElseIf() {
|
||||
for n := n.AsIf(); n != nil; n = n.ElseIf() {
|
||||
cond := n.Condition()
|
||||
if err := q.tcheckExpr(cond, 0); err != nil {
|
||||
return err
|
||||
@@ -112,20 +112,20 @@ func (q *checker) tcheckStatement(n *a.Node) error {
|
||||
}
|
||||
}
|
||||
}
|
||||
for n := n.If(); n != nil; n = n.ElseIf() {
|
||||
n.Node().SetMType(typeExprPlaceholder)
|
||||
for n := n.AsIf(); n != nil; n = n.ElseIf() {
|
||||
n.AsNode().SetMType(typeExprPlaceholder)
|
||||
}
|
||||
return nil
|
||||
|
||||
case a.KIOBind:
|
||||
n := n.IOBind()
|
||||
n := n.AsIOBind()
|
||||
for _, o := range n.InFields() {
|
||||
if err := q.tcheckExpr(o.Expr(), 0); err != nil {
|
||||
if err := q.tcheckExpr(o.AsExpr(), 0); err != nil {
|
||||
return err
|
||||
}
|
||||
if typ := o.Expr().MType(); !typ.IsIOType() {
|
||||
if typ := o.AsExpr().MType(); !typ.IsIOType() {
|
||||
return fmt.Errorf("check: io_bind expression %q, of type %q, does not have an I/O type",
|
||||
o.Expr().Str(q.tm), typ.Str(q.tm))
|
||||
o.AsExpr().Str(q.tm), typ.Str(q.tm))
|
||||
}
|
||||
}
|
||||
for _, o := range n.Body() {
|
||||
@@ -137,7 +137,7 @@ func (q *checker) tcheckStatement(n *a.Node) error {
|
||||
}
|
||||
|
||||
case a.KIterate:
|
||||
for n := n.Iterate(); n != nil; n = n.ElseIterate() {
|
||||
for n := n.AsIterate(); n != nil; n = n.ElseIterate() {
|
||||
for _, o := range n.Variables() {
|
||||
if err := q.tcheckStatement(o); err != nil {
|
||||
return err
|
||||
@@ -149,13 +149,13 @@ func (q *checker) tcheckStatement(n *a.Node) error {
|
||||
return err
|
||||
}
|
||||
}
|
||||
for n := n.Iterate(); n != nil; n = n.ElseIterate() {
|
||||
n.Node().SetMType(typeExprPlaceholder)
|
||||
for n := n.AsIterate(); n != nil; n = n.ElseIterate() {
|
||||
n.AsNode().SetMType(typeExprPlaceholder)
|
||||
}
|
||||
return nil
|
||||
|
||||
case a.KJump:
|
||||
n := n.Jump()
|
||||
n := n.AsJump()
|
||||
jumpTarget := (a.Loop)(nil)
|
||||
if id := n.Label(); id != 0 {
|
||||
for i := len(q.jumpTargets) - 1; i >= 0; i-- {
|
||||
@@ -183,7 +183,7 @@ func (q *checker) tcheckStatement(n *a.Node) error {
|
||||
n.SetJumpTarget(jumpTarget)
|
||||
|
||||
case a.KRet:
|
||||
n := n.Ret()
|
||||
n := n.AsRet()
|
||||
if value := n.Value(); value != nil {
|
||||
if err := q.tcheckExpr(value, 0); err != nil {
|
||||
return err
|
||||
@@ -193,8 +193,8 @@ func (q *checker) tcheckStatement(n *a.Node) error {
|
||||
}
|
||||
|
||||
case a.KVar:
|
||||
n := n.Var()
|
||||
if n.XType().Node().MType() == nil {
|
||||
n := n.AsVar()
|
||||
if n.XType().AsNode().MType() == nil {
|
||||
return fmt.Errorf("check: internal error: unchecked type expression %q", n.XType().Str(q.tm))
|
||||
}
|
||||
if value := n.Value(); value != nil {
|
||||
@@ -222,7 +222,7 @@ func (q *checker) tcheckStatement(n *a.Node) error {
|
||||
}
|
||||
|
||||
case a.KWhile:
|
||||
n := n.While()
|
||||
n := n.AsWhile()
|
||||
cond := n.Condition()
|
||||
if err := q.tcheckExpr(cond, 0); err != nil {
|
||||
return err
|
||||
@@ -253,7 +253,7 @@ func (q *checker) tcheckAssert(n *a.Assert) error {
|
||||
cond.Str(q.tm), cond.MType().Str(q.tm))
|
||||
}
|
||||
for _, o := range n.Args() {
|
||||
if err := q.tcheckExpr(o.Arg().Value(), 0); err != nil {
|
||||
if err := q.tcheckExpr(o.AsArg().Value(), 0); err != nil {
|
||||
return err
|
||||
}
|
||||
o.SetMType(typeExprPlaceholder)
|
||||
@@ -323,7 +323,7 @@ func (q *checker) tcheckAssign(n *a.Assign) error {
|
||||
|
||||
func (q *checker) tcheckLoop(n a.Loop) error {
|
||||
for _, o := range n.Asserts() {
|
||||
if err := q.tcheckAssert(o.Assert()); err != nil {
|
||||
if err := q.tcheckAssert(o.AsAssert()); err != nil {
|
||||
return err
|
||||
}
|
||||
o.SetMType(typeExprPlaceholder)
|
||||
@@ -413,11 +413,11 @@ func (q *checker) tcheckExprOther(n *a.Expr, depth uint32) error {
|
||||
|
||||
case t.IDOpenBracket:
|
||||
// n is an index.
|
||||
lhs := n.LHS().Expr()
|
||||
lhs := n.LHS().AsExpr()
|
||||
if err := q.tcheckExpr(lhs, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
rhs := n.RHS().Expr()
|
||||
rhs := n.RHS().AsExpr()
|
||||
if err := q.tcheckExpr(rhs, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -438,7 +438,7 @@ func (q *checker) tcheckExprOther(n *a.Expr, depth uint32) error {
|
||||
// n is a slice.
|
||||
// TODO: require that the i and j in a[i:j] are *unsigned* (or
|
||||
// non-negative constants)?
|
||||
if mhs := n.MHS().Expr(); mhs != nil {
|
||||
if mhs := n.MHS().AsExpr(); mhs != nil {
|
||||
if err := q.tcheckExpr(mhs, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -448,7 +448,7 @@ func (q *checker) tcheckExprOther(n *a.Expr, depth uint32) error {
|
||||
n.Str(q.tm), mhs.Str(q.tm), mTyp.Str(q.tm))
|
||||
}
|
||||
}
|
||||
if rhs := n.RHS().Expr(); rhs != nil {
|
||||
if rhs := n.RHS().AsExpr(); rhs != nil {
|
||||
if err := q.tcheckExpr(rhs, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -458,7 +458,7 @@ func (q *checker) tcheckExprOther(n *a.Expr, depth uint32) error {
|
||||
n.Str(q.tm), rhs.Str(q.tm), rTyp.Str(q.tm))
|
||||
}
|
||||
}
|
||||
lhs := n.LHS().Expr()
|
||||
lhs := n.LHS().AsExpr()
|
||||
if err := q.tcheckExpr(lhs, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -499,7 +499,7 @@ func (q *checker) tcheckExprOther(n *a.Expr, depth uint32) error {
|
||||
|
||||
case t.IDDollar:
|
||||
for _, o := range n.Args() {
|
||||
o := o.Expr()
|
||||
o := o.AsExpr()
|
||||
if err := q.tcheckExpr(o, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -513,7 +513,7 @@ func (q *checker) tcheckExprOther(n *a.Expr, depth uint32) error {
|
||||
}
|
||||
|
||||
func (q *checker) tcheckExprCall(n *a.Expr, depth uint32) error {
|
||||
lhs := n.LHS().Expr()
|
||||
lhs := n.LHS().AsExpr()
|
||||
if err := q.tcheckExpr(lhs, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -546,12 +546,12 @@ func (q *checker) tcheckExprCall(n *a.Expr, depth uint32) error {
|
||||
lhs.MType().Str(q.tm), len(inFields), len(n.Args()))
|
||||
}
|
||||
for i, o := range n.Args() {
|
||||
o := o.Arg()
|
||||
o := o.AsArg()
|
||||
if err := q.tcheckExpr(o.Value(), depth); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
inField := inFields[i].Field()
|
||||
inField := inFields[i].AsField()
|
||||
if o.Name() != inField.Name() {
|
||||
return fmt.Errorf("check: argument name: got %q, want %q", o.Name().Str(q.tm), inField.Name().Str(q.tm))
|
||||
}
|
||||
@@ -565,7 +565,7 @@ func (q *checker) tcheckExprCall(n *a.Expr, depth uint32) error {
|
||||
if err := q.tcheckEq(inField.Name(), nil, inFieldTyp, o.Value(), o.Value().MType()); err != nil {
|
||||
return err
|
||||
}
|
||||
o.Node().SetMType(typeExprPlaceholder)
|
||||
o.AsNode().SetMType(typeExprPlaceholder)
|
||||
}
|
||||
|
||||
// TODO: distinguish t.IDOpenParen vs t.IDTry in a more principled way?
|
||||
@@ -584,7 +584,7 @@ func (q *checker) tcheckExprCall(n *a.Expr, depth uint32) error {
|
||||
case 0:
|
||||
n.SetMType(typeExprEmptyStruct)
|
||||
case 1:
|
||||
oTyp := outFields[0].Field().XType()
|
||||
oTyp := outFields[0].AsField().XType()
|
||||
if genericType1 != nil && oTyp.Eq(typeExprGeneric1) {
|
||||
n.SetMType(genericType1)
|
||||
} else if genericType2 != nil && oTyp.Eq(typeExprGeneric2) {
|
||||
@@ -598,7 +598,7 @@ func (q *checker) tcheckExprCall(n *a.Expr, depth uint32) error {
|
||||
}
|
||||
|
||||
func (q *checker) tcheckDot(n *a.Expr, depth uint32) error {
|
||||
lhs := n.LHS().Expr()
|
||||
lhs := n.LHS().AsExpr()
|
||||
if err := q.tcheckExpr(lhs, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -612,7 +612,7 @@ func (q *checker) tcheckDot(n *a.Expr, depth uint32) error {
|
||||
if q.c.builtInSliceFuncs[qqid] == nil {
|
||||
return fmt.Errorf("check: no slice method %q", n.Ident().Str(q.tm))
|
||||
}
|
||||
n.SetMType(a.NewTypeExpr(t.IDFunc, 0, n.Ident(), lTyp.Node(), nil, nil))
|
||||
n.SetMType(a.NewTypeExpr(t.IDFunc, 0, n.Ident(), lTyp.AsNode(), nil, nil))
|
||||
return nil
|
||||
|
||||
} else if lTyp.IsTableType() {
|
||||
@@ -621,7 +621,7 @@ func (q *checker) tcheckDot(n *a.Expr, depth uint32) error {
|
||||
if q.c.builtInTableFuncs[qqid] == nil {
|
||||
return fmt.Errorf("check: no table method %q", n.Ident().Str(q.tm))
|
||||
}
|
||||
n.SetMType(a.NewTypeExpr(t.IDFunc, 0, n.Ident(), lTyp.Node(), nil, nil))
|
||||
n.SetMType(a.NewTypeExpr(t.IDFunc, 0, n.Ident(), lTyp.AsNode(), nil, nil))
|
||||
return nil
|
||||
|
||||
} else if lTyp.Decorator() != 0 {
|
||||
@@ -629,7 +629,7 @@ func (q *checker) tcheckDot(n *a.Expr, depth uint32) error {
|
||||
}
|
||||
|
||||
if f := q.c.funcs[qqid]; f != nil {
|
||||
n.SetMType(a.NewTypeExpr(t.IDFunc, 0, n.Ident(), lTyp.Node(), nil, nil))
|
||||
n.SetMType(a.NewTypeExpr(t.IDFunc, 0, n.Ident(), lTyp.AsNode(), nil, nil))
|
||||
return nil
|
||||
}
|
||||
|
||||
@@ -653,7 +653,7 @@ func (q *checker) tcheckDot(n *a.Expr, depth uint32) error {
|
||||
}
|
||||
|
||||
for _, field := range s.Fields() {
|
||||
f := field.Field()
|
||||
f := field.AsField()
|
||||
if f.Name() == n.Ident() {
|
||||
n.SetMType(f.XType())
|
||||
return nil
|
||||
@@ -665,7 +665,7 @@ func (q *checker) tcheckDot(n *a.Expr, depth uint32) error {
|
||||
}
|
||||
|
||||
func (q *checker) tcheckExprUnaryOp(n *a.Expr, depth uint32) error {
|
||||
rhs := n.RHS().Expr()
|
||||
rhs := n.RHS().AsExpr()
|
||||
if err := q.tcheckExpr(rhs, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -712,14 +712,14 @@ func (q *checker) tcheckExprUnaryOp(n *a.Expr, depth uint32) error {
|
||||
}
|
||||
|
||||
func (q *checker) tcheckExprBinaryOp(n *a.Expr, depth uint32) error {
|
||||
lhs := n.LHS().Expr()
|
||||
lhs := n.LHS().AsExpr()
|
||||
if err := q.tcheckExpr(lhs, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
lTyp := lhs.MType()
|
||||
op := n.Operator()
|
||||
if op == t.IDXBinaryAs {
|
||||
rhs := n.RHS().TypeExpr()
|
||||
rhs := n.RHS().AsTypeExpr()
|
||||
if err := q.tcheckTypeExpr(rhs, 0); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -730,7 +730,7 @@ func (q *checker) tcheckExprBinaryOp(n *a.Expr, depth uint32) error {
|
||||
return fmt.Errorf("check: cannot convert expression %q, of type %q, as type %q",
|
||||
lhs.Str(q.tm), lTyp.Str(q.tm), rhs.Str(q.tm))
|
||||
}
|
||||
rhs := n.RHS().Expr()
|
||||
rhs := n.RHS().AsExpr()
|
||||
if err := q.tcheckExpr(rhs, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -839,13 +839,13 @@ func evalConstValueBinaryOp(tm *t.Map, n *a.Expr, l *big.Int, r *big.Int) (*big.
|
||||
case t.IDXBinaryShiftL:
|
||||
if r.Sign() < 0 || r.Cmp(ffff) > 0 {
|
||||
return nil, fmt.Errorf("check: shift %q out of range in const expression %q",
|
||||
n.RHS().Expr().Str(tm), n.Str(tm))
|
||||
n.RHS().AsExpr().Str(tm), n.Str(tm))
|
||||
}
|
||||
return big.NewInt(0).Lsh(l, uint(r.Uint64())), nil
|
||||
case t.IDXBinaryShiftR:
|
||||
if r.Sign() < 0 || r.Cmp(ffff) > 0 {
|
||||
return nil, fmt.Errorf("check: shift %q out of range in const expression %q",
|
||||
n.RHS().Expr().Str(tm), n.Str(tm))
|
||||
n.RHS().AsExpr().Str(tm), n.Str(tm))
|
||||
}
|
||||
return big.NewInt(0).Rsh(l, uint(r.Uint64())), nil
|
||||
case t.IDXBinaryAmp:
|
||||
@@ -890,7 +890,7 @@ func (q *checker) tcheckExprAssociativeOp(n *a.Expr, depth uint32) error {
|
||||
|
||||
expr, typ := (*a.Expr)(nil), (*a.TypeExpr)(nil)
|
||||
for _, o := range n.Args() {
|
||||
o := o.Expr()
|
||||
o := o.AsExpr()
|
||||
if err := q.tcheckExpr(o, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -922,7 +922,7 @@ func (q *checker) tcheckExprAssociativeOp(n *a.Expr, depth uint32) error {
|
||||
|
||||
case t.IDXAssociativeAnd, t.IDXAssociativeOr:
|
||||
for _, o := range n.Args() {
|
||||
o := o.Expr()
|
||||
o := o.AsExpr()
|
||||
if err := q.tcheckExpr(o, depth); err != nil {
|
||||
return err
|
||||
}
|
||||
@@ -997,7 +997,7 @@ swtch:
|
||||
default:
|
||||
return fmt.Errorf("check: %q is not a type", typ.Str(q.tm))
|
||||
}
|
||||
typ.Node().SetMType(typeExprPlaceholder)
|
||||
typ.AsNode().SetMType(typeExprPlaceholder)
|
||||
return nil
|
||||
}
|
||||
|
||||
|
||||
+39
-39
@@ -124,9 +124,9 @@ func (p *parser) parseTopLevelDecl() (*a.Node, error) {
|
||||
if u, ok := base38.Encode(s); !ok || u == 0 {
|
||||
return nil, fmt.Errorf(`parse: %q is not a valid packageid`, s)
|
||||
}
|
||||
return a.NewPackageID(p.filename, line, path).Node(), nil
|
||||
return a.NewPackageID(p.filename, line, path).AsNode(), nil
|
||||
} else {
|
||||
return a.NewUse(p.filename, line, path).Node(), nil
|
||||
return a.NewUse(p.filename, line, path).AsNode(), nil
|
||||
}
|
||||
|
||||
case t.IDPub:
|
||||
@@ -161,7 +161,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.NewConst(flags, p.filename, line, id, typ, value).Node(), nil
|
||||
return a.NewConst(flags, p.filename, line, id, typ, value).AsNode(), nil
|
||||
|
||||
case t.IDFunc:
|
||||
p.src = p.src[1:]
|
||||
@@ -224,7 +224,7 @@ func (p *parser) parseTopLevelDecl() (*a.Node, error) {
|
||||
p.src = p.src[1:]
|
||||
in := a.NewStruct(0, p.filename, line, t.IDIn, inFields)
|
||||
out := a.NewStruct(0, p.filename, line, t.IDOut, outFields)
|
||||
return a.NewFunc(flags, p.filename, line, id0, id1, in, out, asserts, body).Node(), nil
|
||||
return a.NewFunc(flags, p.filename, line, id0, id1, in, out, asserts, body).AsNode(), nil
|
||||
|
||||
case t.IDError, t.IDSuspension:
|
||||
keyword := p.src[0].ID
|
||||
@@ -256,7 +256,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.NewStatus(flags, p.filename, line, keyword, value, message).Node(), nil
|
||||
return a.NewStatus(flags, p.filename, line, keyword, value, message).AsNode(), nil
|
||||
|
||||
case t.IDStruct:
|
||||
p.src = p.src[1:]
|
||||
@@ -286,7 +286,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.NewStruct(flags, p.filename, line, name, fields).Node(), nil
|
||||
return a.NewStruct(flags, p.filename, line, name, fields).AsNode(), nil
|
||||
}
|
||||
}
|
||||
return nil, fmt.Errorf(`parse: unrecognized top level declaration at %s:%d`, p.filename, line)
|
||||
@@ -373,7 +373,7 @@ func (p *parser) parseFieldNode() (*a.Node, error) {
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return a.NewField(name, typ).Node(), nil
|
||||
return a.NewField(name, typ).AsNode(), nil
|
||||
}
|
||||
|
||||
func (p *parser) parseTypeExpr() (*a.TypeExpr, error) {
|
||||
@@ -424,7 +424,7 @@ func (p *parser) parseTypeExpr() (*a.TypeExpr, error) {
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return a.NewTypeExpr(decorator, 0, 0, arrayLength.Node(), nil, rhs), nil
|
||||
return a.NewTypeExpr(decorator, 0, 0, arrayLength.AsNode(), nil, rhs), nil
|
||||
}
|
||||
|
||||
pkg, name, err := p.parseQualifiedIdent()
|
||||
@@ -440,7 +440,7 @@ func (p *parser) parseTypeExpr() (*a.TypeExpr, error) {
|
||||
}
|
||||
}
|
||||
|
||||
return a.NewTypeExpr(0, pkg, name, lhs.Node(), mhs, nil), nil
|
||||
return a.NewTypeExpr(0, pkg, name, lhs.AsNode(), mhs, nil), nil
|
||||
}
|
||||
|
||||
// parseBracket parses "[i:j]", "[i:]", "[:j]" and "[:]". A double dot replaces
|
||||
@@ -527,7 +527,7 @@ func (p *parser) parseBlock() ([]*a.Node, error) {
|
||||
func (p *parser) assertsSorted(asserts []*a.Node) error {
|
||||
seenInv, seenPost := false, false
|
||||
for _, a := range asserts {
|
||||
switch a.Assert().Keyword() {
|
||||
switch a.AsAssert().Keyword() {
|
||||
case t.IDAssert:
|
||||
return fmt.Errorf(`parse: assertion chain cannot contain "assert", `+
|
||||
`only "pre", "inv" and "post" at %s:%d`, p.filename, p.line())
|
||||
@@ -574,7 +574,7 @@ func (p *parser) parseAssertNode() (*a.Node, error) {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
return a.NewAssert(x, condition, reason, args).Node(), nil
|
||||
return a.NewAssert(x, condition, reason, args).AsNode(), nil
|
||||
}
|
||||
return nil, fmt.Errorf(`parse: expected "assert", "pre" or "post" at %s:%d`, p.filename, p.line())
|
||||
}
|
||||
@@ -586,10 +586,10 @@ func (p *parser) parseStatement() (*a.Node, error) {
|
||||
}
|
||||
n, err := p.parseStatement1()
|
||||
if n != nil {
|
||||
n.Raw().SetFilenameLine(p.filename, line)
|
||||
n.AsRaw().SetFilenameLine(p.filename, line)
|
||||
if n.Kind() == a.KIterate {
|
||||
for _, o := range n.Iterate().Variables() {
|
||||
o.Raw().SetFilenameLine(p.filename, line)
|
||||
for _, o := range n.AsIterate().Variables() {
|
||||
o.AsRaw().SetFilenameLine(p.filename, line)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -615,7 +615,7 @@ func (p *parser) parseStatement1() (*a.Node, error) {
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return a.NewJump(x, label).Node(), nil
|
||||
return a.NewJump(x, label).AsNode(), nil
|
||||
|
||||
case t.IDIOBind:
|
||||
p.src = p.src[1:]
|
||||
@@ -627,11 +627,11 @@ func (p *parser) parseStatement1() (*a.Node, error) {
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return a.NewIOBind(in_fields, body).Node(), nil
|
||||
return a.NewIOBind(in_fields, body).AsNode(), nil
|
||||
|
||||
case t.IDIf:
|
||||
o, err := p.parseIf()
|
||||
return o.Node(), err
|
||||
return o.AsNode(), err
|
||||
|
||||
case t.IDIterate:
|
||||
return p.parseIterateNode()
|
||||
@@ -645,7 +645,7 @@ func (p *parser) parseStatement1() (*a.Node, error) {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
return a.NewRet(x, value).Node(), nil
|
||||
return a.NewRet(x, value).AsNode(), nil
|
||||
|
||||
case t.IDVar:
|
||||
p.src = p.src[1:]
|
||||
@@ -669,7 +669,7 @@ func (p *parser) parseStatement1() (*a.Node, error) {
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return a.NewWhile(label, condition, asserts, body).Node(), nil
|
||||
return a.NewWhile(label, condition, asserts, body).AsNode(), nil
|
||||
}
|
||||
|
||||
lhs, err := p.parseExpr()
|
||||
@@ -683,10 +683,10 @@ func (p *parser) parseStatement1() (*a.Node, error) {
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return a.NewAssign(op, lhs, rhs).Node(), nil
|
||||
return a.NewAssign(op, lhs, rhs).AsNode(), nil
|
||||
}
|
||||
|
||||
return lhs.Node(), nil
|
||||
return lhs.AsNode(), nil
|
||||
}
|
||||
|
||||
func (p *parser) parseAsserts() ([]*a.Node, error) {
|
||||
@@ -754,7 +754,7 @@ func (p *parser) parseIterateNode() (*a.Node, error) {
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return n.Node(), nil
|
||||
return n.AsNode(), nil
|
||||
}
|
||||
|
||||
func (p *parser) parseIterateBlock(label t.ID, vars []*a.Node) (*a.Iterate, error) {
|
||||
@@ -849,7 +849,7 @@ func (p *parser) parseArgNode() (*a.Node, error) {
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return a.NewArg(name, value).Node(), nil
|
||||
return a.NewArg(name, value).AsNode(), nil
|
||||
}
|
||||
|
||||
func (p *parser) parseIOBindExprNode() (*a.Node, error) {
|
||||
@@ -859,10 +859,10 @@ func (p *parser) parseIOBindExprNode() (*a.Node, error) {
|
||||
}
|
||||
switch e.Operator() {
|
||||
case 0:
|
||||
return e.Node(), nil
|
||||
return e.AsNode(), nil
|
||||
case t.IDDot:
|
||||
if lhs := e.LHS().Expr(); lhs.Operator() == 0 && lhs.Ident() == t.IDIn {
|
||||
return e.Node(), nil
|
||||
if lhs := e.LHS().AsExpr(); lhs.Operator() == 0 && lhs.Ident() == t.IDIn {
|
||||
return e.AsNode(), nil
|
||||
}
|
||||
}
|
||||
return nil, fmt.Errorf(`parse: expected "in.something", got %q at %s:%d`, e.Str(p.tm), p.filename, p.line())
|
||||
@@ -912,7 +912,7 @@ func (p *parser) parseVarNode(inIterate bool) (*a.Node, error) {
|
||||
}
|
||||
}
|
||||
|
||||
return a.NewVar(op, id, typ, value).Node(), nil
|
||||
return a.NewVar(op, id, typ, value).AsNode(), nil
|
||||
}
|
||||
|
||||
func (p *parser) parsePossibleDollarExprNode() (*a.Node, error) {
|
||||
@@ -920,7 +920,7 @@ func (p *parser) parsePossibleDollarExprNode() (*a.Node, error) {
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return n.Node(), err
|
||||
return n.AsNode(), err
|
||||
}
|
||||
|
||||
func (p *parser) parsePossibleDollarExpr() (*a.Expr, error) {
|
||||
@@ -949,7 +949,7 @@ func (p *parser) parseTryExpr() (*a.Expr, error) {
|
||||
return nil, fmt.Errorf(`parse: expected function call after "try", got %q at %s:%d`,
|
||||
call.Str(p.tm), p.filename, p.line())
|
||||
}
|
||||
return a.NewExpr(call.Node().Raw().Flags(), t.IDTry, 0, call.Ident(),
|
||||
return a.NewExpr(call.AsNode().AsRaw().Flags(), t.IDTry, 0, call.Ident(),
|
||||
call.LHS(), call.MHS(), call.RHS(), call.Args()), nil
|
||||
}
|
||||
|
||||
@@ -958,7 +958,7 @@ func (p *parser) parseExprNode() (*a.Node, error) {
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return n.Node(), err
|
||||
return n.AsNode(), err
|
||||
}
|
||||
|
||||
func (p *parser) parseExpr() (*a.Expr, error) {
|
||||
@@ -974,13 +974,13 @@ func (p *parser) parseExpr() (*a.Expr, error) {
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
rhs = o.Node()
|
||||
rhs = o.AsNode()
|
||||
} else {
|
||||
o, err := p.parseOperand()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
rhs = o.Node()
|
||||
rhs = o.AsNode()
|
||||
}
|
||||
|
||||
if !x.IsAssociativeOp() || x != p.peek1() {
|
||||
@@ -988,17 +988,17 @@ func (p *parser) parseExpr() (*a.Expr, error) {
|
||||
if op == 0 {
|
||||
return nil, fmt.Errorf(`parse: internal error: no binary form for token 0x%02X`, x)
|
||||
}
|
||||
return a.NewExpr(0, op, 0, 0, lhs.Node(), nil, rhs, nil), nil
|
||||
return a.NewExpr(0, op, 0, 0, lhs.AsNode(), nil, rhs, nil), nil
|
||||
}
|
||||
|
||||
args := []*a.Node{lhs.Node(), rhs}
|
||||
args := []*a.Node{lhs.AsNode(), rhs}
|
||||
for p.peek1() == x {
|
||||
p.src = p.src[1:]
|
||||
arg, err := p.parseOperand()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
args = append(args, arg.Node())
|
||||
args = append(args, arg.AsNode())
|
||||
}
|
||||
op := x.AssociativeForm()
|
||||
if op == 0 {
|
||||
@@ -1021,7 +1021,7 @@ func (p *parser) parseOperand() (*a.Expr, error) {
|
||||
if op == 0 {
|
||||
return nil, fmt.Errorf(`parse: internal error: no unary form for token 0x%02X`, x)
|
||||
}
|
||||
return a.NewExpr(0, op, 0, 0, nil, nil, rhs.Node(), nil), nil
|
||||
return a.NewExpr(0, op, 0, 0, nil, nil, rhs.AsNode(), nil), nil
|
||||
|
||||
case x.IsLiteral(p.tm):
|
||||
p.src = p.src[1:]
|
||||
@@ -1082,14 +1082,14 @@ func (p *parser) parseOperand() (*a.Expr, error) {
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
lhs = a.NewExpr(flags, t.IDOpenParen, 0, 0, lhs.Node(), nil, nil, args)
|
||||
lhs = a.NewExpr(flags, t.IDOpenParen, 0, 0, lhs.AsNode(), nil, nil, args)
|
||||
|
||||
case t.IDOpenBracket:
|
||||
id0, mhs, rhs, err := p.parseBracket(t.IDColon)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
lhs = a.NewExpr(0, id0, 0, 0, lhs.Node(), mhs.Node(), rhs.Node(), nil)
|
||||
lhs = a.NewExpr(0, id0, 0, 0, lhs.AsNode(), mhs.AsNode(), rhs.AsNode(), nil)
|
||||
|
||||
case t.IDDot:
|
||||
p.src = p.src[1:]
|
||||
@@ -1097,7 +1097,7 @@ func (p *parser) parseOperand() (*a.Expr, error) {
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
lhs = a.NewExpr(0, t.IDDot, 0, selector, lhs.Node(), nil, nil, nil)
|
||||
lhs = a.NewExpr(0, t.IDDot, 0, selector, lhs.AsNode(), nil, nil, nil)
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user