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
5package syntax
6
7// ----------------------------------------------------------------------------
8// Nodes
9
10type 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
24type 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
30func (n *node) Pos() Pos       { return n.pos }
31func (n *node) SetPos(pos Pos) { n.pos = pos }
32func (*node) aNode()           {}
33
34// ----------------------------------------------------------------------------
35// Files
36
37// package PkgName; DeclList[0], DeclList[1], ...
38type 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
50type (
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
116type decl struct{ node }
117
118func (*decl) aDecl() {}
119
120// All declarations belonging to the same group point to the same Group node.
121type Group struct {
122	_ int // not empty so we are guaranteed different Group instances
123}
124
125// ----------------------------------------------------------------------------
126// Expressions
127
128func NewName(pos Pos, value string) *Name {
129	n := new(Name)
130	n.pos = pos
131	n.Value = value
132	return n
133}
134
135type (
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
315type expr struct {
316	node
317	typeAndValue // After typechecking, contains the results of typechecking this expression.
318}
319
320func (*expr) aExpr() {}
321
322type ChanDir uint
323
324const (
325	_ ChanDir = iota
326	SendOnly
327	RecvOnly
328)
329
330// ----------------------------------------------------------------------------
331// Statements
332
333type (
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
436type (
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
459type stmt struct{ node }
460
461func (stmt) aStmt() {}
462
463type simpleStmt struct {
464	stmt
465}
466
467func (simpleStmt) aSimpleStmt() {}
468
469// ----------------------------------------------------------------------------
470// Comments
471
472// TODO(gri) Consider renaming to CommentPos, CommentPlacement, etc.
473// Kind = Above doesn't make much sense.
474type CommentKind uint
475
476const (
477	Above CommentKind = iota
478	Below
479	Left
480	Right
481)
482
483type Comment struct {
484	Kind CommentKind
485	Text string
486	Next *Comment
487}
488