go/src/cmd/compile/internal/ir/stmt.go

type Decl

func NewDecl(pos src.XPos, op Op, x *Name) *Decl {}

func (*Decl) isStmt() {}

type Stmt

type miniStmt

func (*miniStmt) isStmt() {}

func (n *miniStmt) Init() Nodes     {}

func (n *miniStmt) SetInit(x Nodes) {}

func (n *miniStmt) PtrInit() *Nodes {}

type AssignListStmt

func NewAssignListStmt(pos src.XPos, op Op, lhs, rhs []Node) *AssignListStmt {}

func (n *AssignListStmt) SetOp(op Op) {}

type AssignStmt

func NewAssignStmt(pos src.XPos, x, y Node) *AssignStmt {}

func (n *AssignStmt) SetOp(op Op) {}

type AssignOpStmt

func NewAssignOpStmt(pos src.XPos, asOp Op, x, y Node) *AssignOpStmt {}

type BlockStmt

func NewBlockStmt(pos src.XPos, list []Node) *BlockStmt {}

type BranchStmt

func NewBranchStmt(pos src.XPos, op Op, label *types.Sym) *BranchStmt {}

func (n *BranchStmt) SetOp(op Op) {}

func (n *BranchStmt) Sym() *types.Sym {}

type CaseClause

func NewCaseStmt(pos src.XPos, list, body []Node) *CaseClause {}

type CommClause

func NewCommStmt(pos src.XPos, comm Node, body []Node) *CommClause {}

type ForStmt

func NewForStmt(pos src.XPos, init Node, cond, post Node, body []Node, distinctVars bool) *ForStmt {}

type GoDeferStmt

func NewGoDeferStmt(pos src.XPos, op Op, call Node) *GoDeferStmt {}

type IfStmt

func NewIfStmt(pos src.XPos, cond Node, body, els []Node) *IfStmt {}

type JumpTableStmt

func NewJumpTableStmt(pos src.XPos, idx Node) *JumpTableStmt {}

type InterfaceSwitchStmt

func NewInterfaceSwitchStmt(pos src.XPos, case_, itab, runtimeType, hash Node, descriptor *obj.LSym) *InterfaceSwitchStmt {}

type InlineMarkStmt

func NewInlineMarkStmt(pos src.XPos, index int64) *InlineMarkStmt {}

func (n *InlineMarkStmt) Offset() int64     {}

func (n *InlineMarkStmt) SetOffset(x int64) {}

type LabelStmt

func NewLabelStmt(pos src.XPos, label *types.Sym) *LabelStmt {}

func (n *LabelStmt) Sym() *types.Sym {}

type RangeStmt

func NewRangeStmt(pos src.XPos, key, value, x Node, body []Node, distinctVars bool) *RangeStmt {}

type ReturnStmt

func NewReturnStmt(pos src.XPos, results []Node) *ReturnStmt {}

type SelectStmt

func NewSelectStmt(pos src.XPos, cases []*CommClause) *SelectStmt {}

type SendStmt

func NewSendStmt(pos src.XPos, ch, value Node) *SendStmt {}

type SwitchStmt

func NewSwitchStmt(pos src.XPos, tag Node, cases []*CaseClause) *SwitchStmt {}

type TailCallStmt

func NewTailCallStmt(pos src.XPos, call *CallExpr) *TailCallStmt {}

type TypeSwitchGuard

func NewTypeSwitchGuard(pos src.XPos, tag *Ident, x Node) *TypeSwitchGuard {}