nodes.go raw
1 // Copyright 2016 The Go 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 syntax
6
7 // ----------------------------------------------------------------------------
8 // Nodes
9
10 type Node interface {
11 // Pos() returns the position associated with the node as follows:
12 // 1) The position of a node representing a terminal syntax production
13 // (Name, BasicLit, etc.) is the position of the respective production
14 // in the source.
15 // 2) The position of a node representing a non-terminal production
16 // (IndexExpr, IfStmt, etc.) is the position of a token uniquely
17 // associated with that production; usually the left-most one
18 // ('[' for IndexExpr, 'if' for IfStmt, etc.)
19 Pos() Pos
20 SetPos(Pos)
21 aNode()
22 }
23
24 type node struct {
25 // commented out for now since not yet used
26 // doc *Comment // nil means no comment(s) attached
27 pos Pos
28 }
29
30 func (n *node) Pos() Pos { return n.pos }
31 func (n *node) SetPos(pos Pos) { n.pos = pos }
32 func (*node) aNode() {}
33
34 // ----------------------------------------------------------------------------
35 // Files
36
37 // package PkgName; DeclList[0], DeclList[1], ...
38 type File struct {
39 Pragma Pragma
40 PkgName *Name
41 DeclList []Decl
42 EOF Pos
43 GoVersion string
44 node
45 }
46
47 // ----------------------------------------------------------------------------
48 // Declarations
49
50 type (
51 Decl interface {
52 Node
53 aDecl()
54 }
55
56 // Path
57 // LocalPkgName Path
58 ImportDecl struct {
59 Group *Group // nil means not part of a group
60 Pragma Pragma
61 LocalPkgName *Name // including "."; nil means no rename present
62 Path *BasicLit // Path.Bad || Path.Kind == StringLit; nil means no path
63 decl
64 }
65
66 // NameList
67 // NameList = Values
68 // NameList Type = Values
69 ConstDecl struct {
70 Group *Group // nil means not part of a group
71 Pragma Pragma
72 NameList []*Name
73 Type Expr // nil means no type
74 Values Expr // nil means no values
75 decl
76 }
77
78 // Name Type
79 TypeDecl struct {
80 Group *Group // nil means not part of a group
81 Pragma Pragma
82 Name *Name
83 TParamList []*Field // nil means no type parameters
84 Alias bool
85 Type Expr
86 decl
87 }
88
89 // NameList Type
90 // NameList Type = Values
91 // NameList = Values
92 VarDecl struct {
93 Group *Group // nil means not part of a group
94 Pragma Pragma
95 NameList []*Name
96 Type Expr // nil means no type
97 Values Expr // nil means no values
98 decl
99 }
100
101 // func Name Type { Body }
102 // func Name Type
103 // func Receiver Name Type { Body }
104 // func Receiver Name Type
105 FuncDecl struct {
106 Pragma Pragma
107 Recv *Field // nil means regular function
108 Name *Name
109 TParamList []*Field // nil means no type parameters
110 Type *FuncType
111 Body *BlockStmt // nil means no body (forward declaration)
112 decl
113 }
114 )
115
116 type decl struct{ node }
117
118 func (*decl) aDecl() {}
119
120 // All declarations belonging to the same group point to the same Group node.
121 type Group struct {
122 _ int // not empty so we are guaranteed different Group instances
123 }
124
125 // ----------------------------------------------------------------------------
126 // Expressions
127
128 func NewName(pos Pos, value string) *Name {
129 n := &Name{}
130 n.pos = pos
131 n.Value = value
132 return n
133 }
134
135 type (
136 Expr interface {
137 Node
138 typeInfo
139 aExpr()
140 }
141
142 // Placeholder for an expression that failed to parse
143 // correctly and where we can't provide a better node.
144 BadExpr struct {
145 expr
146 }
147
148 // Value
149 Name struct {
150 Value string
151 expr
152 }
153
154 // Value
155 BasicLit struct {
156 Value string
157 Kind LitKind
158 Bad bool // true means the literal Value has syntax errors
159 expr
160 }
161
162 // Type { ElemList[0], ElemList[1], ... }
163 CompositeLit struct {
164 Type Expr // nil means no literal type
165 ElemList []Expr
166 NKeys int // number of elements with keys
167 Rbrace Pos
168 expr
169 }
170
171 // Key: Value
172 KeyValueExpr struct {
173 Key, Value Expr
174 expr
175 }
176
177 // func Type { Body }
178 FuncLit struct {
179 Type *FuncType
180 Body *BlockStmt
181 expr
182 }
183
184 // (X)
185 ParenExpr struct {
186 X Expr
187 expr
188 }
189
190 // X.Sel
191 SelectorExpr struct {
192 X Expr
193 Sel *Name
194 expr
195 }
196
197 // X[Index]
198 // X[T1, T2, ...] (with Ti = Index.(*ListExpr).ElemList[i])
199 IndexExpr struct {
200 X Expr
201 Index Expr
202 expr
203 }
204
205 // X[Index[0] : Index[1] : Index[2]]
206 SliceExpr struct {
207 X Expr
208 Index [3]Expr
209 // Full indicates whether this is a simple or full slice expression.
210 // In a valid AST, this is equivalent to Index[2] != nil.
211 // TODO(mdempsky): This is only needed to report the "3-index
212 // slice of string" error when Index[2] is missing.
213 Full bool
214 expr
215 }
216
217 // X.(Type)
218 AssertExpr struct {
219 X Expr
220 Type Expr
221 expr
222 }
223
224 // X.(type)
225 // Lhs := X.(type)
226 TypeSwitchGuard struct {
227 Lhs *Name // nil means no Lhs :=
228 X Expr // X.(type)
229 expr
230 }
231
232 Operation struct {
233 Op Operator
234 X, Y Expr // Y == nil means unary expression
235 expr
236 }
237
238 // Fun(ArgList[0], ArgList[1], ...)
239 CallExpr struct {
240 Fun Expr
241 ArgList []Expr // nil means no arguments
242 HasDots bool // last argument is followed by ...
243 expr
244 }
245
246 // ElemList[0], ElemList[1], ...
247 ListExpr struct {
248 ElemList []Expr
249 expr
250 }
251
252 // [Len]Elem
253 ArrayType struct {
254 // TODO(gri) consider using Name{"..."} instead of nil (permits attaching of comments)
255 Len Expr // nil means Len is ...
256 Elem Expr
257 expr
258 }
259
260 // []Elem
261 SliceType struct {
262 Elem Expr
263 expr
264 }
265
266 // ...Elem
267 DotsType struct {
268 Elem Expr
269 expr
270 }
271
272 // struct { FieldList[0] TagList[0]; FieldList[1] TagList[1]; ... }
273 StructType struct {
274 FieldList []*Field
275 TagList []*BasicLit // i >= len(TagList) || TagList[i] == nil means no tag for field i
276 expr
277 }
278
279 // Name Type
280 // Type
281 Field struct {
282 Name *Name // nil means anonymous field/parameter (structs/parameters), or embedded element (interfaces)
283 Type Expr // field names declared in a list share the same Type (identical pointers)
284 node
285 }
286
287 // interface { MethodList[0]; MethodList[1]; ... }
288 InterfaceType struct {
289 MethodList []*Field
290 expr
291 }
292
293 FuncType struct {
294 ParamList []*Field
295 ResultList []*Field
296 expr
297 }
298
299 // map[Key]Value
300 MapType struct {
301 Key, Value Expr
302 expr
303 }
304
305 // chan Elem
306 // <-chan Elem
307 // chan<- Elem
308 ChanType struct {
309 Dir ChanDir // 0 means no direction
310 Elem Expr
311 expr
312 }
313 )
314
315 type expr struct {
316 node
317 typeAndValue // After typechecking, contains the results of typechecking this expression.
318 }
319
320 func (*expr) aExpr() {}
321
322 type ChanDir uint
323
324 const (
325 _ ChanDir = iota
326 SendOnly
327 RecvOnly
328 )
329
330 // ----------------------------------------------------------------------------
331 // Statements
332
333 type (
334 Stmt interface {
335 Node
336 aStmt()
337 }
338
339 SimpleStmt interface {
340 Stmt
341 aSimpleStmt()
342 }
343
344 EmptyStmt struct {
345 simpleStmt
346 }
347
348 LabeledStmt struct {
349 Label *Name
350 Stmt Stmt
351 stmt
352 }
353
354 BlockStmt struct {
355 List []Stmt
356 Rbrace Pos
357 stmt
358 }
359
360 ExprStmt struct {
361 X Expr
362 simpleStmt
363 }
364
365 SendStmt struct {
366 Chan, Value Expr // Chan <- Value
367 simpleStmt
368 }
369
370 DeclStmt struct {
371 DeclList []Decl
372 stmt
373 }
374
375 AssignStmt struct {
376 Op Operator // 0 means no operation
377 Lhs, Rhs Expr // Rhs == nil means Lhs++ (Op == Add) or Lhs-- (Op == Sub)
378 simpleStmt
379 }
380
381 BranchStmt struct {
382 Tok Token // Break, Continue, Fallthrough, or Goto
383 Label *Name
384 // Target is the continuation of the control flow after executing
385 // the branch; it is computed by the parser if CheckBranches is set.
386 // Target is a *LabeledStmt for gotos, and a *SwitchStmt, *SelectStmt,
387 // or *ForStmt for breaks and continues, depending on the context of
388 // the branch. Target is not set for fallthroughs.
389 Target Stmt
390 stmt
391 }
392
393 CallStmt struct {
394 Tok Token // Go or Defer
395 Call Expr
396 DeferAt Expr // argument to runtime.deferprocat
397 stmt
398 }
399
400 ReturnStmt struct {
401 Results Expr // nil means no explicit return values
402 stmt
403 }
404
405 IfStmt struct {
406 Init SimpleStmt
407 Cond Expr
408 Then *BlockStmt
409 Else Stmt // either nil, *IfStmt, or *BlockStmt
410 stmt
411 }
412
413 ForStmt struct {
414 Init SimpleStmt // incl. *RangeClause
415 Cond Expr
416 Post SimpleStmt
417 Body *BlockStmt
418 stmt
419 }
420
421 SwitchStmt struct {
422 Init SimpleStmt
423 Tag Expr // incl. *TypeSwitchGuard
424 Body []*CaseClause
425 Rbrace Pos
426 stmt
427 }
428
429 SelectStmt struct {
430 Body []*CommClause
431 Rbrace Pos
432 stmt
433 }
434 )
435
436 type (
437 RangeClause struct {
438 Lhs Expr // nil means no Lhs = or Lhs :=
439 Def bool // means :=
440 X Expr // range X
441 simpleStmt
442 }
443
444 CaseClause struct {
445 Cases Expr // nil means default clause
446 Body []Stmt
447 Colon Pos
448 node
449 }
450
451 CommClause struct {
452 Comm SimpleStmt // send or receive stmt; nil means default clause
453 Body []Stmt
454 Colon Pos
455 node
456 }
457 )
458
459 type stmt struct{ node }
460
461 func (stmt) aStmt() {}
462
463 type simpleStmt struct {
464 stmt
465 }
466
467 func (simpleStmt) aSimpleStmt() {}
468
469 // ----------------------------------------------------------------------------
470 // Comments
471
472 // TODO(gri) Consider renaming to CommentPos, CommentPlacement, etc.
473 // Kind = Above doesn't make much sense.
474 type CommentKind uint
475
476 const (
477 Above CommentKind = iota
478 Below
479 Left
480 Right
481 )
482
483 type Comment struct {
484 Kind CommentKind
485 Text string
486 Next *Comment
487 }
488