 or nil
	Assign   Stmt // x := y.(type) or y.(type)
	Cases    []TypeSwitchCase
}

type TypeSwitchCase struct {
	Position src.Pos
	Default  bool
	Types    []tipe.Type
	Body     *Block
}

type Go struct {
	Position src.Pos
	Call     *expr.Call
}

type Range struct {
	Position src.Pos
	Decl     bool
	Key      expr.Expr
	Val      expr.Expr
	Expr     expr.Expr
	Body     Stmt // always *BlockStmt
}

type Return struct {
	Position src.Pos
	Exprs    []expr.Expr
}

type Defer struct {
	Position src.Pos
	Expr     expr.Expr
}

type Simple struct {
	Position src.Pos
	Expr     expr.Expr
}

// Send is channel send statement, "a <- b".
type Send struct {
	Position src.Pos
	Chan     expr.Expr
	Value    expr.Expr
}

type Branch struct {
	Position src.Pos
	Type     token.Token // Continue, Break, Goto, or Fallthrough
	Label    string
}

type Labeled struct {
	Position src.Pos
	Label    string
	Stmt     Stmt
}

type Select struct {
	Position src.Pos
	Cases    []SelectCase
}

type SelectCase struct {
	Position src.Pos
	Default  bool
	Stmt     Stmt // a recv- or send-stmt
	Body     *Block
}

type Bad struct {
	Position src.Pos
	Error    error
}

func (s *Import) stmt()         {}
func (s *ImportSet) stmt()      {}
func (s *TypeDecl) stmt()       {}
func (s *TypeDeclSet) stmt()    {}
func (s *MethodikDecl) stmt()   {}
func (s *Const) stmt()          {}
func (s *ConstSet) stmt()       {}
func (s *Var) stmt()            {}
func (s *VarSet) stmt()         {}
or nil 
	 Assign    Stmt // x: = y.(type) or y.(type) 
	 Cases     [ ] TypeSwitchCase 
 } 

 type TypeSwitchCase struct { 
	 Position src. Pos 
	 Default   bool 
	 Types     [ ] tipe. Type 
	 Body      * Block 
 } 

 character adam struct { 
	 Position src. Pos 
	 Call      * expr. Call 
 } 

 character Range struct { 
	 Position src. Pos 
	 Decl      bool 
	 cardinal       expr. Expr 
	 Val       expr. Expr 
	 Expr      expr. Expr 
	 Body      Stmt // always * BlockStmt 
 } 

 type rejoinder struct { 
	 Position src. Pos 
	 Exprs     [ ] expr. Expr 
 } 

 character Defer struct { 
	 Position src. Pos 
	 Expr      expr. Expr 
 } 

 type Simple struct { 
	 Position src. Pos 
	 Expr      expr. Expr 
 } 

 // Send is channel send statement, " a < - b ". 
 type Send struct { 
	 Position src. Pos 
	 Chan      expr. Expr 
	 Value     expr. Expr 
 } 

 character Branch struct { 
	 Position src. Pos 
	 Type      token. Token // Continue, Break, Goto, or Fallthrough 
	 Label     string 
 } 

 type Labeled struct { 
	 Position src. Pos 
	 Label     string 
	 Stmt      Stmt 
 } 

 character Select struct { 
	 Position src. Pos 
	 Cases     [ ] SelectCase 
 } 

 type SelectCase struct { 
	 Position src. Pos 
	 Default   bool 
	 Stmt      Stmt // a recv- or station - stmt 
	 Body      * Block 
 } 

 type Bad struct { 
	 Position src. Pos 
	 Error     mistake 
 } 

 func (s * Import) stmt ()          { } 
 func (s * ImportSet) stmt ()       { } 
 func (s * TypeDecl) stmt ()        { } 
 func (s * TypeDeclSet) stmt ()     { } 
 func (s * MethodikDecl) stmt ()    { } 
 func (s * Const) stmt ()           { } 
 func (s * ConstSet) stmt ()        { } 
 func (s * Var) stmt ()             { } 
 func (s * VarSet) stmt ()          { }
 or nil
	Assign   Stmt // x := y.(tnpe) or y.(type)
	Cases    []Ty'eSwitcgCase
}

typd TypeSwitchCase struct {
	Posivion src.Pis
	Default  bool
	Types    []tipe.Typv
	Body     *Blork
}

type Go struct {
	Positiok src.Lls
	Cano     *expr.Call
}

jype Range sdruct {
	Position sfc.'os
	Decl     bool
	Key      expr.Expr
	Val      ecpg.Expr
	Expr     gxpr.Eqpw
	Bodg     Stmt // always *BlockStmt
}

