Imported Upstream version 2011.01.12upstream/2011.01.12

1 files changed, 391 insertions, 171 deletions

diff --git a/src/pkg/go/ast/ast.go b/src/pkg/go/ast/ast.go
index 2fc8b215f..cf2ce36df 100644
--- a/src/pkg/go/ast/ast.go
+++ b/src/pkg/go/ast/ast.go
@@ -34,8 +34,8 @@ import (
 
 // All node types implement the Node interface.
 type Node interface {
-	// Pos returns the (beginning) position of the node.
-	Pos() token.Position
+	Pos() token.Pos // position of first character belonging to the node
+	End() token.Pos // position of first character immediately after the node
 }
 
 
@@ -65,19 +65,27 @@ type Decl interface {
 
 // A Comment node represents a single //-style or /*-style comment.
 type Comment struct {
-	token.Position        // beginning position of the comment
-	Text           []byte // comment text (excluding '\n' for //-style comments)
+	Slash token.Pos // position of "/" starting the comment
+	Text  []byte    // comment text (excluding '\n' for //-style comments)
 }
 
 
+func (c *Comment) Pos() token.Pos { return c.Slash }
+func (c *Comment) End() token.Pos { return token.Pos(int(c.Slash) + len(c.Text)) }
+
+
 // A CommentGroup represents a sequence of comments
 // with no other tokens and no empty lines between.
 //
 type CommentGroup struct {
-	List []*Comment
+	List []*Comment // len(List) > 0
 }
 
 
+func (g *CommentGroup) Pos() token.Pos { return g.List[0].Pos() }
+func (g *CommentGroup) End() token.Pos { return g.List[len(g.List)-1].End() }
+
+
 // ----------------------------------------------------------------------------
 // Expressions and types
 
@@ -94,7 +102,7 @@ type Field struct {
 }
 
 
-func (f *Field) Pos() token.Position {
+func (f *Field) Pos() token.Pos {
 	if len(f.Names) > 0 {
 		return f.Names[0].Pos()
 	}
@@ -102,11 +110,45 @@ func (f *Field) Pos() token.Position {
 }
 
 
+func (f *Field) End() token.Pos {
+	if f.Tag != nil {
+		return f.Tag.End()
+	}
+	return f.Type.End()
+}
+
+
 // A FieldList represents a list of Fields, enclosed by parentheses or braces.
 type FieldList struct {
-	Opening token.Position // position of opening parenthesis/brace
-	List    []*Field       // field list
-	Closing token.Position // position of closing parenthesis/brace
+	Opening token.Pos // position of opening parenthesis/brace, if any
+	List    []*Field  // field list
+	Closing token.Pos // position of closing parenthesis/brace, if any
+}
+
+
+func (f *FieldList) Pos() token.Pos {
+	if f.Opening.IsValid() {
+		return f.Opening
+	}
+	// the list should not be empty in this case;
+	// be conservative and guard against bad ASTs
+	if len(f.List) > 0 {
+		return f.List[0].Pos()
+	}
+	return token.NoPos
+}
+
+
+func (f *FieldList) End() token.Pos {
+	if f.Closing.IsValid() {
+		return f.Closing + 1
+	}
+	// the list should not be empty in this case;
+	// be conservative and guard against bad ASTs
+	if n := len(f.List); n > 0 {
+		return f.List[n-1].End()
+	}
+	return token.NoPos
 }
 
 
@@ -135,28 +177,29 @@ type (
 	// created.
 	//
 	BadExpr struct {
-		token.Position // beginning position of bad expression
+		From, To token.Pos // position range of bad expression
 	}
 
 	// An Ident node represents an identifier.
 	Ident struct {
-		token.Position         // identifier position
-		Obj            *Object // denoted object
+		NamePos token.Pos // identifier position
+		Name    string    // identifier name
+		Obj     *Object   // denoted object; or nil
 	}
 
 	// An Ellipsis node stands for the "..." type in a
 	// parameter list or the "..." length in an array type.
 	//
 	Ellipsis struct {
-		token.Position      // position of "..."
-		Elt            Expr // ellipsis element type (parameter lists only)
+		Ellipsis token.Pos // position of "..."
+		Elt      Expr      // ellipsis element type (parameter lists only); or nil
 	}
 
 	// A BasicLit node represents a literal of basic type.
 	BasicLit struct {
-		token.Position             // literal position
-		Kind           token.Token // token.INT, token.FLOAT, token.IMAG, token.CHAR, or token.STRING
-		Value          []byte      // literal string; e.g. 42, 0x7f, 3.14, 1e-9, 'a', '\x7f', "foo" or `\m\n\o`
+		ValuePos token.Pos   // literal position
+		Kind     token.Token // token.INT, token.FLOAT, token.IMAG, token.CHAR, or token.STRING
+		Value    []byte      // literal string; e.g. 42, 0x7f, 3.14, 1e-9, 2.4i, 'a', '\x7f', "foo" or `\m\n\o`
 	}
 
 	// A FuncLit node represents a function literal.
@@ -166,19 +209,18 @@ type (
 	}
 
 	// A CompositeLit node represents a composite literal.
-	//
 	CompositeLit struct {
-		Type   Expr           // literal type
-		Lbrace token.Position // position of "{"
-		Elts   []Expr         // list of composite elements
-		Rbrace token.Position // position of "}"
+		Type   Expr      // literal type; or nil
+		Lbrace token.Pos // position of "{"
+		Elts   []Expr    // list of composite elements; or nil
+		Rbrace token.Pos // position of "}"
 	}
 
 	// A ParenExpr node represents a parenthesized expression.
 	ParenExpr struct {
-		token.Position                // position of "("
-		X              Expr           // parenthesized expression
-		Rparen         token.Position // position of ")"
+		Lparen token.Pos // position of "("
+		X      Expr      // parenthesized expression
+		Rparen token.Pos // position of ")"
 	}
 
 	// A SelectorExpr node represents an expression followed by a selector.
@@ -189,15 +231,19 @@ type (
 
 	// An IndexExpr node represents an expression followed by an index.
 	IndexExpr struct {
-		X     Expr // expression
-		Index Expr // index expression
+		X      Expr      // expression
+		Lbrack token.Pos // position of "["
+		Index  Expr      // index expression
+		Rbrack token.Pos // position of "]"
 	}
 
 	// An SliceExpr node represents an expression followed by slice indices.
 	SliceExpr struct {
-		X     Expr // expression
-		Index Expr // beginning of slice range
-		End   Expr // end of slice range; or nil
+		X      Expr      // expression
+		Lbrack token.Pos // position of "["
+		Low    Expr      // begin of slice range; or nil
+		High   Expr      // end of slice range; or nil
+		Rbrack token.Pos // position of "]"
 	}
 
 	// A TypeAssertExpr node represents an expression followed by a
@@ -210,35 +256,36 @@ type (
 
 	// A CallExpr node represents an expression followed by an argument list.
 	CallExpr struct {
-		Fun    Expr           // function expression
-		Lparen token.Position // position of "("
-		Args   []Expr         // function arguments
-		Rparen token.Position // positions of ")"
+		Fun      Expr      // function expression
+		Lparen   token.Pos // position of "("
+		Args     []Expr    // function arguments; or nil
+		Ellipsis token.Pos // position of "...", if any
+		Rparen   token.Pos // position of ")"
 	}
 
 	// A StarExpr node represents an expression of the form "*" Expression.
 	// Semantically it could be a unary "*" expression, or a pointer type.
+	//
 	StarExpr struct {
-		token.Position      // position of "*"
-		X              Expr // operand
+		Star token.Pos // position of "*"
+		X    Expr      // operand
 	}
 
 	// A UnaryExpr node represents a unary expression.
 	// Unary "*" expressions are represented via StarExpr nodes.
 	//
 	UnaryExpr struct {
-		token.Position             // position of Op
-		Op             token.Token // operator
-		X              Expr        // operand
+		OpPos token.Pos   // position of Op
+		Op    token.Token // operator
+		X     Expr        // operand
 	}
 
 	// A BinaryExpr node represents a binary expression.
-	//
 	BinaryExpr struct {
-		X     Expr           // left operand
-		OpPos token.Position // position of Op
-		Op    token.Token    // operator
-		Y     Expr           // right operand
+		X     Expr        // left operand
+		OpPos token.Pos   // position of Op
+		Op    token.Token // operator
+		Y     Expr        // right operand
 	}
 
 	// A KeyValueExpr node represents (key : value) pairs
@@ -246,7 +293,7 @@ type (
 	//
 	KeyValueExpr struct {
 		Key   Expr
-		Colon token.Position // position of ":"
+		Colon token.Pos // position of ":"
 		Value Expr
 	}
 )
@@ -270,66 +317,123 @@ const (
 type (
 	// An ArrayType node represents an array or slice type.
 	ArrayType struct {
-		token.Position      // position of "["
-		Len            Expr // Ellipsis node for [...]T array types, nil for slice types
-		Elt            Expr // element type
+		Lbrack token.Pos // position of "["
+		Len    Expr      // Ellipsis node for [...]T array types, nil for slice types
+		Elt    Expr      // element type
 	}
 
 	// A StructType node represents a struct type.
 	StructType struct {
-		token.Position            // position of "struct" keyword
-		Fields         *FieldList // list of field declarations
-		Incomplete     bool       // true if (source) fields are missing in the Fields list
+		Struct     token.Pos  // position of "struct" keyword
+		Fields     *FieldList // list of field declarations
+		Incomplete bool       // true if (source) fields are missing in the Fields list
 	}
 
 	// Pointer types are represented via StarExpr nodes.
 
 	// A FuncType node represents a function type.
 	FuncType struct {
-		token.Position            // position of "func" keyword
-		Params         *FieldList // (incoming) parameters
-		Results        *FieldList // (outgoing) results
+		Func    token.Pos  // position of "func" keyword
+		Params  *FieldList // (incoming) parameters
+		Results *FieldList // (outgoing) results; or nil
 	}
 
 	// An InterfaceType node represents an interface type.
 	InterfaceType struct {
-		token.Position            // position of "interface" keyword
-		Methods        *FieldList // list of methods
-		Incomplete     bool       // true if (source) methods are missing in the Methods list
+		Interface  token.Pos  // position of "interface" keyword
+		Methods    *FieldList // list of methods
+		Incomplete bool       // true if (source) methods are missing in the Methods list
 	}
 
 	// A MapType node represents a map type.
 	MapType struct {
-		token.Position // position of "map" keyword
-		Key            Expr
-		Value          Expr
+		Map   token.Pos // position of "map" keyword
+		Key   Expr
+		Value Expr
 	}
 
 	// A ChanType node represents a channel type.
 	ChanType struct {
-		token.Position         // position of "chan" keyword or "<-" (whichever comes first)
-		Dir            ChanDir // channel direction
-		Value          Expr    // value type
+		Begin token.Pos // position of "chan" keyword or "<-" (whichever comes first)
+		Dir   ChanDir   // channel direction
+		Value Expr      // value type
 	}
 )
 
 
-// Pos() implementations for expression/type where the position
-// corresponds to the position of a sub-node.
+// Pos and End implementations for expression/type nodes.
 //
-func (x *FuncLit) Pos() token.Position        { return x.Type.Pos() }
-func (x *CompositeLit) Pos() token.Position   { return x.Type.Pos() }
-func (x *SelectorExpr) Pos() token.Position   { return x.X.Pos() }
-func (x *IndexExpr) Pos() token.Position      { return x.X.Pos() }
-func (x *SliceExpr) Pos() token.Position      { return x.X.Pos() }
-func (x *TypeAssertExpr) Pos() token.Position { return x.X.Pos() }
-func (x *CallExpr) Pos() token.Position       { return x.Fun.Pos() }
-func (x *BinaryExpr) Pos() token.Position     { return x.X.Pos() }
-func (x *KeyValueExpr) Pos() token.Position   { return x.Key.Pos() }
+func (x *BadExpr) Pos() token.Pos  { return x.From }
+func (x *Ident) Pos() token.Pos    { return x.NamePos }
+func (x *Ellipsis) Pos() token.Pos { return x.Ellipsis }
+func (x *BasicLit) Pos() token.Pos { return x.ValuePos }
+func (x *FuncLit) Pos() token.Pos  { return x.Type.Pos() }
+func (x *CompositeLit) Pos() token.Pos {
+	if x.Type != nil {
+		return x.Type.Pos()
+	}
+	return x.Lbrace
+}
+func (x *ParenExpr) Pos() token.Pos      { return x.Lparen }
+func (x *SelectorExpr) Pos() token.Pos   { return x.X.Pos() }
+func (x *IndexExpr) Pos() token.Pos      { return x.X.Pos() }
+func (x *SliceExpr) Pos() token.Pos      { return x.X.Pos() }
+func (x *TypeAssertExpr) Pos() token.Pos { return x.X.Pos() }
+func (x *CallExpr) Pos() token.Pos       { return x.Fun.Pos() }
+func (x *StarExpr) Pos() token.Pos       { return x.Star }
+func (x *UnaryExpr) Pos() token.Pos      { return x.OpPos }
+func (x *BinaryExpr) Pos() token.Pos     { return x.X.Pos() }
+func (x *KeyValueExpr) Pos() token.Pos   { return x.Key.Pos() }
+func (x *ArrayType) Pos() token.Pos      { return x.Lbrack }
+func (x *StructType) Pos() token.Pos     { return x.Struct }
+func (x *FuncType) Pos() token.Pos       { return x.Func }
+func (x *InterfaceType) Pos() token.Pos  { return x.Interface }
+func (x *MapType) Pos() token.Pos        { return x.Map }
+func (x *ChanType) Pos() token.Pos       { return x.Begin }
+
+
+func (x *BadExpr) End() token.Pos { return x.To }
+func (x *Ident) End() token.Pos   { return token.Pos(int(x.NamePos) + len(x.Name)) }
+func (x *Ellipsis) End() token.Pos {
+	if x.Elt != nil {
+		return x.Elt.End()
+	}
+	return x.Ellipsis + 3 // len("...")
+}
+func (x *BasicLit) End() token.Pos     { return token.Pos(int(x.ValuePos) + len(x.Value)) }
+func (x *FuncLit) End() token.Pos      { return x.Body.End() }
+func (x *CompositeLit) End() token.Pos { return x.Rbrace + 1 }
+func (x *ParenExpr) End() token.Pos    { return x.Rparen + 1 }
+func (x *SelectorExpr) End() token.Pos { return x.Sel.End() }
+func (x *IndexExpr) End() token.Pos    { return x.Rbrack + 1 }
+func (x *SliceExpr) End() token.Pos    { return x.Rbrack + 1 }
+func (x *TypeAssertExpr) End() token.Pos {
+	if x.Type != nil {
+		return x.Type.End()
+	}
+	return x.X.End()
+}
+func (x *CallExpr) End() token.Pos     { return x.Rparen + 1 }
+func (x *StarExpr) End() token.Pos     { return x.X.End() }
+func (x *UnaryExpr) End() token.Pos    { return x.X.End() }
+func (x *BinaryExpr) End() token.Pos   { return x.Y.End() }
+func (x *KeyValueExpr) End() token.Pos { return x.Value.End() }
+func (x *ArrayType) End() token.Pos    { return x.Elt.End() }
+func (x *StructType) End() token.Pos   { return x.Fields.End() }
+func (x *FuncType) End() token.Pos {
+	if x.Results != nil {
+		return x.Results.End()
+	}
+	return x.Params.End()
+}
+func (x *InterfaceType) End() token.Pos { return x.Methods.End() }
+func (x *MapType) End() token.Pos       { return x.Value.End() }
+func (x *ChanType) End() token.Pos      { return x.Value.End() }
 
 
 // exprNode() ensures that only expression/type nodes can be
 // assigned to an ExprNode.
+//
 func (x *BadExpr) exprNode()        {}
 func (x *Ident) exprNode()          {}
 func (x *Ellipsis) exprNode()       {}
@@ -358,17 +462,17 @@ func (x *ChanType) exprNode()      {}
 // ----------------------------------------------------------------------------
 // Convenience functions for Idents
 
-var noPos token.Position
+var noPos token.Pos
 
-// NewIdent creates a new Ident without position and minimal object
-// information. Useful for ASTs generated by code other than the Go
-// parser.
+// NewIdent creates a new Ident without position.
+// Useful for ASTs generated by code other than the Go parser.
 //
-func NewIdent(name string) *Ident { return &Ident{noPos, NewObj(Err, noPos, name)} }
+func NewIdent(name string) *Ident { return &Ident{noPos, name, nil} }
 
 
 // IsExported returns whether name is an exported Go symbol
 // (i.e., whether it begins with an uppercase letter).
+//
 func IsExported(name string) bool {
 	ch, _ := utf8.DecodeRuneInString(name)
 	return unicode.IsUpper(ch)
@@ -377,16 +481,13 @@ func IsExported(name string) bool {
 
 // IsExported returns whether id is an exported Go symbol
 // (i.e., whether it begins with an uppercase letter).
-func (id *Ident) IsExported() bool { return id.Obj.IsExported() }
-
-
-// Name returns an identifier's name.
-func (id *Ident) Name() string { return id.Obj.Name }
+//
+func (id *Ident) IsExported() bool { return IsExported(id.Name) }
 
 
 func (id *Ident) String() string {
-	if id != nil && id.Obj != nil {
-		return id.Obj.Name
+	if id != nil {
+		return id.Name
 	}
 	return "<nil>"
 }
@@ -404,7 +505,7 @@ type (
 	// created.
 	//
 	BadStmt struct {
-		token.Position // beginning position of bad statement
+		From, To token.Pos // position range of bad statement
 	}
 
 	// A DeclStmt node represents a declaration in a statement list.
@@ -417,12 +518,13 @@ type (
 	// of the immediately preceeding semicolon.
 	//
 	EmptyStmt struct {
-		token.Position // position of preceeding ";"
+		Semicolon token.Pos // position of preceeding ";"
 	}
 
 	// A LabeledStmt node represents a labeled statement.
 	LabeledStmt struct {
 		Label *Ident
+		Colon token.Pos // position of ":"
 		Stmt  Stmt
 	}
 
@@ -435,138 +537,212 @@ type (
 
 	// An IncDecStmt node represents an increment or decrement statement.
 	IncDecStmt struct {
-		X   Expr
-		Tok token.Token // INC or DEC
+		X      Expr
+		TokPos token.Pos   // position of Tok
+		Tok    token.Token // INC or DEC
 	}
 
 	// An AssignStmt node represents an assignment or
 	// a short variable declaration.
+	//
 	AssignStmt struct {
 		Lhs    []Expr
-		TokPos token.Position // position of Tok
-		Tok    token.Token    // assignment token, DEFINE
+		TokPos token.Pos   // position of Tok
+		Tok    token.Token // assignment token, DEFINE
 		Rhs    []Expr
 	}
 
 	// A GoStmt node represents a go statement.
 	GoStmt struct {
-		token.Position // position of "go" keyword
-		Call           *CallExpr
+		Go   token.Pos // position of "go" keyword
+		Call *CallExpr
 	}
 
 	// A DeferStmt node represents a defer statement.
 	DeferStmt struct {
-		token.Position // position of "defer" keyword
-		Call           *CallExpr
+		Defer token.Pos // position of "defer" keyword
+		Call  *CallExpr
 	}
 
 	// A ReturnStmt node represents a return statement.
 	ReturnStmt struct {
-		token.Position // position of "return" keyword
-		Results        []Expr
+		Return  token.Pos // position of "return" keyword
+		Results []Expr    // result expressions; or nil
 	}
 
 	// A BranchStmt node represents a break, continue, goto,
 	// or fallthrough statement.
 	//
 	BranchStmt struct {
-		token.Position             // position of Tok
-		Tok            token.Token // keyword token (BREAK, CONTINUE, GOTO, FALLTHROUGH)
-		Label          *Ident
+		TokPos token.Pos   // position of Tok
+		Tok    token.Token // keyword token (BREAK, CONTINUE, GOTO, FALLTHROUGH)
+		Label  *Ident      // label name; or nil
 	}
 
 	// A BlockStmt node represents a braced statement list.
 	BlockStmt struct {
-		token.Position // position of "{"
-		List           []Stmt
-		Rbrace         token.Position // position of "}"
+		Lbrace token.Pos // position of "{"
+		List   []Stmt
+		Rbrace token.Pos // position of "}"
 	}
 
 	// An IfStmt node represents an if statement.
 	IfStmt struct {
-		token.Position // position of "if" keyword
-		Init           Stmt
-		Cond           Expr
-		Body           *BlockStmt
-		Else           Stmt
+		If   token.Pos // position of "if" keyword
+		Init Stmt      // initalization statement; or nil
+		Cond Expr      // condition; or nil
+		Body *BlockStmt
+		Else Stmt // else branch; or nil
 	}
 
 	// A CaseClause represents a case of an expression switch statement.
 	CaseClause struct {
-		token.Position                // position of "case" or "default" keyword
-		Values         []Expr         // nil means default case
-		Colon          token.Position // position of ":"
-		Body           []Stmt         // statement list; or nil
+		Case   token.Pos // position of "case" or "default" keyword
+		Values []Expr    // nil means default case
+		Colon  token.Pos // position of ":"
+		Body   []Stmt    // statement list; or nil
 	}
 
 	// A SwitchStmt node represents an expression switch statement.
 	SwitchStmt struct {
-		token.Position // position of "switch" keyword
-		Init           Stmt
-		Tag            Expr
-		Body           *BlockStmt // CaseClauses only
+		Switch token.Pos  // position of "switch" keyword
+		Init   Stmt       // initalization statement; or nil
+		Tag    Expr       // tag expression; or nil
+		Body   *BlockStmt // CaseClauses only
 	}
 
 	// A TypeCaseClause represents a case of a type switch statement.
 	TypeCaseClause struct {
-		token.Position                // position of "case" or "default" keyword
-		Types          []Expr         // nil means default case
-		Colon          token.Position // position of ":"
-		Body           []Stmt         // statement list; or nil
+		Case  token.Pos // position of "case" or "default" keyword
+		Types []Expr    // nil means default case
+		Colon token.Pos // position of ":"
+		Body  []Stmt    // statement list; or nil
 	}
 
 	// An TypeSwitchStmt node represents a type switch statement.
 	TypeSwitchStmt struct {
-		token.Position // position of "switch" keyword
-		Init           Stmt
-		Assign         Stmt       // x := y.(type)
-		Body           *BlockStmt // TypeCaseClauses only
+		Switch token.Pos  // position of "switch" keyword
+		Init   Stmt       // initalization statement; or nil
+		Assign Stmt       // x := y.(type)
+		Body   *BlockStmt // TypeCaseClauses only
 	}
 
 	// A CommClause node represents a case of a select statement.
 	CommClause struct {
-		token.Position                // position of "case" or "default" keyword
-		Tok            token.Token    // ASSIGN or DEFINE (valid only if Lhs != nil)
-		Lhs, Rhs       Expr           // Rhs == nil means default case
-		Colon          token.Position // position of ":"
-		Body           []Stmt         // statement list; or nil
+		Case     token.Pos   // position of "case" or "default" keyword
+		Tok      token.Token // ASSIGN or DEFINE (valid only if Lhs != nil)
+		Lhs, Rhs Expr        // Rhs == nil means default case
+		Colon    token.Pos   // position of ":"
+		Body     []Stmt      // statement list; or nil
 	}
 
 	// An SelectStmt node represents a select statement.
 	SelectStmt struct {
-		token.Position            // position of "select" keyword
-		Body           *BlockStmt // CommClauses only
+		Select token.Pos  // position of "select" keyword
+		Body   *BlockStmt // CommClauses only
 	}
 
 	// A ForStmt represents a for statement.
 	ForStmt struct {
-		token.Position // position of "for" keyword
-		Init           Stmt
-		Cond           Expr
-		Post           Stmt
-		Body           *BlockStmt
+		For  token.Pos // position of "for" keyword
+		Init Stmt      // initalization statement; or nil
+		Cond Expr      // condition; or nil
+		Post Stmt      // post iteration statement; or nil
+		Body *BlockStmt
 	}
 
 	// A RangeStmt represents a for statement with a range clause.
 	RangeStmt struct {
-		token.Position                // position of "for" keyword
-		Key, Value     Expr           // Value may be nil
-		TokPos         token.Position // position of Tok
-		Tok            token.Token    // ASSIGN, DEFINE
-		X              Expr           // value to range over
-		Body           *BlockStmt
+		For        token.Pos   // position of "for" keyword
+		Key, Value Expr        // Value may be nil
+		TokPos     token.Pos   // position of Tok
+		Tok        token.Token // ASSIGN, DEFINE
+		X          Expr        // value to range over
+		Body       *BlockStmt
 	}
 )
 
 
-// Pos() implementations for statement nodes where the position
-// corresponds to the position of a sub-node.
+// Pos and End implementations for statement nodes.
 //
-func (s *DeclStmt) Pos() token.Position    { return s.Decl.Pos() }
-func (s *LabeledStmt) Pos() token.Position { return s.Label.Pos() }
-func (s *ExprStmt) Pos() token.Position    { return s.X.Pos() }
-func (s *IncDecStmt) Pos() token.Position  { return s.X.Pos() }
-func (s *AssignStmt) Pos() token.Position  { return s.Lhs[0].Pos() }
+func (s *BadStmt) Pos() token.Pos        { return s.From }
+func (s *DeclStmt) Pos() token.Pos       { return s.Decl.Pos() }
+func (s *EmptyStmt) Pos() token.Pos      { return s.Semicolon }
+func (s *LabeledStmt) Pos() token.Pos    { return s.Label.Pos() }
+func (s *ExprStmt) Pos() token.Pos       { return s.X.Pos() }
+func (s *IncDecStmt) Pos() token.Pos     { return s.X.Pos() }
+func (s *AssignStmt) Pos() token.Pos     { return s.Lhs[0].Pos() }
+func (s *GoStmt) Pos() token.Pos         { return s.Go }
+func (s *DeferStmt) Pos() token.Pos      { return s.Defer }
+func (s *ReturnStmt) Pos() token.Pos     { return s.Return }
+func (s *BranchStmt) Pos() token.Pos     { return s.TokPos }
+func (s *BlockStmt) Pos() token.Pos      { return s.Lbrace }
+func (s *IfStmt) Pos() token.Pos         { return s.If }
+func (s *CaseClause) Pos() token.Pos     { return s.Case }
+func (s *SwitchStmt) Pos() token.Pos     { return s.Switch }
+func (s *TypeCaseClause) Pos() token.Pos { return s.Case }
+func (s *TypeSwitchStmt) Pos() token.Pos { return s.Switch }
+func (s *CommClause) Pos() token.Pos     { return s.Case }
+func (s *SelectStmt) Pos() token.Pos     { return s.Select }
+func (s *ForStmt) Pos() token.Pos        { return s.For }
+func (s *RangeStmt) Pos() token.Pos      { return s.For }
+
+
+func (s *BadStmt) End() token.Pos  { return s.To }
+func (s *DeclStmt) End() token.Pos { return s.Decl.End() }
+func (s *EmptyStmt) End() token.Pos {
+	return s.Semicolon + 1 /* len(";") */
+}
+func (s *LabeledStmt) End() token.Pos { return s.Stmt.End() }
+func (s *ExprStmt) End() token.Pos    { return s.X.End() }
+func (s *IncDecStmt) End() token.Pos {
+	return s.TokPos + 2 /* len("++") */
+}
+func (s *AssignStmt) End() token.Pos { return s.Rhs[len(s.Rhs)-1].End() }
+func (s *GoStmt) End() token.Pos     { return s.Call.End() }
+func (s *DeferStmt) End() token.Pos  { return s.Call.End() }
+func (s *ReturnStmt) End() token.Pos {
+	if n := len(s.Results); n > 0 {
+		return s.Results[n-1].End()
+	}
+	return s.Return + 6 // len("return")
+}
+func (s *BranchStmt) End() token.Pos {
+	if s.Label != nil {
+		return s.Label.End()
+	}
+	return token.Pos(int(s.TokPos) + len(s.Tok.String()))
+}
+func (s *BlockStmt) End() token.Pos { return s.Rbrace + 1 }
+func (s *IfStmt) End() token.Pos {
+	if s.Else != nil {
+		return s.Else.End()
+	}
+	return s.Body.End()
+}
+func (s *CaseClause) End() token.Pos {
+	if n := len(s.Body); n > 0 {
+		return s.Body[n-1].End()
+	}
+	return s.Colon + 1
+}
+func (s *SwitchStmt) End() token.Pos { return s.Body.End() }
+func (s *TypeCaseClause) End() token.Pos {
+	if n := len(s.Body); n > 0 {
+		return s.Body[n-1].End()
+	}
+	return s.Colon + 1
+}
+func (s *TypeSwitchStmt) End() token.Pos { return s.Body.End() }
+func (s *CommClause) End() token.Pos {
+	if n := len(s.Body); n > 0 {
+		return s.Body[n-1].End()
+	}
+	return s.Colon + 1
+}
+func (s *SelectStmt) End() token.Pos { return s.Body.End() }
+func (s *ForStmt) End() token.Pos    { return s.Body.End() }
+func (s *RangeStmt) End() token.Pos  { return s.Body.End() }
 
 
 // stmtNode() ensures that only statement nodes can be
@@ -618,9 +794,10 @@ type (
 
 	// A ValueSpec node represents a constant or variable declaration
 	// (ConstSpec or VarSpec production).
+	//
 	ValueSpec struct {
 		Doc     *CommentGroup // associated documentation; or nil
-		Names   []*Ident      // value names
+		Names   []*Ident      // value names (len(Names) > 0)
 		Type    Expr          // value type; or nil
 		Values  []Expr        // initial values; or nil
 		Comment *CommentGroup // line comments; or nil
@@ -630,23 +807,35 @@ type (
 	TypeSpec struct {
 		Doc     *CommentGroup // associated documentation; or nil
 		Name    *Ident        // type name
-		Type    Expr          // *ArrayType, *StructType, *FuncType, *InterfaceType, *MapType, *ChanType or *Ident
+		Type    Expr          // *Ident, *ParenExpr, *SelectorExpr, *StarExpr, or any of the *XxxTypes
 		Comment *CommentGroup // line comments; or nil
 	}
 )
 
 
-// Pos() implementations for spec nodes.
+// Pos and End implementations for spec nodes.
 //
-func (s *ImportSpec) Pos() token.Position {
+func (s *ImportSpec) Pos() token.Pos {
 	if s.Name != nil {
 		return s.Name.Pos()
 	}
 	return s.Path.Pos()
 }
+func (s *ValueSpec) Pos() token.Pos { return s.Names[0].Pos() }
+func (s *TypeSpec) Pos() token.Pos  { return s.Name.Pos() }
+
 
-func (s *ValueSpec) Pos() token.Position { return s.Names[0].Pos() }
-func (s *TypeSpec) Pos() token.Position  { return s.Name.Pos() }
+func (s *ImportSpec) End() token.Pos { return s.Path.End() }
+func (s *ValueSpec) End() token.Pos {
+	if n := len(s.Values); n > 0 {
+		return s.Values[n-1].End()
+	}
+	if s.Type != nil {
+		return s.Type.End()
+	}
+	return s.Names[len(s.Names)-1].End()
+}
+func (s *TypeSpec) End() token.Pos { return s.Type.End() }
 
 
 // specNode() ensures that only spec nodes can be
@@ -665,7 +854,7 @@ type (
 	// created.
 	//
 	BadDecl struct {
-		token.Position // beginning position of bad declaration
+		From, To token.Pos // position range of bad declaration
 	}
 
 	// A GenDecl node (generic declaration node) represents an import,
@@ -680,12 +869,12 @@ type (
 	//	token.VAR     *ValueSpec
 	//
 	GenDecl struct {
-		Doc            *CommentGroup  // associated documentation; or nil
-		token.Position                // position of Tok
-		Tok            token.Token    // IMPORT, CONST, TYPE, VAR
-		Lparen         token.Position // position of '(', if any
-		Specs          []Spec
-		Rparen         token.Position // position of ')', if any
+		Doc    *CommentGroup // associated documentation; or nil
+		TokPos token.Pos     // position of Tok
+		Tok    token.Token   // IMPORT, CONST, TYPE, VAR
+		Lparen token.Pos     // position of '(', if any
+		Specs  []Spec
+		Rparen token.Pos // position of ')', if any
 	}
 
 	// A FuncDecl node represents a function declaration.
@@ -699,8 +888,26 @@ type (
 )
 
 
-// The position of a FuncDecl node is the position of its function type.
-func (d *FuncDecl) Pos() token.Position { return d.Type.Pos() }
+// Pos and End implementations for declaration nodes.
+//
+func (d *BadDecl) Pos() token.Pos  { return d.From }
+func (d *GenDecl) Pos() token.Pos  { return d.TokPos }
+func (d *FuncDecl) Pos() token.Pos { return d.Type.Pos() }
+
+
+func (d *BadDecl) End() token.Pos { return d.To }
+func (d *GenDecl) End() token.Pos {
+	if d.Rparen.IsValid() {
+		return d.Rparen + 1
+	}
+	return d.Specs[0].End()
+}
+func (d *FuncDecl) End() token.Pos {
+	if d.Body != nil {
+		return d.Body.End()
+	}
+	return d.Type.End()
+}
 
 
 // declNode() ensures that only declaration nodes can be
@@ -721,11 +928,20 @@ func (d *FuncDecl) declNode() {}
 // via Doc and Comment fields.
 //
 type File struct {
-	Doc            *CommentGroup   // associated documentation; or nil
-	token.Position                 // position of "package" keyword
-	Name           *Ident          // package name
-	Decls          []Decl          // top-level declarations
-	Comments       []*CommentGroup // list of all comments in the source file
+	Doc      *CommentGroup   // associated documentation; or nil
+	Package  token.Pos       // position of "package" keyword
+	Name     *Ident          // package name
+	Decls    []Decl          // top-level declarations; or nil
+	Comments []*CommentGroup // list of all comments in the source file
+}
+
+
+func (f *File) Pos() token.Pos { return f.Package }
+func (f *File) End() token.Pos {
+	if n := len(f.Decls); n > 0 {
+		return f.Decls[n-1].End()
+	}
+	return f.Name.End()
 }
 
 
@@ -734,6 +950,10 @@ type File struct {
 //
 type Package struct {
 	Name  string           // package name
-	Scope *Scope           // package scope
+	Scope *Scope           // package scope; or nil
 	Files map[string]*File // Go source files by filename
 }
+
+
+func (p *Package) Pos() token.Pos { return token.NoPos }
+func (p *Package) End() token.Pos { return token.NoPos }