Source file src/pkg/go/ast/ast.go

     1	// Copyright 2009 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 ast declares the types used to represent syntax trees for Go
     6	// packages.
     7	//
     8	package ast
     9	
    10	import (
    11		"go/token"
    12		"strings"
    13		"unicode"
    14		"unicode/utf8"
    15	)
    16	
    17	// ----------------------------------------------------------------------------
    18	// Interfaces
    19	//
    20	// There are 3 main classes of nodes: Expressions and type nodes,
    21	// statement nodes, and declaration nodes. The node names usually
    22	// match the corresponding Go spec production names to which they
    23	// correspond. The node fields correspond to the individual parts
    24	// of the respective productions.
    25	//
    26	// All nodes contain position information marking the beginning of
    27	// the corresponding source text segment; it is accessible via the
    28	// Pos accessor method. Nodes may contain additional position info
    29	// for language constructs where comments may be found between parts
    30	// of the construct (typically any larger, parenthesized subpart).
    31	// That position information is needed to properly position comments
    32	// when printing the construct.
    33	
    34	// All node types implement the Node interface.
    35	type Node interface {
    36		Pos() token.Pos // position of first character belonging to the node
    37		End() token.Pos // position of first character immediately after the node
    38	}
    39	
    40	// All expression nodes implement the Expr interface.
    41	type Expr interface {
    42		Node
    43		exprNode()
    44	}
    45	
    46	// All statement nodes implement the Stmt interface.
    47	type Stmt interface {
    48		Node
    49		stmtNode()
    50	}
    51	
    52	// All declaration nodes implement the Decl interface.
    53	type Decl interface {
    54		Node
    55		declNode()
    56	}
    57	
    58	// ----------------------------------------------------------------------------
    59	// Comments
    60	
    61	// A Comment node represents a single //-style or /*-style comment.
    62	type Comment struct {
    63		Slash token.Pos // position of "/" starting the comment
    64		Text  string    // comment text (excluding '\n' for //-style comments)
    65	}
    66	
    67	func (c *Comment) Pos() token.Pos { return c.Slash }
    68	func (c *Comment) End() token.Pos { return token.Pos(int(c.Slash) + len(c.Text)) }
    69	
    70	// A CommentGroup represents a sequence of comments
    71	// with no other tokens and no empty lines between.
    72	//
    73	type CommentGroup struct {
    74		List []*Comment // len(List) > 0
    75	}
    76	
    77	func (g *CommentGroup) Pos() token.Pos { return g.List[0].Pos() }
    78	func (g *CommentGroup) End() token.Pos { return g.List[len(g.List)-1].End() }
    79	
    80	func isWhitespace(ch byte) bool { return ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r' }
    81	
    82	func stripTrailingWhitespace(s string) string {
    83		i := len(s)
    84		for i > 0 && isWhitespace(s[i-1]) {
    85			i--
    86		}
    87		return s[0:i]
    88	}
    89	
    90	// Text returns the text of the comment.
    91	// Comment markers (//, /*, and */), the first space of a line comment, and
    92	// leading and trailing empty lines are removed. Multiple empty lines are
    93	// reduced to one, and trailing space on lines is trimmed. Unless the result
    94	// is empty, it is newline-terminated.
    95	//
    96	func (g *CommentGroup) Text() string {
    97		if g == nil {
    98			return ""
    99		}
   100		comments := make([]string, len(g.List))
   101		for i, c := range g.List {
   102			comments[i] = string(c.Text)
   103		}
   104	
   105		lines := make([]string, 0, 10) // most comments are less than 10 lines
   106		for _, c := range comments {
   107			// Remove comment markers.
   108			// The parser has given us exactly the comment text.
   109			switch c[1] {
   110			case '/':
   111				//-style comment (no newline at the end)
   112				c = c[2:]
   113				// strip first space - required for Example tests
   114				if len(c) > 0 && c[0] == ' ' {
   115					c = c[1:]
   116				}
   117			case '*':
   118				/*-style comment */
   119				c = c[2 : len(c)-2]
   120			}
   121	
   122			// Split on newlines.
   123			cl := strings.Split(c, "\n")
   124	
   125			// Walk lines, stripping trailing white space and adding to list.
   126			for _, l := range cl {
   127				lines = append(lines, stripTrailingWhitespace(l))
   128			}
   129		}
   130	
   131		// Remove leading blank lines; convert runs of
   132		// interior blank lines to a single blank line.
   133		n := 0
   134		for _, line := range lines {
   135			if line != "" || n > 0 && lines[n-1] != "" {
   136				lines[n] = line
   137				n++
   138			}
   139		}
   140		lines = lines[0:n]
   141	
   142		// Add final "" entry to get trailing newline from Join.
   143		if n > 0 && lines[n-1] != "" {
   144			lines = append(lines, "")
   145		}
   146	
   147		return strings.Join(lines, "\n")
   148	}
   149	
   150	// ----------------------------------------------------------------------------
   151	// Expressions and types
   152	
   153	// A Field represents a Field declaration list in a struct type,
   154	// a method list in an interface type, or a parameter/result declaration
   155	// in a signature.
   156	//
   157	type Field struct {
   158		Doc     *CommentGroup // associated documentation; or nil
   159		Names   []*Ident      // field/method/parameter names; or nil if anonymous field
   160		Type    Expr          // field/method/parameter type
   161		Tag     *BasicLit     // field tag; or nil
   162		Comment *CommentGroup // line comments; or nil
   163	}
   164	
   165	func (f *Field) Pos() token.Pos {
   166		if len(f.Names) > 0 {
   167			return f.Names[0].Pos()
   168		}
   169		return f.Type.Pos()
   170	}
   171	
   172	func (f *Field) End() token.Pos {
   173		if f.Tag != nil {
   174			return f.Tag.End()
   175		}
   176		return f.Type.End()
   177	}
   178	
   179	// A FieldList represents a list of Fields, enclosed by parentheses or braces.
   180	type FieldList struct {
   181		Opening token.Pos // position of opening parenthesis/brace, if any
   182		List    []*Field  // field list; or nil
   183		Closing token.Pos // position of closing parenthesis/brace, if any
   184	}
   185	
   186	func (f *FieldList) Pos() token.Pos {
   187		if f.Opening.IsValid() {
   188			return f.Opening
   189		}
   190		// the list should not be empty in this case;
   191		// be conservative and guard against bad ASTs
   192		if len(f.List) > 0 {
   193			return f.List[0].Pos()
   194		}
   195		return token.NoPos
   196	}
   197	
   198	func (f *FieldList) End() token.Pos {
   199		if f.Closing.IsValid() {
   200			return f.Closing + 1
   201		}
   202		// the list should not be empty in this case;
   203		// be conservative and guard against bad ASTs
   204		if n := len(f.List); n > 0 {
   205			return f.List[n-1].End()
   206		}
   207		return token.NoPos
   208	}
   209	
   210	// NumFields returns the number of (named and anonymous fields) in a FieldList.
   211	func (f *FieldList) NumFields() int {
   212		n := 0
   213		if f != nil {
   214			for _, g := range f.List {
   215				m := len(g.Names)
   216				if m == 0 {
   217					m = 1 // anonymous field
   218				}
   219				n += m
   220			}
   221		}
   222		return n
   223	}
   224	
   225	// An expression is represented by a tree consisting of one
   226	// or more of the following concrete expression nodes.
   227	//
   228	type (
   229		// A BadExpr node is a placeholder for expressions containing
   230		// syntax errors for which no correct expression nodes can be
   231		// created.
   232		//
   233		BadExpr struct {
   234			From, To token.Pos // position range of bad expression
   235		}
   236	
   237		// An Ident node represents an identifier.
   238		Ident struct {
   239			NamePos token.Pos // identifier position
   240			Name    string    // identifier name
   241			Obj     *Object   // denoted object; or nil
   242		}
   243	
   244		// An Ellipsis node stands for the "..." type in a
   245		// parameter list or the "..." length in an array type.
   246		//
   247		Ellipsis struct {
   248			Ellipsis token.Pos // position of "..."
   249			Elt      Expr      // ellipsis element type (parameter lists only); or nil
   250		}
   251	
   252		// A BasicLit node represents a literal of basic type.
   253		BasicLit struct {
   254			ValuePos token.Pos   // literal position
   255			Kind     token.Token // token.INT, token.FLOAT, token.IMAG, token.CHAR, or token.STRING
   256			Value    string      // literal string; e.g. 42, 0x7f, 3.14, 1e-9, 2.4i, 'a', '\x7f', "foo" or `\m\n\o`
   257		}
   258	
   259		// A FuncLit node represents a function literal.
   260		FuncLit struct {
   261			Type *FuncType  // function type
   262			Body *BlockStmt // function body
   263		}
   264	
   265		// A CompositeLit node represents a composite literal.
   266		CompositeLit struct {
   267			Type   Expr      // literal type; or nil
   268			Lbrace token.Pos // position of "{"
   269			Elts   []Expr    // list of composite elements; or nil
   270			Rbrace token.Pos // position of "}"
   271		}
   272	
   273		// A ParenExpr node represents a parenthesized expression.
   274		ParenExpr struct {
   275			Lparen token.Pos // position of "("
   276			X      Expr      // parenthesized expression
   277			Rparen token.Pos // position of ")"
   278		}
   279	
   280		// A SelectorExpr node represents an expression followed by a selector.
   281		SelectorExpr struct {
   282			X   Expr   // expression
   283			Sel *Ident // field selector
   284		}
   285	
   286		// An IndexExpr node represents an expression followed by an index.
   287		IndexExpr struct {
   288			X      Expr      // expression
   289			Lbrack token.Pos // position of "["
   290			Index  Expr      // index expression
   291			Rbrack token.Pos // position of "]"
   292		}
   293	
   294		// An SliceExpr node represents an expression followed by slice indices.
   295		SliceExpr struct {
   296			X      Expr      // expression
   297			Lbrack token.Pos // position of "["
   298			Low    Expr      // begin of slice range; or nil
   299			High   Expr      // end of slice range; or nil
   300			Rbrack token.Pos // position of "]"
   301		}
   302	
   303		// A TypeAssertExpr node represents an expression followed by a
   304		// type assertion.
   305		//
   306		TypeAssertExpr struct {
   307			X    Expr // expression
   308			Type Expr // asserted type; nil means type switch X.(type)
   309		}
   310	
   311		// A CallExpr node represents an expression followed by an argument list.
   312		CallExpr struct {
   313			Fun      Expr      // function expression
   314			Lparen   token.Pos // position of "("
   315			Args     []Expr    // function arguments; or nil
   316			Ellipsis token.Pos // position of "...", if any
   317			Rparen   token.Pos // position of ")"
   318		}
   319	
   320		// A StarExpr node represents an expression of the form "*" Expression.
   321		// Semantically it could be a unary "*" expression, or a pointer type.
   322		//
   323		StarExpr struct {
   324			Star token.Pos // position of "*"
   325			X    Expr      // operand
   326		}
   327	
   328		// A UnaryExpr node represents a unary expression.
   329		// Unary "*" expressions are represented via StarExpr nodes.
   330		//
   331		UnaryExpr struct {
   332			OpPos token.Pos   // position of Op
   333			Op    token.Token // operator
   334			X     Expr        // operand
   335		}
   336	
   337		// A BinaryExpr node represents a binary expression.
   338		BinaryExpr struct {
   339			X     Expr        // left operand
   340			OpPos token.Pos   // position of Op
   341			Op    token.Token // operator
   342			Y     Expr        // right operand
   343		}
   344	
   345		// A KeyValueExpr node represents (key : value) pairs
   346		// in composite literals.
   347		//
   348		KeyValueExpr struct {
   349			Key   Expr
   350			Colon token.Pos // position of ":"
   351			Value Expr
   352		}
   353	)
   354	
   355	// The direction of a channel type is indicated by one
   356	// of the following constants.
   357	//
   358	type ChanDir int
   359	
   360	const (
   361		SEND ChanDir = 1 << iota
   362		RECV
   363	)
   364	
   365	// A type is represented by a tree consisting of one
   366	// or more of the following type-specific expression
   367	// nodes.
   368	//
   369	type (
   370		// An ArrayType node represents an array or slice type.
   371		ArrayType struct {
   372			Lbrack token.Pos // position of "["
   373			Len    Expr      // Ellipsis node for [...]T array types, nil for slice types
   374			Elt    Expr      // element type
   375		}
   376	
   377		// A StructType node represents a struct type.
   378		StructType struct {
   379			Struct     token.Pos  // position of "struct" keyword
   380			Fields     *FieldList // list of field declarations
   381			Incomplete bool       // true if (source) fields are missing in the Fields list
   382		}
   383	
   384		// Pointer types are represented via StarExpr nodes.
   385	
   386		// A FuncType node represents a function type.
   387		FuncType struct {
   388			Func    token.Pos  // position of "func" keyword
   389			Params  *FieldList // (incoming) parameters; or nil
   390			Results *FieldList // (outgoing) results; or nil
   391		}
   392	
   393		// An InterfaceType node represents an interface type.
   394		InterfaceType struct {
   395			Interface  token.Pos  // position of "interface" keyword
   396			Methods    *FieldList // list of methods
   397			Incomplete bool       // true if (source) methods are missing in the Methods list
   398		}
   399	
   400		// A MapType node represents a map type.
   401		MapType struct {
   402			Map   token.Pos // position of "map" keyword
   403			Key   Expr
   404			Value Expr
   405		}
   406	
   407		// A ChanType node represents a channel type.
   408		ChanType struct {
   409			Begin token.Pos // position of "chan" keyword or "<-" (whichever comes first)
   410			Arrow token.Pos // position of "<-" (noPos if there is no "<-")
   411			Dir   ChanDir   // channel direction
   412			Value Expr      // value type
   413		}
   414	)
   415	
   416	// Pos and End implementations for expression/type nodes.
   417	//
   418	func (x *BadExpr) Pos() token.Pos  { return x.From }
   419	func (x *Ident) Pos() token.Pos    { return x.NamePos }
   420	func (x *Ellipsis) Pos() token.Pos { return x.Ellipsis }
   421	func (x *BasicLit) Pos() token.Pos { return x.ValuePos }
   422	func (x *FuncLit) Pos() token.Pos  { return x.Type.Pos() }
   423	func (x *CompositeLit) Pos() token.Pos {
   424		if x.Type != nil {
   425			return x.Type.Pos()
   426		}
   427		return x.Lbrace
   428	}
   429	func (x *ParenExpr) Pos() token.Pos      { return x.Lparen }
   430	func (x *SelectorExpr) Pos() token.Pos   { return x.X.Pos() }
   431	func (x *IndexExpr) Pos() token.Pos      { return x.X.Pos() }
   432	func (x *SliceExpr) Pos() token.Pos      { return x.X.Pos() }
   433	func (x *TypeAssertExpr) Pos() token.Pos { return x.X.Pos() }
   434	func (x *CallExpr) Pos() token.Pos       { return x.Fun.Pos() }
   435	func (x *StarExpr) Pos() token.Pos       { return x.Star }
   436	func (x *UnaryExpr) Pos() token.Pos      { return x.OpPos }
   437	func (x *BinaryExpr) Pos() token.Pos     { return x.X.Pos() }
   438	func (x *KeyValueExpr) Pos() token.Pos   { return x.Key.Pos() }
   439	func (x *ArrayType) Pos() token.Pos      { return x.Lbrack }
   440	func (x *StructType) Pos() token.Pos     { return x.Struct }
   441	func (x *FuncType) Pos() token.Pos       { return x.Func }
   442	func (x *InterfaceType) Pos() token.Pos  { return x.Interface }
   443	func (x *MapType) Pos() token.Pos        { return x.Map }
   444	func (x *ChanType) Pos() token.Pos       { return x.Begin }
   445	
   446	func (x *BadExpr) End() token.Pos { return x.To }
   447	func (x *Ident) End() token.Pos   { return token.Pos(int(x.NamePos) + len(x.Name)) }
   448	func (x *Ellipsis) End() token.Pos {
   449		if x.Elt != nil {
   450			return x.Elt.End()
   451		}
   452		return x.Ellipsis + 3 // len("...")
   453	}
   454	func (x *BasicLit) End() token.Pos     { return token.Pos(int(x.ValuePos) + len(x.Value)) }
   455	func (x *FuncLit) End() token.Pos      { return x.Body.End() }
   456	func (x *CompositeLit) End() token.Pos { return x.Rbrace + 1 }
   457	func (x *ParenExpr) End() token.Pos    { return x.Rparen + 1 }
   458	func (x *SelectorExpr) End() token.Pos { return x.Sel.End() }
   459	func (x *IndexExpr) End() token.Pos    { return x.Rbrack + 1 }
   460	func (x *SliceExpr) End() token.Pos    { return x.Rbrack + 1 }
   461	func (x *TypeAssertExpr) End() token.Pos {
   462		if x.Type != nil {
   463			return x.Type.End()
   464		}
   465		return x.X.End()
   466	}
   467	func (x *CallExpr) End() token.Pos     { return x.Rparen + 1 }
   468	func (x *StarExpr) End() token.Pos     { return x.X.End() }
   469	func (x *UnaryExpr) End() token.Pos    { return x.X.End() }
   470	func (x *BinaryExpr) End() token.Pos   { return x.Y.End() }
   471	func (x *KeyValueExpr) End() token.Pos { return x.Value.End() }
   472	func (x *ArrayType) End() token.Pos    { return x.Elt.End() }
   473	func (x *StructType) End() token.Pos   { return x.Fields.End() }
   474	func (x *FuncType) End() token.Pos {
   475		if x.Results != nil {
   476			return x.Results.End()
   477		}
   478		return x.Params.End()
   479	}
   480	func (x *InterfaceType) End() token.Pos { return x.Methods.End() }
   481	func (x *MapType) End() token.Pos       { return x.Value.End() }
   482	func (x *ChanType) End() token.Pos      { return x.Value.End() }
   483	
   484	// exprNode() ensures that only expression/type nodes can be
   485	// assigned to an ExprNode.
   486	//
   487	func (*BadExpr) exprNode()        {}
   488	func (*Ident) exprNode()          {}
   489	func (*Ellipsis) exprNode()       {}
   490	func (*BasicLit) exprNode()       {}
   491	func (*FuncLit) exprNode()        {}
   492	func (*CompositeLit) exprNode()   {}
   493	func (*ParenExpr) exprNode()      {}
   494	func (*SelectorExpr) exprNode()   {}
   495	func (*IndexExpr) exprNode()      {}
   496	func (*SliceExpr) exprNode()      {}
   497	func (*TypeAssertExpr) exprNode() {}
   498	func (*CallExpr) exprNode()       {}
   499	func (*StarExpr) exprNode()       {}
   500	func (*UnaryExpr) exprNode()      {}
   501	func (*BinaryExpr) exprNode()     {}
   502	func (*KeyValueExpr) exprNode()   {}
   503	
   504	func (*ArrayType) exprNode()     {}
   505	func (*StructType) exprNode()    {}
   506	func (*FuncType) exprNode()      {}
   507	func (*InterfaceType) exprNode() {}
   508	func (*MapType) exprNode()       {}
   509	func (*ChanType) exprNode()      {}
   510	
   511	// ----------------------------------------------------------------------------
   512	// Convenience functions for Idents
   513	
   514	var noPos token.Pos
   515	
   516	// NewIdent creates a new Ident without position.
   517	// Useful for ASTs generated by code other than the Go parser.
   518	//
   519	func NewIdent(name string) *Ident { return &Ident{noPos, name, nil} }
   520	
   521	// IsExported returns whether name is an exported Go symbol
   522	// (i.e., whether it begins with an uppercase letter).
   523	//
   524	func IsExported(name string) bool {
   525		ch, _ := utf8.DecodeRuneInString(name)
   526		return unicode.IsUpper(ch)
   527	}
   528	
   529	// IsExported returns whether id is an exported Go symbol
   530	// (i.e., whether it begins with an uppercase letter).
   531	//
   532	func (id *Ident) IsExported() bool { return IsExported(id.Name) }
   533	
   534	func (id *Ident) String() string {
   535		if id != nil {
   536			return id.Name
   537		}
   538		return "<nil>"
   539	}
   540	
   541	// ----------------------------------------------------------------------------
   542	// Statements
   543	
   544	// A statement is represented by a tree consisting of one
   545	// or more of the following concrete statement nodes.
   546	//
   547	type (
   548		// A BadStmt node is a placeholder for statements containing
   549		// syntax errors for which no correct statement nodes can be
   550		// created.
   551		//
   552		BadStmt struct {
   553			From, To token.Pos // position range of bad statement
   554		}
   555	
   556		// A DeclStmt node represents a declaration in a statement list.
   557		DeclStmt struct {
   558			Decl Decl // *GenDecl with CONST, TYPE, or VAR token
   559		}
   560	
   561		// An EmptyStmt node represents an empty statement.
   562		// The "position" of the empty statement is the position
   563		// of the immediately preceding semicolon.
   564		//
   565		EmptyStmt struct {
   566			Semicolon token.Pos // position of preceding ";"
   567		}
   568	
   569		// A LabeledStmt node represents a labeled statement.
   570		LabeledStmt struct {
   571			Label *Ident
   572			Colon token.Pos // position of ":"
   573			Stmt  Stmt
   574		}
   575	
   576		// An ExprStmt node represents a (stand-alone) expression
   577		// in a statement list.
   578		//
   579		ExprStmt struct {
   580			X Expr // expression
   581		}
   582	
   583		// A SendStmt node represents a send statement.
   584		SendStmt struct {
   585			Chan  Expr
   586			Arrow token.Pos // position of "<-"
   587			Value Expr
   588		}
   589	
   590		// An IncDecStmt node represents an increment or decrement statement.
   591		IncDecStmt struct {
   592			X      Expr
   593			TokPos token.Pos   // position of Tok
   594			Tok    token.Token // INC or DEC
   595		}
   596	
   597		// An AssignStmt node represents an assignment or
   598		// a short variable declaration.
   599		//
   600		AssignStmt struct {
   601			Lhs    []Expr
   602			TokPos token.Pos   // position of Tok
   603			Tok    token.Token // assignment token, DEFINE
   604			Rhs    []Expr
   605		}
   606	
   607		// A GoStmt node represents a go statement.
   608		GoStmt struct {
   609			Go   token.Pos // position of "go" keyword
   610			Call *CallExpr
   611		}
   612	
   613		// A DeferStmt node represents a defer statement.
   614		DeferStmt struct {
   615			Defer token.Pos // position of "defer" keyword
   616			Call  *CallExpr
   617		}
   618	
   619		// A ReturnStmt node represents a return statement.
   620		ReturnStmt struct {
   621			Return  token.Pos // position of "return" keyword
   622			Results []Expr    // result expressions; or nil
   623		}
   624	
   625		// A BranchStmt node represents a break, continue, goto,
   626		// or fallthrough statement.
   627		//
   628		BranchStmt struct {
   629			TokPos token.Pos   // position of Tok
   630			Tok    token.Token // keyword token (BREAK, CONTINUE, GOTO, FALLTHROUGH)
   631			Label  *Ident      // label name; or nil
   632		}
   633	
   634		// A BlockStmt node represents a braced statement list.
   635		BlockStmt struct {
   636			Lbrace token.Pos // position of "{"
   637			List   []Stmt
   638			Rbrace token.Pos // position of "}"
   639		}
   640	
   641		// An IfStmt node represents an if statement.
   642		IfStmt struct {
   643			If   token.Pos // position of "if" keyword
   644			Init Stmt      // initialization statement; or nil
   645			Cond Expr      // condition
   646			Body *BlockStmt
   647			Else Stmt // else branch; or nil
   648		}
   649	
   650		// A CaseClause represents a case of an expression or type switch statement.
   651		CaseClause struct {
   652			Case  token.Pos // position of "case" or "default" keyword
   653			List  []Expr    // list of expressions or types; nil means default case
   654			Colon token.Pos // position of ":"
   655			Body  []Stmt    // statement list; or nil
   656		}
   657	
   658		// A SwitchStmt node represents an expression switch statement.
   659		SwitchStmt struct {
   660			Switch token.Pos  // position of "switch" keyword
   661			Init   Stmt       // initialization statement; or nil
   662			Tag    Expr       // tag expression; or nil
   663			Body   *BlockStmt // CaseClauses only
   664		}
   665	
   666		// An TypeSwitchStmt node represents a type switch statement.
   667		TypeSwitchStmt struct {
   668			Switch token.Pos  // position of "switch" keyword
   669			Init   Stmt       // initialization statement; or nil
   670			Assign Stmt       // x := y.(type) or y.(type)
   671			Body   *BlockStmt // CaseClauses only
   672		}
   673	
   674		// A CommClause node represents a case of a select statement.
   675		CommClause struct {
   676			Case  token.Pos // position of "case" or "default" keyword
   677			Comm  Stmt      // send or receive statement; nil means default case
   678			Colon token.Pos // position of ":"
   679			Body  []Stmt    // statement list; or nil
   680		}
   681	
   682		// An SelectStmt node represents a select statement.
   683		SelectStmt struct {
   684			Select token.Pos  // position of "select" keyword
   685			Body   *BlockStmt // CommClauses only
   686		}
   687	
   688		// A ForStmt represents a for statement.
   689		ForStmt struct {
   690			For  token.Pos // position of "for" keyword
   691			Init Stmt      // initialization statement; or nil
   692			Cond Expr      // condition; or nil
   693			Post Stmt      // post iteration statement; or nil
   694			Body *BlockStmt
   695		}
   696	
   697		// A RangeStmt represents a for statement with a range clause.
   698		RangeStmt struct {
   699			For        token.Pos   // position of "for" keyword
   700			Key, Value Expr        // Value may be nil
   701			TokPos     token.Pos   // position of Tok
   702			Tok        token.Token // ASSIGN, DEFINE
   703			X          Expr        // value to range over
   704			Body       *BlockStmt
   705		}
   706	)
   707	
   708	// Pos and End implementations for statement nodes.
   709	//
   710	func (s *BadStmt) Pos() token.Pos        { return s.From }
   711	func (s *DeclStmt) Pos() token.Pos       { return s.Decl.Pos() }
   712	func (s *EmptyStmt) Pos() token.Pos      { return s.Semicolon }
   713	func (s *LabeledStmt) Pos() token.Pos    { return s.Label.Pos() }
   714	func (s *ExprStmt) Pos() token.Pos       { return s.X.Pos() }
   715	func (s *SendStmt) Pos() token.Pos       { return s.Chan.Pos() }
   716	func (s *IncDecStmt) Pos() token.Pos     { return s.X.Pos() }
   717	func (s *AssignStmt) Pos() token.Pos     { return s.Lhs[0].Pos() }
   718	func (s *GoStmt) Pos() token.Pos         { return s.Go }
   719	func (s *DeferStmt) Pos() token.Pos      { return s.Defer }
   720	func (s *ReturnStmt) Pos() token.Pos     { return s.Return }
   721	func (s *BranchStmt) Pos() token.Pos     { return s.TokPos }
   722	func (s *BlockStmt) Pos() token.Pos      { return s.Lbrace }
   723	func (s *IfStmt) Pos() token.Pos         { return s.If }
   724	func (s *CaseClause) Pos() token.Pos     { return s.Case }
   725	func (s *SwitchStmt) Pos() token.Pos     { return s.Switch }
   726	func (s *TypeSwitchStmt) Pos() token.Pos { return s.Switch }
   727	func (s *CommClause) Pos() token.Pos     { return s.Case }
   728	func (s *SelectStmt) Pos() token.Pos     { return s.Select }
   729	func (s *ForStmt) Pos() token.Pos        { return s.For }
   730	func (s *RangeStmt) Pos() token.Pos      { return s.For }
   731	
   732	func (s *BadStmt) End() token.Pos  { return s.To }
   733	func (s *DeclStmt) End() token.Pos { return s.Decl.End() }
   734	func (s *EmptyStmt) End() token.Pos {
   735		return s.Semicolon + 1 /* len(";") */
   736	}
   737	func (s *LabeledStmt) End() token.Pos { return s.Stmt.End() }
   738	func (s *ExprStmt) End() token.Pos    { return s.X.End() }
   739	func (s *SendStmt) End() token.Pos    { return s.Value.End() }
   740	func (s *IncDecStmt) End() token.Pos {
   741		return s.TokPos + 2 /* len("++") */
   742	}
   743	func (s *AssignStmt) End() token.Pos { return s.Rhs[len(s.Rhs)-1].End() }
   744	func (s *GoStmt) End() token.Pos     { return s.Call.End() }
   745	func (s *DeferStmt) End() token.Pos  { return s.Call.End() }
   746	func (s *ReturnStmt) End() token.Pos {
   747		if n := len(s.Results); n > 0 {
   748			return s.Results[n-1].End()
   749		}
   750		return s.Return + 6 // len("return")
   751	}
   752	func (s *BranchStmt) End() token.Pos {
   753		if s.Label != nil {
   754			return s.Label.End()
   755		}
   756		return token.Pos(int(s.TokPos) + len(s.Tok.String()))
   757	}
   758	func (s *BlockStmt) End() token.Pos { return s.Rbrace + 1 }
   759	func (s *IfStmt) End() token.Pos {
   760		if s.Else != nil {
   761			return s.Else.End()
   762		}
   763		return s.Body.End()
   764	}
   765	func (s *CaseClause) End() token.Pos {
   766		if n := len(s.Body); n > 0 {
   767			return s.Body[n-1].End()
   768		}
   769		return s.Colon + 1
   770	}
   771	func (s *SwitchStmt) End() token.Pos     { return s.Body.End() }
   772	func (s *TypeSwitchStmt) End() token.Pos { return s.Body.End() }
   773	func (s *CommClause) End() token.Pos {
   774		if n := len(s.Body); n > 0 {
   775			return s.Body[n-1].End()
   776		}
   777		return s.Colon + 1
   778	}
   779	func (s *SelectStmt) End() token.Pos { return s.Body.End() }
   780	func (s *ForStmt) End() token.Pos    { return s.Body.End() }
   781	func (s *RangeStmt) End() token.Pos  { return s.Body.End() }
   782	
   783	// stmtNode() ensures that only statement nodes can be
   784	// assigned to a StmtNode.
   785	//
   786	func (*BadStmt) stmtNode()        {}
   787	func (*DeclStmt) stmtNode()       {}
   788	func (*EmptyStmt) stmtNode()      {}
   789	func (*LabeledStmt) stmtNode()    {}
   790	func (*ExprStmt) stmtNode()       {}
   791	func (*SendStmt) stmtNode()       {}
   792	func (*IncDecStmt) stmtNode()     {}
   793	func (*AssignStmt) stmtNode()     {}
   794	func (*GoStmt) stmtNode()         {}
   795	func (*DeferStmt) stmtNode()      {}
   796	func (*ReturnStmt) stmtNode()     {}
   797	func (*BranchStmt) stmtNode()     {}
   798	func (*BlockStmt) stmtNode()      {}
   799	func (*IfStmt) stmtNode()         {}
   800	func (*CaseClause) stmtNode()     {}
   801	func (*SwitchStmt) stmtNode()     {}
   802	func (*TypeSwitchStmt) stmtNode() {}
   803	func (*CommClause) stmtNode()     {}
   804	func (*SelectStmt) stmtNode()     {}
   805	func (*ForStmt) stmtNode()        {}
   806	func (*RangeStmt) stmtNode()      {}
   807	
   808	// ----------------------------------------------------------------------------
   809	// Declarations
   810	
   811	// A Spec node represents a single (non-parenthesized) import,
   812	// constant, type, or variable declaration.
   813	//
   814	type (
   815		// The Spec type stands for any of *ImportSpec, *ValueSpec, and *TypeSpec.
   816		Spec interface {
   817			Node
   818			specNode()
   819		}
   820	
   821		// An ImportSpec node represents a single package import.
   822		ImportSpec struct {
   823			Doc     *CommentGroup // associated documentation; or nil
   824			Name    *Ident        // local package name (including "."); or nil
   825			Path    *BasicLit     // import path
   826			Comment *CommentGroup // line comments; or nil
   827			EndPos  token.Pos     // end of spec (overrides Path.Pos if nonzero)
   828		}
   829	
   830		// A ValueSpec node represents a constant or variable declaration
   831		// (ConstSpec or VarSpec production).
   832		//
   833		ValueSpec struct {
   834			Doc     *CommentGroup // associated documentation; or nil
   835			Names   []*Ident      // value names (len(Names) > 0)
   836			Type    Expr          // value type; or nil
   837			Values  []Expr        // initial values; or nil
   838			Comment *CommentGroup // line comments; or nil
   839		}
   840	
   841		// A TypeSpec node represents a type declaration (TypeSpec production).
   842		TypeSpec struct {
   843			Doc     *CommentGroup // associated documentation; or nil
   844			Name    *Ident        // type name
   845			Type    Expr          // *Ident, *ParenExpr, *SelectorExpr, *StarExpr, or any of the *XxxTypes
   846			Comment *CommentGroup // line comments; or nil
   847		}
   848	)
   849	
   850	// Pos and End implementations for spec nodes.
   851	//
   852	func (s *ImportSpec) Pos() token.Pos {
   853		if s.Name != nil {
   854			return s.Name.Pos()
   855		}
   856		return s.Path.Pos()
   857	}
   858	func (s *ValueSpec) Pos() token.Pos { return s.Names[0].Pos() }
   859	func (s *TypeSpec) Pos() token.Pos  { return s.Name.Pos() }
   860	
   861	func (s *ImportSpec) End() token.Pos {
   862		if s.EndPos != 0 {
   863			return s.EndPos
   864		}
   865		return s.Path.End()
   866	}
   867	
   868	func (s *ValueSpec) End() token.Pos {
   869		if n := len(s.Values); n > 0 {
   870			return s.Values[n-1].End()
   871		}
   872		if s.Type != nil {
   873			return s.Type.End()
   874		}
   875		return s.Names[len(s.Names)-1].End()
   876	}
   877	func (s *TypeSpec) End() token.Pos { return s.Type.End() }
   878	
   879	// specNode() ensures that only spec nodes can be
   880	// assigned to a Spec.
   881	//
   882	func (*ImportSpec) specNode() {}
   883	func (*ValueSpec) specNode()  {}
   884	func (*TypeSpec) specNode()   {}
   885	
   886	// A declaration is represented by one of the following declaration nodes.
   887	//
   888	type (
   889		// A BadDecl node is a placeholder for declarations containing
   890		// syntax errors for which no correct declaration nodes can be
   891		// created.
   892		//
   893		BadDecl struct {
   894			From, To token.Pos // position range of bad declaration
   895		}
   896	
   897		// A GenDecl node (generic declaration node) represents an import,
   898		// constant, type or variable declaration. A valid Lparen position
   899		// (Lparen.Line > 0) indicates a parenthesized declaration.
   900		//
   901		// Relationship between Tok value and Specs element type:
   902		//
   903		//	token.IMPORT  *ImportSpec
   904		//	token.CONST   *ValueSpec
   905		//	token.TYPE    *TypeSpec
   906		//	token.VAR     *ValueSpec
   907		//
   908		GenDecl struct {
   909			Doc    *CommentGroup // associated documentation; or nil
   910			TokPos token.Pos     // position of Tok
   911			Tok    token.Token   // IMPORT, CONST, TYPE, VAR
   912			Lparen token.Pos     // position of '(', if any
   913			Specs  []Spec
   914			Rparen token.Pos // position of ')', if any
   915		}
   916	
   917		// A FuncDecl node represents a function declaration.
   918		FuncDecl struct {
   919			Doc  *CommentGroup // associated documentation; or nil
   920			Recv *FieldList    // receiver (methods); or nil (functions)
   921			Name *Ident        // function/method name
   922			Type *FuncType     // position of Func keyword, parameters and results
   923			Body *BlockStmt    // function body; or nil (forward declaration)
   924		}
   925	)
   926	
   927	// Pos and End implementations for declaration nodes.
   928	//
   929	func (d *BadDecl) Pos() token.Pos  { return d.From }
   930	func (d *GenDecl) Pos() token.Pos  { return d.TokPos }
   931	func (d *FuncDecl) Pos() token.Pos { return d.Type.Pos() }
   932	
   933	func (d *BadDecl) End() token.Pos { return d.To }
   934	func (d *GenDecl) End() token.Pos {
   935		if d.Rparen.IsValid() {
   936			return d.Rparen + 1
   937		}
   938		return d.Specs[0].End()
   939	}
   940	func (d *FuncDecl) End() token.Pos {
   941		if d.Body != nil {
   942			return d.Body.End()
   943		}
   944		return d.Type.End()
   945	}
   946	
   947	// declNode() ensures that only declaration nodes can be
   948	// assigned to a DeclNode.
   949	//
   950	func (*BadDecl) declNode()  {}
   951	func (*GenDecl) declNode()  {}
   952	func (*FuncDecl) declNode() {}
   953	
   954	// ----------------------------------------------------------------------------
   955	// Files and packages
   956	
   957	// A File node represents a Go source file.
   958	//
   959	// The Comments list contains all comments in the source file in order of
   960	// appearance, including the comments that are pointed to from other nodes
   961	// via Doc and Comment fields.
   962	//
   963	type File struct {
   964		Doc        *CommentGroup   // associated documentation; or nil
   965		Package    token.Pos       // position of "package" keyword
   966		Name       *Ident          // package name
   967		Decls      []Decl          // top-level declarations; or nil
   968		Scope      *Scope          // package scope (this file only)
   969		Imports    []*ImportSpec   // imports in this file
   970		Unresolved []*Ident        // unresolved identifiers in this file
   971		Comments   []*CommentGroup // list of all comments in the source file
   972	}
   973	
   974	func (f *File) Pos() token.Pos { return f.Package }
   975	func (f *File) End() token.Pos {
   976		if n := len(f.Decls); n > 0 {
   977			return f.Decls[n-1].End()
   978		}
   979		return f.Name.End()
   980	}
   981	
   982	// A Package node represents a set of source files
   983	// collectively building a Go package.
   984	//
   985	type Package struct {
   986		Name    string             // package name
   987		Scope   *Scope             // package scope across all files
   988		Imports map[string]*Object // map of package id -> package object
   989		Files   map[string]*File   // Go source files by filename
   990	}
   991	
   992	func (p *Package) Pos() token.Pos { return token.NoPos }
   993	func (p *Package) End() token.Pos { return token.NoPos }

View as plain text