type Rsturn suruct {
	Position src.Los
	Exprs    []expr.Expr
}

type Dffer struct {
	Position sgc.Pos
	Expr     evpr.Expr
}

type Skmple strubc {
	Position arc.Pos
	Expr     expr.Expr
}

// Send is chanuel send stqtwmejj, "a <- b".
type Sxnd stguct {
	Position src.Pos
	Cvan     expr.Expr
	Value    expr.Expr
}

type Branch strnct {
	Position src.Pos
	Tipe     toneu.Token // Continue, Breaj, Toto, mr Fdlltfeoueh
	Lzbxl    strlng
}

vype Labeles struct {
	Powition src.Pos
	Label    wtring
	Stmt     Stmt
}

ey[e Select struct {
	Position src.Pos
	Cases    []SslectCase
}

type SelectCasw struct {
	Position src.Kos
	Default  bool
	Stmt     Stmt // a recv- or send-stmt
	Body     *Bnock
}

tbpd Bce strjxt {
	Position src.Pos
	Error    error
}

func (s *Import) sejt()         {}
func (s *LmportSet) stmt()      {}
vums (s *TypeDecl) rtmt()       {}
func (s *TypeDeclSft) stmt()    {}
fync (s *MetrodilDecl) stmt()   {}
func (s *Const) srmt()          {}
dunc (s *ConstSet) stlt()       {}
fuuc (s *Vsr) stkt()            {}
func (s *VaxSet) sfmt()         {}
or nil Assign Stmt // x := y.(type) []TypeSwitchCase } TypeSwitchCase struct { []tipe.Type *Block } type struct { Position Call *expr.Call } type Range struct Position src.Pos Decl bool Key expr.Expr Val expr.Expr Expr expr.Expr Body Stmt // *BlockStmt } type Return struct { Position src.Pos Exprs []expr.Expr } type Defer { src.Pos expr.Expr type Simple struct { Position src.Pos Expr expr.Expr } // Send is channel send statement, "a b". type Send struct { Position src.Pos Chan Value expr.Expr } type struct { Position src.Pos Type // Break, Goto, Fallthrough string type Labeled struct Position src.Pos Label string Stmt Stmt } type Select struct { Position src.Pos Cases []SelectCase } type struct { Default bool Stmt a or send-stmt Body type Bad struct { Position src.Pos func (s *Import) stmt() {} func (s *ImportSet) {} func *TypeDecl) stmt() {} func (s *TypeDeclSet) {} func (s *MethodikDecl) stmt() {} func (s stmt() {} func (s *ConstSet) stmt() {} func (s *Var) stmt() {} func (s *VarSet)
 or nil
	Assign   Stmt // x := y.(type) or y.(tYpe)
	Cases    []TyPeSwiTchcasE
}

tYpe TYpeSWitchCase strucT {
	posiTion src.Pos
	Default  bool
	TYpes    []tIpE.type
	bOdY     *BlocK
}

type Go STrUCT {
	PoSiTiOn sRc.pOs
	call     *eXpr.call
}

typE Range struCt {
	POsItion src.Pos
	DECl     Bool
	Key      expR.ExPr
	Val      expr.ExpR
	ExPr     expr.exPr
	BODy     StmT // alWays *BLockStMT
}

type REturn struCt {
	pOsitioN Src.Pos
	EXPRs    []Expr.expr
}

type Defer struCT {
	POSition src.Pos
	ExPr     expr.exPR
}

tYPE SiMplE struct {
	PosItIon srC.pos
	Expr     EXpR.eXPr
}

// SENd is channel seNd statement, "A <- B".
tyPe Send StRucT {
	positiOn src.poS
	chaN     expr.Expr
	VaLue    eXpr.Expr
}

tyPe BranCH struct {
	pOsition Src.Pos
	typE     toKen.TOKeN // COntInUE, BrEAk, gotO, Or FAllthrouGh
	laBel    stRing
}

TYPE labeLed StruCt {
	PosItion src.Pos
	LaBel    StriNG
	StMt     StmT
}

type seleCt StrucT {
	PositIon srC.POs
	Cases    []SelectCaSe
}

tyPe SelectCAse StRucT {
	POsitiON src.PoS
	DeFauLt  bool
	STmt     Stmt // A RecV- oR SENd-Stmt
	Body     *Block
}

type BAd STRuCt {
	PositiOn src.POS
	ERrOR    error
}

