github.com/neugram/ng@v0.0.0-20180309130942-d472ff93d872/syntax/stmt/stmt.go (about)

     1  // Copyright 2015 The Neugram Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  // Package stmt defines data structures representing Neugram statements.
     6  package stmt
     7  
     8  import (
     9  	"neugram.io/ng/syntax/expr"
    10  	"neugram.io/ng/syntax/src"
    11  	"neugram.io/ng/syntax/tipe"
    12  	"neugram.io/ng/syntax/token"
    13  )
    14  
    15  type Stmt interface {
    16  	stmt()
    17  	Pos() src.Pos // implements syntax.Node
    18  }
    19  
    20  type Import struct {
    21  	Position src.Pos
    22  	Name     string
    23  	Path     string
    24  }
    25  
    26  type ImportSet struct {
    27  	Position src.Pos
    28  	Imports  []*Import
    29  }
    30  
    31  type TypeDecl struct {
    32  	Position src.Pos
    33  	Name     string
    34  	Type     *tipe.Named
    35  }
    36  
    37  type TypeDeclSet struct {
    38  	Position  src.Pos
    39  	TypeDecls []*TypeDecl
    40  }
    41  
    42  type MethodikDecl struct {
    43  	Position src.Pos
    44  	Name     string
    45  	Type     *tipe.Named
    46  	Methods  []*expr.FuncLiteral
    47  }
    48  
    49  // TODO InterfaceLiteral struct { Name string, MethodNames []string, Methods []*tipe.Func }
    50  
    51  type Const struct {
    52  	Position src.Pos
    53  	NameList []string
    54  	Type     tipe.Type
    55  	Values   []expr.Expr
    56  }
    57  
    58  type ConstSet struct {
    59  	Position src.Pos
    60  	Consts   []*Const
    61  }
    62  
    63  type VarSet struct {
    64  	Position src.Pos
    65  	Vars     []*Var
    66  }
    67  
    68  type Var struct {
    69  	Position src.Pos
    70  	NameList []string
    71  	Type     tipe.Type
    72  	Values   []expr.Expr
    73  }
    74  
    75  type Assign struct {
    76  	Position src.Pos
    77  	Decl     bool
    78  	Left     []expr.Expr
    79  	Right    []expr.Expr // TODO: give up on multiple rhs values for now.
    80  }
    81  
    82  type Block struct {
    83  	Position src.Pos
    84  	Stmts    []Stmt
    85  }
    86  
    87  type If struct {
    88  	Position src.Pos
    89  	Init     Stmt
    90  	Cond     expr.Expr
    91  	Body     Stmt // always *BlockStmt
    92  	Else     Stmt
    93  }
    94  
    95  type For struct {
    96  	Position src.Pos
    97  	Init     Stmt
    98  	Cond     expr.Expr
    99  	Post     Stmt
   100  	Body     Stmt // always *BlockStmt
   101  }
   102  
   103  type Switch struct {
   104  	Position src.Pos
   105  	Init     Stmt
   106  	Cond     expr.Expr
   107  	Cases    []SwitchCase
   108  }
   109  
   110  type SwitchCase struct {
   111  	Position src.Pos
   112  	Conds    []expr.Expr
   113  	Default  bool
   114  	Body     *Block
   115  }
   116  
   117  type TypeSwitch struct {
   118  	Position src.Pos
   119  	Init     Stmt // initialization statement; or nil
   120  	Assign   Stmt // x := y.(type) or y.(type)
   121  	Cases    []TypeSwitchCase
   122  }
   123  
   124  type TypeSwitchCase struct {
   125  	Position src.Pos
   126  	Default  bool
   127  	Types    []tipe.Type
   128  	Body     *Block
   129  }
   130  
   131  type Go struct {
   132  	Position src.Pos
   133  	Call     *expr.Call
   134  }
   135  
   136  type Range struct {
   137  	Position src.Pos
   138  	Decl     bool
   139  	Key      expr.Expr
   140  	Val      expr.Expr
   141  	Expr     expr.Expr
   142  	Body     Stmt // always *BlockStmt
   143  }
   144  
   145  type Return struct {
   146  	Position src.Pos
   147  	Exprs    []expr.Expr
   148  }
   149  
   150  type Defer struct {
   151  	Position src.Pos
   152  	Expr     expr.Expr
   153  }
   154  
   155  type Simple struct {
   156  	Position src.Pos
   157  	Expr     expr.Expr
   158  }
   159  
   160  // Send is channel send statement, "a <- b".
   161  type Send struct {
   162  	Position src.Pos
   163  	Chan     expr.Expr
   164  	Value    expr.Expr
   165  }
   166  
   167  type Branch struct {
   168  	Position src.Pos
   169  	Type     token.Token // Continue, Break, Goto, or Fallthrough
   170  	Label    string
   171  }
   172  
   173  type Labeled struct {
   174  	Position src.Pos
   175  	Label    string
   176  	Stmt     Stmt
   177  }
   178  
   179  type Select struct {
   180  	Position src.Pos
   181  	Cases    []SelectCase
   182  }
   183  
   184  type SelectCase struct {
   185  	Position src.Pos
   186  	Default  bool
   187  	Stmt     Stmt // a recv- or send-stmt
   188  	Body     *Block
   189  }
   190  
   191  type Bad struct {
   192  	Position src.Pos
   193  	Error    error
   194  }
   195  
   196  func (s *Import) stmt()         {}
   197  func (s *ImportSet) stmt()      {}
   198  func (s *TypeDecl) stmt()       {}
   199  func (s *TypeDeclSet) stmt()    {}
   200  func (s *MethodikDecl) stmt()   {}
   201  func (s *Const) stmt()          {}
   202  func (s *ConstSet) stmt()       {}
   203  func (s *Var) stmt()            {}
   204  func (s *VarSet) stmt()         {}
   205  func (s *Assign) stmt()         {}
   206  func (s *Block) stmt()          {}
   207  func (s *If) stmt()             {}
   208  func (s *For) stmt()            {}
   209  func (s *Switch) stmt()         {}
   210  func (s *SwitchCase) stmt()     {}
   211  func (s *TypeSwitch) stmt()     {}
   212  func (s *TypeSwitchCase) stmt() {}
   213  func (s *Go) stmt()             {}
   214  func (s *Range) stmt()          {}
   215  func (s *Return) stmt()         {}
   216  func (s *Defer) stmt()          {}
   217  func (s *Simple) stmt()         {}
   218  func (s *Send) stmt()           {}
   219  func (s *Branch) stmt()         {}
   220  func (s *Labeled) stmt()        {}
   221  func (s *Select) stmt()         {}
   222  func (s *Bad) stmt()            {}
   223  
   224  func (s *Import) Pos() src.Pos        { return s.Position }
   225  func (s *ImportSet) Pos() src.Pos     { return s.Position }
   226  func (s *TypeDecl) Pos() src.Pos      { return s.Position }
   227  func (s *TypeDeclSet) Pos() src.Pos   { return s.Position }
   228  func (s *MethodikDecl) Pos() src.Pos  { return s.Position }
   229  func (s *Const) Pos() src.Pos         { return s.Position }
   230  func (s *ConstSet) Pos() src.Pos      { return s.Position }
   231  func (s *Var) Pos() src.Pos           { return s.Position }
   232  func (s *VarSet) Pos() src.Pos        { return s.Position }
   233  func (s *Assign) Pos() src.Pos        { return s.Position }
   234  func (s *Block) Pos() src.Pos         { return s.Position }
   235  func (s *If) Pos() src.Pos            { return s.Position }
   236  func (s *For) Pos() src.Pos           { return s.Position }
   237  func (s *Switch) Pos() src.Pos        { return s.Position }
   238  func (s SwitchCase) Pos() src.Pos     { return s.Position }
   239  func (s *TypeSwitch) Pos() src.Pos    { return s.Position }
   240  func (s TypeSwitchCase) Pos() src.Pos { return s.Position }
   241  func (s *Go) Pos() src.Pos            { return s.Position }
   242  func (s *Range) Pos() src.Pos         { return s.Position }
   243  func (s *Return) Pos() src.Pos        { return s.Position }
   244  func (s *Defer) Pos() src.Pos         { return s.Position }
   245  func (s *Simple) Pos() src.Pos        { return s.Position }
   246  func (s *Send) Pos() src.Pos          { return s.Position }
   247  func (s *Branch) Pos() src.Pos        { return s.Position }
   248  func (s *Labeled) Pos() src.Pos       { return s.Position }
   249  func (s *Select) Pos() src.Pos        { return s.Position }
   250  func (s SelectCase) Pos() src.Pos     { return s.Position }
   251  func (s *Bad) Pos() src.Pos           { return s.Position }