// Copyright 2017 The Puffs Authors. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // https://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. package ast import ( "math/big" t "github.com/google/puffs/lang/token" ) // Kind is what kind of node it is. For example, a top-level func or a numeric // constant. Kind is different from Type; the latter is used for type-checking // in the programming language sense. type Kind uint32 // XType is the explicit type, directly from the source code. // // MType is the implicit type, deduced for expressions during type checking. const ( KInvalid = Kind(iota) KArg KAssert KAssign KConst KExpr KField KFile KFunc KIf KIterate KJump KPackageID KReturn KStatus KStruct KTypeExpr KUse KVar KWhile ) func (k Kind) String() string { if uint(k) < uint(len(kindStrings)) { return kindStrings[k] } return "KUnknown" } var kindStrings = [...]string{ KInvalid: "KInvalid", KArg: "KArg", KAssert: "KAssert", KAssign: "KAssign", KConst: "KConst", KExpr: "KExpr", KField: "KField", KFile: "KFile", KFunc: "KFunc", KIf: "KIf", KIterate: "KIterate", KJump: "KJump", KPackageID: "KPackageID", KReturn: "KReturn", KStatus: "KStatus", KStruct: "KStruct", KTypeExpr: "KTypeExpr", KUse: "KUse", KVar: "KVar", KWhile: "KWhile", } type Flags uint32 const ( FlagsImpure = Flags(0x00000001) FlagsSuspendible = Flags(0x00000002) FlagsCallImpure = Flags(0x00000004) FlagsCallSuspendible = Flags(0x00000008) FlagsPublic = Flags(0x00000010) FlagsTypeChecked = Flags(0x00000020) FlagsHasBreak = Flags(0x00000040) FlagsHasContinue = Flags(0x00000080) FlagsGlobalIdent = Flags(0x00000100) ) type Node struct { kind Kind flags Flags constValue *big.Int mType *TypeExpr jumpTarget *While filename string line uint32 id0 t.ID id1 t.ID lhs *Node // Left Hand Side. mhs *Node // Middle Hand Side. rhs *Node // Right Hand Side. list0 []*Node list1 []*Node list2 []*Node } func (n *Node) Kind() Kind { return n.kind } func (n *Node) TypeChecked() bool { return n.flags&FlagsTypeChecked != 0 } func (n *Node) SetTypeChecked() { n.flags |= FlagsTypeChecked } 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) 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) Return() *Return { return (*Return)(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) Walk(f func(*Node) error) error { if n != nil { if err := f(n); err != nil { return err } for _, o := range n.Raw().SubNodes() { if err := o.Walk(f); err != nil { return err } } for _, l := range n.Raw().SubLists() { for _, o := range l { if err := o.Walk(f); err != nil { return err } } } } return nil } type Raw Node func (n *Raw) Node() *Node { return (*Node)(n) } func (n *Raw) Kind() Kind { return n.kind } func (n *Raw) Flags() Flags { return n.flags } func (n *Raw) ConstValue() *big.Int { return n.constValue } func (n *Raw) MType() *TypeExpr { return n.mType } func (n *Raw) FilenameLine() (string, uint32) { return n.filename, n.line } func (n *Raw) Filename() string { return n.filename } func (n *Raw) Line() uint32 { return n.line } func (n *Raw) QID() t.QID { return t.QID{n.id0, n.id1} } func (n *Raw) ID0() t.ID { return n.id0 } func (n *Raw) ID1() t.ID { return n.id1 } func (n *Raw) SubNodes() [3]*Node { return [3]*Node{n.lhs, n.mhs, n.rhs} } func (n *Raw) LHS() *Node { return n.lhs } func (n *Raw) MHS() *Node { return n.mhs } func (n *Raw) RHS() *Node { return n.rhs } func (n *Raw) SubLists() [3][]*Node { return [3][]*Node{n.list0, n.list1, n.list2} } func (n *Raw) List0() []*Node { return n.list0 } func (n *Raw) List1() []*Node { return n.list1 } func (n *Raw) List2() []*Node { return n.list2 } func (n *Raw) SetFilenameLine(f string, l uint32) { n.filename, n.line = f, l } // MaxExprDepth is an advisory limit for an Expr's recursion depth. const MaxExprDepth = 255 // Expr is an expression, such as "i", "+j" or "k + l[m(n, o)].p": // - FlagsImpure is if it or a sub-expr is FlagsCallImpure // - FlagsSuspendible is if it or a sub-expr is FlagsCallSuspendible // - FlagsCallImpure is "f(x)" vs "f!(x)" // - FlagsCallSuspendible is "f(x)" vs "f?(x)", it implies FlagsCallImpure // - ID0: <0|operator|IDOpenParen|IDOpenBracket|IDColon|IDDot> // - ID1: <0|ident|literal> // - LHS: // - MHS: // - RHS: // - List0: function call args, assoc. op args or list members. // // A zero ID0 means an identifier or literal in ID1, like "foo" or "42". // // For unary operators, ID0 is the operator and RHS is the operand. // // For binary operators, ID0 is the operator and LHS and RHS are the operands. // // For associative operators, ID0 is the operator and List0 holds the operands. // // The ID0 operator is in disambiguous form. For example, IDXUnaryPlus, // IDXBinaryPlus or IDXAssociativePlus, not a bare IDPlus. // // For function calls, like "LHS(List0)", ID0 is IDOpenParen. // // For try/function calls, like "try LHS(List0)", ID0 is IDTry. // // For indexes, like "LHS[RHS]", ID0 is IDOpenBracket. // // For slices, like "LHS[MHS:RHS]", ID0 is IDColon. // // For selectors, like "LHS.ID1", ID0 is IDDot. // // For lists, like "$(0, 1, 2)", ID0 is IDDollar. // // For limits, like "limit (LHS) RHS", ID0 is IDLimit. type Expr Node func (n *Expr) Node() *Node { return (*Node)(n) } func (n *Expr) Pure() bool { return n.flags&FlagsImpure == 0 } func (n *Expr) Impure() bool { return n.flags&FlagsImpure != 0 } func (n *Expr) Suspendible() bool { return n.flags&FlagsSuspendible != 0 } func (n *Expr) CallImpure() bool { return n.flags&FlagsCallImpure != 0 } func (n *Expr) CallSuspendible() bool { return n.flags&FlagsCallSuspendible != 0 } func (n *Expr) GlobalIdent() bool { return n.flags&FlagsGlobalIdent != 0 } func (n *Expr) ConstValue() *big.Int { return n.constValue } func (n *Expr) MType() *TypeExpr { return n.mType } func (n *Expr) ID0() t.ID { return n.id0 } func (n *Expr) ID1() t.ID { return n.id1 } func (n *Expr) LHS() *Node { return n.lhs } func (n *Expr) MHS() *Node { return n.mhs } func (n *Expr) RHS() *Node { return n.rhs } func (n *Expr) Args() []*Node { return n.list0 } func (n *Expr) SetConstValue(x *big.Int) { n.constValue = x } func (n *Expr) SetMType(x *TypeExpr) { n.mType = x } func (n *Expr) SetGlobalIdent() { n.flags |= FlagsGlobalIdent } func NewExpr(flags Flags, operator t.ID, nameLiteralSelector t.ID, lhs *Node, mhs *Node, rhs *Node, args []*Node) *Expr { if lhs != nil { flags |= lhs.flags & (FlagsImpure | FlagsSuspendible) } if mhs != nil { flags |= mhs.flags & (FlagsImpure | FlagsSuspendible) } if rhs != nil { flags |= rhs.flags & (FlagsImpure | FlagsSuspendible) } for _, o := range args { flags |= o.flags & (FlagsImpure | FlagsSuspendible) } return &Expr{ kind: KExpr, flags: flags, id0: operator, id1: nameLiteralSelector, lhs: lhs, mhs: mhs, rhs: rhs, list0: args, } } // Assert is "assert RHS via ID1(args)", "pre etc", "inv etc" or "post etc": // - ID0: // - ID1: reason // - RHS: // - List0: reason arguments type Assert Node func (n *Assert) Node() *Node { return (*Node)(n) } func (n *Assert) Keyword() t.ID { return n.id0 } func (n *Assert) Reason() t.ID { return n.id1 } func (n *Assert) Condition() *Expr { return n.rhs.Expr() } func (n *Assert) Args() []*Node { return n.list0 } func NewAssert(keyword t.ID, condition *Expr, reason t.ID, args []*Node) *Assert { return &Assert{ kind: KAssert, id0: keyword, id1: reason, rhs: condition.Node(), list0: args, } } // Arg is "name:value". // - ID1: name // - RHS: value type Arg Node func (n *Arg) Node() *Node { return (*Node)(n) } func (n *Arg) Name() t.ID { return n.id1 } func (n *Arg) Value() *Expr { return n.rhs.Expr() } func NewArg(name t.ID, value *Expr) *Arg { return &Arg{ kind: KArg, id1: name, rhs: value.Node(), } } // Assign is "LHS = RHS" or "LHS op= RHS": // - ID0: operator // - LHS: // - RHS: type Assign Node func (n *Assign) Node() *Node { return (*Node)(n) } func (n *Assign) Operator() t.ID { return n.id0 } func (n *Assign) LHS() *Expr { return n.lhs.Expr() } func (n *Assign) RHS() *Expr { return n.rhs.Expr() } func NewAssign(operator t.ID, lhs *Expr, rhs *Expr) *Assign { return &Assign{ kind: KAssign, id0: operator, lhs: lhs.Node(), rhs: rhs.Node(), } } // Var is "var ID1 LHS" or "var ID1 LHS = RHS" or an iterate variable // declaration "ID1 LHS : RHS": // - ID0: <0|IDEq|IDColon> // - ID1: name // - LHS: // - RHS: type Var Node func (n *Var) Node() *Node { return (*Node)(n) } func (n *Var) IterateVariable() bool { return n.id0 == t.IDColon } func (n *Var) Name() t.ID { return n.id1 } func (n *Var) XType() *TypeExpr { return n.lhs.TypeExpr() } func (n *Var) Value() *Expr { return n.rhs.Expr() } func NewVar(op t.ID, name t.ID, xType *TypeExpr, value *Expr) *Var { return &Var{ kind: KVar, id0: op, id1: name, lhs: xType.Node(), rhs: value.Node(), } } // Field is a "name type = default_value" struct field: // - ID1: name // - LHS: // - RHS: type Field Node func (n *Field) Node() *Node { return (*Node)(n) } func (n *Field) Name() t.ID { return n.id1 } func (n *Field) XType() *TypeExpr { return n.lhs.TypeExpr() } func (n *Field) DefaultValue() *Expr { return n.rhs.Expr() } func NewField(name t.ID, xType *TypeExpr, defaultValue *Expr) *Field { return &Field{ kind: KField, id1: name, lhs: xType.Node(), rhs: defaultValue.Node(), } } // Iterate is "iterate:ID1 (vars) { List2 }": // - FlagsHasBreak is the iterate has an explicit break // - FlagsHasContinue is the iterate has an explicit continue // - ID1: <0|label> // - List0: variables // - List2: loop body type Iterate Node func (n *Iterate) Node() *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) Label() t.ID { return n.id1 } func (n *Iterate) Variables() []*Node { return n.list0 } func (n *Iterate) Body() []*Node { return n.list2 } func (n *Iterate) SetHasBreak() { n.flags |= FlagsHasBreak } func (n *Iterate) SetHasContinue() { n.flags |= FlagsHasContinue } func NewIterate(label t.ID, variables []*Node, body []*Node) *Iterate { return &Iterate{ kind: KIterate, id1: label, list0: variables, list2: body, } } // While is "while:ID1 LHS, List1 { List2 }": // - FlagsHasBreak is the while has an explicit break // - FlagsHasContinue is the while has an explicit continue // - ID1: <0|label> // - LHS: // - List1: asserts // - List2: loop body type While Node func (n *While) Node() *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.lhs.Expr() } func (n *While) Asserts() []*Node { return n.list1 } func (n *While) Body() []*Node { return n.list2 } func (n *While) SetHasBreak() { n.flags |= FlagsHasBreak } func (n *While) SetHasContinue() { n.flags |= FlagsHasContinue } func NewWhile(label t.ID, condition *Expr, asserts []*Node, body []*Node) *While { return &While{ kind: KWhile, id1: label, lhs: condition.Node(), list1: asserts, list2: body, } } // If is "if LHS { List0 } else RHS" or "if LHS { List0 } else { List1 }": // - LHS: // - RHS: // - List0: if-true body // - List1: if-false body type If Node func (n *If) Node() *Node { return (*Node)(n) } func (n *If) Condition() *Expr { return n.lhs.Expr() } func (n *If) ElseIf() *If { return n.rhs.If() } func (n *If) BodyIfTrue() []*Node { return n.list0 } func (n *If) BodyIfFalse() []*Node { return n.list1 } func NewIf(condition *Expr, elseIf *If, bodyIfTrue []*Node, bodyIfFalse []*Node) *If { return &If{ kind: KIf, lhs: condition.Node(), rhs: elseIf.Node(), list0: bodyIfTrue, list1: bodyIfFalse, } } // Return is "return LHS", "return error ID1" or "return suspension ID1": // - ID0: <0|IDError|IDSuspension> // - ID1: message // - LHS: type Return Node func (n *Return) Node() *Node { return (*Node)(n) } func (n *Return) Keyword() t.ID { return n.id0 } func (n *Return) Message() t.ID { return n.id1 } func (n *Return) Value() *Expr { return n.lhs.Expr() } func NewReturn(keyword t.ID, message t.ID, value *Expr) *Return { return &Return{ kind: KReturn, id0: keyword, id1: message, lhs: value.Node(), } } // Jump is "break" or "continue", with an optional label, "break:label": // - ID0: // - ID1: <0|label> type Jump Node func (n *Jump) Node() *Node { return (*Node)(n) } func (n *Jump) JumpTarget() *While { return n.jumpTarget } func (n *Jump) Keyword() t.ID { return n.id0 } func (n *Jump) Label() t.ID { return n.id1 } func (n *Jump) SetJumpTarget(o *While) { n.jumpTarget = o } func NewJump(keyword t.ID, label t.ID) *Jump { return &Jump{ kind: KJump, id0: keyword, id1: label, } } // MaxTypeExprDepth is an advisory limit for a TypeExpr's recursion depth. const MaxTypeExprDepth = 63 // TypeExpr is a type expression, such as "u32", "u32[..8]", "pkg.foo", "ptr // T", "[8] T" or "[] T": // - ID0: <0|package name|IDPtr|IDOpenBracket|IDColon> // - ID1: <0|type name> // - LHS: // - MHS: // - RHS: // // An IDPtr ID0 means "ptr RHS". RHS is the inner type. // // An IDOpenBracket ID0 means "[LHS] RHS". RHS is the inner type. // // An IDColon ID0 means "[] RHS". RHS is the inner type. // // Other ID0 values mean a (possibly package-qualified) type like "pkg.foo" or // "foo". ID0 is the "pkg" or zero, ID1 is the "foo". Such a type can be // refined as "foo[LHS..MHS]". LHS and MHS are Expr's, possibly nil. For // example, the LHS for "u32[..4095]" is nil. // // TODO: function / method types, struct types, list types. type TypeExpr Node func (n *TypeExpr) Node() *Node { return (*Node)(n) } func (n *TypeExpr) Decorator() t.ID { return n.id0 } func (n *TypeExpr) Name() t.ID { return n.id1 } func (n *TypeExpr) ArrayLength() *Expr { return n.lhs.Expr() } 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) Innermost() *TypeExpr { for ; n != nil && n.Inner() != nil; n = n.Inner() { } return n } func (n *TypeExpr) IsBool() bool { return n.id0 == 0 && n.id1.Key() == t.KeyBool } func (n *TypeExpr) IsIdeal() bool { return n.id0 == 0 && n.id1.Key() == t.KeyDoubleZ } func (n *TypeExpr) IsNumType() bool { return n.id0 == 0 && n.id1.IsNumType() } func (n *TypeExpr) IsNumTypeOrIdeal() bool { return n.id0 == 0 && (n.id1.IsNumType() || n.id1.Key() == t.KeyDoubleZ) } func (n *TypeExpr) IsRefined() bool { return t.Key(n.id0>>t.KeyShift) != t.KeyOpenBracket && (n.lhs != nil || n.mhs != nil) } func (n *TypeExpr) IsUnsignedInteger() bool { return n.id0 == 0 && (n.id1.Key() == t.KeyU8 || n.id1.Key() == t.KeyU16 || n.id1.Key() == t.KeyU32 || n.id1.Key() == t.KeyU64) // TODO: t.KeyUsize? } func (n *TypeExpr) HasPointers() bool { for ; n != nil; n = n.Inner() { switch n.id0.Key() { case 0: // TODO: add t.KeyReader1, after figuring out how limit's should really work. switch n.id1.Key() { case t.KeyBuf1, t.KeyWriter1, t.KeyBuf2: return true } case t.KeyPtr, t.KeyNptr, t.KeyColon: return true } } return false } func (n *TypeExpr) Unrefined() *TypeExpr { if !n.IsRefined() { return n } o := *n o.lhs = nil o.mhs = nil return &o } func NewTypeExpr(pkgOrDec t.ID, name t.ID, arrayLengthMin *Expr, max *Expr, inner *TypeExpr) *TypeExpr { return &TypeExpr{ kind: KTypeExpr, id0: pkgOrDec, id1: name, lhs: arrayLengthMin.Node(), mhs: max.Node(), rhs: inner.Node(), } } // MaxBodyDepth is an advisory limit for a function body's recursion depth. const MaxBodyDepth = 255 // Func is "func ID0.ID1(LHS)(RHS) { List2 }": // - FlagsImpure is "ID1" vs "ID1!" // - FlagsSuspendible is "ID1" vs "ID1?", it implies FlagsImpure // - FlagsPublic is "pub" vs "pri" // - ID0: <0|receiver> // - ID1: name // - LHS: in-parameters // - RHS: out-parameters // - List1: asserts // - List2: function body // // Statement means one of: // - Assert // - Assign // - Expr // - If // - Iterate // - Jump // - Return // - Var // - While type Func Node func (n *Func) Node() *Node { return (*Node)(n) } func (n *Func) Pure() bool { return n.flags&FlagsImpure == 0 } func (n *Func) Impure() bool { return n.flags&FlagsImpure != 0 } func (n *Func) Suspendible() bool { return n.flags&FlagsSuspendible != 0 } func (n *Func) Public() bool { return n.flags&FlagsPublic != 0 } func (n *Func) Filename() string { return n.filename } func (n *Func) Line() uint32 { return n.line } func (n *Func) QID() t.QID { return t.QID{n.id0, n.id1} } func (n *Func) Receiver() t.ID { return n.id0 } func (n *Func) Name() t.ID { return n.id1 } func (n *Func) In() *Struct { return n.lhs.Struct() } func (n *Func) Out() *Struct { return n.rhs.Struct() } func (n *Func) Asserts() []*Node { return n.list1 } func (n *Func) Body() []*Node { return n.list2 } func NewFunc(flags Flags, filename string, line uint32, receiver t.ID, name t.ID, in *Struct, out *Struct, asserts []*Node, body []*Node) *Func { return &Func{ kind: KFunc, flags: flags, filename: filename, line: line, id0: receiver, id1: name, lhs: in.Node(), rhs: out.Node(), list1: asserts, list2: body, } } // Status is "error ID1" or "suspension ID1": // - FlagsPublic is "pub" vs "pri" // - ID0: // - ID1: message type Status Node func (n *Status) Node() *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) Message() t.ID { return n.id1 } func NewStatus(flags Flags, filename string, line uint32, keyword t.ID, message t.ID) *Status { return &Status{ kind: KStatus, flags: flags, filename: filename, line: line, id0: keyword, id1: message, } } // Const is "const ID1 LHS = RHS": // - FlagsPublic is "pub" vs "pri" // - ID1: name // - LHS: // - RHS: type Const Node func (n *Const) Node() *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) Name() t.ID { return n.id1 } func (n *Const) XType() *TypeExpr { return n.lhs.TypeExpr() } func (n *Const) Value() *Expr { return n.rhs.Expr() } func NewConst(flags Flags, filename string, line uint32, name t.ID, xType *TypeExpr, value *Expr) *Const { return &Const{ kind: KConst, flags: flags, filename: filename, line: line, id1: name, lhs: xType.Node(), rhs: value.Node(), } } // Struct is "struct ID1(List0)": // - FlagsSuspendible is "ID1" vs "ID1?" // - FlagsPublic is "pub" vs "pri" // - ID1: name // - List0: fields type Struct Node func (n *Struct) Node() *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 } func (n *Struct) Line() uint32 { return n.line } func (n *Struct) Name() t.ID { return n.id1 } func (n *Struct) Fields() []*Node { return n.list0 } func NewStruct(flags Flags, filename string, line uint32, name t.ID, fields []*Node) *Struct { return &Struct{ kind: KStruct, flags: flags, filename: filename, line: line, id1: name, list0: fields, } } // PackageID is "packageid ID1": // - ID1: package ID type PackageID Node func (n *PackageID) Node() *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.id1 } func NewPackageID(filename string, line uint32, id t.ID) *PackageID { return &PackageID{ kind: KPackageID, filename: filename, line: line, id1: id, } } // Use is "use ID1": // - ID1: package path type Use Node func (n *Use) Node() *Node { return (*Node)(n) } func (n *Use) Filename() string { return n.filename } func (n *Use) Line() uint32 { return n.line } func (n *Use) Path() t.ID { return n.id1 } func NewUse(filename string, line uint32, path t.ID) *Use { return &Use{ kind: KUse, filename: filename, line: line, id1: path, } } // File is a file of source code: // - List0: top-level declarations type File Node func (n *File) Node() *Node { return (*Node)(n) } func (n *File) Filename() string { return n.filename } func (n *File) TopLevelDecls() []*Node { return n.list0 } func NewFile(filename string, topLevelDecls []*Node) *File { return &File{ kind: KFile, filename: filename, list0: topLevelDecls, } }