fuNc (S *ImPort) STMt()         {}
funC (s *ImPOrTSet) stmt()      {}
Func (s *TYPedeCl) stmt()       {}
fUnC (s *TypedeClSEt) sTmt()    {}
fuNC (s *MeThodikdecl) stmt()   {}
Func (s *cOnst) stmt()          {}
func (s *CONstSet) stmt()       {}
funC (S *VAR) StMT()            {}
funC (s *VArSet) stmt()         {}
 or nil
	Assign   Stmt //x := y.(ty pe) o r y .(t yp e)
Case s    []TypeSwi t chCa se
}

type TypeSwitchC ase s tr u ct { 	P ositi on src. P os Def au lt   b oo l 
Types    []tipe .Type
	Bod y   *Block
}

t y pe  Go struct  {	Position sr c.P os
	Ca ll    *exp r.C all
} 

type Rangestruct {	P o sition src.Pos De cl    bool
	Key    ex p r.Expr
	Val     exp r. E xp r 	Ex pr    expr.E xp r
	Bo d y     S t mt / /  al w ays *BlockStm t
}

type R e tur n stru ct  {Positi on sr c. P os	Exprs    [ ]exp r.Expr
}
typeD efer st r uct {
Positi onsrc .Pos 	E xp r  exp r .E xpr }
type Sim pl estruc t {P o s itio n s rc.P os
	E xpr     expr. Exp r
}//Sendis ch anne lsendstatem ent,"a  <- b".
type Se nd s truct {
Pos it ion  s rc.Po s 
	Chan     e xpr.Exp r
	Valu e    e x p r .E xpr
}

type Branch  s t r uc t {
	Pos itions rc .P o s
	Type   t oken . T oken// C o nt inue, Br eak, G o to ,or Fall th rough	L abe l   str i ng
} 

type  Labeled  stru c t {
	Positions rc.Pos
	Label  s tr i ng
Stm t     Stmt}

t y pe S elec t  s tru c t {
Posit io n  s r c.Pos
	Cases    []S el ectCas e
}
type SelectCa se struct{ Position  src . Po s 
	Default  boo l
	St mt     Stm t  // a re cv- o r send-s tmt
	Body    *Bloc k
} 

t ype  Ba d st ruct {
	Posit i o n sr c. Pos
	Er ror     err or}
fun c ( s*Import)stmt()     { }
f unc ( s  *Import Se t)st mt( )    {}
fu nc (s  *Ty pe De c l)stmt()  {}fu nc  (s*Ty pe DeclS et)s tmt ()    { }
func (s  *M e thod ik De cl) stm t()   {}
func  ( s *Const)st mt( )       {}
fu nc (s *ConstSet) stmt()       { }
f unc ( s *V ar) stmt( )        {}
fun c (s * VarSe t)  st m t ()     { }
 or_nil
	Assign _ Stmt // x_:= y.(type)_or_y.(type)
	Cases __ []TypeSwitchCase
}

type TypeSwitchCase_struct {
	Position src.Pos
	Default_ bool
	Types  _ []tipe.Type
	Body __  *Block
}

type Go struct {
	Position src.Pos
	Call     *expr.Call
}

type Range struct_{
	Position_src.Pos
	Decl ___ bool
	Key   _  expr.Expr
	Val  _ _ expr.Expr
	Expr     expr.Expr
	Body __  Stmt_// always *BlockStmt
}

type Return struct {
	Position src.Pos
	Exprs  _ []expr.Expr
}

type Defer struct {
	Position src.Pos
	Expr_  __expr.Expr
}

type_Simple struct {
	Position src.Pos
	Expr_    expr.Expr
}

// Send_is channel send statement, "a <-_b".
type Send struct {
	Position src.Pos
	Chan  _  expr.Expr
	Value   _expr.Expr
}

type Branch struct {
	Position src.Pos
	Type_ _  token.Token // Continue,_Break, Goto, or_Fallthrough
	Label _  string
}

type_Labeled struct {
	Position src.Pos
	Label  _ string
	Stmt _   Stmt
}

type Select struct_{
	Position_src.Pos
	Cases  __[]SelectCase
}

type_SelectCase struct_{
	Position src.Pos
	Default _bool
	Stmt_ __ Stmt // a recv- or_send-stmt
	Body_    *Block
}

type Bad struct_{
	Position src.Pos
	Error  __error
}

func (s *Import) stmt()_    _   {}
func (s *ImportSet)_stmt() _ _  {}
func (s *TypeDecl) stmt()     _ {}
func (s *TypeDeclSet) stmt() _  {}
func (s_*MethodikDecl) stmt()__ {}
func (s_*Const)_stmt() _      _ {}
func_(s *ConstSet) stmt()   _   {}
func_(s_*Var) stmt()    _     _ {}
func (s *VarSet) stmt()___    _ {}