diff --git a/cmd/libs/go2idl/go-to-protobuf/protobuf/package.go b/cmd/libs/go2idl/go-to-protobuf/protobuf/package.go index cab22352211b5..88e9b4d4d81f4 100644 --- a/cmd/libs/go2idl/go-to-protobuf/protobuf/package.go +++ b/cmd/libs/go2idl/go-to-protobuf/protobuf/package.go @@ -18,14 +18,13 @@ package protobuf import ( "fmt" + "go/ast" "log" "os" "path/filepath" "reflect" "strings" - "k8s.io/kubernetes/third_party/golang/go/ast" - "k8s.io/kubernetes/cmd/libs/go2idl/generator" "k8s.io/kubernetes/cmd/libs/go2idl/types" ) diff --git a/cmd/libs/go2idl/go-to-protobuf/protobuf/parser.go b/cmd/libs/go2idl/go-to-protobuf/protobuf/parser.go index 50a857323f5df..90991fa4bc1c7 100644 --- a/cmd/libs/go2idl/go-to-protobuf/protobuf/parser.go +++ b/cmd/libs/go2idl/go-to-protobuf/protobuf/parser.go @@ -20,17 +20,17 @@ import ( "bytes" "errors" "fmt" + "go/ast" "go/format" + "go/parser" + "go/printer" + "go/token" "io/ioutil" "os" "reflect" "strings" customreflect "k8s.io/kubernetes/third_party/forked/reflect" - "k8s.io/kubernetes/third_party/golang/go/ast" - "k8s.io/kubernetes/third_party/golang/go/parser" - "k8s.io/kubernetes/third_party/golang/go/printer" - "k8s.io/kubernetes/third_party/golang/go/token" ) func rewriteFile(name string, header []byte, rewriteFn func(*token.FileSet, *ast.File) error) error { diff --git a/cmd/libs/go2idl/parser/parse.go b/cmd/libs/go2idl/parser/parse.go index b82b862d922c8..e360bde4457f0 100644 --- a/cmd/libs/go2idl/parser/parse.go +++ b/cmd/libs/go2idl/parser/parse.go @@ -18,20 +18,19 @@ package parser import ( "fmt" + "go/ast" + "go/build" + "go/parser" + "go/token" + tc "go/types" "io/ioutil" "os" "os/exec" "path/filepath" "strings" - "k8s.io/kubernetes/cmd/libs/go2idl/types" - "k8s.io/kubernetes/third_party/golang/go/ast" - "k8s.io/kubernetes/third_party/golang/go/build" - "k8s.io/kubernetes/third_party/golang/go/parser" - "k8s.io/kubernetes/third_party/golang/go/token" - tc "k8s.io/kubernetes/third_party/golang/go/types" - "github.com/golang/glog" + "k8s.io/kubernetes/cmd/libs/go2idl/types" ) // Builder lets you add all the go files in all the packages that you care diff --git a/third_party/golang/go/README.md b/third_party/golang/go/README.md deleted file mode 100644 index 73caaea5caa58..0000000000000 --- a/third_party/golang/go/README.md +++ /dev/null @@ -1,15 +0,0 @@ -# Vendored copy of go1.5.1's standard library's go/... packages. - -Q: Why did you do this awful vendoring? - -A: We need to build under go 1.3 and go 1.4 (soon to be go 1.4 and go 1.5.1). A -version of the go/types package existed for go 1.4, but it does not have the -same interface as the go 1.5 package, and @lavalamp had much better luck with -the 1.5.1 package anyway. - -We will get rid of this as soon as there's a more standard way to do this, or -when we roll over to supporting go 1.5 and go 1.6. - -Note that the packages here were not very happy about being transplated like -this and if you do a diff you will see the changes made to get everything to -compile. diff --git a/third_party/golang/go/ast/ast.go b/third_party/golang/go/ast/ast.go deleted file mode 100644 index 602866fef17d9..0000000000000 --- a/third_party/golang/go/ast/ast.go +++ /dev/null @@ -1,999 +0,0 @@ -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// Package ast declares the types used to represent syntax trees for Go -// packages. -// -package ast - -import ( - "k8s.io/kubernetes/third_party/golang/go/token" - "strings" - "unicode" - "unicode/utf8" -) - -// ---------------------------------------------------------------------------- -// Interfaces -// -// There are 3 main classes of nodes: Expressions and type nodes, -// statement nodes, and declaration nodes. The node names usually -// match the corresponding Go spec production names to which they -// correspond. The node fields correspond to the individual parts -// of the respective productions. -// -// All nodes contain position information marking the beginning of -// the corresponding source text segment; it is accessible via the -// Pos accessor method. Nodes may contain additional position info -// for language constructs where comments may be found between parts -// of the construct (typically any larger, parenthesized subpart). -// That position information is needed to properly position comments -// when printing the construct. - -// All node types implement the Node interface. -type Node interface { - Pos() token.Pos // position of first character belonging to the node - End() token.Pos // position of first character immediately after the node -} - -// All expression nodes implement the Expr interface. -type Expr interface { - Node - exprNode() -} - -// All statement nodes implement the Stmt interface. -type Stmt interface { - Node - stmtNode() -} - -// All declaration nodes implement the Decl interface. -type Decl interface { - Node - declNode() -} - -// ---------------------------------------------------------------------------- -// Comments - -// A Comment node represents a single //-style or /*-style comment. -type Comment struct { - Slash token.Pos // position of "/" starting the comment - Text string // 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 // 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() } - -func isWhitespace(ch byte) bool { return ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r' } - -func stripTrailingWhitespace(s string) string { - i := len(s) - for i > 0 && isWhitespace(s[i-1]) { - i-- - } - return s[0:i] -} - -// Text returns the text of the comment. -// Comment markers (//, /*, and */), the first space of a line comment, and -// leading and trailing empty lines are removed. Multiple empty lines are -// reduced to one, and trailing space on lines is trimmed. Unless the result -// is empty, it is newline-terminated. -// -func (g *CommentGroup) Text() string { - if g == nil { - return "" - } - comments := make([]string, len(g.List)) - for i, c := range g.List { - comments[i] = string(c.Text) - } - - lines := make([]string, 0, 10) // most comments are less than 10 lines - for _, c := range comments { - // Remove comment markers. - // The parser has given us exactly the comment text. - switch c[1] { - case '/': - //-style comment (no newline at the end) - c = c[2:] - // strip first space - required for Example tests - if len(c) > 0 && c[0] == ' ' { - c = c[1:] - } - case '*': - /*-style comment */ - c = c[2 : len(c)-2] - } - - // Split on newlines. - cl := strings.Split(c, "\n") - - // Walk lines, stripping trailing white space and adding to list. - for _, l := range cl { - lines = append(lines, stripTrailingWhitespace(l)) - } - } - - // Remove leading blank lines; convert runs of - // interior blank lines to a single blank line. - n := 0 - for _, line := range lines { - if line != "" || n > 0 && lines[n-1] != "" { - lines[n] = line - n++ - } - } - lines = lines[0:n] - - // Add final "" entry to get trailing newline from Join. - if n > 0 && lines[n-1] != "" { - lines = append(lines, "") - } - - return strings.Join(lines, "\n") -} - -// ---------------------------------------------------------------------------- -// Expressions and types - -// A Field represents a Field declaration list in a struct type, -// a method list in an interface type, or a parameter/result declaration -// in a signature. -// -type Field struct { - Doc *CommentGroup // associated documentation; or nil - Names []*Ident // field/method/parameter names; or nil if anonymous field - Type Expr // field/method/parameter type - Tag *BasicLit // field tag; or nil - Comment *CommentGroup // line comments; or nil -} - -func (f *Field) Pos() token.Pos { - if len(f.Names) > 0 { - return f.Names[0].Pos() - } - return f.Type.Pos() -} - -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.Pos // position of opening parenthesis/brace, if any - List []*Field // field list; or nil - 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 -} - -// NumFields returns the number of (named and anonymous fields) in a FieldList. -func (f *FieldList) NumFields() int { - n := 0 - if f != nil { - for _, g := range f.List { - m := len(g.Names) - if m == 0 { - m = 1 // anonymous field - } - n += m - } - } - return n -} - -// An expression is represented by a tree consisting of one -// or more of the following concrete expression nodes. -// -type ( - // A BadExpr node is a placeholder for expressions containing - // syntax errors for which no correct expression nodes can be - // created. - // - BadExpr struct { - From, To token.Pos // position range of bad expression - } - - // An Ident node represents an identifier. - Ident struct { - 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 { - 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 { - ValuePos token.Pos // literal position - Kind token.Token // token.INT, token.FLOAT, token.IMAG, token.CHAR, or token.STRING - Value string // 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. - FuncLit struct { - Type *FuncType // function type - Body *BlockStmt // function body - } - - // A CompositeLit node represents a composite literal. - CompositeLit struct { - 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 { - Lparen token.Pos // position of "(" - X Expr // parenthesized expression - Rparen token.Pos // position of ")" - } - - // A SelectorExpr node represents an expression followed by a selector. - SelectorExpr struct { - X Expr // expression - Sel *Ident // field selector - } - - // An IndexExpr node represents an expression followed by an index. - IndexExpr struct { - 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 - Lbrack token.Pos // position of "[" - Low Expr // begin of slice range; or nil - High Expr // end of slice range; or nil - Max Expr // maximum capacity of slice; or nil - Slice3 bool // true if 3-index slice (2 colons present) - Rbrack token.Pos // position of "]" - } - - // A TypeAssertExpr node represents an expression followed by a - // type assertion. - // - TypeAssertExpr struct { - X Expr // expression - Lparen token.Pos // position of "(" - Type Expr // asserted type; nil means type switch X.(type) - Rparen token.Pos // position of ")" - } - - // A CallExpr node represents an expression followed by an argument list. - CallExpr struct { - 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 { - Star token.Pos // position of "*" - X Expr // operand - } - - // A UnaryExpr node represents a unary expression. - // Unary "*" expressions are represented via StarExpr nodes. - // - UnaryExpr struct { - 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.Pos // position of Op - Op token.Token // operator - Y Expr // right operand - } - - // A KeyValueExpr node represents (key : value) pairs - // in composite literals. - // - KeyValueExpr struct { - Key Expr - Colon token.Pos // position of ":" - Value Expr - } -) - -// The direction of a channel type is indicated by one -// of the following constants. -// -type ChanDir int - -const ( - SEND ChanDir = 1 << iota - RECV -) - -// A type is represented by a tree consisting of one -// or more of the following type-specific expression -// nodes. -// -type ( - // An ArrayType node represents an array or slice type. - ArrayType struct { - 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 { - 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 { - Func token.Pos // position of "func" keyword (token.NoPos if there is no "func") - Params *FieldList // (incoming) parameters; non-nil - Results *FieldList // (outgoing) results; or nil - } - - // An InterfaceType node represents an interface type. - InterfaceType struct { - 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 { - Map token.Pos // position of "map" keyword - Key Expr - Value Expr - } - - // A ChanType node represents a channel type. - ChanType struct { - Begin token.Pos // position of "chan" keyword or "<-" (whichever comes first) - Arrow token.Pos // position of "<-" (token.NoPos if there is no "<-") - Dir ChanDir // channel direction - Value Expr // value type - } -) - -// Pos and End implementations for expression/type nodes. -// -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 { - if x.Func.IsValid() || x.Params == nil { // see issue 3870 - return x.Func - } - return x.Params.Pos() // interface method declarations have no "func" keyword -} -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 { return x.Rparen + 1 } -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 Expr. -// -func (*BadExpr) exprNode() {} -func (*Ident) exprNode() {} -func (*Ellipsis) exprNode() {} -func (*BasicLit) exprNode() {} -func (*FuncLit) exprNode() {} -func (*CompositeLit) exprNode() {} -func (*ParenExpr) exprNode() {} -func (*SelectorExpr) exprNode() {} -func (*IndexExpr) exprNode() {} -func (*SliceExpr) exprNode() {} -func (*TypeAssertExpr) exprNode() {} -func (*CallExpr) exprNode() {} -func (*StarExpr) exprNode() {} -func (*UnaryExpr) exprNode() {} -func (*BinaryExpr) exprNode() {} -func (*KeyValueExpr) exprNode() {} - -func (*ArrayType) exprNode() {} -func (*StructType) exprNode() {} -func (*FuncType) exprNode() {} -func (*InterfaceType) exprNode() {} -func (*MapType) exprNode() {} -func (*ChanType) exprNode() {} - -// ---------------------------------------------------------------------------- -// Convenience functions for Idents - -// 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{token.NoPos, name, nil} } - -// IsExported reports whether name is an exported Go symbol -// (that is, whether it begins with an upper-case letter). -// -func IsExported(name string) bool { - ch, _ := utf8.DecodeRuneInString(name) - return unicode.IsUpper(ch) -} - -// IsExported reports whether id is an exported Go symbol -// (that is, whether it begins with an uppercase letter). -// -func (id *Ident) IsExported() bool { return IsExported(id.Name) } - -func (id *Ident) String() string { - if id != nil { - return id.Name - } - return "" -} - -// ---------------------------------------------------------------------------- -// Statements - -// A statement is represented by a tree consisting of one -// or more of the following concrete statement nodes. -// -type ( - // A BadStmt node is a placeholder for statements containing - // syntax errors for which no correct statement nodes can be - // created. - // - BadStmt struct { - From, To token.Pos // position range of bad statement - } - - // A DeclStmt node represents a declaration in a statement list. - DeclStmt struct { - Decl Decl // *GenDecl with CONST, TYPE, or VAR token - } - - // An EmptyStmt node represents an empty statement. - // The "position" of the empty statement is the position - // of the immediately following (explicit or implicit) semicolon. - // - EmptyStmt struct { - Semicolon token.Pos // position of following ";" - Implicit bool // if set, ";" was omitted in the source - } - - // A LabeledStmt node represents a labeled statement. - LabeledStmt struct { - Label *Ident - Colon token.Pos // position of ":" - Stmt Stmt - } - - // An ExprStmt node represents a (stand-alone) expression - // in a statement list. - // - ExprStmt struct { - X Expr // expression - } - - // A SendStmt node represents a send statement. - SendStmt struct { - Chan Expr - Arrow token.Pos // position of "<-" - Value Expr - } - - // An IncDecStmt node represents an increment or decrement statement. - IncDecStmt struct { - 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.Pos // position of Tok - Tok token.Token // assignment token, DEFINE - Rhs []Expr - } - - // A GoStmt node represents a go statement. - GoStmt struct { - Go token.Pos // position of "go" keyword - Call *CallExpr - } - - // A DeferStmt node represents a defer statement. - DeferStmt struct { - Defer token.Pos // position of "defer" keyword - Call *CallExpr - } - - // A ReturnStmt node represents a return statement. - ReturnStmt struct { - 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 { - 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 { - Lbrace token.Pos // position of "{" - List []Stmt - Rbrace token.Pos // position of "}" - } - - // An IfStmt node represents an if statement. - IfStmt struct { - If token.Pos // position of "if" keyword - Init Stmt // initialization statement; or nil - Cond Expr // condition - Body *BlockStmt - Else Stmt // else branch; or nil - } - - // A CaseClause represents a case of an expression or type switch statement. - CaseClause struct { - Case token.Pos // position of "case" or "default" keyword - List []Expr // list of expressions or types; 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 { - Switch token.Pos // position of "switch" keyword - Init Stmt // initialization statement; or nil - Tag Expr // tag expression; or nil - Body *BlockStmt // CaseClauses only - } - - // An TypeSwitchStmt node represents a type switch statement. - TypeSwitchStmt struct { - Switch token.Pos // position of "switch" keyword - Init Stmt // initialization statement; or nil - Assign Stmt // x := y.(type) or y.(type) - Body *BlockStmt // CaseClauses only - } - - // A CommClause node represents a case of a select statement. - CommClause struct { - Case token.Pos // position of "case" or "default" keyword - Comm Stmt // send or receive statement; nil means default case - Colon token.Pos // position of ":" - Body []Stmt // statement list; or nil - } - - // An SelectStmt node represents a select statement. - SelectStmt struct { - Select token.Pos // position of "select" keyword - Body *BlockStmt // CommClauses only - } - - // A ForStmt represents a for statement. - ForStmt struct { - For token.Pos // position of "for" keyword - Init Stmt // initialization 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 { - For token.Pos // position of "for" keyword - Key, Value Expr // Key, Value may be nil - TokPos token.Pos // position of Tok; invalid if Key == nil - Tok token.Token // ILLEGAL if Key == nil, ASSIGN, DEFINE - X Expr // value to range over - Body *BlockStmt - } -) - -// Pos and End implementations for statement nodes. -// -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 *SendStmt) Pos() token.Pos { return s.Chan.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 *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 { - if s.Implicit { - return s.Semicolon - } - 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 *SendStmt) End() token.Pos { return s.Value.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 *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 -// assigned to a Stmt. -// -func (*BadStmt) stmtNode() {} -func (*DeclStmt) stmtNode() {} -func (*EmptyStmt) stmtNode() {} -func (*LabeledStmt) stmtNode() {} -func (*ExprStmt) stmtNode() {} -func (*SendStmt) stmtNode() {} -func (*IncDecStmt) stmtNode() {} -func (*AssignStmt) stmtNode() {} -func (*GoStmt) stmtNode() {} -func (*DeferStmt) stmtNode() {} -func (*ReturnStmt) stmtNode() {} -func (*BranchStmt) stmtNode() {} -func (*BlockStmt) stmtNode() {} -func (*IfStmt) stmtNode() {} -func (*CaseClause) stmtNode() {} -func (*SwitchStmt) stmtNode() {} -func (*TypeSwitchStmt) stmtNode() {} -func (*CommClause) stmtNode() {} -func (*SelectStmt) stmtNode() {} -func (*ForStmt) stmtNode() {} -func (*RangeStmt) stmtNode() {} - -// ---------------------------------------------------------------------------- -// Declarations - -// A Spec node represents a single (non-parenthesized) import, -// constant, type, or variable declaration. -// -type ( - // The Spec type stands for any of *ImportSpec, *ValueSpec, and *TypeSpec. - Spec interface { - Node - specNode() - } - - // An ImportSpec node represents a single package import. - ImportSpec struct { - Doc *CommentGroup // associated documentation; or nil - Name *Ident // local package name (including "."); or nil - Path *BasicLit // import path - Comment *CommentGroup // line comments; or nil - EndPos token.Pos // end of spec (overrides Path.Pos if nonzero) - } - - // 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 (len(Names) > 0) - Type Expr // value type; or nil - Values []Expr // initial values; or nil - Comment *CommentGroup // line comments; or nil - } - - // A TypeSpec node represents a type declaration (TypeSpec production). - TypeSpec struct { - Doc *CommentGroup // associated documentation; or nil - Name *Ident // type name - Type Expr // *Ident, *ParenExpr, *SelectorExpr, *StarExpr, or any of the *XxxTypes - Comment *CommentGroup // line comments; or nil - } -) - -// Pos and End implementations for spec nodes. -// -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 *ImportSpec) End() token.Pos { - if s.EndPos != 0 { - return s.EndPos - } - 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 -// assigned to a Spec. -// -func (*ImportSpec) specNode() {} -func (*ValueSpec) specNode() {} -func (*TypeSpec) specNode() {} - -// A declaration is represented by one of the following declaration nodes. -// -type ( - // A BadDecl node is a placeholder for declarations containing - // syntax errors for which no correct declaration nodes can be - // created. - // - BadDecl struct { - From, To token.Pos // position range of bad declaration - } - - // A GenDecl node (generic declaration node) represents an import, - // constant, type or variable declaration. A valid Lparen position - // (Lparen.Line > 0) indicates a parenthesized declaration. - // - // Relationship between Tok value and Specs element type: - // - // token.IMPORT *ImportSpec - // token.CONST *ValueSpec - // token.TYPE *TypeSpec - // token.VAR *ValueSpec - // - GenDecl struct { - 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. - FuncDecl struct { - Doc *CommentGroup // associated documentation; or nil - Recv *FieldList // receiver (methods); or nil (functions) - Name *Ident // function/method name - Type *FuncType // function signature: parameters, results, and position of "func" keyword - Body *BlockStmt // function body; or nil (forward declaration) - } -) - -// 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 -// assigned to a Decl. -// -func (*BadDecl) declNode() {} -func (*GenDecl) declNode() {} -func (*FuncDecl) declNode() {} - -// ---------------------------------------------------------------------------- -// Files and packages - -// A File node represents a Go source file. -// -// The Comments list contains all comments in the source file in order of -// appearance, including the comments that are pointed to from other nodes -// via Doc and Comment fields. -// -type File struct { - Doc *CommentGroup // associated documentation; or nil - Package token.Pos // position of "package" keyword - Name *Ident // package name - Decls []Decl // top-level declarations; or nil - Scope *Scope // package scope (this file only) - Imports []*ImportSpec // imports in this file - Unresolved []*Ident // unresolved identifiers in this file - 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() -} - -// A Package node represents a set of source files -// collectively building a Go package. -// -type Package struct { - Name string // package name - Scope *Scope // package scope across all files - Imports map[string]*Object // map of package id -> package object - 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 } diff --git a/third_party/golang/go/ast/ast_test.go b/third_party/golang/go/ast/ast_test.go deleted file mode 100644 index 1a6a283f232bb..0000000000000 --- a/third_party/golang/go/ast/ast_test.go +++ /dev/null @@ -1,50 +0,0 @@ -// Copyright 2012 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package ast - -import ( - "testing" -) - -var comments = []struct { - list []string - text string -}{ - {[]string{"//"}, ""}, - {[]string{"// "}, ""}, - {[]string{"//", "//", "// "}, ""}, - {[]string{"// foo "}, "foo\n"}, - {[]string{"//", "//", "// foo"}, "foo\n"}, - {[]string{"// foo bar "}, "foo bar\n"}, - {[]string{"// foo", "// bar"}, "foo\nbar\n"}, - {[]string{"// foo", "//", "//", "//", "// bar"}, "foo\n\nbar\n"}, - {[]string{"// foo", "/* bar */"}, "foo\n bar\n"}, - {[]string{"//", "//", "//", "// foo", "//", "//", "//"}, "foo\n"}, - - {[]string{"/**/"}, ""}, - {[]string{"/* */"}, ""}, - {[]string{"/**/", "/**/", "/* */"}, ""}, - {[]string{"/* Foo */"}, " Foo\n"}, - {[]string{"/* Foo Bar */"}, " Foo Bar\n"}, - {[]string{"/* Foo*/", "/* Bar*/"}, " Foo\n Bar\n"}, - {[]string{"/* Foo*/", "/**/", "/**/", "/**/", "// Bar"}, " Foo\n\nBar\n"}, - {[]string{"/* Foo*/", "/*\n*/", "//", "/*\n*/", "// Bar"}, " Foo\n\nBar\n"}, - {[]string{"/* Foo*/", "// Bar"}, " Foo\nBar\n"}, - {[]string{"/* Foo\n Bar*/"}, " Foo\n Bar\n"}, -} - -func TestCommentText(t *testing.T) { - for i, c := range comments { - list := make([]*Comment, len(c.list)) - for i, s := range c.list { - list[i] = &Comment{Text: s} - } - - text := (&CommentGroup{list}).Text() - if text != c.text { - t.Errorf("case %d: got %q; expected %q", i, text, c.text) - } - } -} diff --git a/third_party/golang/go/ast/commentmap.go b/third_party/golang/go/ast/commentmap.go deleted file mode 100644 index ce289f21f8d30..0000000000000 --- a/third_party/golang/go/ast/commentmap.go +++ /dev/null @@ -1,332 +0,0 @@ -// Copyright 2012 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package ast - -import ( - "bytes" - "fmt" - "k8s.io/kubernetes/third_party/golang/go/token" - "sort" -) - -type byPos []*CommentGroup - -func (a byPos) Len() int { return len(a) } -func (a byPos) Less(i, j int) bool { return a[i].Pos() < a[j].Pos() } -func (a byPos) Swap(i, j int) { a[i], a[j] = a[j], a[i] } - -// sortComments sorts the list of comment groups in source order. -// -func sortComments(list []*CommentGroup) { - // TODO(gri): Does it make sense to check for sorted-ness - // first (because we know that sorted-ness is - // very likely)? - if orderedList := byPos(list); !sort.IsSorted(orderedList) { - sort.Sort(orderedList) - } -} - -// A CommentMap maps an AST node to a list of comment groups -// associated with it. See NewCommentMap for a description of -// the association. -// -type CommentMap map[Node][]*CommentGroup - -func (cmap CommentMap) addComment(n Node, c *CommentGroup) { - list := cmap[n] - if len(list) == 0 { - list = []*CommentGroup{c} - } else { - list = append(list, c) - } - cmap[n] = list -} - -type byInterval []Node - -func (a byInterval) Len() int { return len(a) } -func (a byInterval) Less(i, j int) bool { - pi, pj := a[i].Pos(), a[j].Pos() - return pi < pj || pi == pj && a[i].End() > a[j].End() -} -func (a byInterval) Swap(i, j int) { a[i], a[j] = a[j], a[i] } - -// nodeList returns the list of nodes of the AST n in source order. -// -func nodeList(n Node) []Node { - var list []Node - Inspect(n, func(n Node) bool { - // don't collect comments - switch n.(type) { - case nil, *CommentGroup, *Comment: - return false - } - list = append(list, n) - return true - }) - // Note: The current implementation assumes that Inspect traverses the - // AST in depth-first and thus _source_ order. If AST traversal - // does not follow source order, the sorting call below will be - // required. - // sort.Sort(byInterval(list)) - return list -} - -// A commentListReader helps iterating through a list of comment groups. -// -type commentListReader struct { - fset *token.FileSet - list []*CommentGroup - index int - comment *CommentGroup // comment group at current index - pos, end token.Position // source interval of comment group at current index -} - -func (r *commentListReader) eol() bool { - return r.index >= len(r.list) -} - -func (r *commentListReader) next() { - if !r.eol() { - r.comment = r.list[r.index] - r.pos = r.fset.Position(r.comment.Pos()) - r.end = r.fset.Position(r.comment.End()) - r.index++ - } -} - -// A nodeStack keeps track of nested nodes. -// A node lower on the stack lexically contains the nodes higher on the stack. -// -type nodeStack []Node - -// push pops all nodes that appear lexically before n -// and then pushes n on the stack. -// -func (s *nodeStack) push(n Node) { - s.pop(n.Pos()) - *s = append((*s), n) -} - -// pop pops all nodes that appear lexically before pos -// (i.e., whose lexical extent has ended before or at pos). -// It returns the last node popped. -// -func (s *nodeStack) pop(pos token.Pos) (top Node) { - i := len(*s) - for i > 0 && (*s)[i-1].End() <= pos { - top = (*s)[i-1] - i-- - } - *s = (*s)[0:i] - return top -} - -// NewCommentMap creates a new comment map by associating comment groups -// of the comments list with the nodes of the AST specified by node. -// -// A comment group g is associated with a node n if: -// -// - g starts on the same line as n ends -// - g starts on the line immediately following n, and there is -// at least one empty line after g and before the next node -// - g starts before n and is not associated to the node before n -// via the previous rules -// -// NewCommentMap tries to associate a comment group to the "largest" -// node possible: For instance, if the comment is a line comment -// trailing an assignment, the comment is associated with the entire -// assignment rather than just the last operand in the assignment. -// -func NewCommentMap(fset *token.FileSet, node Node, comments []*CommentGroup) CommentMap { - if len(comments) == 0 { - return nil // no comments to map - } - - cmap := make(CommentMap) - - // set up comment reader r - tmp := make([]*CommentGroup, len(comments)) - copy(tmp, comments) // don't change incoming comments - sortComments(tmp) - r := commentListReader{fset: fset, list: tmp} // !r.eol() because len(comments) > 0 - r.next() - - // create node list in lexical order - nodes := nodeList(node) - nodes = append(nodes, nil) // append sentinel - - // set up iteration variables - var ( - p Node // previous node - pend token.Position // end of p - pg Node // previous node group (enclosing nodes of "importance") - pgend token.Position // end of pg - stack nodeStack // stack of node groups - ) - - for _, q := range nodes { - var qpos token.Position - if q != nil { - qpos = fset.Position(q.Pos()) // current node position - } else { - // set fake sentinel position to infinity so that - // all comments get processed before the sentinel - const infinity = 1 << 30 - qpos.Offset = infinity - qpos.Line = infinity - } - - // process comments before current node - for r.end.Offset <= qpos.Offset { - // determine recent node group - if top := stack.pop(r.comment.Pos()); top != nil { - pg = top - pgend = fset.Position(pg.End()) - } - // Try to associate a comment first with a node group - // (i.e., a node of "importance" such as a declaration); - // if that fails, try to associate it with the most recent - // node. - // TODO(gri) try to simplify the logic below - var assoc Node - switch { - case pg != nil && - (pgend.Line == r.pos.Line || - pgend.Line+1 == r.pos.Line && r.end.Line+1 < qpos.Line): - // 1) comment starts on same line as previous node group ends, or - // 2) comment starts on the line immediately after the - // previous node group and there is an empty line before - // the current node - // => associate comment with previous node group - assoc = pg - case p != nil && - (pend.Line == r.pos.Line || - pend.Line+1 == r.pos.Line && r.end.Line+1 < qpos.Line || - q == nil): - // same rules apply as above for p rather than pg, - // but also associate with p if we are at the end (q == nil) - assoc = p - default: - // otherwise, associate comment with current node - if q == nil { - // we can only reach here if there was no p - // which would imply that there were no nodes - panic("internal error: no comments should be associated with sentinel") - } - assoc = q - } - cmap.addComment(assoc, r.comment) - if r.eol() { - return cmap - } - r.next() - } - - // update previous node - p = q - pend = fset.Position(p.End()) - - // update previous node group if we see an "important" node - switch q.(type) { - case *File, *Field, Decl, Spec, Stmt: - stack.push(q) - } - } - - return cmap -} - -// Update replaces an old node in the comment map with the new node -// and returns the new node. Comments that were associated with the -// old node are associated with the new node. -// -func (cmap CommentMap) Update(old, new Node) Node { - if list := cmap[old]; len(list) > 0 { - delete(cmap, old) - cmap[new] = append(cmap[new], list...) - } - return new -} - -// Filter returns a new comment map consisting of only those -// entries of cmap for which a corresponding node exists in -// the AST specified by node. -// -func (cmap CommentMap) Filter(node Node) CommentMap { - umap := make(CommentMap) - Inspect(node, func(n Node) bool { - if g := cmap[n]; len(g) > 0 { - umap[n] = g - } - return true - }) - return umap -} - -// Comments returns the list of comment groups in the comment map. -// The result is sorted is source order. -// -func (cmap CommentMap) Comments() []*CommentGroup { - list := make([]*CommentGroup, 0, len(cmap)) - for _, e := range cmap { - list = append(list, e...) - } - sortComments(list) - return list -} - -func summary(list []*CommentGroup) string { - const maxLen = 40 - var buf bytes.Buffer - - // collect comments text -loop: - for _, group := range list { - // Note: CommentGroup.Text() does too much work for what we - // need and would only replace this innermost loop. - // Just do it explicitly. - for _, comment := range group.List { - if buf.Len() >= maxLen { - break loop - } - buf.WriteString(comment.Text) - } - } - - // truncate if too long - if buf.Len() > maxLen { - buf.Truncate(maxLen - 3) - buf.WriteString("...") - } - - // replace any invisibles with blanks - bytes := buf.Bytes() - for i, b := range bytes { - switch b { - case '\t', '\n', '\r': - bytes[i] = ' ' - } - } - - return string(bytes) -} - -func (cmap CommentMap) String() string { - var buf bytes.Buffer - fmt.Fprintln(&buf, "CommentMap {") - for node, comment := range cmap { - // print name of identifiers; print node type for other nodes - var s string - if ident, ok := node.(*Ident); ok { - s = ident.Name - } else { - s = fmt.Sprintf("%T", node) - } - fmt.Fprintf(&buf, "\t%p %20s: %s\n", node, s, summary(comment)) - } - fmt.Fprintln(&buf, "}") - return buf.String() -} diff --git a/third_party/golang/go/ast/commentmap_test.go b/third_party/golang/go/ast/commentmap_test.go deleted file mode 100644 index 254d878465ef1..0000000000000 --- a/third_party/golang/go/ast/commentmap_test.go +++ /dev/null @@ -1,143 +0,0 @@ -// Copyright 2012 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// To avoid a cyclic dependency with go/parser, this file is in a separate package. - -package ast_test - -import ( - "bytes" - "fmt" - . "k8s.io/kubernetes/third_party/golang/go/ast" - "k8s.io/kubernetes/third_party/golang/go/parser" - "k8s.io/kubernetes/third_party/golang/go/token" - "sort" - "testing" -) - -const src = ` -// the very first comment - -// package p -package p /* the name is p */ - -// imports -import ( - "bytes" // bytes - "fmt" // fmt - "k8s.io/kubernetes/third_party/golang/go/ast" - "k8s.io/kubernetes/third_party/golang/go/parser" -) - -// T -type T struct { - a, b, c int // associated with a, b, c - // associated with x, y - x, y float64 // float values - z complex128 // complex value -} -// also associated with T - -// x -var x = 0 // x = 0 -// also associated with x - -// f1 -func f1() { - /* associated with s1 */ - s1() - // also associated with s1 - - // associated with s2 - - // also associated with s2 - s2() // line comment for s2 -} -// associated with f1 -// also associated with f1 - -// associated with f2 - -// f2 -func f2() { -} - -func f3() { - i := 1 /* 1 */ + 2 // addition - _ = i -} - -// the very last comment -` - -// res maps a key of the form "line number: node type" -// to the associated comments' text. -// -var res = map[string]string{ - " 5: *ast.File": "the very first comment\npackage p\n", - " 5: *ast.Ident": " the name is p\n", - " 8: *ast.GenDecl": "imports\n", - " 9: *ast.ImportSpec": "bytes\n", - "10: *ast.ImportSpec": "fmt\n", - "16: *ast.GenDecl": "T\nalso associated with T\n", - "17: *ast.Field": "associated with a, b, c\n", - "19: *ast.Field": "associated with x, y\nfloat values\n", - "20: *ast.Field": "complex value\n", - "25: *ast.GenDecl": "x\nx = 0\nalso associated with x\n", - "29: *ast.FuncDecl": "f1\nassociated with f1\nalso associated with f1\n", - "31: *ast.ExprStmt": " associated with s1\nalso associated with s1\n", - "37: *ast.ExprStmt": "associated with s2\nalso associated with s2\nline comment for s2\n", - "45: *ast.FuncDecl": "associated with f2\nf2\n", - "49: *ast.AssignStmt": "addition\n", - "49: *ast.BasicLit": " 1\n", - "50: *ast.Ident": "the very last comment\n", -} - -func ctext(list []*CommentGroup) string { - var buf bytes.Buffer - for _, g := range list { - buf.WriteString(g.Text()) - } - return buf.String() -} - -func TestCommentMap(t *testing.T) { - fset := token.NewFileSet() - f, err := parser.ParseFile(fset, "", src, parser.ParseComments) - if err != nil { - t.Fatal(err) - } - cmap := NewCommentMap(fset, f, f.Comments) - - // very correct association of comments - for n, list := range cmap { - key := fmt.Sprintf("%2d: %T", fset.Position(n.Pos()).Line, n) - got := ctext(list) - want := res[key] - if got != want { - t.Errorf("%s: got %q; want %q", key, got, want) - } - } - - // verify that no comments got lost - if n := len(cmap.Comments()); n != len(f.Comments) { - t.Errorf("got %d comment groups in map; want %d", n, len(f.Comments)) - } - - // support code to update test: - // set genMap to true to generate res map - const genMap = false - if genMap { - out := make([]string, 0, len(cmap)) - for n, list := range cmap { - out = append(out, fmt.Sprintf("\t\"%2d: %T\":\t%q,", fset.Position(n.Pos()).Line, n, ctext(list))) - } - sort.Strings(out) - for _, s := range out { - fmt.Println(s) - } - } -} - -// TODO(gri): add tests for Filter. diff --git a/third_party/golang/go/ast/example_test.go b/third_party/golang/go/ast/example_test.go deleted file mode 100644 index d2e734f2cbec0..0000000000000 --- a/third_party/golang/go/ast/example_test.go +++ /dev/null @@ -1,210 +0,0 @@ -// Copyright 2012 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package ast_test - -import ( - "bytes" - "fmt" - "go/ast" - "go/format" - "go/parser" - "go/token" -) - -// This example demonstrates how to inspect the AST of a Go program. -func ExampleInspect() { - // src is the input for which we want to inspect the AST. - src := ` -package p -const c = 1.0 -var X = f(3.14)*2 + c -` - - // Create the AST by parsing src. - fset := token.NewFileSet() // positions are relative to fset - f, err := parser.ParseFile(fset, "src.go", src, 0) - if err != nil { - panic(err) - } - - // Inspect the AST and print all identifiers and literals. - ast.Inspect(f, func(n ast.Node) bool { - var s string - switch x := n.(type) { - case *ast.BasicLit: - s = x.Value - case *ast.Ident: - s = x.Name - } - if s != "" { - fmt.Printf("%s:\t%s\n", fset.Position(n.Pos()), s) - } - return true - }) - - // output: - // src.go:2:9: p - // src.go:3:7: c - // src.go:3:11: 1.0 - // src.go:4:5: X - // src.go:4:9: f - // src.go:4:11: 3.14 - // src.go:4:17: 2 - // src.go:4:21: c -} - -// This example shows what an AST looks like when printed for debugging. -func ExamplePrint() { - // src is the input for which we want to print the AST. - src := ` -package main -func main() { - println("Hello, World!") -} -` - - // Create the AST by parsing src. - fset := token.NewFileSet() // positions are relative to fset - f, err := parser.ParseFile(fset, "", src, 0) - if err != nil { - panic(err) - } - - // Print the AST. - ast.Print(fset, f) - - // output: - // 0 *ast.File { - // 1 . Package: 2:1 - // 2 . Name: *ast.Ident { - // 3 . . NamePos: 2:9 - // 4 . . Name: "main" - // 5 . } - // 6 . Decls: []ast.Decl (len = 1) { - // 7 . . 0: *ast.FuncDecl { - // 8 . . . Name: *ast.Ident { - // 9 . . . . NamePos: 3:6 - // 10 . . . . Name: "main" - // 11 . . . . Obj: *ast.Object { - // 12 . . . . . Kind: func - // 13 . . . . . Name: "main" - // 14 . . . . . Decl: *(obj @ 7) - // 15 . . . . } - // 16 . . . } - // 17 . . . Type: *ast.FuncType { - // 18 . . . . Func: 3:1 - // 19 . . . . Params: *ast.FieldList { - // 20 . . . . . Opening: 3:10 - // 21 . . . . . Closing: 3:11 - // 22 . . . . } - // 23 . . . } - // 24 . . . Body: *ast.BlockStmt { - // 25 . . . . Lbrace: 3:13 - // 26 . . . . List: []ast.Stmt (len = 1) { - // 27 . . . . . 0: *ast.ExprStmt { - // 28 . . . . . . X: *ast.CallExpr { - // 29 . . . . . . . Fun: *ast.Ident { - // 30 . . . . . . . . NamePos: 4:2 - // 31 . . . . . . . . Name: "println" - // 32 . . . . . . . } - // 33 . . . . . . . Lparen: 4:9 - // 34 . . . . . . . Args: []ast.Expr (len = 1) { - // 35 . . . . . . . . 0: *ast.BasicLit { - // 36 . . . . . . . . . ValuePos: 4:10 - // 37 . . . . . . . . . Kind: STRING - // 38 . . . . . . . . . Value: "\"Hello, World!\"" - // 39 . . . . . . . . } - // 40 . . . . . . . } - // 41 . . . . . . . Ellipsis: - - // 42 . . . . . . . Rparen: 4:25 - // 43 . . . . . . } - // 44 . . . . . } - // 45 . . . . } - // 46 . . . . Rbrace: 5:1 - // 47 . . . } - // 48 . . } - // 49 . } - // 50 . Scope: *ast.Scope { - // 51 . . Objects: map[string]*ast.Object (len = 1) { - // 52 . . . "main": *(obj @ 11) - // 53 . . } - // 54 . } - // 55 . Unresolved: []*ast.Ident (len = 1) { - // 56 . . 0: *(obj @ 29) - // 57 . } - // 58 } -} - -// This example illustrates how to remove a variable declaration -// in a Go program while maintaining correct comment association -// using an ast.CommentMap. -func ExampleCommentMap() { - // src is the input for which we create the AST that we - // are going to manipulate. - src := ` -// This is the package comment. -package main - -// This comment is associated with the hello constant. -const hello = "Hello, World!" // line comment 1 - -// This comment is associated with the foo variable. -var foo = hello // line comment 2 - -// This comment is associated with the main function. -func main() { - fmt.Println(hello) // line comment 3 -} -` - - // Create the AST by parsing src. - fset := token.NewFileSet() // positions are relative to fset - f, err := parser.ParseFile(fset, "src.go", src, parser.ParseComments) - if err != nil { - panic(err) - } - - // Create an ast.CommentMap from the ast.File's comments. - // This helps keeping the association between comments - // and AST nodes. - cmap := ast.NewCommentMap(fset, f, f.Comments) - - // Remove the first variable declaration from the list of declarations. - f.Decls = removeFirstVarDecl(f.Decls) - - // Use the comment map to filter comments that don't belong anymore - // (the comments associated with the variable declaration), and create - // the new comments list. - f.Comments = cmap.Filter(f).Comments() - - // Print the modified AST. - var buf bytes.Buffer - if err := format.Node(&buf, fset, f); err != nil { - panic(err) - } - fmt.Printf("%s", buf.Bytes()) - - // output: - // // This is the package comment. - // package main - // - // // This comment is associated with the hello constant. - // const hello = "Hello, World!" // line comment 1 - // - // // This comment is associated with the main function. - // func main() { - // fmt.Println(hello) // line comment 3 - // } -} - -func removeFirstVarDecl(list []ast.Decl) []ast.Decl { - for i, decl := range list { - if gen, ok := decl.(*ast.GenDecl); ok && gen.Tok == token.VAR { - copy(list[i:], list[i+1:]) - return list[:len(list)-1] - } - } - panic("variable declaration not found") -} diff --git a/third_party/golang/go/ast/filter.go b/third_party/golang/go/ast/filter.go deleted file mode 100644 index b5616039bca4a..0000000000000 --- a/third_party/golang/go/ast/filter.go +++ /dev/null @@ -1,465 +0,0 @@ -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package ast - -import ( - "k8s.io/kubernetes/third_party/golang/go/token" - "sort" -) - -// ---------------------------------------------------------------------------- -// Export filtering - -// exportFilter is a special filter function to extract exported nodes. -func exportFilter(name string) bool { - return IsExported(name) -} - -// FileExports trims the AST for a Go source file in place such that -// only exported nodes remain: all top-level identifiers which are not exported -// and their associated information (such as type, initial value, or function -// body) are removed. Non-exported fields and methods of exported types are -// stripped. The File.Comments list is not changed. -// -// FileExports reports whether there are exported declarations. -// -func FileExports(src *File) bool { - return filterFile(src, exportFilter, true) -} - -// PackageExports trims the AST for a Go package in place such that -// only exported nodes remain. The pkg.Files list is not changed, so that -// file names and top-level package comments don't get lost. -// -// PackageExports reports whether there are exported declarations; -// it returns false otherwise. -// -func PackageExports(pkg *Package) bool { - return filterPackage(pkg, exportFilter, true) -} - -// ---------------------------------------------------------------------------- -// General filtering - -type Filter func(string) bool - -func filterIdentList(list []*Ident, f Filter) []*Ident { - j := 0 - for _, x := range list { - if f(x.Name) { - list[j] = x - j++ - } - } - return list[0:j] -} - -// fieldName assumes that x is the type of an anonymous field and -// returns the corresponding field name. If x is not an acceptable -// anonymous field, the result is nil. -// -func fieldName(x Expr) *Ident { - switch t := x.(type) { - case *Ident: - return t - case *SelectorExpr: - if _, ok := t.X.(*Ident); ok { - return t.Sel - } - case *StarExpr: - return fieldName(t.X) - } - return nil -} - -func filterFieldList(fields *FieldList, filter Filter, export bool) (removedFields bool) { - if fields == nil { - return false - } - list := fields.List - j := 0 - for _, f := range list { - keepField := false - if len(f.Names) == 0 { - // anonymous field - name := fieldName(f.Type) - keepField = name != nil && filter(name.Name) - } else { - n := len(f.Names) - f.Names = filterIdentList(f.Names, filter) - if len(f.Names) < n { - removedFields = true - } - keepField = len(f.Names) > 0 - } - if keepField { - if export { - filterType(f.Type, filter, export) - } - list[j] = f - j++ - } - } - if j < len(list) { - removedFields = true - } - fields.List = list[0:j] - return -} - -func filterParamList(fields *FieldList, filter Filter, export bool) bool { - if fields == nil { - return false - } - var b bool - for _, f := range fields.List { - if filterType(f.Type, filter, export) { - b = true - } - } - return b -} - -func filterType(typ Expr, f Filter, export bool) bool { - switch t := typ.(type) { - case *Ident: - return f(t.Name) - case *ParenExpr: - return filterType(t.X, f, export) - case *ArrayType: - return filterType(t.Elt, f, export) - case *StructType: - if filterFieldList(t.Fields, f, export) { - t.Incomplete = true - } - return len(t.Fields.List) > 0 - case *FuncType: - b1 := filterParamList(t.Params, f, export) - b2 := filterParamList(t.Results, f, export) - return b1 || b2 - case *InterfaceType: - if filterFieldList(t.Methods, f, export) { - t.Incomplete = true - } - return len(t.Methods.List) > 0 - case *MapType: - b1 := filterType(t.Key, f, export) - b2 := filterType(t.Value, f, export) - return b1 || b2 - case *ChanType: - return filterType(t.Value, f, export) - } - return false -} - -func filterSpec(spec Spec, f Filter, export bool) bool { - switch s := spec.(type) { - case *ValueSpec: - s.Names = filterIdentList(s.Names, f) - if len(s.Names) > 0 { - if export { - filterType(s.Type, f, export) - } - return true - } - case *TypeSpec: - if f(s.Name.Name) { - if export { - filterType(s.Type, f, export) - } - return true - } - if !export { - // For general filtering (not just exports), - // filter type even if name is not filtered - // out. - // If the type contains filtered elements, - // keep the declaration. - return filterType(s.Type, f, export) - } - } - return false -} - -func filterSpecList(list []Spec, f Filter, export bool) []Spec { - j := 0 - for _, s := range list { - if filterSpec(s, f, export) { - list[j] = s - j++ - } - } - return list[0:j] -} - -// FilterDecl trims the AST for a Go declaration in place by removing -// all names (including struct field and interface method names, but -// not from parameter lists) that don't pass through the filter f. -// -// FilterDecl reports whether there are any declared names left after -// filtering. -// -func FilterDecl(decl Decl, f Filter) bool { - return filterDecl(decl, f, false) -} - -func filterDecl(decl Decl, f Filter, export bool) bool { - switch d := decl.(type) { - case *GenDecl: - d.Specs = filterSpecList(d.Specs, f, export) - return len(d.Specs) > 0 - case *FuncDecl: - return f(d.Name.Name) - } - return false -} - -// FilterFile trims the AST for a Go file in place by removing all -// names from top-level declarations (including struct field and -// interface method names, but not from parameter lists) that don't -// pass through the filter f. If the declaration is empty afterwards, -// the declaration is removed from the AST. Import declarations are -// always removed. The File.Comments list is not changed. -// -// FilterFile reports whether there are any top-level declarations -// left after filtering. -// -func FilterFile(src *File, f Filter) bool { - return filterFile(src, f, false) -} - -func filterFile(src *File, f Filter, export bool) bool { - j := 0 - for _, d := range src.Decls { - if filterDecl(d, f, export) { - src.Decls[j] = d - j++ - } - } - src.Decls = src.Decls[0:j] - return j > 0 -} - -// FilterPackage trims the AST for a Go package in place by removing -// all names from top-level declarations (including struct field and -// interface method names, but not from parameter lists) that don't -// pass through the filter f. If the declaration is empty afterwards, -// the declaration is removed from the AST. The pkg.Files list is not -// changed, so that file names and top-level package comments don't get -// lost. -// -// FilterPackage reports whether there are any top-level declarations -// left after filtering. -// -func FilterPackage(pkg *Package, f Filter) bool { - return filterPackage(pkg, f, false) -} - -func filterPackage(pkg *Package, f Filter, export bool) bool { - hasDecls := false - for _, src := range pkg.Files { - if filterFile(src, f, export) { - hasDecls = true - } - } - return hasDecls -} - -// ---------------------------------------------------------------------------- -// Merging of package files - -// The MergeMode flags control the behavior of MergePackageFiles. -type MergeMode uint - -const ( - // If set, duplicate function declarations are excluded. - FilterFuncDuplicates MergeMode = 1 << iota - // If set, comments that are not associated with a specific - // AST node (as Doc or Comment) are excluded. - FilterUnassociatedComments - // If set, duplicate import declarations are excluded. - FilterImportDuplicates -) - -// nameOf returns the function (foo) or method name (foo.bar) for -// the given function declaration. If the AST is incorrect for the -// receiver, it assumes a function instead. -// -func nameOf(f *FuncDecl) string { - if r := f.Recv; r != nil && len(r.List) == 1 { - // looks like a correct receiver declaration - t := r.List[0].Type - // dereference pointer receiver types - if p, _ := t.(*StarExpr); p != nil { - t = p.X - } - // the receiver type must be a type name - if p, _ := t.(*Ident); p != nil { - return p.Name + "." + f.Name.Name - } - // otherwise assume a function instead - } - return f.Name.Name -} - -// separator is an empty //-style comment that is interspersed between -// different comment groups when they are concatenated into a single group -// -var separator = &Comment{token.NoPos, "//"} - -// MergePackageFiles creates a file AST by merging the ASTs of the -// files belonging to a package. The mode flags control merging behavior. -// -func MergePackageFiles(pkg *Package, mode MergeMode) *File { - // Count the number of package docs, comments and declarations across - // all package files. Also, compute sorted list of filenames, so that - // subsequent iterations can always iterate in the same order. - ndocs := 0 - ncomments := 0 - ndecls := 0 - filenames := make([]string, len(pkg.Files)) - i := 0 - for filename, f := range pkg.Files { - filenames[i] = filename - i++ - if f.Doc != nil { - ndocs += len(f.Doc.List) + 1 // +1 for separator - } - ncomments += len(f.Comments) - ndecls += len(f.Decls) - } - sort.Strings(filenames) - - // Collect package comments from all package files into a single - // CommentGroup - the collected package documentation. In general - // there should be only one file with a package comment; but it's - // better to collect extra comments than drop them on the floor. - var doc *CommentGroup - var pos token.Pos - if ndocs > 0 { - list := make([]*Comment, ndocs-1) // -1: no separator before first group - i := 0 - for _, filename := range filenames { - f := pkg.Files[filename] - if f.Doc != nil { - if i > 0 { - // not the first group - add separator - list[i] = separator - i++ - } - for _, c := range f.Doc.List { - list[i] = c - i++ - } - if f.Package > pos { - // Keep the maximum package clause position as - // position for the package clause of the merged - // files. - pos = f.Package - } - } - } - doc = &CommentGroup{list} - } - - // Collect declarations from all package files. - var decls []Decl - if ndecls > 0 { - decls = make([]Decl, ndecls) - funcs := make(map[string]int) // map of func name -> decls index - i := 0 // current index - n := 0 // number of filtered entries - for _, filename := range filenames { - f := pkg.Files[filename] - for _, d := range f.Decls { - if mode&FilterFuncDuplicates != 0 { - // A language entity may be declared multiple - // times in different package files; only at - // build time declarations must be unique. - // For now, exclude multiple declarations of - // functions - keep the one with documentation. - // - // TODO(gri): Expand this filtering to other - // entities (const, type, vars) if - // multiple declarations are common. - if f, isFun := d.(*FuncDecl); isFun { - name := nameOf(f) - if j, exists := funcs[name]; exists { - // function declared already - if decls[j] != nil && decls[j].(*FuncDecl).Doc == nil { - // existing declaration has no documentation; - // ignore the existing declaration - decls[j] = nil - } else { - // ignore the new declaration - d = nil - } - n++ // filtered an entry - } else { - funcs[name] = i - } - } - } - decls[i] = d - i++ - } - } - - // Eliminate nil entries from the decls list if entries were - // filtered. We do this using a 2nd pass in order to not disturb - // the original declaration order in the source (otherwise, this - // would also invalidate the monotonically increasing position - // info within a single file). - if n > 0 { - i = 0 - for _, d := range decls { - if d != nil { - decls[i] = d - i++ - } - } - decls = decls[0:i] - } - } - - // Collect import specs from all package files. - var imports []*ImportSpec - if mode&FilterImportDuplicates != 0 { - seen := make(map[string]bool) - for _, filename := range filenames { - f := pkg.Files[filename] - for _, imp := range f.Imports { - if path := imp.Path.Value; !seen[path] { - // TODO: consider handling cases where: - // - 2 imports exist with the same import path but - // have different local names (one should probably - // keep both of them) - // - 2 imports exist but only one has a comment - // - 2 imports exist and they both have (possibly - // different) comments - imports = append(imports, imp) - seen[path] = true - } - } - } - } else { - for _, f := range pkg.Files { - imports = append(imports, f.Imports...) - } - } - - // Collect comments from all package files. - var comments []*CommentGroup - if mode&FilterUnassociatedComments == 0 { - comments = make([]*CommentGroup, ncomments) - i := 0 - for _, f := range pkg.Files { - i += copy(comments[i:], f.Comments) - } - } - - // TODO(gri) need to compute unresolved identifiers! - return &File{doc, pos, NewIdent(pkg.Name), decls, pkg.Scope, imports, nil, comments} -} diff --git a/third_party/golang/go/ast/filter_test.go b/third_party/golang/go/ast/filter_test.go deleted file mode 100644 index 9fd86cb46710e..0000000000000 --- a/third_party/golang/go/ast/filter_test.go +++ /dev/null @@ -1,86 +0,0 @@ -// Copyright 2013 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// To avoid a cyclic dependency with go/parser, this file is in a separate package. - -package ast_test - -import ( - "bytes" - "go/ast" - "go/format" - "go/parser" - "go/token" - "testing" -) - -const input = `package p - -type t1 struct{} -type t2 struct{} - -func f1() {} -func f1() {} -func f2() {} - -func (*t1) f1() {} -func (t1) f1() {} -func (t1) f2() {} - -func (t2) f1() {} -func (t2) f2() {} -func (x *t2) f2() {} -` - -// Calling ast.MergePackageFiles with ast.FilterFuncDuplicates -// keeps a duplicate entry with attached documentation in favor -// of one without, and it favors duplicate entries appearing -// later in the source over ones appearing earlier. This is why -// (*t2).f2 is kept and t2.f2 is eliminated in this test case. -// -const golden = `package p - -type t1 struct{} -type t2 struct{} - -func f1() {} -func f2() {} - -func (t1) f1() {} -func (t1) f2() {} - -func (t2) f1() {} - -func (x *t2) f2() {} -` - -func TestFilterDuplicates(t *testing.T) { - // parse input - fset := token.NewFileSet() - file, err := parser.ParseFile(fset, "", input, 0) - if err != nil { - t.Fatal(err) - } - - // create package - files := map[string]*ast.File{"": file} - pkg, err := ast.NewPackage(fset, files, nil, nil) - if err != nil { - t.Fatal(err) - } - - // filter - merged := ast.MergePackageFiles(pkg, ast.FilterFuncDuplicates) - - // pretty-print - var buf bytes.Buffer - if err := format.Node(&buf, fset, merged); err != nil { - t.Fatal(err) - } - output := buf.String() - - if output != golden { - t.Errorf("incorrect output:\n%s", output) - } -} diff --git a/third_party/golang/go/ast/import.go b/third_party/golang/go/ast/import.go deleted file mode 100644 index 11066920037d4..0000000000000 --- a/third_party/golang/go/ast/import.go +++ /dev/null @@ -1,196 +0,0 @@ -// Copyright 2011 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package ast - -import ( - "k8s.io/kubernetes/third_party/golang/go/token" - "sort" - "strconv" -) - -// SortImports sorts runs of consecutive import lines in import blocks in f. -// It also removes duplicate imports when it is possible to do so without data loss. -func SortImports(fset *token.FileSet, f *File) { - for _, d := range f.Decls { - d, ok := d.(*GenDecl) - if !ok || d.Tok != token.IMPORT { - // Not an import declaration, so we're done. - // Imports are always first. - break - } - - if !d.Lparen.IsValid() { - // Not a block: sorted by default. - continue - } - - // Identify and sort runs of specs on successive lines. - i := 0 - specs := d.Specs[:0] - for j, s := range d.Specs { - if j > i && fset.Position(s.Pos()).Line > 1+fset.Position(d.Specs[j-1].End()).Line { - // j begins a new run. End this one. - specs = append(specs, sortSpecs(fset, f, d.Specs[i:j])...) - i = j - } - } - specs = append(specs, sortSpecs(fset, f, d.Specs[i:])...) - d.Specs = specs - - // Deduping can leave a blank line before the rparen; clean that up. - if len(d.Specs) > 0 { - lastSpec := d.Specs[len(d.Specs)-1] - lastLine := fset.Position(lastSpec.Pos()).Line - if rParenLine := fset.Position(d.Rparen).Line; rParenLine > lastLine+1 { - fset.File(d.Rparen).MergeLine(rParenLine - 1) - } - } - } -} - -func importPath(s Spec) string { - t, err := strconv.Unquote(s.(*ImportSpec).Path.Value) - if err == nil { - return t - } - return "" -} - -func importName(s Spec) string { - n := s.(*ImportSpec).Name - if n == nil { - return "" - } - return n.Name -} - -func importComment(s Spec) string { - c := s.(*ImportSpec).Comment - if c == nil { - return "" - } - return c.Text() -} - -// collapse indicates whether prev may be removed, leaving only next. -func collapse(prev, next Spec) bool { - if importPath(next) != importPath(prev) || importName(next) != importName(prev) { - return false - } - return prev.(*ImportSpec).Comment == nil -} - -type posSpan struct { - Start token.Pos - End token.Pos -} - -func sortSpecs(fset *token.FileSet, f *File, specs []Spec) []Spec { - // Can't short-circuit here even if specs are already sorted, - // since they might yet need deduplication. - // A lone import, however, may be safely ignored. - if len(specs) <= 1 { - return specs - } - - // Record positions for specs. - pos := make([]posSpan, len(specs)) - for i, s := range specs { - pos[i] = posSpan{s.Pos(), s.End()} - } - - // Identify comments in this range. - // Any comment from pos[0].Start to the final line counts. - lastLine := fset.Position(pos[len(pos)-1].End).Line - cstart := len(f.Comments) - cend := len(f.Comments) - for i, g := range f.Comments { - if g.Pos() < pos[0].Start { - continue - } - if i < cstart { - cstart = i - } - if fset.Position(g.End()).Line > lastLine { - cend = i - break - } - } - comments := f.Comments[cstart:cend] - - // Assign each comment to the import spec preceding it. - importComment := map[*ImportSpec][]*CommentGroup{} - specIndex := 0 - for _, g := range comments { - for specIndex+1 < len(specs) && pos[specIndex+1].Start <= g.Pos() { - specIndex++ - } - s := specs[specIndex].(*ImportSpec) - importComment[s] = append(importComment[s], g) - } - - // Sort the import specs by import path. - // Remove duplicates, when possible without data loss. - // Reassign the import paths to have the same position sequence. - // Reassign each comment to abut the end of its spec. - // Sort the comments by new position. - sort.Sort(byImportSpec(specs)) - - // Dedup. Thanks to our sorting, we can just consider - // adjacent pairs of imports. - deduped := specs[:0] - for i, s := range specs { - if i == len(specs)-1 || !collapse(s, specs[i+1]) { - deduped = append(deduped, s) - } else { - p := s.Pos() - fset.File(p).MergeLine(fset.Position(p).Line) - } - } - specs = deduped - - // Fix up comment positions - for i, s := range specs { - s := s.(*ImportSpec) - if s.Name != nil { - s.Name.NamePos = pos[i].Start - } - s.Path.ValuePos = pos[i].Start - s.EndPos = pos[i].End - for _, g := range importComment[s] { - for _, c := range g.List { - c.Slash = pos[i].End - } - } - } - - sort.Sort(byCommentPos(comments)) - - return specs -} - -type byImportSpec []Spec // slice of *ImportSpec - -func (x byImportSpec) Len() int { return len(x) } -func (x byImportSpec) Swap(i, j int) { x[i], x[j] = x[j], x[i] } -func (x byImportSpec) Less(i, j int) bool { - ipath := importPath(x[i]) - jpath := importPath(x[j]) - if ipath != jpath { - return ipath < jpath - } - iname := importName(x[i]) - jname := importName(x[j]) - if iname != jname { - return iname < jname - } - return importComment(x[i]) < importComment(x[j]) -} - -type byCommentPos []*CommentGroup - -func (x byCommentPos) Len() int { return len(x) } -func (x byCommentPos) Swap(i, j int) { x[i], x[j] = x[j], x[i] } -func (x byCommentPos) Less(i, j int) bool { return x[i].Pos() < x[j].Pos() } diff --git a/third_party/golang/go/ast/print.go b/third_party/golang/go/ast/print.go deleted file mode 100644 index 63a38e22f85cc..0000000000000 --- a/third_party/golang/go/ast/print.go +++ /dev/null @@ -1,252 +0,0 @@ -// Copyright 2010 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// This file contains printing support for ASTs. - -package ast - -import ( - "fmt" - "io" - "os" - "reflect" - - "k8s.io/kubernetes/third_party/golang/go/token" -) - -// A FieldFilter may be provided to Fprint to control the output. -type FieldFilter func(name string, value reflect.Value) bool - -// NotNilFilter returns true for field values that are not nil; -// it returns false otherwise. -func NotNilFilter(_ string, v reflect.Value) bool { - switch v.Kind() { - case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice: - return !v.IsNil() - } - return true -} - -// Fprint prints the (sub-)tree starting at AST node x to w. -// If fset != nil, position information is interpreted relative -// to that file set. Otherwise positions are printed as integer -// values (file set specific offsets). -// -// A non-nil FieldFilter f may be provided to control the output: -// struct fields for which f(fieldname, fieldvalue) is true are -// printed; all others are filtered from the output. Unexported -// struct fields are never printed. -// -func Fprint(w io.Writer, fset *token.FileSet, x interface{}, f FieldFilter) (err error) { - // setup printer - p := printer{ - output: w, - fset: fset, - filter: f, - ptrmap: make(map[interface{}]int), - last: '\n', // force printing of line number on first line - } - - // install error handler - defer func() { - if e := recover(); e != nil { - err = e.(localError).err // re-panics if it's not a localError - } - }() - - // print x - if x == nil { - p.printf("nil\n") - return - } - p.print(reflect.ValueOf(x)) - p.printf("\n") - - return -} - -// Print prints x to standard output, skipping nil fields. -// Print(fset, x) is the same as Fprint(os.Stdout, fset, x, NotNilFilter). -func Print(fset *token.FileSet, x interface{}) error { - return Fprint(os.Stdout, fset, x, NotNilFilter) -} - -type printer struct { - output io.Writer - fset *token.FileSet - filter FieldFilter - ptrmap map[interface{}]int // *T -> line number - indent int // current indentation level - last byte // the last byte processed by Write - line int // current line number -} - -var indent = []byte(". ") - -func (p *printer) Write(data []byte) (n int, err error) { - var m int - for i, b := range data { - // invariant: data[0:n] has been written - if b == '\n' { - m, err = p.output.Write(data[n : i+1]) - n += m - if err != nil { - return - } - p.line++ - } else if p.last == '\n' { - _, err = fmt.Fprintf(p.output, "%6d ", p.line) - if err != nil { - return - } - for j := p.indent; j > 0; j-- { - _, err = p.output.Write(indent) - if err != nil { - return - } - } - } - p.last = b - } - if len(data) > n { - m, err = p.output.Write(data[n:]) - n += m - } - return -} - -// localError wraps locally caught errors so we can distinguish -// them from genuine panics which we don't want to return as errors. -type localError struct { - err error -} - -// printf is a convenience wrapper that takes care of print errors. -func (p *printer) printf(format string, args ...interface{}) { - if _, err := fmt.Fprintf(p, format, args...); err != nil { - panic(localError{err}) - } -} - -// Implementation note: Print is written for AST nodes but could be -// used to print arbitrary data structures; such a version should -// probably be in a different package. -// -// Note: This code detects (some) cycles created via pointers but -// not cycles that are created via slices or maps containing the -// same slice or map. Code for general data structures probably -// should catch those as well. - -func (p *printer) print(x reflect.Value) { - if !NotNilFilter("", x) { - p.printf("nil") - return - } - - switch x.Kind() { - case reflect.Interface: - p.print(x.Elem()) - - case reflect.Map: - p.printf("%s (len = %d) {", x.Type(), x.Len()) - if x.Len() > 0 { - p.indent++ - p.printf("\n") - for _, key := range x.MapKeys() { - p.print(key) - p.printf(": ") - p.print(x.MapIndex(key)) - p.printf("\n") - } - p.indent-- - } - p.printf("}") - - case reflect.Ptr: - p.printf("*") - // type-checked ASTs may contain cycles - use ptrmap - // to keep track of objects that have been printed - // already and print the respective line number instead - ptr := x.Interface() - if line, exists := p.ptrmap[ptr]; exists { - p.printf("(obj @ %d)", line) - } else { - p.ptrmap[ptr] = p.line - p.print(x.Elem()) - } - - case reflect.Array: - p.printf("%s {", x.Type()) - if x.Len() > 0 { - p.indent++ - p.printf("\n") - for i, n := 0, x.Len(); i < n; i++ { - p.printf("%d: ", i) - p.print(x.Index(i)) - p.printf("\n") - } - p.indent-- - } - p.printf("}") - - case reflect.Slice: - if s, ok := x.Interface().([]byte); ok { - p.printf("%#q", s) - return - } - p.printf("%s (len = %d) {", x.Type(), x.Len()) - if x.Len() > 0 { - p.indent++ - p.printf("\n") - for i, n := 0, x.Len(); i < n; i++ { - p.printf("%d: ", i) - p.print(x.Index(i)) - p.printf("\n") - } - p.indent-- - } - p.printf("}") - - case reflect.Struct: - t := x.Type() - p.printf("%s {", t) - p.indent++ - first := true - for i, n := 0, t.NumField(); i < n; i++ { - // exclude non-exported fields because their - // values cannot be accessed via reflection - if name := t.Field(i).Name; IsExported(name) { - value := x.Field(i) - if p.filter == nil || p.filter(name, value) { - if first { - p.printf("\n") - first = false - } - p.printf("%s: ", name) - p.print(value) - p.printf("\n") - } - } - } - p.indent-- - p.printf("}") - - default: - v := x.Interface() - switch v := v.(type) { - case string: - // print strings in quotes - p.printf("%q", v) - return - case token.Pos: - // position values can be printed nicely if we have a file set - if p.fset != nil { - p.printf("%s", p.fset.Position(v)) - return - } - } - // default - p.printf("%v", v) - } -} diff --git a/third_party/golang/go/ast/print_test.go b/third_party/golang/go/ast/print_test.go deleted file mode 100644 index 210f1643010c7..0000000000000 --- a/third_party/golang/go/ast/print_test.go +++ /dev/null @@ -1,97 +0,0 @@ -// Copyright 2011 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package ast - -import ( - "bytes" - "strings" - "testing" -) - -var tests = []struct { - x interface{} // x is printed as s - s string -}{ - // basic types - {nil, "0 nil"}, - {true, "0 true"}, - {42, "0 42"}, - {3.14, "0 3.14"}, - {1 + 2.718i, "0 (1+2.718i)"}, - {"foobar", "0 \"foobar\""}, - - // maps - {map[Expr]string{}, `0 map[ast.Expr]string (len = 0) {}`}, - {map[string]int{"a": 1}, - `0 map[string]int (len = 1) { - 1 . "a": 1 - 2 }`}, - - // pointers - {new(int), "0 *0"}, - - // arrays - {[0]int{}, `0 [0]int {}`}, - {[3]int{1, 2, 3}, - `0 [3]int { - 1 . 0: 1 - 2 . 1: 2 - 3 . 2: 3 - 4 }`}, - {[...]int{42}, - `0 [1]int { - 1 . 0: 42 - 2 }`}, - - // slices - {[]int{}, `0 []int (len = 0) {}`}, - {[]int{1, 2, 3}, - `0 []int (len = 3) { - 1 . 0: 1 - 2 . 1: 2 - 3 . 2: 3 - 4 }`}, - - // structs - {struct{}{}, `0 struct {} {}`}, - {struct{ x int }{007}, `0 struct { x int } {}`}, - {struct{ X, y int }{42, 991}, - `0 struct { X int; y int } { - 1 . X: 42 - 2 }`}, - {struct{ X, Y int }{42, 991}, - `0 struct { X int; Y int } { - 1 . X: 42 - 2 . Y: 991 - 3 }`}, -} - -// Split s into lines, trim whitespace from all lines, and return -// the concatenated non-empty lines. -func trim(s string) string { - lines := strings.Split(s, "\n") - i := 0 - for _, line := range lines { - line = strings.TrimSpace(line) - if line != "" { - lines[i] = line - i++ - } - } - return strings.Join(lines[0:i], "\n") -} - -func TestPrint(t *testing.T) { - var buf bytes.Buffer - for _, test := range tests { - buf.Reset() - if err := Fprint(&buf, nil, test.x, nil); err != nil { - t.Errorf("Fprint failed: %s", err) - } - if s, ts := trim(buf.String()), trim(test.s); s != ts { - t.Errorf("got:\n%s\nexpected:\n%s\n", s, ts) - } - } -} diff --git a/third_party/golang/go/ast/resolve.go b/third_party/golang/go/ast/resolve.go deleted file mode 100644 index e4d5b2db332eb..0000000000000 --- a/third_party/golang/go/ast/resolve.go +++ /dev/null @@ -1,174 +0,0 @@ -// Copyright 2011 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// This file implements NewPackage. - -package ast - -import ( - "fmt" - "k8s.io/kubernetes/third_party/golang/go/scanner" - "k8s.io/kubernetes/third_party/golang/go/token" - "strconv" -) - -type pkgBuilder struct { - fset *token.FileSet - errors scanner.ErrorList -} - -func (p *pkgBuilder) error(pos token.Pos, msg string) { - p.errors.Add(p.fset.Position(pos), msg) -} - -func (p *pkgBuilder) errorf(pos token.Pos, format string, args ...interface{}) { - p.error(pos, fmt.Sprintf(format, args...)) -} - -func (p *pkgBuilder) declare(scope, altScope *Scope, obj *Object) { - alt := scope.Insert(obj) - if alt == nil && altScope != nil { - // see if there is a conflicting declaration in altScope - alt = altScope.Lookup(obj.Name) - } - if alt != nil { - prevDecl := "" - if pos := alt.Pos(); pos.IsValid() { - prevDecl = fmt.Sprintf("\n\tprevious declaration at %s", p.fset.Position(pos)) - } - p.error(obj.Pos(), fmt.Sprintf("%s redeclared in this block%s", obj.Name, prevDecl)) - } -} - -func resolve(scope *Scope, ident *Ident) bool { - for ; scope != nil; scope = scope.Outer { - if obj := scope.Lookup(ident.Name); obj != nil { - ident.Obj = obj - return true - } - } - return false -} - -// An Importer resolves import paths to package Objects. -// The imports map records the packages already imported, -// indexed by package id (canonical import path). -// An Importer must determine the canonical import path and -// check the map to see if it is already present in the imports map. -// If so, the Importer can return the map entry. Otherwise, the -// Importer should load the package data for the given path into -// a new *Object (pkg), record pkg in the imports map, and then -// return pkg. -type Importer func(imports map[string]*Object, path string) (pkg *Object, err error) - -// NewPackage creates a new Package node from a set of File nodes. It resolves -// unresolved identifiers across files and updates each file's Unresolved list -// accordingly. If a non-nil importer and universe scope are provided, they are -// used to resolve identifiers not declared in any of the package files. Any -// remaining unresolved identifiers are reported as undeclared. If the files -// belong to different packages, one package name is selected and files with -// different package names are reported and then ignored. -// The result is a package node and a scanner.ErrorList if there were errors. -// -func NewPackage(fset *token.FileSet, files map[string]*File, importer Importer, universe *Scope) (*Package, error) { - var p pkgBuilder - p.fset = fset - - // complete package scope - pkgName := "" - pkgScope := NewScope(universe) - for _, file := range files { - // package names must match - switch name := file.Name.Name; { - case pkgName == "": - pkgName = name - case name != pkgName: - p.errorf(file.Package, "package %s; expected %s", name, pkgName) - continue // ignore this file - } - - // collect top-level file objects in package scope - for _, obj := range file.Scope.Objects { - p.declare(pkgScope, nil, obj) - } - } - - // package global mapping of imported package ids to package objects - imports := make(map[string]*Object) - - // complete file scopes with imports and resolve identifiers - for _, file := range files { - // ignore file if it belongs to a different package - // (error has already been reported) - if file.Name.Name != pkgName { - continue - } - - // build file scope by processing all imports - importErrors := false - fileScope := NewScope(pkgScope) - for _, spec := range file.Imports { - if importer == nil { - importErrors = true - continue - } - path, _ := strconv.Unquote(spec.Path.Value) - pkg, err := importer(imports, path) - if err != nil { - p.errorf(spec.Path.Pos(), "could not import %s (%s)", path, err) - importErrors = true - continue - } - // TODO(gri) If a local package name != "." is provided, - // global identifier resolution could proceed even if the - // import failed. Consider adjusting the logic here a bit. - - // local name overrides imported package name - name := pkg.Name - if spec.Name != nil { - name = spec.Name.Name - } - - // add import to file scope - if name == "." { - // merge imported scope with file scope - for _, obj := range pkg.Data.(*Scope).Objects { - p.declare(fileScope, pkgScope, obj) - } - } else if name != "_" { - // declare imported package object in file scope - // (do not re-use pkg in the file scope but create - // a new object instead; the Decl field is different - // for different files) - obj := NewObj(Pkg, name) - obj.Decl = spec - obj.Data = pkg.Data - p.declare(fileScope, pkgScope, obj) - } - } - - // resolve identifiers - if importErrors { - // don't use the universe scope without correct imports - // (objects in the universe may be shadowed by imports; - // with missing imports, identifiers might get resolved - // incorrectly to universe objects) - pkgScope.Outer = nil - } - i := 0 - for _, ident := range file.Unresolved { - if !resolve(fileScope, ident) { - p.errorf(ident.Pos(), "undeclared name: %s", ident.Name) - file.Unresolved[i] = ident - i++ - } - - } - file.Unresolved = file.Unresolved[0:i] - pkgScope.Outer = universe // reset universe scope - } - - p.errors.Sort() - return &Package{pkgName, pkgScope, imports, files}, p.errors.Err() -} diff --git a/third_party/golang/go/ast/scope.go b/third_party/golang/go/ast/scope.go deleted file mode 100644 index 0dbf751b0a5e2..0000000000000 --- a/third_party/golang/go/ast/scope.go +++ /dev/null @@ -1,163 +0,0 @@ -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// This file implements scopes and the objects they contain. - -package ast - -import ( - "bytes" - "fmt" - - "k8s.io/kubernetes/third_party/golang/go/token" -) - -// A Scope maintains the set of named language entities declared -// in the scope and a link to the immediately surrounding (outer) -// scope. -// -type Scope struct { - Outer *Scope - Objects map[string]*Object -} - -// NewScope creates a new scope nested in the outer scope. -func NewScope(outer *Scope) *Scope { - const n = 4 // initial scope capacity - return &Scope{outer, make(map[string]*Object, n)} -} - -// Lookup returns the object with the given name if it is -// found in scope s, otherwise it returns nil. Outer scopes -// are ignored. -// -func (s *Scope) Lookup(name string) *Object { - return s.Objects[name] -} - -// Insert attempts to insert a named object obj into the scope s. -// If the scope already contains an object alt with the same name, -// Insert leaves the scope unchanged and returns alt. Otherwise -// it inserts obj and returns nil. -// -func (s *Scope) Insert(obj *Object) (alt *Object) { - if alt = s.Objects[obj.Name]; alt == nil { - s.Objects[obj.Name] = obj - } - return -} - -// Debugging support -func (s *Scope) String() string { - var buf bytes.Buffer - fmt.Fprintf(&buf, "scope %p {", s) - if s != nil && len(s.Objects) > 0 { - fmt.Fprintln(&buf) - for _, obj := range s.Objects { - fmt.Fprintf(&buf, "\t%s %s\n", obj.Kind, obj.Name) - } - } - fmt.Fprintf(&buf, "}\n") - return buf.String() -} - -// ---------------------------------------------------------------------------- -// Objects - -// An Object describes a named language entity such as a package, -// constant, type, variable, function (incl. methods), or label. -// -// The Data fields contains object-specific data: -// -// Kind Data type Data value -// Pkg *types.Package package scope -// Con int iota for the respective declaration -// Con != nil constant value -// Typ *Scope (used as method scope during type checking - transient) -// -type Object struct { - Kind ObjKind - Name string // declared name - Decl interface{} // corresponding Field, XxxSpec, FuncDecl, LabeledStmt, AssignStmt, Scope; or nil - Data interface{} // object-specific data; or nil - Type interface{} // placeholder for type information; may be nil -} - -// NewObj creates a new object of a given kind and name. -func NewObj(kind ObjKind, name string) *Object { - return &Object{Kind: kind, Name: name} -} - -// Pos computes the source position of the declaration of an object name. -// The result may be an invalid position if it cannot be computed -// (obj.Decl may be nil or not correct). -func (obj *Object) Pos() token.Pos { - name := obj.Name - switch d := obj.Decl.(type) { - case *Field: - for _, n := range d.Names { - if n.Name == name { - return n.Pos() - } - } - case *ImportSpec: - if d.Name != nil && d.Name.Name == name { - return d.Name.Pos() - } - return d.Path.Pos() - case *ValueSpec: - for _, n := range d.Names { - if n.Name == name { - return n.Pos() - } - } - case *TypeSpec: - if d.Name.Name == name { - return d.Name.Pos() - } - case *FuncDecl: - if d.Name.Name == name { - return d.Name.Pos() - } - case *LabeledStmt: - if d.Label.Name == name { - return d.Label.Pos() - } - case *AssignStmt: - for _, x := range d.Lhs { - if ident, isIdent := x.(*Ident); isIdent && ident.Name == name { - return ident.Pos() - } - } - case *Scope: - // predeclared object - nothing to do for now - } - return token.NoPos -} - -// ObjKind describes what an object represents. -type ObjKind int - -// The list of possible Object kinds. -const ( - Bad ObjKind = iota // for error handling - Pkg // package - Con // constant - Typ // type - Var // variable - Fun // function or method - Lbl // label -) - -var objKindStrings = [...]string{ - Bad: "bad", - Pkg: "package", - Con: "const", - Typ: "type", - Var: "var", - Fun: "func", - Lbl: "label", -} - -func (kind ObjKind) String() string { return objKindStrings[kind] } diff --git a/third_party/golang/go/ast/walk.go b/third_party/golang/go/ast/walk.go deleted file mode 100644 index 8ca21959b11a0..0000000000000 --- a/third_party/golang/go/ast/walk.go +++ /dev/null @@ -1,386 +0,0 @@ -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package ast - -import "fmt" - -// A Visitor's Visit method is invoked for each node encountered by Walk. -// If the result visitor w is not nil, Walk visits each of the children -// of node with the visitor w, followed by a call of w.Visit(nil). -type Visitor interface { - Visit(node Node) (w Visitor) -} - -// Helper functions for common node lists. They may be empty. - -func walkIdentList(v Visitor, list []*Ident) { - for _, x := range list { - Walk(v, x) - } -} - -func walkExprList(v Visitor, list []Expr) { - for _, x := range list { - Walk(v, x) - } -} - -func walkStmtList(v Visitor, list []Stmt) { - for _, x := range list { - Walk(v, x) - } -} - -func walkDeclList(v Visitor, list []Decl) { - for _, x := range list { - Walk(v, x) - } -} - -// TODO(gri): Investigate if providing a closure to Walk leads to -// simpler use (and may help eliminate Inspect in turn). - -// Walk traverses an AST in depth-first order: It starts by calling -// v.Visit(node); node must not be nil. If the visitor w returned by -// v.Visit(node) is not nil, Walk is invoked recursively with visitor -// w for each of the non-nil children of node, followed by a call of -// w.Visit(nil). -// -func Walk(v Visitor, node Node) { - if v = v.Visit(node); v == nil { - return - } - - // walk children - // (the order of the cases matches the order - // of the corresponding node types in ast.go) - switch n := node.(type) { - // Comments and fields - case *Comment: - // nothing to do - - case *CommentGroup: - for _, c := range n.List { - Walk(v, c) - } - - case *Field: - if n.Doc != nil { - Walk(v, n.Doc) - } - walkIdentList(v, n.Names) - Walk(v, n.Type) - if n.Tag != nil { - Walk(v, n.Tag) - } - if n.Comment != nil { - Walk(v, n.Comment) - } - - case *FieldList: - for _, f := range n.List { - Walk(v, f) - } - - // Expressions - case *BadExpr, *Ident, *BasicLit: - // nothing to do - - case *Ellipsis: - if n.Elt != nil { - Walk(v, n.Elt) - } - - case *FuncLit: - Walk(v, n.Type) - Walk(v, n.Body) - - case *CompositeLit: - if n.Type != nil { - Walk(v, n.Type) - } - walkExprList(v, n.Elts) - - case *ParenExpr: - Walk(v, n.X) - - case *SelectorExpr: - Walk(v, n.X) - Walk(v, n.Sel) - - case *IndexExpr: - Walk(v, n.X) - Walk(v, n.Index) - - case *SliceExpr: - Walk(v, n.X) - if n.Low != nil { - Walk(v, n.Low) - } - if n.High != nil { - Walk(v, n.High) - } - if n.Max != nil { - Walk(v, n.Max) - } - - case *TypeAssertExpr: - Walk(v, n.X) - if n.Type != nil { - Walk(v, n.Type) - } - - case *CallExpr: - Walk(v, n.Fun) - walkExprList(v, n.Args) - - case *StarExpr: - Walk(v, n.X) - - case *UnaryExpr: - Walk(v, n.X) - - case *BinaryExpr: - Walk(v, n.X) - Walk(v, n.Y) - - case *KeyValueExpr: - Walk(v, n.Key) - Walk(v, n.Value) - - // Types - case *ArrayType: - if n.Len != nil { - Walk(v, n.Len) - } - Walk(v, n.Elt) - - case *StructType: - Walk(v, n.Fields) - - case *FuncType: - if n.Params != nil { - Walk(v, n.Params) - } - if n.Results != nil { - Walk(v, n.Results) - } - - case *InterfaceType: - Walk(v, n.Methods) - - case *MapType: - Walk(v, n.Key) - Walk(v, n.Value) - - case *ChanType: - Walk(v, n.Value) - - // Statements - case *BadStmt: - // nothing to do - - case *DeclStmt: - Walk(v, n.Decl) - - case *EmptyStmt: - // nothing to do - - case *LabeledStmt: - Walk(v, n.Label) - Walk(v, n.Stmt) - - case *ExprStmt: - Walk(v, n.X) - - case *SendStmt: - Walk(v, n.Chan) - Walk(v, n.Value) - - case *IncDecStmt: - Walk(v, n.X) - - case *AssignStmt: - walkExprList(v, n.Lhs) - walkExprList(v, n.Rhs) - - case *GoStmt: - Walk(v, n.Call) - - case *DeferStmt: - Walk(v, n.Call) - - case *ReturnStmt: - walkExprList(v, n.Results) - - case *BranchStmt: - if n.Label != nil { - Walk(v, n.Label) - } - - case *BlockStmt: - walkStmtList(v, n.List) - - case *IfStmt: - if n.Init != nil { - Walk(v, n.Init) - } - Walk(v, n.Cond) - Walk(v, n.Body) - if n.Else != nil { - Walk(v, n.Else) - } - - case *CaseClause: - walkExprList(v, n.List) - walkStmtList(v, n.Body) - - case *SwitchStmt: - if n.Init != nil { - Walk(v, n.Init) - } - if n.Tag != nil { - Walk(v, n.Tag) - } - Walk(v, n.Body) - - case *TypeSwitchStmt: - if n.Init != nil { - Walk(v, n.Init) - } - Walk(v, n.Assign) - Walk(v, n.Body) - - case *CommClause: - if n.Comm != nil { - Walk(v, n.Comm) - } - walkStmtList(v, n.Body) - - case *SelectStmt: - Walk(v, n.Body) - - case *ForStmt: - if n.Init != nil { - Walk(v, n.Init) - } - if n.Cond != nil { - Walk(v, n.Cond) - } - if n.Post != nil { - Walk(v, n.Post) - } - Walk(v, n.Body) - - case *RangeStmt: - if n.Key != nil { - Walk(v, n.Key) - } - if n.Value != nil { - Walk(v, n.Value) - } - Walk(v, n.X) - Walk(v, n.Body) - - // Declarations - case *ImportSpec: - if n.Doc != nil { - Walk(v, n.Doc) - } - if n.Name != nil { - Walk(v, n.Name) - } - Walk(v, n.Path) - if n.Comment != nil { - Walk(v, n.Comment) - } - - case *ValueSpec: - if n.Doc != nil { - Walk(v, n.Doc) - } - walkIdentList(v, n.Names) - if n.Type != nil { - Walk(v, n.Type) - } - walkExprList(v, n.Values) - if n.Comment != nil { - Walk(v, n.Comment) - } - - case *TypeSpec: - if n.Doc != nil { - Walk(v, n.Doc) - } - Walk(v, n.Name) - Walk(v, n.Type) - if n.Comment != nil { - Walk(v, n.Comment) - } - - case *BadDecl: - // nothing to do - - case *GenDecl: - if n.Doc != nil { - Walk(v, n.Doc) - } - for _, s := range n.Specs { - Walk(v, s) - } - - case *FuncDecl: - if n.Doc != nil { - Walk(v, n.Doc) - } - if n.Recv != nil { - Walk(v, n.Recv) - } - Walk(v, n.Name) - Walk(v, n.Type) - if n.Body != nil { - Walk(v, n.Body) - } - - // Files and packages - case *File: - if n.Doc != nil { - Walk(v, n.Doc) - } - Walk(v, n.Name) - walkDeclList(v, n.Decls) - // don't walk n.Comments - they have been - // visited already through the individual - // nodes - - case *Package: - for _, f := range n.Files { - Walk(v, f) - } - - default: - panic(fmt.Sprintf("ast.Walk: unexpected node type %T", n)) - } - - v.Visit(nil) -} - -type inspector func(Node) bool - -func (f inspector) Visit(node Node) Visitor { - if f(node) { - return f - } - return nil -} - -// Inspect traverses an AST in depth-first order: It starts by calling -// f(node); node must not be nil. If f returns true, Inspect invokes f -// recursively for each of the non-nil children of node, followed by a -// call of f(nil). -// -func Inspect(node Node, f func(Node) bool) { - Walk(inspector(f), node) -} diff --git a/third_party/golang/go/build/build.go b/third_party/golang/go/build/build.go deleted file mode 100644 index c1b70bcdd7513..0000000000000 --- a/third_party/golang/go/build/build.go +++ /dev/null @@ -1,1523 +0,0 @@ -// Copyright 2011 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package build - -import ( - "bytes" - "errors" - "fmt" - "go/ast" - "go/doc" - "go/parser" - "go/token" - "io" - "io/ioutil" - "log" - "os" - pathpkg "path" - "path/filepath" - "runtime" - "sort" - "strconv" - "strings" - "unicode" - "unicode/utf8" -) - -// A Context specifies the supporting context for a build. -type Context struct { - GOARCH string // target architecture - GOOS string // target operating system - GOROOT string // Go root - GOPATH string // Go path - CgoEnabled bool // whether cgo can be used - UseAllFiles bool // use files regardless of +build lines, file names - Compiler string // compiler to assume when computing target paths - - // The build and release tags specify build constraints - // that should be considered satisfied when processing +build lines. - // Clients creating a new context may customize BuildTags, which - // defaults to empty, but it is usually an error to customize ReleaseTags, - // which defaults to the list of Go releases the current release is compatible with. - // In addition to the BuildTags and ReleaseTags, build constraints - // consider the values of GOARCH and GOOS as satisfied tags. - BuildTags []string - ReleaseTags []string - - // The install suffix specifies a suffix to use in the name of the installation - // directory. By default it is empty, but custom builds that need to keep - // their outputs separate can set InstallSuffix to do so. For example, when - // using the race detector, the go command uses InstallSuffix = "race", so - // that on a Linux/386 system, packages are written to a directory named - // "linux_386_race" instead of the usual "linux_386". - InstallSuffix string - - // By default, Import uses the operating system's file system calls - // to read directories and files. To read from other sources, - // callers can set the following functions. They all have default - // behaviors that use the local file system, so clients need only set - // the functions whose behaviors they wish to change. - - // JoinPath joins the sequence of path fragments into a single path. - // If JoinPath is nil, Import uses filepath.Join. - JoinPath func(elem ...string) string - - // SplitPathList splits the path list into a slice of individual paths. - // If SplitPathList is nil, Import uses filepath.SplitList. - SplitPathList func(list string) []string - - // IsAbsPath reports whether path is an absolute path. - // If IsAbsPath is nil, Import uses filepath.IsAbs. - IsAbsPath func(path string) bool - - // IsDir reports whether the path names a directory. - // If IsDir is nil, Import calls os.Stat and uses the result's IsDir method. - IsDir func(path string) bool - - // HasSubdir reports whether dir is a subdirectory of - // (perhaps multiple levels below) root. - // If so, HasSubdir sets rel to a slash-separated path that - // can be joined to root to produce a path equivalent to dir. - // If HasSubdir is nil, Import uses an implementation built on - // filepath.EvalSymlinks. - HasSubdir func(root, dir string) (rel string, ok bool) - - // ReadDir returns a slice of os.FileInfo, sorted by Name, - // describing the content of the named directory. - // If ReadDir is nil, Import uses ioutil.ReadDir. - ReadDir func(dir string) (fi []os.FileInfo, err error) - - // OpenFile opens a file (not a directory) for reading. - // If OpenFile is nil, Import uses os.Open. - OpenFile func(path string) (r io.ReadCloser, err error) -} - -// joinPath calls ctxt.JoinPath (if not nil) or else filepath.Join. -func (ctxt *Context) joinPath(elem ...string) string { - if f := ctxt.JoinPath; f != nil { - return f(elem...) - } - return filepath.Join(elem...) -} - -// splitPathList calls ctxt.SplitPathList (if not nil) or else filepath.SplitList. -func (ctxt *Context) splitPathList(s string) []string { - if f := ctxt.SplitPathList; f != nil { - return f(s) - } - return filepath.SplitList(s) -} - -// isAbsPath calls ctxt.IsAbsPath (if not nil) or else filepath.IsAbs. -func (ctxt *Context) isAbsPath(path string) bool { - if f := ctxt.IsAbsPath; f != nil { - return f(path) - } - return filepath.IsAbs(path) -} - -// isDir calls ctxt.IsDir (if not nil) or else uses os.Stat. -func (ctxt *Context) isDir(path string) bool { - if f := ctxt.IsDir; f != nil { - return f(path) - } - fi, err := os.Stat(path) - return err == nil && fi.IsDir() -} - -// hasSubdir calls ctxt.HasSubdir (if not nil) or else uses -// the local file system to answer the question. -func (ctxt *Context) hasSubdir(root, dir string) (rel string, ok bool) { - if f := ctxt.HasSubdir; f != nil { - return f(root, dir) - } - - // Try using paths we received. - if rel, ok = hasSubdir(root, dir); ok { - return - } - - // Try expanding symlinks and comparing - // expanded against unexpanded and - // expanded against expanded. - rootSym, _ := filepath.EvalSymlinks(root) - dirSym, _ := filepath.EvalSymlinks(dir) - - if rel, ok = hasSubdir(rootSym, dir); ok { - return - } - if rel, ok = hasSubdir(root, dirSym); ok { - return - } - return hasSubdir(rootSym, dirSym) -} - -func hasSubdir(root, dir string) (rel string, ok bool) { - const sep = string(filepath.Separator) - root = filepath.Clean(root) - if !strings.HasSuffix(root, sep) { - root += sep - } - dir = filepath.Clean(dir) - if !strings.HasPrefix(dir, root) { - return "", false - } - return filepath.ToSlash(dir[len(root):]), true -} - -// readDir calls ctxt.ReadDir (if not nil) or else ioutil.ReadDir. -func (ctxt *Context) readDir(path string) ([]os.FileInfo, error) { - if f := ctxt.ReadDir; f != nil { - return f(path) - } - return ioutil.ReadDir(path) -} - -// openFile calls ctxt.OpenFile (if not nil) or else os.Open. -func (ctxt *Context) openFile(path string) (io.ReadCloser, error) { - if fn := ctxt.OpenFile; fn != nil { - return fn(path) - } - - f, err := os.Open(path) - if err != nil { - return nil, err // nil interface - } - return f, nil -} - -// isFile determines whether path is a file by trying to open it. -// It reuses openFile instead of adding another function to the -// list in Context. -func (ctxt *Context) isFile(path string) bool { - f, err := ctxt.openFile(path) - if err != nil { - return false - } - f.Close() - return true -} - -// gopath returns the list of Go path directories. -func (ctxt *Context) gopath() []string { - var all []string - for _, p := range ctxt.splitPathList(ctxt.GOPATH) { - if p == "" || p == ctxt.GOROOT { - // Empty paths are uninteresting. - // If the path is the GOROOT, ignore it. - // People sometimes set GOPATH=$GOROOT. - // Do not get confused by this common mistake. - continue - } - if strings.HasPrefix(p, "~") { - // Path segments starting with ~ on Unix are almost always - // users who have incorrectly quoted ~ while setting GOPATH, - // preventing it from expanding to $HOME. - // The situation is made more confusing by the fact that - // bash allows quoted ~ in $PATH (most shells do not). - // Do not get confused by this, and do not try to use the path. - // It does not exist, and printing errors about it confuses - // those users even more, because they think "sure ~ exists!". - // The go command diagnoses this situation and prints a - // useful error. - // On Windows, ~ is used in short names, such as c:\progra~1 - // for c:\program files. - continue - } - all = append(all, p) - } - return all -} - -// SrcDirs returns a list of package source root directories. -// It draws from the current Go root and Go path but omits directories -// that do not exist. -func (ctxt *Context) SrcDirs() []string { - var all []string - if ctxt.GOROOT != "" { - dir := ctxt.joinPath(ctxt.GOROOT, "src") - if ctxt.isDir(dir) { - all = append(all, dir) - } - } - for _, p := range ctxt.gopath() { - dir := ctxt.joinPath(p, "src") - if ctxt.isDir(dir) { - all = append(all, dir) - } - } - return all -} - -// Default is the default Context for builds. -// It uses the GOARCH, GOOS, GOROOT, and GOPATH environment variables -// if set, or else the compiled code's GOARCH, GOOS, and GOROOT. -var Default Context = defaultContext() - -// Also known to cmd/dist/build.go. -var cgoEnabled = map[string]bool{ - "darwin/386": true, - "darwin/amd64": true, - "darwin/arm": true, - "darwin/arm64": true, - "dragonfly/amd64": true, - "freebsd/386": true, - "freebsd/amd64": true, - "freebsd/arm": true, - "linux/386": true, - "linux/amd64": true, - "linux/arm": true, - "linux/arm64": true, - "linux/ppc64le": true, - "android/386": true, - "android/amd64": true, - "android/arm": true, - "netbsd/386": true, - "netbsd/amd64": true, - "netbsd/arm": true, - "openbsd/386": true, - "openbsd/amd64": true, - "solaris/amd64": true, - "windows/386": true, - "windows/amd64": true, -} - -func defaultContext() Context { - var c Context - - c.GOARCH = envOr("GOARCH", runtime.GOARCH) - c.GOOS = envOr("GOOS", runtime.GOOS) - c.GOROOT = pathpkg.Clean(runtime.GOROOT()) - c.GOPATH = envOr("GOPATH", "") - c.Compiler = runtime.Compiler - - // Each major Go release in the Go 1.x series should add a tag here. - // Old tags should not be removed. That is, the go1.x tag is present - // in all releases >= Go 1.x. Code that requires Go 1.x or later should - // say "+build go1.x", and code that should only be built before Go 1.x - // (perhaps it is the stub to use in that case) should say "+build !go1.x". - c.ReleaseTags = []string{"go1.1", "go1.2", "go1.3", "go1.4", "go1.5", "go1.6"} - - switch os.Getenv("CGO_ENABLED") { - case "1": - c.CgoEnabled = true - case "0": - c.CgoEnabled = false - default: - // cgo must be explicitly enabled for cross compilation builds - if runtime.GOARCH == c.GOARCH && runtime.GOOS == c.GOOS { - c.CgoEnabled = cgoEnabled[c.GOOS+"/"+c.GOARCH] - break - } - c.CgoEnabled = false - } - - return c -} - -func envOr(name, def string) string { - s := os.Getenv(name) - if s == "" { - return def - } - return s -} - -// An ImportMode controls the behavior of the Import method. -type ImportMode uint - -const ( - // If FindOnly is set, Import stops after locating the directory - // that should contain the sources for a package. It does not - // read any files in the directory. - FindOnly ImportMode = 1 << iota - - // If AllowBinary is set, Import can be satisfied by a compiled - // package object without corresponding sources. - AllowBinary - - // If ImportComment is set, parse import comments on package statements. - // Import returns an error if it finds a comment it cannot understand - // or finds conflicting comments in multiple source files. - // See golang.org/s/go14customimport for more information. - ImportComment - - // By default, Import searches vendor directories - // that apply in the given source directory before searching - // the GOROOT and GOPATH roots. - // If an Import finds and returns a package using a vendor - // directory, the resulting ImportPath is the complete path - // to the package, including the path elements leading up - // to and including "vendor". - // For example, if Import("y", "x/subdir", 0) finds - // "x/vendor/y", the returned package's ImportPath is "x/vendor/y", - // not plain "y". - // See golang.org/s/go15vendor for more information. - // - // Setting IgnoreVendor ignores vendor directories. - IgnoreVendor -) - -// A Package describes the Go package found in a directory. -type Package struct { - Dir string // directory containing package sources - Name string // package name - ImportComment string // path in import comment on package statement - Doc string // documentation synopsis - ImportPath string // import path of package ("" if unknown) - Root string // root of Go tree where this package lives - SrcRoot string // package source root directory ("" if unknown) - PkgRoot string // package install root directory ("" if unknown) - PkgTargetRoot string // architecture dependent install root directory ("" if unknown) - BinDir string // command install directory ("" if unknown) - Goroot bool // package found in Go root - PkgObj string // installed .a file - AllTags []string // tags that can influence file selection in this directory - ConflictDir string // this directory shadows Dir in $GOPATH - - // Source files - GoFiles []string // .go source files (excluding CgoFiles, TestGoFiles, XTestGoFiles) - CgoFiles []string // .go source files that import "C" - IgnoredGoFiles []string // .go source files ignored for this build - InvalidGoFiles []string // .go source files with detected problems (parse error, wrong package name, and so on) - CFiles []string // .c source files - CXXFiles []string // .cc, .cpp and .cxx source files - MFiles []string // .m (Objective-C) source files - HFiles []string // .h, .hh, .hpp and .hxx source files - SFiles []string // .s source files - SwigFiles []string // .swig files - SwigCXXFiles []string // .swigcxx files - SysoFiles []string // .syso system object files to add to archive - - // Cgo directives - CgoCFLAGS []string // Cgo CFLAGS directives - CgoCPPFLAGS []string // Cgo CPPFLAGS directives - CgoCXXFLAGS []string // Cgo CXXFLAGS directives - CgoLDFLAGS []string // Cgo LDFLAGS directives - CgoPkgConfig []string // Cgo pkg-config directives - - // Dependency information - Imports []string // imports from GoFiles, CgoFiles - ImportPos map[string][]token.Position // line information for Imports - - // Test information - TestGoFiles []string // _test.go files in package - TestImports []string // imports from TestGoFiles - TestImportPos map[string][]token.Position // line information for TestImports - XTestGoFiles []string // _test.go files outside package - XTestImports []string // imports from XTestGoFiles - XTestImportPos map[string][]token.Position // line information for XTestImports -} - -// IsCommand reports whether the package is considered a -// command to be installed (not just a library). -// Packages named "main" are treated as commands. -func (p *Package) IsCommand() bool { - return p.Name == "main" -} - -// ImportDir is like Import but processes the Go package found in -// the named directory. -func (ctxt *Context) ImportDir(dir string, mode ImportMode) (*Package, error) { - return ctxt.Import(".", dir, mode) -} - -// NoGoError is the error used by Import to describe a directory -// containing no buildable Go source files. (It may still contain -// test files, files hidden by build tags, and so on.) -type NoGoError struct { - Dir string -} - -func (e *NoGoError) Error() string { - return "no buildable Go source files in " + e.Dir -} - -// MultiplePackageError describes a directory containing -// multiple buildable Go source files for multiple packages. -type MultiplePackageError struct { - Dir string // directory containing files - Packages []string // package names found - Files []string // corresponding files: Files[i] declares package Packages[i] -} - -func (e *MultiplePackageError) Error() string { - // Error string limited to two entries for compatibility. - return fmt.Sprintf("found packages %s (%s) and %s (%s) in %s", e.Packages[0], e.Files[0], e.Packages[1], e.Files[1], e.Dir) -} - -func nameExt(name string) string { - i := strings.LastIndex(name, ".") - if i < 0 { - return "" - } - return name[i:] -} - -// Import returns details about the Go package named by the import path, -// interpreting local import paths relative to the srcDir directory. -// If the path is a local import path naming a package that can be imported -// using a standard import path, the returned package will set p.ImportPath -// to that path. -// -// In the directory containing the package, .go, .c, .h, and .s files are -// considered part of the package except for: -// -// - .go files in package documentation -// - files starting with _ or . (likely editor temporary files) -// - files with build constraints not satisfied by the context -// -// If an error occurs, Import returns a non-nil error and a non-nil -// *Package containing partial information. -// -func (ctxt *Context) Import(path string, srcDir string, mode ImportMode) (*Package, error) { - p := &Package{ - ImportPath: path, - } - if path == "" { - return p, fmt.Errorf("import %q: invalid import path", path) - } - - var pkgtargetroot string - var pkga string - var pkgerr error - suffix := "" - if ctxt.InstallSuffix != "" { - suffix = "_" + ctxt.InstallSuffix - } - switch ctxt.Compiler { - case "gccgo": - pkgtargetroot = "pkg/gccgo_" + ctxt.GOOS + "_" + ctxt.GOARCH + suffix - case "gc": - pkgtargetroot = "pkg/" + ctxt.GOOS + "_" + ctxt.GOARCH + suffix - default: - // Save error for end of function. - pkgerr = fmt.Errorf("import %q: unknown compiler %q", path, ctxt.Compiler) - } - setPkga := func() { - switch ctxt.Compiler { - case "gccgo": - dir, elem := pathpkg.Split(p.ImportPath) - pkga = pkgtargetroot + "/" + dir + "lib" + elem + ".a" - case "gc": - pkga = pkgtargetroot + "/" + p.ImportPath + ".a" - } - } - setPkga() - - binaryOnly := false - if IsLocalImport(path) { - pkga = "" // local imports have no installed path - if srcDir == "" { - return p, fmt.Errorf("import %q: import relative to unknown directory", path) - } - if !ctxt.isAbsPath(path) { - p.Dir = ctxt.joinPath(srcDir, path) - } - // Determine canonical import path, if any. - // Exclude results where the import path would include /testdata/. - inTestdata := func(sub string) bool { - return strings.Contains(sub, "/testdata/") || strings.HasSuffix(sub, "/testdata") || strings.HasPrefix(sub, "testdata/") || sub == "testdata" - } - if ctxt.GOROOT != "" { - root := ctxt.joinPath(ctxt.GOROOT, "src") - if sub, ok := ctxt.hasSubdir(root, p.Dir); ok && !inTestdata(sub) { - p.Goroot = true - p.ImportPath = sub - p.Root = ctxt.GOROOT - goto Found - } - } - all := ctxt.gopath() - for i, root := range all { - rootsrc := ctxt.joinPath(root, "src") - if sub, ok := ctxt.hasSubdir(rootsrc, p.Dir); ok && !inTestdata(sub) { - // We found a potential import path for dir, - // but check that using it wouldn't find something - // else first. - if ctxt.GOROOT != "" { - if dir := ctxt.joinPath(ctxt.GOROOT, "src", sub); ctxt.isDir(dir) { - p.ConflictDir = dir - goto Found - } - } - for _, earlyRoot := range all[:i] { - if dir := ctxt.joinPath(earlyRoot, "src", sub); ctxt.isDir(dir) { - p.ConflictDir = dir - goto Found - } - } - - // sub would not name some other directory instead of this one. - // Record it. - p.ImportPath = sub - p.Root = root - goto Found - } - } - // It's okay that we didn't find a root containing dir. - // Keep going with the information we have. - } else { - if strings.HasPrefix(path, "/") { - return p, fmt.Errorf("import %q: cannot import absolute path", path) - } - - // tried records the location of unsuccessful package lookups - var tried struct { - vendor []string - goroot string - gopath []string - } - gopath := ctxt.gopath() - - // Vendor directories get first chance to satisfy import. - if mode&IgnoreVendor == 0 && srcDir != "" { - searchVendor := func(root string, isGoroot bool) bool { - sub, ok := ctxt.hasSubdir(root, srcDir) - if !ok || !strings.HasPrefix(sub, "src/") || strings.Contains(sub, "/testdata/") { - return false - } - for { - vendor := ctxt.joinPath(root, sub, "vendor") - if ctxt.isDir(vendor) { - dir := ctxt.joinPath(vendor, path) - if ctxt.isDir(dir) && hasGoFiles(ctxt, dir) { - p.Dir = dir - p.ImportPath = strings.TrimPrefix(pathpkg.Join(sub, "vendor", path), "src/") - p.Goroot = isGoroot - p.Root = root - setPkga() // p.ImportPath changed - return true - } - tried.vendor = append(tried.vendor, dir) - } - i := strings.LastIndex(sub, "/") - if i < 0 { - break - } - sub = sub[:i] - } - return false - } - if searchVendor(ctxt.GOROOT, true) { - goto Found - } - for _, root := range gopath { - if searchVendor(root, false) { - goto Found - } - } - } - - // Determine directory from import path. - if ctxt.GOROOT != "" { - dir := ctxt.joinPath(ctxt.GOROOT, "src", path) - isDir := ctxt.isDir(dir) - binaryOnly = !isDir && mode&AllowBinary != 0 && pkga != "" && ctxt.isFile(ctxt.joinPath(ctxt.GOROOT, pkga)) - if isDir || binaryOnly { - p.Dir = dir - p.Goroot = true - p.Root = ctxt.GOROOT - goto Found - } - tried.goroot = dir - } - for _, root := range gopath { - dir := ctxt.joinPath(root, "src", path) - isDir := ctxt.isDir(dir) - binaryOnly = !isDir && mode&AllowBinary != 0 && pkga != "" && ctxt.isFile(ctxt.joinPath(root, pkga)) - if isDir || binaryOnly { - p.Dir = dir - p.Root = root - goto Found - } - tried.gopath = append(tried.gopath, dir) - } - - // package was not found - var paths []string - format := "\t%s (vendor tree)" - for _, dir := range tried.vendor { - paths = append(paths, fmt.Sprintf(format, dir)) - format = "\t%s" - } - if tried.goroot != "" { - paths = append(paths, fmt.Sprintf("\t%s (from $GOROOT)", tried.goroot)) - } else { - paths = append(paths, "\t($GOROOT not set)") - } - format = "\t%s (from $GOPATH)" - for _, dir := range tried.gopath { - paths = append(paths, fmt.Sprintf(format, dir)) - format = "\t%s" - } - if len(tried.gopath) == 0 { - paths = append(paths, "\t($GOPATH not set)") - } - return p, fmt.Errorf("cannot find package %q in any of:\n%s", path, strings.Join(paths, "\n")) - } - -Found: - if p.Root != "" { - p.SrcRoot = ctxt.joinPath(p.Root, "src") - p.PkgRoot = ctxt.joinPath(p.Root, "pkg") - p.BinDir = ctxt.joinPath(p.Root, "bin") - if pkga != "" { - p.PkgTargetRoot = ctxt.joinPath(p.Root, pkgtargetroot) - p.PkgObj = ctxt.joinPath(p.Root, pkga) - } - } - - if mode&FindOnly != 0 { - return p, pkgerr - } - if binaryOnly && (mode&AllowBinary) != 0 { - return p, pkgerr - } - - dirs, err := ctxt.readDir(p.Dir) - if err != nil { - return p, err - } - - var badGoError error - var Sfiles []string // files with ".S" (capital S) - var firstFile, firstCommentFile string - imported := make(map[string][]token.Position) - testImported := make(map[string][]token.Position) - xTestImported := make(map[string][]token.Position) - allTags := make(map[string]bool) - fset := token.NewFileSet() - for _, d := range dirs { - if d.IsDir() { - continue - } - - name := d.Name() - ext := nameExt(name) - - badFile := func(err error) { - if badGoError == nil { - badGoError = err - } - p.InvalidGoFiles = append(p.InvalidGoFiles, name) - } - - match, data, filename, err := ctxt.matchFile(p.Dir, name, true, allTags) - if err != nil { - badFile(err) - continue - } - if !match { - if ext == ".go" { - p.IgnoredGoFiles = append(p.IgnoredGoFiles, name) - } - continue - } - - // Going to save the file. For non-Go files, can stop here. - switch ext { - case ".c": - p.CFiles = append(p.CFiles, name) - continue - case ".cc", ".cpp", ".cxx": - p.CXXFiles = append(p.CXXFiles, name) - continue - case ".m": - p.MFiles = append(p.MFiles, name) - continue - case ".h", ".hh", ".hpp", ".hxx": - p.HFiles = append(p.HFiles, name) - continue - case ".s": - p.SFiles = append(p.SFiles, name) - continue - case ".S": - Sfiles = append(Sfiles, name) - continue - case ".swig": - p.SwigFiles = append(p.SwigFiles, name) - continue - case ".swigcxx": - p.SwigCXXFiles = append(p.SwigCXXFiles, name) - continue - case ".syso": - // binary objects to add to package archive - // Likely of the form foo_windows.syso, but - // the name was vetted above with goodOSArchFile. - p.SysoFiles = append(p.SysoFiles, name) - continue - } - - pf, err := parser.ParseFile(fset, filename, data, parser.ImportsOnly|parser.ParseComments) - if err != nil { - badFile(err) - continue - } - - pkg := pf.Name.Name - if pkg == "documentation" { - p.IgnoredGoFiles = append(p.IgnoredGoFiles, name) - continue - } - - isTest := strings.HasSuffix(name, "_test.go") - isXTest := false - if isTest && strings.HasSuffix(pkg, "_test") { - isXTest = true - pkg = pkg[:len(pkg)-len("_test")] - } - - if p.Name == "" { - p.Name = pkg - firstFile = name - } else if pkg != p.Name { - badFile(&MultiplePackageError{ - Dir: p.Dir, - Packages: []string{p.Name, pkg}, - Files: []string{firstFile, name}, - }) - p.InvalidGoFiles = append(p.InvalidGoFiles, name) - } - if pf.Doc != nil && p.Doc == "" { - p.Doc = doc.Synopsis(pf.Doc.Text()) - } - - if mode&ImportComment != 0 { - qcom, line := findImportComment(data) - if line != 0 { - com, err := strconv.Unquote(qcom) - if err != nil { - badFile(fmt.Errorf("%s:%d: cannot parse import comment", filename, line)) - } else if p.ImportComment == "" { - p.ImportComment = com - firstCommentFile = name - } else if p.ImportComment != com { - badFile(fmt.Errorf("found import comments %q (%s) and %q (%s) in %s", p.ImportComment, firstCommentFile, com, name, p.Dir)) - } - } - } - - // Record imports and information about cgo. - isCgo := false - for _, decl := range pf.Decls { - d, ok := decl.(*ast.GenDecl) - if !ok { - continue - } - for _, dspec := range d.Specs { - spec, ok := dspec.(*ast.ImportSpec) - if !ok { - continue - } - quoted := spec.Path.Value - path, err := strconv.Unquote(quoted) - if err != nil { - log.Panicf("%s: parser returned invalid quoted string: <%s>", filename, quoted) - } - if isXTest { - xTestImported[path] = append(xTestImported[path], fset.Position(spec.Pos())) - } else if isTest { - testImported[path] = append(testImported[path], fset.Position(spec.Pos())) - } else { - imported[path] = append(imported[path], fset.Position(spec.Pos())) - } - if path == "C" { - if isTest { - badFile(fmt.Errorf("use of cgo in test %s not supported", filename)) - } else { - cg := spec.Doc - if cg == nil && len(d.Specs) == 1 { - cg = d.Doc - } - if cg != nil { - if err := ctxt.saveCgo(filename, p, cg); err != nil { - badFile(err) - } - } - isCgo = true - } - } - } - } - if isCgo { - allTags["cgo"] = true - if ctxt.CgoEnabled { - p.CgoFiles = append(p.CgoFiles, name) - } else { - p.IgnoredGoFiles = append(p.IgnoredGoFiles, name) - } - } else if isXTest { - p.XTestGoFiles = append(p.XTestGoFiles, name) - } else if isTest { - p.TestGoFiles = append(p.TestGoFiles, name) - } else { - p.GoFiles = append(p.GoFiles, name) - } - } - if badGoError != nil { - return p, badGoError - } - if len(p.GoFiles)+len(p.CgoFiles)+len(p.TestGoFiles)+len(p.XTestGoFiles) == 0 { - return p, &NoGoError{p.Dir} - } - - for tag := range allTags { - p.AllTags = append(p.AllTags, tag) - } - sort.Strings(p.AllTags) - - p.Imports, p.ImportPos = cleanImports(imported) - p.TestImports, p.TestImportPos = cleanImports(testImported) - p.XTestImports, p.XTestImportPos = cleanImports(xTestImported) - - // add the .S files only if we are using cgo - // (which means gcc will compile them). - // The standard assemblers expect .s files. - if len(p.CgoFiles) > 0 { - p.SFiles = append(p.SFiles, Sfiles...) - sort.Strings(p.SFiles) - } - - return p, pkgerr -} - -// hasGoFiles reports whether dir contains any files with names ending in .go. -// For a vendor check we must exclude directories that contain no .go files. -// Otherwise it is not possible to vendor just a/b/c and still import the -// non-vendored a/b. See golang.org/issue/13832. -func hasGoFiles(ctxt *Context, dir string) bool { - ents, _ := ctxt.readDir(dir) - for _, ent := range ents { - if !ent.IsDir() && strings.HasSuffix(ent.Name(), ".go") { - return true - } - } - return false -} - -func findImportComment(data []byte) (s string, line int) { - // expect keyword package - word, data := parseWord(data) - if string(word) != "package" { - return "", 0 - } - - // expect package name - _, data = parseWord(data) - - // now ready for import comment, a // or /* */ comment - // beginning and ending on the current line. - for len(data) > 0 && (data[0] == ' ' || data[0] == '\t' || data[0] == '\r') { - data = data[1:] - } - - var comment []byte - switch { - case bytes.HasPrefix(data, slashSlash): - i := bytes.Index(data, newline) - if i < 0 { - i = len(data) - } - comment = data[2:i] - case bytes.HasPrefix(data, slashStar): - data = data[2:] - i := bytes.Index(data, starSlash) - if i < 0 { - // malformed comment - return "", 0 - } - comment = data[:i] - if bytes.Contains(comment, newline) { - return "", 0 - } - } - comment = bytes.TrimSpace(comment) - - // split comment into `import`, `"pkg"` - word, arg := parseWord(comment) - if string(word) != "import" { - return "", 0 - } - - line = 1 + bytes.Count(data[:cap(data)-cap(arg)], newline) - return strings.TrimSpace(string(arg)), line -} - -var ( - slashSlash = []byte("//") - slashStar = []byte("/*") - starSlash = []byte("*/") - newline = []byte("\n") -) - -// skipSpaceOrComment returns data with any leading spaces or comments removed. -func skipSpaceOrComment(data []byte) []byte { - for len(data) > 0 { - switch data[0] { - case ' ', '\t', '\r', '\n': - data = data[1:] - continue - case '/': - if bytes.HasPrefix(data, slashSlash) { - i := bytes.Index(data, newline) - if i < 0 { - return nil - } - data = data[i+1:] - continue - } - if bytes.HasPrefix(data, slashStar) { - data = data[2:] - i := bytes.Index(data, starSlash) - if i < 0 { - return nil - } - data = data[i+2:] - continue - } - } - break - } - return data -} - -// parseWord skips any leading spaces or comments in data -// and then parses the beginning of data as an identifier or keyword, -// returning that word and what remains after the word. -func parseWord(data []byte) (word, rest []byte) { - data = skipSpaceOrComment(data) - - // Parse past leading word characters. - rest = data - for { - r, size := utf8.DecodeRune(rest) - if unicode.IsLetter(r) || '0' <= r && r <= '9' || r == '_' { - rest = rest[size:] - continue - } - break - } - - word = data[:len(data)-len(rest)] - if len(word) == 0 { - return nil, nil - } - - return word, rest -} - -// MatchFile reports whether the file with the given name in the given directory -// matches the context and would be included in a Package created by ImportDir -// of that directory. -// -// MatchFile considers the name of the file and may use ctxt.OpenFile to -// read some or all of the file's content. -func (ctxt *Context) MatchFile(dir, name string) (match bool, err error) { - match, _, _, err = ctxt.matchFile(dir, name, false, nil) - return -} - -// matchFile determines whether the file with the given name in the given directory -// should be included in the package being constructed. -// It returns the data read from the file. -// If returnImports is true and name denotes a Go program, matchFile reads -// until the end of the imports (and returns that data) even though it only -// considers text until the first non-comment. -// If allTags is non-nil, matchFile records any encountered build tag -// by setting allTags[tag] = true. -func (ctxt *Context) matchFile(dir, name string, returnImports bool, allTags map[string]bool) (match bool, data []byte, filename string, err error) { - if strings.HasPrefix(name, "_") || - strings.HasPrefix(name, ".") { - return - } - - i := strings.LastIndex(name, ".") - if i < 0 { - i = len(name) - } - ext := name[i:] - - if !ctxt.goodOSArchFile(name, allTags) && !ctxt.UseAllFiles { - return - } - - switch ext { - case ".go", ".c", ".cc", ".cxx", ".cpp", ".m", ".s", ".h", ".hh", ".hpp", ".hxx", ".S", ".swig", ".swigcxx": - // tentatively okay - read to make sure - case ".syso": - // binary, no reading - match = true - return - default: - // skip - return - } - - filename = ctxt.joinPath(dir, name) - f, err := ctxt.openFile(filename) - if err != nil { - return - } - - if strings.HasSuffix(filename, ".go") { - data, err = readImports(f, false, nil) - } else { - data, err = readComments(f) - } - f.Close() - if err != nil { - err = fmt.Errorf("read %s: %v", filename, err) - return - } - - // Look for +build comments to accept or reject the file. - if !ctxt.shouldBuild(data, allTags) && !ctxt.UseAllFiles { - return - } - - match = true - return -} - -func cleanImports(m map[string][]token.Position) ([]string, map[string][]token.Position) { - all := make([]string, 0, len(m)) - for path := range m { - all = append(all, path) - } - sort.Strings(all) - return all, m -} - -// Import is shorthand for Default.Import. -func Import(path, srcDir string, mode ImportMode) (*Package, error) { - return Default.Import(path, srcDir, mode) -} - -// ImportDir is shorthand for Default.ImportDir. -func ImportDir(dir string, mode ImportMode) (*Package, error) { - return Default.ImportDir(dir, mode) -} - -var slashslash = []byte("//") - -// shouldBuild reports whether it is okay to use this file, -// The rule is that in the file's leading run of // comments -// and blank lines, which must be followed by a blank line -// (to avoid including a Go package clause doc comment), -// lines beginning with '// +build' are taken as build directives. -// -// The file is accepted only if each such line lists something -// matching the file. For example: -// -// // +build windows linux -// -// marks the file as applicable only on Windows and Linux. -// -func (ctxt *Context) shouldBuild(content []byte, allTags map[string]bool) bool { - // Pass 1. Identify leading run of // comments and blank lines, - // which must be followed by a blank line. - end := 0 - p := content - for len(p) > 0 { - line := p - if i := bytes.IndexByte(line, '\n'); i >= 0 { - line, p = line[:i], p[i+1:] - } else { - p = p[len(p):] - } - line = bytes.TrimSpace(line) - if len(line) == 0 { // Blank line - end = len(content) - len(p) - continue - } - if !bytes.HasPrefix(line, slashslash) { // Not comment line - break - } - } - content = content[:end] - - // Pass 2. Process each line in the run. - p = content - allok := true - for len(p) > 0 { - line := p - if i := bytes.IndexByte(line, '\n'); i >= 0 { - line, p = line[:i], p[i+1:] - } else { - p = p[len(p):] - } - line = bytes.TrimSpace(line) - if bytes.HasPrefix(line, slashslash) { - line = bytes.TrimSpace(line[len(slashslash):]) - if len(line) > 0 && line[0] == '+' { - // Looks like a comment +line. - f := strings.Fields(string(line)) - if f[0] == "+build" { - ok := false - for _, tok := range f[1:] { - if ctxt.match(tok, allTags) { - ok = true - } - } - if !ok { - allok = false - } - } - } - } - } - - return allok -} - -// saveCgo saves the information from the #cgo lines in the import "C" comment. -// These lines set CFLAGS, CPPFLAGS, CXXFLAGS and LDFLAGS and pkg-config directives -// that affect the way cgo's C code is built. -func (ctxt *Context) saveCgo(filename string, di *Package, cg *ast.CommentGroup) error { - text := cg.Text() - for _, line := range strings.Split(text, "\n") { - orig := line - - // Line is - // #cgo [GOOS/GOARCH...] LDFLAGS: stuff - // - line = strings.TrimSpace(line) - if len(line) < 5 || line[:4] != "#cgo" || (line[4] != ' ' && line[4] != '\t') { - continue - } - - // Split at colon. - line = strings.TrimSpace(line[4:]) - i := strings.Index(line, ":") - if i < 0 { - return fmt.Errorf("%s: invalid #cgo line: %s", filename, orig) - } - line, argstr := line[:i], line[i+1:] - - // Parse GOOS/GOARCH stuff. - f := strings.Fields(line) - if len(f) < 1 { - return fmt.Errorf("%s: invalid #cgo line: %s", filename, orig) - } - - cond, verb := f[:len(f)-1], f[len(f)-1] - if len(cond) > 0 { - ok := false - for _, c := range cond { - if ctxt.match(c, nil) { - ok = true - break - } - } - if !ok { - continue - } - } - - args, err := splitQuoted(argstr) - if err != nil { - return fmt.Errorf("%s: invalid #cgo line: %s", filename, orig) - } - var ok bool - for i, arg := range args { - if arg, ok = expandSrcDir(arg, di.Dir); !ok { - return fmt.Errorf("%s: malformed #cgo argument: %s", filename, arg) - } - args[i] = arg - } - - switch verb { - case "CFLAGS": - di.CgoCFLAGS = append(di.CgoCFLAGS, args...) - case "CPPFLAGS": - di.CgoCPPFLAGS = append(di.CgoCPPFLAGS, args...) - case "CXXFLAGS": - di.CgoCXXFLAGS = append(di.CgoCXXFLAGS, args...) - case "LDFLAGS": - di.CgoLDFLAGS = append(di.CgoLDFLAGS, args...) - case "pkg-config": - di.CgoPkgConfig = append(di.CgoPkgConfig, args...) - default: - return fmt.Errorf("%s: invalid #cgo verb: %s", filename, orig) - } - } - return nil -} - -// expandSrcDir expands any occurrence of ${SRCDIR}, making sure -// the result is safe for the shell. -func expandSrcDir(str string, srcdir string) (string, bool) { - // "\" delimited paths cause safeCgoName to fail - // so convert native paths with a different delimeter - // to "/" before starting (eg: on windows). - srcdir = filepath.ToSlash(srcdir) - - // Spaces are tolerated in ${SRCDIR}, but not anywhere else. - chunks := strings.Split(str, "${SRCDIR}") - if len(chunks) < 2 { - return str, safeCgoName(str, false) - } - ok := true - for _, chunk := range chunks { - ok = ok && (chunk == "" || safeCgoName(chunk, false)) - } - ok = ok && (srcdir == "" || safeCgoName(srcdir, true)) - res := strings.Join(chunks, srcdir) - return res, ok && res != "" -} - -// NOTE: $ is not safe for the shell, but it is allowed here because of linker options like -Wl,$ORIGIN. -// We never pass these arguments to a shell (just to programs we construct argv for), so this should be okay. -// See golang.org/issue/6038. -// The @ is for OS X. See golang.org/issue/13720. -const safeString = "+-.,/0123456789=ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz:$@" -const safeSpaces = " " - -var safeBytes = []byte(safeSpaces + safeString) - -func safeCgoName(s string, spaces bool) bool { - if s == "" { - return false - } - safe := safeBytes - if !spaces { - safe = safe[len(safeSpaces):] - } - for i := 0; i < len(s); i++ { - if c := s[i]; c < 0x80 && bytes.IndexByte(safe, c) < 0 { - return false - } - } - return true -} - -// splitQuoted splits the string s around each instance of one or more consecutive -// white space characters while taking into account quotes and escaping, and -// returns an array of substrings of s or an empty list if s contains only white space. -// Single quotes and double quotes are recognized to prevent splitting within the -// quoted region, and are removed from the resulting substrings. If a quote in s -// isn't closed err will be set and r will have the unclosed argument as the -// last element. The backslash is used for escaping. -// -// For example, the following string: -// -// a b:"c d" 'e''f' "g\"" -// -// Would be parsed as: -// -// []string{"a", "b:c d", "ef", `g"`} -// -func splitQuoted(s string) (r []string, err error) { - var args []string - arg := make([]rune, len(s)) - escaped := false - quoted := false - quote := '\x00' - i := 0 - for _, rune := range s { - switch { - case escaped: - escaped = false - case rune == '\\': - escaped = true - continue - case quote != '\x00': - if rune == quote { - quote = '\x00' - continue - } - case rune == '"' || rune == '\'': - quoted = true - quote = rune - continue - case unicode.IsSpace(rune): - if quoted || i > 0 { - quoted = false - args = append(args, string(arg[:i])) - i = 0 - } - continue - } - arg[i] = rune - i++ - } - if quoted || i > 0 { - args = append(args, string(arg[:i])) - } - if quote != 0 { - err = errors.New("unclosed quote") - } else if escaped { - err = errors.New("unfinished escaping") - } - return args, err -} - -// match reports whether the name is one of: -// -// $GOOS -// $GOARCH -// cgo (if cgo is enabled) -// !cgo (if cgo is disabled) -// ctxt.Compiler -// !ctxt.Compiler -// tag (if tag is listed in ctxt.BuildTags or ctxt.ReleaseTags) -// !tag (if tag is not listed in ctxt.BuildTags or ctxt.ReleaseTags) -// a comma-separated list of any of these -// -func (ctxt *Context) match(name string, allTags map[string]bool) bool { - if name == "" { - if allTags != nil { - allTags[name] = true - } - return false - } - if i := strings.Index(name, ","); i >= 0 { - // comma-separated list - ok1 := ctxt.match(name[:i], allTags) - ok2 := ctxt.match(name[i+1:], allTags) - return ok1 && ok2 - } - if strings.HasPrefix(name, "!!") { // bad syntax, reject always - return false - } - if strings.HasPrefix(name, "!") { // negation - return len(name) > 1 && !ctxt.match(name[1:], allTags) - } - - if allTags != nil { - allTags[name] = true - } - - // Tags must be letters, digits, underscores or dots. - // Unlike in Go identifiers, all digits are fine (e.g., "386"). - for _, c := range name { - if !unicode.IsLetter(c) && !unicode.IsDigit(c) && c != '_' && c != '.' { - return false - } - } - - // special tags - if ctxt.CgoEnabled && name == "cgo" { - return true - } - if name == ctxt.GOOS || name == ctxt.GOARCH || name == ctxt.Compiler { - return true - } - if ctxt.GOOS == "android" && name == "linux" { - return true - } - - // other tags - for _, tag := range ctxt.BuildTags { - if tag == name { - return true - } - } - for _, tag := range ctxt.ReleaseTags { - if tag == name { - return true - } - } - - return false -} - -// goodOSArchFile returns false if the name contains a $GOOS or $GOARCH -// suffix which does not match the current system. -// The recognized name formats are: -// -// name_$(GOOS).* -// name_$(GOARCH).* -// name_$(GOOS)_$(GOARCH).* -// name_$(GOOS)_test.* -// name_$(GOARCH)_test.* -// name_$(GOOS)_$(GOARCH)_test.* -// -// An exception: if GOOS=android, then files with GOOS=linux are also matched. -func (ctxt *Context) goodOSArchFile(name string, allTags map[string]bool) bool { - if dot := strings.Index(name, "."); dot != -1 { - name = name[:dot] - } - - // Before Go 1.4, a file called "linux.go" would be equivalent to having a - // build tag "linux" in that file. For Go 1.4 and beyond, we require this - // auto-tagging to apply only to files with a non-empty prefix, so - // "foo_linux.go" is tagged but "linux.go" is not. This allows new operating - // systems, such as android, to arrive without breaking existing code with - // innocuous source code in "android.go". The easiest fix: cut everything - // in the name before the initial _. - i := strings.Index(name, "_") - if i < 0 { - return true - } - name = name[i:] // ignore everything before first _ - - l := strings.Split(name, "_") - if n := len(l); n > 0 && l[n-1] == "test" { - l = l[:n-1] - } - n := len(l) - if n >= 2 && knownOS[l[n-2]] && knownArch[l[n-1]] { - if allTags != nil { - allTags[l[n-2]] = true - allTags[l[n-1]] = true - } - if l[n-1] != ctxt.GOARCH { - return false - } - if ctxt.GOOS == "android" && l[n-2] == "linux" { - return true - } - return l[n-2] == ctxt.GOOS - } - if n >= 1 && knownOS[l[n-1]] { - if allTags != nil { - allTags[l[n-1]] = true - } - if ctxt.GOOS == "android" && l[n-1] == "linux" { - return true - } - return l[n-1] == ctxt.GOOS - } - if n >= 1 && knownArch[l[n-1]] { - if allTags != nil { - allTags[l[n-1]] = true - } - return l[n-1] == ctxt.GOARCH - } - return true -} - -var knownOS = make(map[string]bool) -var knownArch = make(map[string]bool) - -func init() { - for _, v := range strings.Fields(goosList) { - knownOS[v] = true - } - for _, v := range strings.Fields(goarchList) { - knownArch[v] = true - } -} - -// ToolDir is the directory containing build tools. -var ToolDir = filepath.Join(runtime.GOROOT(), "pkg/tool/"+runtime.GOOS+"_"+runtime.GOARCH) - -// IsLocalImport reports whether the import path is -// a local import path, like ".", "..", "./foo", or "../foo". -func IsLocalImport(path string) bool { - return path == "." || path == ".." || - strings.HasPrefix(path, "./") || strings.HasPrefix(path, "../") -} - -// ArchChar returns "?" and an error. -// In earlier versions of Go, the returned string was used to derive -// the compiler and linker tool names, the default object file suffix, -// and the default linker output name. As of Go 1.5, those strings -// no longer vary by architecture; they are compile, link, .o, and a.out, respectively. -func ArchChar(goarch string) (string, error) { - return "?", errors.New("architecture letter no longer used") -} diff --git a/third_party/golang/go/build/build_test.go b/third_party/golang/go/build/build_test.go deleted file mode 100644 index 7312af08b57b1..0000000000000 --- a/third_party/golang/go/build/build_test.go +++ /dev/null @@ -1,348 +0,0 @@ -// Copyright 2011 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package build - -import ( - "internal/testenv" - "io" - "os" - "path/filepath" - "reflect" - "runtime" - "strings" - "testing" -) - -func TestMatch(t *testing.T) { - ctxt := Default - what := "default" - match := func(tag string, want map[string]bool) { - m := make(map[string]bool) - if !ctxt.match(tag, m) { - t.Errorf("%s context should match %s, does not", what, tag) - } - if !reflect.DeepEqual(m, want) { - t.Errorf("%s tags = %v, want %v", tag, m, want) - } - } - nomatch := func(tag string, want map[string]bool) { - m := make(map[string]bool) - if ctxt.match(tag, m) { - t.Errorf("%s context should NOT match %s, does", what, tag) - } - if !reflect.DeepEqual(m, want) { - t.Errorf("%s tags = %v, want %v", tag, m, want) - } - } - - match(runtime.GOOS+","+runtime.GOARCH, map[string]bool{runtime.GOOS: true, runtime.GOARCH: true}) - match(runtime.GOOS+","+runtime.GOARCH+",!foo", map[string]bool{runtime.GOOS: true, runtime.GOARCH: true, "foo": true}) - nomatch(runtime.GOOS+","+runtime.GOARCH+",foo", map[string]bool{runtime.GOOS: true, runtime.GOARCH: true, "foo": true}) - - what = "modified" - ctxt.BuildTags = []string{"foo"} - match(runtime.GOOS+","+runtime.GOARCH, map[string]bool{runtime.GOOS: true, runtime.GOARCH: true}) - match(runtime.GOOS+","+runtime.GOARCH+",foo", map[string]bool{runtime.GOOS: true, runtime.GOARCH: true, "foo": true}) - nomatch(runtime.GOOS+","+runtime.GOARCH+",!foo", map[string]bool{runtime.GOOS: true, runtime.GOARCH: true, "foo": true}) - match(runtime.GOOS+","+runtime.GOARCH+",!bar", map[string]bool{runtime.GOOS: true, runtime.GOARCH: true, "bar": true}) - nomatch(runtime.GOOS+","+runtime.GOARCH+",bar", map[string]bool{runtime.GOOS: true, runtime.GOARCH: true, "bar": true}) - nomatch("!", map[string]bool{}) -} - -func TestDotSlashImport(t *testing.T) { - p, err := ImportDir("testdata/other", 0) - if err != nil { - t.Fatal(err) - } - if len(p.Imports) != 1 || p.Imports[0] != "./file" { - t.Fatalf("testdata/other: Imports=%v, want [./file]", p.Imports) - } - - p1, err := Import("./file", "testdata/other", 0) - if err != nil { - t.Fatal(err) - } - if p1.Name != "file" { - t.Fatalf("./file: Name=%q, want %q", p1.Name, "file") - } - dir := filepath.Clean("testdata/other/file") // Clean to use \ on Windows - if p1.Dir != dir { - t.Fatalf("./file: Dir=%q, want %q", p1.Name, dir) - } -} - -func TestEmptyImport(t *testing.T) { - p, err := Import("", Default.GOROOT, FindOnly) - if err == nil { - t.Fatal(`Import("") returned nil error.`) - } - if p == nil { - t.Fatal(`Import("") returned nil package.`) - } - if p.ImportPath != "" { - t.Fatalf("ImportPath=%q, want %q.", p.ImportPath, "") - } -} - -func TestEmptyFolderImport(t *testing.T) { - _, err := Import(".", "testdata/empty", 0) - if _, ok := err.(*NoGoError); !ok { - t.Fatal(`Import("testdata/empty") did not return NoGoError.`) - } -} - -func TestMultiplePackageImport(t *testing.T) { - _, err := Import(".", "testdata/multi", 0) - mpe, ok := err.(*MultiplePackageError) - if !ok { - t.Fatal(`Import("testdata/multi") did not return MultiplePackageError.`) - } - want := &MultiplePackageError{ - Dir: filepath.FromSlash("testdata/multi"), - Packages: []string{"main", "test_package"}, - Files: []string{"file.go", "file_appengine.go"}, - } - if !reflect.DeepEqual(mpe, want) { - t.Errorf("got %#v; want %#v", mpe, want) - } -} - -func TestLocalDirectory(t *testing.T) { - if runtime.GOOS == "darwin" { - switch runtime.GOARCH { - case "arm", "arm64": - t.Skipf("skipping on %s/%s, no valid GOROOT", runtime.GOOS, runtime.GOARCH) - } - } - - cwd, err := os.Getwd() - if err != nil { - t.Fatal(err) - } - - p, err := ImportDir(cwd, 0) - if err != nil { - t.Fatal(err) - } - if p.ImportPath != "go/build" { - t.Fatalf("ImportPath=%q, want %q", p.ImportPath, "go/build") - } -} - -func TestShouldBuild(t *testing.T) { - const file1 = "// +build tag1\n\n" + - "package main\n" - want1 := map[string]bool{"tag1": true} - - const file2 = "// +build cgo\n\n" + - "// This package implements parsing of tags like\n" + - "// +build tag1\n" + - "package build" - want2 := map[string]bool{"cgo": true} - - const file3 = "// Copyright The Go Authors.\n\n" + - "package build\n\n" + - "// shouldBuild checks tags given by lines of the form\n" + - "// +build tag\n" + - "func shouldBuild(content []byte)\n" - want3 := map[string]bool{} - - ctx := &Context{BuildTags: []string{"tag1"}} - m := map[string]bool{} - if !ctx.shouldBuild([]byte(file1), m) { - t.Errorf("shouldBuild(file1) = false, want true") - } - if !reflect.DeepEqual(m, want1) { - t.Errorf("shoudBuild(file1) tags = %v, want %v", m, want1) - } - - m = map[string]bool{} - if ctx.shouldBuild([]byte(file2), m) { - t.Errorf("shouldBuild(file2) = true, want fakse") - } - if !reflect.DeepEqual(m, want2) { - t.Errorf("shoudBuild(file2) tags = %v, want %v", m, want2) - } - - m = map[string]bool{} - ctx = &Context{BuildTags: nil} - if !ctx.shouldBuild([]byte(file3), m) { - t.Errorf("shouldBuild(file3) = false, want true") - } - if !reflect.DeepEqual(m, want3) { - t.Errorf("shoudBuild(file3) tags = %v, want %v", m, want3) - } -} - -type readNopCloser struct { - io.Reader -} - -func (r readNopCloser) Close() error { - return nil -} - -var ( - ctxtP9 = Context{GOARCH: "arm", GOOS: "plan9"} - ctxtAndroid = Context{GOARCH: "arm", GOOS: "android"} -) - -var matchFileTests = []struct { - ctxt Context - name string - data string - match bool -}{ - {ctxtP9, "foo_arm.go", "", true}, - {ctxtP9, "foo1_arm.go", "// +build linux\n\npackage main\n", false}, - {ctxtP9, "foo_darwin.go", "", false}, - {ctxtP9, "foo.go", "", true}, - {ctxtP9, "foo1.go", "// +build linux\n\npackage main\n", false}, - {ctxtP9, "foo.badsuffix", "", false}, - {ctxtAndroid, "foo_linux.go", "", true}, - {ctxtAndroid, "foo_android.go", "", true}, - {ctxtAndroid, "foo_plan9.go", "", false}, - {ctxtAndroid, "android.go", "", true}, - {ctxtAndroid, "plan9.go", "", true}, - {ctxtAndroid, "plan9_test.go", "", true}, - {ctxtAndroid, "arm.s", "", true}, - {ctxtAndroid, "amd64.s", "", true}, -} - -func TestMatchFile(t *testing.T) { - for _, tt := range matchFileTests { - ctxt := tt.ctxt - ctxt.OpenFile = func(path string) (r io.ReadCloser, err error) { - if path != "x+"+tt.name { - t.Fatalf("OpenFile asked for %q, expected %q", path, "x+"+tt.name) - } - return &readNopCloser{strings.NewReader(tt.data)}, nil - } - ctxt.JoinPath = func(elem ...string) string { - return strings.Join(elem, "+") - } - match, err := ctxt.MatchFile("x", tt.name) - if match != tt.match || err != nil { - t.Fatalf("MatchFile(%q) = %v, %v, want %v, nil", tt.name, match, err, tt.match) - } - } -} - -func TestImportCmd(t *testing.T) { - if runtime.GOOS == "darwin" { - switch runtime.GOARCH { - case "arm", "arm64": - t.Skipf("skipping on %s/%s, no valid GOROOT", runtime.GOOS, runtime.GOARCH) - } - } - - p, err := Import("cmd/internal/objfile", "", 0) - if err != nil { - t.Fatal(err) - } - if !strings.HasSuffix(filepath.ToSlash(p.Dir), "src/cmd/internal/objfile") { - t.Fatalf("Import cmd/internal/objfile returned Dir=%q, want %q", filepath.ToSlash(p.Dir), ".../src/cmd/internal/objfile") - } -} - -var ( - expandSrcDirPath = filepath.Join(string(filepath.Separator)+"projects", "src", "add") -) - -var expandSrcDirTests = []struct { - input, expected string -}{ - {"-L ${SRCDIR}/libs -ladd", "-L /projects/src/add/libs -ladd"}, - {"${SRCDIR}/add_linux_386.a -pthread -lstdc++", "/projects/src/add/add_linux_386.a -pthread -lstdc++"}, - {"Nothing to expand here!", "Nothing to expand here!"}, - {"$", "$"}, - {"$$", "$$"}, - {"${", "${"}, - {"$}", "$}"}, - {"$FOO ${BAR}", "$FOO ${BAR}"}, - {"Find me the $SRCDIRECTORY.", "Find me the $SRCDIRECTORY."}, - {"$SRCDIR is missing braces", "$SRCDIR is missing braces"}, -} - -func TestExpandSrcDir(t *testing.T) { - for _, test := range expandSrcDirTests { - output, _ := expandSrcDir(test.input, expandSrcDirPath) - if output != test.expected { - t.Errorf("%q expands to %q with SRCDIR=%q when %q is expected", test.input, output, expandSrcDirPath, test.expected) - } else { - t.Logf("%q expands to %q with SRCDIR=%q", test.input, output, expandSrcDirPath) - } - } -} - -func TestShellSafety(t *testing.T) { - tests := []struct { - input, srcdir, expected string - result bool - }{ - {"-I${SRCDIR}/../include", "/projects/src/issue 11868", "-I/projects/src/issue 11868/../include", true}, - {"-X${SRCDIR}/1,${SRCDIR}/2", "/projects/src/issue 11868", "-X/projects/src/issue 11868/1,/projects/src/issue 11868/2", true}, - {"-I/tmp -I/tmp", "/tmp2", "-I/tmp -I/tmp", false}, - {"-I/tmp", "/tmp/[0]", "-I/tmp", true}, - {"-I${SRCDIR}/dir", "/tmp/[0]", "-I/tmp/[0]/dir", false}, - } - for _, test := range tests { - output, ok := expandSrcDir(test.input, test.srcdir) - if ok != test.result { - t.Errorf("Expected %t while %q expands to %q with SRCDIR=%q; got %t", test.result, test.input, output, test.srcdir, ok) - } - if output != test.expected { - t.Errorf("Expected %q while %q expands with SRCDIR=%q; got %q", test.expected, test.input, test.srcdir, output) - } - } -} - -func TestImportVendor(t *testing.T) { - t.Skip("skipping; hpack has moved to internal for now; golang.org/issue/14047") - testenv.MustHaveGoBuild(t) // really must just have source - ctxt := Default - ctxt.GOPATH = "" - p, err := ctxt.Import("golang.org/x/net/http2/hpack", filepath.Join(ctxt.GOROOT, "src/net/http"), 0) - if err != nil { - t.Fatalf("cannot find vendored golang.org/x/net/http2/hpack from net/http directory: %v", err) - } - want := "vendor/golang.org/x/net/http2/hpack" - if p.ImportPath != want { - t.Fatalf("Import succeeded but found %q, want %q", p.ImportPath, want) - } -} - -func TestImportVendorFailure(t *testing.T) { - testenv.MustHaveGoBuild(t) // really must just have source - ctxt := Default - ctxt.GOPATH = "" - p, err := ctxt.Import("x.com/y/z", filepath.Join(ctxt.GOROOT, "src/net/http"), 0) - if err == nil { - t.Fatalf("found made-up package x.com/y/z in %s", p.Dir) - } - - e := err.Error() - if !strings.Contains(e, " (vendor tree)") { - t.Fatalf("error on failed import does not mention GOROOT/src/vendor directory:\n%s", e) - } -} - -func TestImportVendorParentFailure(t *testing.T) { - testenv.MustHaveGoBuild(t) // really must just have source - ctxt := Default - ctxt.GOPATH = "" - // This import should fail because the vendor/golang.org/x/net/http2 directory has no source code. - p, err := ctxt.Import("golang.org/x/net/http2", filepath.Join(ctxt.GOROOT, "src/net/http"), 0) - if err == nil { - t.Fatalf("found empty parent in %s", p.Dir) - } - if p != nil && p.Dir != "" { - t.Fatalf("decided to use %s", p.Dir) - } - e := err.Error() - if !strings.Contains(e, " (vendor tree)") { - t.Fatalf("error on failed import does not mention GOROOT/src/vendor directory:\n%s", e) - } -} diff --git a/third_party/golang/go/build/deps_test.go b/third_party/golang/go/build/deps_test.go deleted file mode 100644 index 1e6be2f746933..0000000000000 --- a/third_party/golang/go/build/deps_test.go +++ /dev/null @@ -1,525 +0,0 @@ -// Copyright 2012 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// This file exercises the import parser but also checks that -// some low-level packages do not have new dependencies added. - -package build - -import ( - "bytes" - "fmt" - "io/ioutil" - "os" - "path/filepath" - "runtime" - "sort" - "strconv" - "strings" - "testing" -) - -// pkgDeps defines the expected dependencies between packages in -// the Go source tree. It is a statement of policy. -// Changes should not be made to this map without prior discussion. -// -// The map contains two kinds of entries: -// 1) Lower-case keys are standard import paths and list the -// allowed imports in that package. -// 2) Upper-case keys define aliases for package sets, which can then -// be used as dependencies by other rules. -// -// DO NOT CHANGE THIS DATA TO FIX BUILDS. -// -var pkgDeps = map[string][]string{ - // L0 is the lowest level, core, nearly unavoidable packages. - "errors": {}, - "io": {"errors", "sync"}, - "runtime": {"unsafe", "runtime/internal/atomic", "runtime/internal/sys"}, - "runtime/internal/sys": {}, - "runtime/internal/atomic": {"unsafe", "runtime/internal/sys"}, - "internal/race": {"runtime", "unsafe"}, - "sync": {"internal/race", "runtime", "sync/atomic", "unsafe"}, - "sync/atomic": {"unsafe"}, - "unsafe": {}, - - "L0": { - "errors", - "io", - "runtime", - "runtime/internal/atomic", - "sync", - "sync/atomic", - "unsafe", - }, - - // L1 adds simple functions and strings processing, - // but not Unicode tables. - "math": {"unsafe"}, - "math/cmplx": {"math"}, - "math/rand": {"L0", "math"}, - "sort": {}, - "strconv": {"L0", "unicode/utf8", "math"}, - "unicode/utf16": {}, - "unicode/utf8": {}, - - "L1": { - "L0", - "math", - "math/cmplx", - "math/rand", - "sort", - "strconv", - "unicode/utf16", - "unicode/utf8", - }, - - // L2 adds Unicode and strings processing. - "bufio": {"L0", "unicode/utf8", "bytes"}, - "bytes": {"L0", "unicode", "unicode/utf8"}, - "path": {"L0", "unicode/utf8", "strings"}, - "strings": {"L0", "unicode", "unicode/utf8"}, - "unicode": {}, - - "L2": { - "L1", - "bufio", - "bytes", - "path", - "strings", - "unicode", - }, - - // L3 adds reflection and some basic utility packages - // and interface definitions, but nothing that makes - // system calls. - "crypto": {"L2", "hash"}, // interfaces - "crypto/cipher": {"L2", "crypto/subtle"}, // interfaces - "crypto/subtle": {}, - "encoding/base32": {"L2"}, - "encoding/base64": {"L2"}, - "encoding/binary": {"L2", "reflect"}, - "hash": {"L2"}, // interfaces - "hash/adler32": {"L2", "hash"}, - "hash/crc32": {"L2", "hash"}, - "hash/crc64": {"L2", "hash"}, - "hash/fnv": {"L2", "hash"}, - "image": {"L2", "image/color"}, // interfaces - "image/color": {"L2"}, // interfaces - "image/color/palette": {"L2", "image/color"}, - "reflect": {"L2"}, - - "L3": { - "L2", - "crypto", - "crypto/cipher", - "crypto/subtle", - "encoding/base32", - "encoding/base64", - "encoding/binary", - "hash", - "hash/adler32", - "hash/crc32", - "hash/crc64", - "hash/fnv", - "image", - "image/color", - "image/color/palette", - "reflect", - }, - - // End of linear dependency definitions. - - // Operating system access. - "syscall": {"L0", "internal/race", "internal/syscall/windows/sysdll", "unicode/utf16"}, - "internal/syscall/unix": {"L0", "syscall"}, - "internal/syscall/windows": {"L0", "syscall", "internal/syscall/windows/sysdll"}, - "internal/syscall/windows/registry": {"L0", "syscall", "internal/syscall/windows/sysdll", "unicode/utf16"}, - "time": {"L0", "syscall", "internal/syscall/windows/registry"}, - "os": {"L1", "os", "syscall", "time", "internal/syscall/windows"}, - "path/filepath": {"L2", "os", "syscall"}, - "io/ioutil": {"L2", "os", "path/filepath", "time"}, - "os/exec": {"L2", "os", "path/filepath", "syscall"}, - "os/signal": {"L2", "os", "syscall"}, - - // OS enables basic operating system functionality, - // but not direct use of package syscall, nor os/signal. - "OS": { - "io/ioutil", - "os", - "os/exec", - "path/filepath", - "time", - }, - - // Formatted I/O: few dependencies (L1) but we must add reflect. - "fmt": {"L1", "os", "reflect"}, - "log": {"L1", "os", "fmt", "time"}, - - // Packages used by testing must be low-level (L2+fmt). - "regexp": {"L2", "regexp/syntax"}, - "regexp/syntax": {"L2"}, - "runtime/debug": {"L2", "fmt", "io/ioutil", "os", "time"}, - "runtime/pprof": {"L2", "fmt", "text/tabwriter"}, - "runtime/trace": {"L0"}, - "text/tabwriter": {"L2"}, - - "testing": {"L2", "flag", "fmt", "os", "runtime/debug", "runtime/pprof", "runtime/trace", "time"}, - "testing/iotest": {"L2", "log"}, - "testing/quick": {"L2", "flag", "fmt", "reflect"}, - "internal/testenv": {"L2", "os", "testing"}, - - // L4 is defined as L3+fmt+log+time, because in general once - // you're using L3 packages, use of fmt, log, or time is not a big deal. - "L4": { - "L3", - "fmt", - "log", - "time", - }, - - // Go parser. - "go/ast": {"L4", "OS", "go/scanner", "go/token"}, - "go/doc": {"L4", "go/ast", "go/token", "regexp", "text/template"}, - "go/parser": {"L4", "OS", "go/ast", "go/scanner", "go/token"}, - "go/printer": {"L4", "OS", "go/ast", "go/scanner", "go/token", "text/tabwriter"}, - "go/scanner": {"L4", "OS", "go/token"}, - "go/token": {"L4"}, - - "GOPARSER": { - "go/ast", - "go/doc", - "go/parser", - "go/printer", - "go/scanner", - "go/token", - }, - - "go/format": {"L4", "GOPARSER", "internal/format"}, - "internal/format": {"L4", "GOPARSER"}, - - // Go type checking. - "go/constant": {"L4", "go/token", "math/big"}, - "go/importer": {"L4", "go/internal/gcimporter", "go/internal/gccgoimporter", "go/types"}, - "go/internal/gcimporter": {"L4", "OS", "go/build", "go/constant", "go/token", "go/types", "text/scanner"}, - "go/internal/gccgoimporter": {"L4", "OS", "debug/elf", "go/constant", "go/token", "go/types", "text/scanner"}, - "go/types": {"L4", "GOPARSER", "container/heap", "go/constant"}, - - // One of a kind. - "archive/tar": {"L4", "OS", "syscall"}, - "archive/zip": {"L4", "OS", "compress/flate"}, - "container/heap": {"sort"}, - "compress/bzip2": {"L4"}, - "compress/flate": {"L4"}, - "compress/gzip": {"L4", "compress/flate"}, - "compress/lzw": {"L4"}, - "compress/zlib": {"L4", "compress/flate"}, - "database/sql": {"L4", "container/list", "database/sql/driver"}, - "database/sql/driver": {"L4", "time"}, - "debug/dwarf": {"L4"}, - "debug/elf": {"L4", "OS", "debug/dwarf", "compress/zlib"}, - "debug/gosym": {"L4"}, - "debug/macho": {"L4", "OS", "debug/dwarf"}, - "debug/pe": {"L4", "OS", "debug/dwarf"}, - "debug/plan9obj": {"L4", "OS"}, - "encoding": {"L4"}, - "encoding/ascii85": {"L4"}, - "encoding/asn1": {"L4", "math/big"}, - "encoding/csv": {"L4"}, - "encoding/gob": {"L4", "OS", "encoding"}, - "encoding/hex": {"L4"}, - "encoding/json": {"L4", "encoding"}, - "encoding/pem": {"L4"}, - "encoding/xml": {"L4", "encoding"}, - "flag": {"L4", "OS"}, - "go/build": {"L4", "OS", "GOPARSER"}, - "html": {"L4"}, - "image/draw": {"L4", "image/internal/imageutil"}, - "image/gif": {"L4", "compress/lzw", "image/color/palette", "image/draw"}, - "image/internal/imageutil": {"L4"}, - "image/jpeg": {"L4", "image/internal/imageutil"}, - "image/png": {"L4", "compress/zlib"}, - "index/suffixarray": {"L4", "regexp"}, - "internal/singleflight": {"sync"}, - "internal/trace": {"L4", "OS"}, - "math/big": {"L4"}, - "mime": {"L4", "OS", "syscall", "internal/syscall/windows/registry"}, - "mime/quotedprintable": {"L4"}, - "net/internal/socktest": {"L4", "OS", "syscall"}, - "net/url": {"L4"}, - "text/scanner": {"L4", "OS"}, - "text/template/parse": {"L4"}, - - "html/template": { - "L4", "OS", "encoding/json", "html", "text/template", - "text/template/parse", - }, - "text/template": { - "L4", "OS", "net/url", "text/template/parse", - }, - - // Cgo. - // If you add a dependency on CGO, you must add the package to - // cgoPackages in cmd/dist/test.go. - "runtime/cgo": {"L0", "C"}, - "CGO": {"C", "runtime/cgo"}, - - // Fake entry to satisfy the pseudo-import "C" - // that shows up in programs that use cgo. - "C": {}, - - // Race detector/MSan uses cgo. - "runtime/race": {"C"}, - "runtime/msan": {"C"}, - - // Plan 9 alone needs io/ioutil and os. - "os/user": {"L4", "CGO", "io/ioutil", "os", "syscall"}, - - // Basic networking. - // Because net must be used by any package that wants to - // do networking portably, it must have a small dependency set: just L0+basic os. - "net": {"L0", "CGO", "math/rand", "os", "sort", "syscall", "time", "internal/syscall/windows", "internal/singleflight", "internal/race"}, - - // NET enables use of basic network-related packages. - "NET": { - "net", - "mime", - "net/textproto", - "net/url", - }, - - // Uses of networking. - "log/syslog": {"L4", "OS", "net"}, - "net/mail": {"L4", "NET", "OS", "mime"}, - "net/textproto": {"L4", "OS", "net"}, - - // Core crypto. - "crypto/aes": {"L3"}, - "crypto/des": {"L3"}, - "crypto/hmac": {"L3"}, - "crypto/md5": {"L3"}, - "crypto/rc4": {"L3"}, - "crypto/sha1": {"L3"}, - "crypto/sha256": {"L3"}, - "crypto/sha512": {"L3"}, - - "CRYPTO": { - "crypto/aes", - "crypto/des", - "crypto/hmac", - "crypto/md5", - "crypto/rc4", - "crypto/sha1", - "crypto/sha256", - "crypto/sha512", - }, - - // Random byte, number generation. - // This would be part of core crypto except that it imports - // math/big, which imports fmt. - "crypto/rand": {"L4", "CRYPTO", "OS", "math/big", "syscall", "internal/syscall/unix"}, - - // Mathematical crypto: dependencies on fmt (L4) and math/big. - // We could avoid some of the fmt, but math/big imports fmt anyway. - "crypto/dsa": {"L4", "CRYPTO", "math/big"}, - "crypto/ecdsa": {"L4", "CRYPTO", "crypto/elliptic", "math/big", "encoding/asn1"}, - "crypto/elliptic": {"L4", "CRYPTO", "math/big"}, - "crypto/rsa": {"L4", "CRYPTO", "crypto/rand", "math/big"}, - - "CRYPTO-MATH": { - "CRYPTO", - "crypto/dsa", - "crypto/ecdsa", - "crypto/elliptic", - "crypto/rand", - "crypto/rsa", - "encoding/asn1", - "math/big", - }, - - // SSL/TLS. - "crypto/tls": { - "L4", "CRYPTO-MATH", "OS", - "container/list", "crypto/x509", "encoding/pem", "net", "syscall", - }, - "crypto/x509": { - "L4", "CRYPTO-MATH", "OS", "CGO", - "crypto/x509/pkix", "encoding/pem", "encoding/hex", "net", "syscall", - }, - "crypto/x509/pkix": {"L4", "CRYPTO-MATH"}, - - // Simple net+crypto-aware packages. - "mime/multipart": {"L4", "OS", "mime", "crypto/rand", "net/textproto", "mime/quotedprintable"}, - "net/smtp": {"L4", "CRYPTO", "NET", "crypto/tls"}, - - // HTTP, kingpin of dependencies. - "net/http": { - "L4", "NET", "OS", - "compress/gzip", "crypto/tls", "mime/multipart", "runtime/debug", - "net/http/internal", - "internal/golang.org/x/net/http2/hpack", - }, - "net/http/internal": {"L4"}, - - // HTTP-using packages. - "expvar": {"L4", "OS", "encoding/json", "net/http"}, - "net/http/cgi": {"L4", "NET", "OS", "crypto/tls", "net/http", "regexp"}, - "net/http/cookiejar": {"L4", "NET", "net/http"}, - "net/http/fcgi": {"L4", "NET", "OS", "net/http", "net/http/cgi"}, - "net/http/httptest": {"L4", "NET", "OS", "crypto/tls", "flag", "net/http", "net/http/internal"}, - "net/http/httputil": {"L4", "NET", "OS", "net/http", "net/http/internal"}, - "net/http/pprof": {"L4", "OS", "html/template", "net/http", "runtime/pprof", "runtime/trace"}, - "net/rpc": {"L4", "NET", "encoding/gob", "html/template", "net/http"}, - "net/rpc/jsonrpc": {"L4", "NET", "encoding/json", "net/rpc"}, -} - -// isMacro reports whether p is a package dependency macro -// (uppercase name). -func isMacro(p string) bool { - return 'A' <= p[0] && p[0] <= 'Z' -} - -func allowed(pkg string) map[string]bool { - m := map[string]bool{} - var allow func(string) - allow = func(p string) { - if m[p] { - return - } - m[p] = true // set even for macros, to avoid loop on cycle - - // Upper-case names are macro-expanded. - if isMacro(p) { - for _, pp := range pkgDeps[p] { - allow(pp) - } - } - } - for _, pp := range pkgDeps[pkg] { - allow(pp) - } - return m -} - -var bools = []bool{false, true} -var geese = []string{"android", "darwin", "dragonfly", "freebsd", "linux", "nacl", "netbsd", "openbsd", "plan9", "solaris", "windows"} -var goarches = []string{"386", "amd64", "arm"} - -type osPkg struct { - goos, pkg string -} - -// allowedErrors are the operating systems and packages known to contain errors -// (currently just "no Go source files") -var allowedErrors = map[osPkg]bool{ - osPkg{"windows", "log/syslog"}: true, - osPkg{"plan9", "log/syslog"}: true, -} - -// listStdPkgs returns the same list of packages as "go list std". -func listStdPkgs(goroot string) ([]string, error) { - // Based on cmd/go's matchPackages function. - var pkgs []string - - src := filepath.Join(goroot, "src") + string(filepath.Separator) - walkFn := func(path string, fi os.FileInfo, err error) error { - if err != nil || !fi.IsDir() || path == src { - return nil - } - - base := filepath.Base(path) - if strings.HasPrefix(base, ".") || strings.HasPrefix(base, "_") || base == "testdata" { - return filepath.SkipDir - } - - name := filepath.ToSlash(path[len(src):]) - if name == "builtin" || name == "cmd" || strings.Contains(name, ".") { - return filepath.SkipDir - } - - pkgs = append(pkgs, name) - return nil - } - if err := filepath.Walk(src, walkFn); err != nil { - return nil, err - } - return pkgs, nil -} - -func TestDependencies(t *testing.T) { - iOS := runtime.GOOS == "darwin" && (runtime.GOARCH == "arm" || runtime.GOARCH == "arm64") - if runtime.GOOS == "nacl" || iOS { - // Tests run in a limited file system and we do not - // provide access to every source file. - t.Skipf("skipping on %s/%s, missing full GOROOT", runtime.GOOS, runtime.GOARCH) - } - - ctxt := Default - all, err := listStdPkgs(ctxt.GOROOT) - if err != nil { - t.Fatal(err) - } - sort.Strings(all) - - for _, pkg := range all { - imports, err := findImports(pkg) - if err != nil { - t.Error(err) - continue - } - ok := allowed(pkg) - var bad []string - for _, imp := range imports { - if !ok[imp] { - bad = append(bad, imp) - } - } - if bad != nil { - t.Errorf("unexpected dependency: %s imports %v", pkg, bad) - } - } -} - -var buildIgnore = []byte("\n// +build ignore") - -func findImports(pkg string) ([]string, error) { - dir := filepath.Join(Default.GOROOT, "src", pkg) - files, err := ioutil.ReadDir(dir) - if err != nil { - return nil, err - } - var imports []string - var haveImport = map[string]bool{} - for _, file := range files { - name := file.Name() - if !strings.HasSuffix(name, ".go") || strings.HasSuffix(name, "_test.go") { - continue - } - f, err := os.Open(filepath.Join(dir, name)) - if err != nil { - return nil, err - } - var imp []string - data, err := readImports(f, false, &imp) - f.Close() - if err != nil { - return nil, fmt.Errorf("reading %v: %v", name, err) - } - if bytes.Contains(data, buildIgnore) { - continue - } - for _, quoted := range imp { - path, err := strconv.Unquote(quoted) - if err != nil { - continue - } - if !haveImport[path] { - haveImport[path] = true - imports = append(imports, path) - } - } - } - sort.Strings(imports) - return imports, nil -} diff --git a/third_party/golang/go/build/doc.go b/third_party/golang/go/build/doc.go deleted file mode 100644 index d436d28b3172b..0000000000000 --- a/third_party/golang/go/build/doc.go +++ /dev/null @@ -1,141 +0,0 @@ -// Copyright 2011 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// Package build gathers information about Go packages. -// -// Go Path -// -// The Go path is a list of directory trees containing Go source code. -// It is consulted to resolve imports that cannot be found in the standard -// Go tree. The default path is the value of the GOPATH environment -// variable, interpreted as a path list appropriate to the operating system -// (on Unix, the variable is a colon-separated string; -// on Windows, a semicolon-separated string; -// on Plan 9, a list). -// -// Each directory listed in the Go path must have a prescribed structure: -// -// The src/ directory holds source code. The path below 'src' determines -// the import path or executable name. -// -// The pkg/ directory holds installed package objects. -// As in the Go tree, each target operating system and -// architecture pair has its own subdirectory of pkg -// (pkg/GOOS_GOARCH). -// -// If DIR is a directory listed in the Go path, a package with -// source in DIR/src/foo/bar can be imported as "foo/bar" and -// has its compiled form installed to "DIR/pkg/GOOS_GOARCH/foo/bar.a" -// (or, for gccgo, "DIR/pkg/gccgo/foo/libbar.a"). -// -// The bin/ directory holds compiled commands. -// Each command is named for its source directory, but only -// using the final element, not the entire path. That is, the -// command with source in DIR/src/foo/quux is installed into -// DIR/bin/quux, not DIR/bin/foo/quux. The foo/ is stripped -// so that you can add DIR/bin to your PATH to get at the -// installed commands. -// -// Here's an example directory layout: -// -// GOPATH=/home/user/gocode -// -// /home/user/gocode/ -// src/ -// foo/ -// bar/ (go code in package bar) -// x.go -// quux/ (go code in package main) -// y.go -// bin/ -// quux (installed command) -// pkg/ -// linux_amd64/ -// foo/ -// bar.a (installed package object) -// -// Build Constraints -// -// A build constraint, also known as a build tag, is a line comment that begins -// -// // +build -// -// that lists the conditions under which a file should be included in the package. -// Constraints may appear in any kind of source file (not just Go), but -// they must appear near the top of the file, preceded -// only by blank lines and other line comments. These rules mean that in Go -// files a build constraint must appear before the package clause. -// -// To distinguish build constraints from package documentation, a series of -// build constraints must be followed by a blank line. -// -// A build constraint is evaluated as the OR of space-separated options; -// each option evaluates as the AND of its comma-separated terms; -// and each term is an alphanumeric word or, preceded by !, its negation. -// That is, the build constraint: -// -// // +build linux,386 darwin,!cgo -// -// corresponds to the boolean formula: -// -// (linux AND 386) OR (darwin AND (NOT cgo)) -// -// A file may have multiple build constraints. The overall constraint is the AND -// of the individual constraints. That is, the build constraints: -// -// // +build linux darwin -// // +build 386 -// -// corresponds to the boolean formula: -// -// (linux OR darwin) AND 386 -// -// During a particular build, the following words are satisfied: -// -// - the target operating system, as spelled by runtime.GOOS -// - the target architecture, as spelled by runtime.GOARCH -// - the compiler being used, either "gc" or "gccgo" -// - "cgo", if ctxt.CgoEnabled is true -// - "go1.1", from Go version 1.1 onward -// - "go1.2", from Go version 1.2 onward -// - "go1.3", from Go version 1.3 onward -// - "go1.4", from Go version 1.4 onward -// - "go1.5", from Go version 1.5 onward -// - "go1.6", from Go version 1.6 onward -// - any additional words listed in ctxt.BuildTags -// -// If a file's name, after stripping the extension and a possible _test suffix, -// matches any of the following patterns: -// *_GOOS -// *_GOARCH -// *_GOOS_GOARCH -// (example: source_windows_amd64.go) where GOOS and GOARCH represent -// any known operating system and architecture values respectively, then -// the file is considered to have an implicit build constraint requiring -// those terms (in addition to any explicit constraints in the file). -// -// To keep a file from being considered for the build: -// -// // +build ignore -// -// (any other unsatisfied word will work as well, but ``ignore'' is conventional.) -// -// To build a file only when using cgo, and only on Linux and OS X: -// -// // +build linux,cgo darwin,cgo -// -// Such a file is usually paired with another file implementing the -// default functionality for other systems, which in this case would -// carry the constraint: -// -// // +build !linux,!darwin !cgo -// -// Naming a file dns_windows.go will cause it to be included only when -// building the package for Windows; similarly, math_386.s will be included -// only when building the package for 32-bit x86. -// -// Using GOOS=android matches build tags and files as for GOOS=linux -// in addition to android tags and files. -// -package build diff --git a/third_party/golang/go/build/read.go b/third_party/golang/go/build/read.go deleted file mode 100644 index 1049ac50d9475..0000000000000 --- a/third_party/golang/go/build/read.go +++ /dev/null @@ -1,246 +0,0 @@ -// Copyright 2012 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package build - -import ( - "bufio" - "errors" - "io" -) - -type importReader struct { - b *bufio.Reader - buf []byte - peek byte - err error - eof bool - nerr int -} - -func isIdent(c byte) bool { - return 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z' || '0' <= c && c <= '9' || c == '_' || c >= 0x80 -} - -var ( - errSyntax = errors.New("syntax error") - errNUL = errors.New("unexpected NUL in input") -) - -// syntaxError records a syntax error, but only if an I/O error has not already been recorded. -func (r *importReader) syntaxError() { - if r.err == nil { - r.err = errSyntax - } -} - -// readByte reads the next byte from the input, saves it in buf, and returns it. -// If an error occurs, readByte records the error in r.err and returns 0. -func (r *importReader) readByte() byte { - c, err := r.b.ReadByte() - if err == nil { - r.buf = append(r.buf, c) - if c == 0 { - err = errNUL - } - } - if err != nil { - if err == io.EOF { - r.eof = true - } else if r.err == nil { - r.err = err - } - c = 0 - } - return c -} - -// peekByte returns the next byte from the input reader but does not advance beyond it. -// If skipSpace is set, peekByte skips leading spaces and comments. -func (r *importReader) peekByte(skipSpace bool) byte { - if r.err != nil { - if r.nerr++; r.nerr > 10000 { - panic("go/build: import reader looping") - } - return 0 - } - - // Use r.peek as first input byte. - // Don't just return r.peek here: it might have been left by peekByte(false) - // and this might be peekByte(true). - c := r.peek - if c == 0 { - c = r.readByte() - } - for r.err == nil && !r.eof { - if skipSpace { - // For the purposes of this reader, semicolons are never necessary to - // understand the input and are treated as spaces. - switch c { - case ' ', '\f', '\t', '\r', '\n', ';': - c = r.readByte() - continue - - case '/': - c = r.readByte() - if c == '/' { - for c != '\n' && r.err == nil && !r.eof { - c = r.readByte() - } - } else if c == '*' { - var c1 byte - for (c != '*' || c1 != '/') && r.err == nil { - if r.eof { - r.syntaxError() - } - c, c1 = c1, r.readByte() - } - } else { - r.syntaxError() - } - c = r.readByte() - continue - } - } - break - } - r.peek = c - return r.peek -} - -// nextByte is like peekByte but advances beyond the returned byte. -func (r *importReader) nextByte(skipSpace bool) byte { - c := r.peekByte(skipSpace) - r.peek = 0 - return c -} - -// readKeyword reads the given keyword from the input. -// If the keyword is not present, readKeyword records a syntax error. -func (r *importReader) readKeyword(kw string) { - r.peekByte(true) - for i := 0; i < len(kw); i++ { - if r.nextByte(false) != kw[i] { - r.syntaxError() - return - } - } - if isIdent(r.peekByte(false)) { - r.syntaxError() - } -} - -// readIdent reads an identifier from the input. -// If an identifier is not present, readIdent records a syntax error. -func (r *importReader) readIdent() { - c := r.peekByte(true) - if !isIdent(c) { - r.syntaxError() - return - } - for isIdent(r.peekByte(false)) { - r.peek = 0 - } -} - -// readString reads a quoted string literal from the input. -// If an identifier is not present, readString records a syntax error. -func (r *importReader) readString(save *[]string) { - switch r.nextByte(true) { - case '`': - start := len(r.buf) - 1 - for r.err == nil { - if r.nextByte(false) == '`' { - if save != nil { - *save = append(*save, string(r.buf[start:])) - } - break - } - if r.eof { - r.syntaxError() - } - } - case '"': - start := len(r.buf) - 1 - for r.err == nil { - c := r.nextByte(false) - if c == '"' { - if save != nil { - *save = append(*save, string(r.buf[start:])) - } - break - } - if r.eof || c == '\n' { - r.syntaxError() - } - if c == '\\' { - r.nextByte(false) - } - } - default: - r.syntaxError() - } -} - -// readImport reads an import clause - optional identifier followed by quoted string - -// from the input. -func (r *importReader) readImport(imports *[]string) { - c := r.peekByte(true) - if c == '.' { - r.peek = 0 - } else if isIdent(c) { - r.readIdent() - } - r.readString(imports) -} - -// readComments is like ioutil.ReadAll, except that it only reads the leading -// block of comments in the file. -func readComments(f io.Reader) ([]byte, error) { - r := &importReader{b: bufio.NewReader(f)} - r.peekByte(true) - if r.err == nil && !r.eof { - // Didn't reach EOF, so must have found a non-space byte. Remove it. - r.buf = r.buf[:len(r.buf)-1] - } - return r.buf, r.err -} - -// readImports is like ioutil.ReadAll, except that it expects a Go file as input -// and stops reading the input once the imports have completed. -func readImports(f io.Reader, reportSyntaxError bool, imports *[]string) ([]byte, error) { - r := &importReader{b: bufio.NewReader(f)} - - r.readKeyword("package") - r.readIdent() - for r.peekByte(true) == 'i' { - r.readKeyword("import") - if r.peekByte(true) == '(' { - r.nextByte(false) - for r.peekByte(true) != ')' && r.err == nil { - r.readImport(imports) - } - r.nextByte(false) - } else { - r.readImport(imports) - } - } - - // If we stopped successfully before EOF, we read a byte that told us we were done. - // Return all but that last byte, which would cause a syntax error if we let it through. - if r.err == nil && !r.eof { - return r.buf[:len(r.buf)-1], nil - } - - // If we stopped for a syntax error, consume the whole file so that - // we are sure we don't change the errors that go/parser returns. - if r.err == errSyntax && !reportSyntaxError { - r.err = nil - for r.err == nil && !r.eof { - r.readByte() - } - } - - return r.buf, r.err -} diff --git a/third_party/golang/go/build/read_test.go b/third_party/golang/go/build/read_test.go deleted file mode 100644 index 326960bdc91d4..0000000000000 --- a/third_party/golang/go/build/read_test.go +++ /dev/null @@ -1,226 +0,0 @@ -// Copyright 2012 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package build - -import ( - "io" - "strings" - "testing" -) - -const quote = "`" - -type readTest struct { - // Test input contains ℙ where readImports should stop. - in string - err string -} - -var readImportsTests = []readTest{ - { - `package p`, - "", - }, - { - `package p; import "x"`, - "", - }, - { - `package p; import . "x"`, - "", - }, - { - `package p; import "x";ℙvar x = 1`, - "", - }, - { - `package p - - // comment - - import "x" - import _ "x" - import a "x" - - /* comment */ - - import ( - "x" /* comment */ - _ "x" - a "x" // comment - ` + quote + `x` + quote + ` - _ /*comment*/ ` + quote + `x` + quote + ` - a ` + quote + `x` + quote + ` - ) - import ( - ) - import () - import()import()import() - import();import();import() - - ℙvar x = 1 - `, - "", - }, -} - -var readCommentsTests = []readTest{ - { - `ℙpackage p`, - "", - }, - { - `ℙpackage p; import "x"`, - "", - }, - { - `ℙpackage p; import . "x"`, - "", - }, - { - `// foo - - /* bar */ - - /* quux */ // baz - - /*/ zot */ - - // asdf - ℙHello, world`, - "", - }, -} - -func testRead(t *testing.T, tests []readTest, read func(io.Reader) ([]byte, error)) { - for i, tt := range tests { - var in, testOut string - j := strings.Index(tt.in, "ℙ") - if j < 0 { - in = tt.in - testOut = tt.in - } else { - in = tt.in[:j] + tt.in[j+len("ℙ"):] - testOut = tt.in[:j] - } - r := strings.NewReader(in) - buf, err := read(r) - if err != nil { - if tt.err == "" { - t.Errorf("#%d: err=%q, expected success (%q)", i, err, string(buf)) - continue - } - if !strings.Contains(err.Error(), tt.err) { - t.Errorf("#%d: err=%q, expected %q", i, err, tt.err) - continue - } - continue - } - if err == nil && tt.err != "" { - t.Errorf("#%d: success, expected %q", i, tt.err) - continue - } - - out := string(buf) - if out != testOut { - t.Errorf("#%d: wrong output:\nhave %q\nwant %q\n", i, out, testOut) - } - } -} - -func TestReadImports(t *testing.T) { - testRead(t, readImportsTests, func(r io.Reader) ([]byte, error) { return readImports(r, true, nil) }) -} - -func TestReadComments(t *testing.T) { - testRead(t, readCommentsTests, readComments) -} - -var readFailuresTests = []readTest{ - { - `package`, - "syntax error", - }, - { - "package p\n\x00\nimport `math`\n", - "unexpected NUL in input", - }, - { - `package p; import`, - "syntax error", - }, - { - `package p; import "`, - "syntax error", - }, - { - "package p; import ` \n\n", - "syntax error", - }, - { - `package p; import "x`, - "syntax error", - }, - { - `package p; import _`, - "syntax error", - }, - { - `package p; import _ "`, - "syntax error", - }, - { - `package p; import _ "x`, - "syntax error", - }, - { - `package p; import .`, - "syntax error", - }, - { - `package p; import . "`, - "syntax error", - }, - { - `package p; import . "x`, - "syntax error", - }, - { - `package p; import (`, - "syntax error", - }, - { - `package p; import ("`, - "syntax error", - }, - { - `package p; import ("x`, - "syntax error", - }, - { - `package p; import ("x"`, - "syntax error", - }, -} - -func TestReadFailures(t *testing.T) { - // Errors should be reported (true arg to readImports). - testRead(t, readFailuresTests, func(r io.Reader) ([]byte, error) { return readImports(r, true, nil) }) -} - -func TestReadFailuresIgnored(t *testing.T) { - // Syntax errors should not be reported (false arg to readImports). - // Instead, entire file should be the output and no error. - // Convert tests not to return syntax errors. - tests := make([]readTest, len(readFailuresTests)) - copy(tests, readFailuresTests) - for i := range tests { - tt := &tests[i] - if !strings.Contains(tt.err, "NUL") { - tt.err = "" - } - } - testRead(t, tests, func(r io.Reader) ([]byte, error) { return readImports(r, false, nil) }) -} diff --git a/third_party/golang/go/build/syslist.go b/third_party/golang/go/build/syslist.go deleted file mode 100644 index 7adb0ca3d80e8..0000000000000 --- a/third_party/golang/go/build/syslist.go +++ /dev/null @@ -1,8 +0,0 @@ -// Copyright 2011 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package build - -const goosList = "android darwin dragonfly freebsd linux nacl netbsd openbsd plan9 solaris windows " -const goarchList = "386 amd64 amd64p32 arm armbe arm64 arm64be ppc64 ppc64le mips mipsle mips64 mips64le mips64p32 mips64p32le ppc s390 s390x sparc sparc64 " diff --git a/third_party/golang/go/build/syslist_test.go b/third_party/golang/go/build/syslist_test.go deleted file mode 100644 index 3be2928f5253b..0000000000000 --- a/third_party/golang/go/build/syslist_test.go +++ /dev/null @@ -1,62 +0,0 @@ -// Copyright 2011 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package build - -import ( - "runtime" - "testing" -) - -var ( - thisOS = runtime.GOOS - thisArch = runtime.GOARCH - otherOS = anotherOS() - otherArch = anotherArch() -) - -func anotherOS() string { - if thisOS != "darwin" { - return "darwin" - } - return "linux" -} - -func anotherArch() string { - if thisArch != "amd64" { - return "amd64" - } - return "386" -} - -type GoodFileTest struct { - name string - result bool -} - -var tests = []GoodFileTest{ - {"file.go", true}, - {"file.c", true}, - {"file_foo.go", true}, - {"file_" + thisArch + ".go", true}, - {"file_" + otherArch + ".go", false}, - {"file_" + thisOS + ".go", true}, - {"file_" + otherOS + ".go", false}, - {"file_" + thisOS + "_" + thisArch + ".go", true}, - {"file_" + otherOS + "_" + thisArch + ".go", false}, - {"file_" + thisOS + "_" + otherArch + ".go", false}, - {"file_" + otherOS + "_" + otherArch + ".go", false}, - {"file_foo_" + thisArch + ".go", true}, - {"file_foo_" + otherArch + ".go", false}, - {"file_" + thisOS + ".c", true}, - {"file_" + otherOS + ".c", false}, -} - -func TestGoodOSArch(t *testing.T) { - for _, test := range tests { - if Default.goodOSArchFile(test.name, make(map[string]bool)) != test.result { - t.Fatalf("goodOSArchFile(%q) != %v", test.name, test.result) - } - } -} diff --git a/third_party/golang/go/build/testdata/empty/dummy b/third_party/golang/go/build/testdata/empty/dummy deleted file mode 100644 index e69de29bb2d1d..0000000000000 diff --git a/third_party/golang/go/build/testdata/multi/file.go b/third_party/golang/go/build/testdata/multi/file.go deleted file mode 100644 index ee946eb2a2d74..0000000000000 --- a/third_party/golang/go/build/testdata/multi/file.go +++ /dev/null @@ -1,5 +0,0 @@ -// Test data - not compiled. - -package main - -func main() {} diff --git a/third_party/golang/go/build/testdata/multi/file_appengine.go b/third_party/golang/go/build/testdata/multi/file_appengine.go deleted file mode 100644 index 4ea31e7031ebd..0000000000000 --- a/third_party/golang/go/build/testdata/multi/file_appengine.go +++ /dev/null @@ -1,5 +0,0 @@ -// Test data - not compiled. - -package test_package - -func init() {} diff --git a/third_party/golang/go/build/testdata/other/file/file.go b/third_party/golang/go/build/testdata/other/file/file.go deleted file mode 100644 index bbfd3e9e59887..0000000000000 --- a/third_party/golang/go/build/testdata/other/file/file.go +++ /dev/null @@ -1,5 +0,0 @@ -// Test data - not compiled. - -package file - -func F() {} diff --git a/third_party/golang/go/build/testdata/other/main.go b/third_party/golang/go/build/testdata/other/main.go deleted file mode 100644 index e0904357c926d..0000000000000 --- a/third_party/golang/go/build/testdata/other/main.go +++ /dev/null @@ -1,11 +0,0 @@ -// Test data - not compiled. - -package main - -import ( - "./file" -) - -func main() { - file.F() -} diff --git a/third_party/golang/go/constant/go13.go b/third_party/golang/go/constant/go13.go deleted file mode 100644 index a4a838a290834..0000000000000 --- a/third_party/golang/go/constant/go13.go +++ /dev/null @@ -1,24 +0,0 @@ -// Copyright 2014 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// +build !go1.4 - -package constant - -import ( - "math" - "math/big" -) - -func ratToFloat32(x *big.Rat) (float32, bool) { - // Before 1.4, there's no Rat.Float32. - // Emulate it, albeit at the cost of - // imprecision in corner cases. - x64, exact := x.Float64() - x32 := float32(x64) - if math.IsInf(float64(x32), 0) { - exact = false - } - return x32, exact -} diff --git a/third_party/golang/go/constant/go14.go b/third_party/golang/go/constant/go14.go deleted file mode 100644 index 2ab6da02f6704..0000000000000 --- a/third_party/golang/go/constant/go14.go +++ /dev/null @@ -1,13 +0,0 @@ -// Copyright 2014 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// +build go1.4 - -package constant - -import "math/big" - -func ratToFloat32(x *big.Rat) (float32, bool) { - return x.Float32() -} diff --git a/third_party/golang/go/constant/value.go b/third_party/golang/go/constant/value.go deleted file mode 100644 index 5d24eebef8b28..0000000000000 --- a/third_party/golang/go/constant/value.go +++ /dev/null @@ -1,925 +0,0 @@ -// Copyright 2013 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// Package constant implements Values representing untyped -// Go constants and the corresponding operations. Values -// and operations may have arbitrary or unlimited precision. -// -// A special Unknown value may be used when a value -// is unknown due to an error. Operations on unknown -// values produce unknown values unless specified -// otherwise. -// -package constant - -import ( - "fmt" - "k8s.io/kubernetes/third_party/golang/go/token" - "math/big" - "strconv" -) - -// Kind specifies the kind of value represented by a Value. -type Kind int - -// Implementation note: Kinds must be enumerated in -// order of increasing "complexity" (used by match). - -const ( - // unknown values - Unknown Kind = iota - - // non-numeric values - Bool - String - - // numeric values - Int - Float - Complex -) - -// A Value represents a mathematically exact value of a given Kind. -type Value interface { - // Kind returns the value kind; it is always the smallest - // kind in which the value can be represented exactly. - Kind() Kind - - // String returns a human-readable form of the value. - String() string - - // Prevent external implementations. - implementsValue() -} - -// ---------------------------------------------------------------------------- -// Implementations - -type ( - unknownVal struct{} - boolVal bool - stringVal string - int64Val int64 - intVal struct{ val *big.Int } - floatVal struct{ val *big.Rat } - complexVal struct{ re, im *big.Rat } -) - -func (unknownVal) Kind() Kind { return Unknown } -func (boolVal) Kind() Kind { return Bool } -func (stringVal) Kind() Kind { return String } -func (int64Val) Kind() Kind { return Int } -func (intVal) Kind() Kind { return Int } -func (floatVal) Kind() Kind { return Float } -func (complexVal) Kind() Kind { return Complex } - -func (unknownVal) String() string { return "unknown" } -func (x boolVal) String() string { return fmt.Sprintf("%v", bool(x)) } -func (x stringVal) String() string { return strconv.Quote(string(x)) } -func (x int64Val) String() string { return strconv.FormatInt(int64(x), 10) } -func (x intVal) String() string { return x.val.String() } -func (x floatVal) String() string { return x.val.String() } -func (x complexVal) String() string { return fmt.Sprintf("(%s + %si)", x.re, x.im) } - -func (unknownVal) implementsValue() {} -func (boolVal) implementsValue() {} -func (stringVal) implementsValue() {} -func (int64Val) implementsValue() {} -func (intVal) implementsValue() {} -func (floatVal) implementsValue() {} -func (complexVal) implementsValue() {} - -// int64 bounds -var ( - minInt64 = big.NewInt(-1 << 63) - maxInt64 = big.NewInt(1<<63 - 1) -) - -func normInt(x *big.Int) Value { - if minInt64.Cmp(x) <= 0 && x.Cmp(maxInt64) <= 0 { - return int64Val(x.Int64()) - } - return intVal{x} -} - -func normFloat(x *big.Rat) Value { - if x.IsInt() { - return normInt(x.Num()) - } - return floatVal{x} -} - -func normComplex(re, im *big.Rat) Value { - if im.Sign() == 0 { - return normFloat(re) - } - return complexVal{re, im} -} - -// ---------------------------------------------------------------------------- -// Factories - -// MakeUnknown returns the Unknown value. -func MakeUnknown() Value { return unknownVal{} } - -// MakeBool returns the Bool value for x. -func MakeBool(b bool) Value { return boolVal(b) } - -// MakeString returns the String value for x. -func MakeString(s string) Value { return stringVal(s) } - -// MakeInt64 returns the Int value for x. -func MakeInt64(x int64) Value { return int64Val(x) } - -// MakeUint64 returns the Int value for x. -func MakeUint64(x uint64) Value { return normInt(new(big.Int).SetUint64(x)) } - -// MakeFloat64 returns the numeric value for x. -// If x is not finite, the result is unknown. -func MakeFloat64(x float64) Value { - if f := new(big.Rat).SetFloat64(x); f != nil { - return normFloat(f) - } - return unknownVal{} -} - -// MakeFromLiteral returns the corresponding integer, floating-point, -// imaginary, character, or string value for a Go literal string. -// If prec > 0, prec specifies an upper limit for the precision of -// a numeric value. If the literal string is invalid, the result is -// nil. -// BUG(gri) Only prec == 0 is supported at the moment. -func MakeFromLiteral(lit string, tok token.Token, prec uint) Value { - if prec != 0 { - panic("limited precision not supported") - } - switch tok { - case token.INT: - if x, err := strconv.ParseInt(lit, 0, 64); err == nil { - return int64Val(x) - } - if x, ok := new(big.Int).SetString(lit, 0); ok { - return intVal{x} - } - - case token.FLOAT: - if x, ok := new(big.Rat).SetString(lit); ok { - return normFloat(x) - } - - case token.IMAG: - if n := len(lit); n > 0 && lit[n-1] == 'i' { - if im, ok := new(big.Rat).SetString(lit[0 : n-1]); ok { - return normComplex(big.NewRat(0, 1), im) - } - } - - case token.CHAR: - if n := len(lit); n >= 2 { - if code, _, _, err := strconv.UnquoteChar(lit[1:n-1], '\''); err == nil { - return int64Val(code) - } - } - - case token.STRING: - if s, err := strconv.Unquote(lit); err == nil { - return stringVal(s) - } - } - - return nil -} - -// ---------------------------------------------------------------------------- -// Accessors -// -// For unknown arguments the result is the zero value for the respective -// accessor type, except for Sign, where the result is 1. - -// BoolVal returns the Go boolean value of x, which must be a Bool or an Unknown. -// If x is Unknown, the result is false. -func BoolVal(x Value) bool { - switch x := x.(type) { - case boolVal: - return bool(x) - case unknownVal: - return false - } - panic(fmt.Sprintf("%v not a Bool", x)) -} - -// StringVal returns the Go string value of x, which must be a String or an Unknown. -// If x is Unknown, the result is "". -func StringVal(x Value) string { - switch x := x.(type) { - case stringVal: - return string(x) - case unknownVal: - return "" - } - panic(fmt.Sprintf("%v not a String", x)) -} - -// Int64Val returns the Go int64 value of x and whether the result is exact; -// x must be an Int or an Unknown. If the result is not exact, its value is undefined. -// If x is Unknown, the result is (0, false). -func Int64Val(x Value) (int64, bool) { - switch x := x.(type) { - case int64Val: - return int64(x), true - case intVal: - return x.val.Int64(), x.val.BitLen() <= 63 - case unknownVal: - return 0, false - } - panic(fmt.Sprintf("%v not an Int", x)) -} - -// Uint64Val returns the Go uint64 value of x and whether the result is exact; -// x must be an Int or an Unknown. If the result is not exact, its value is undefined. -// If x is Unknown, the result is (0, false). -func Uint64Val(x Value) (uint64, bool) { - switch x := x.(type) { - case int64Val: - return uint64(x), x >= 0 - case intVal: - return x.val.Uint64(), x.val.Sign() >= 0 && x.val.BitLen() <= 64 - case unknownVal: - return 0, false - } - panic(fmt.Sprintf("%v not an Int", x)) -} - -// Float32Val is like Float64Val but for float32 instead of float64. -func Float32Val(x Value) (float32, bool) { - switch x := x.(type) { - case int64Val: - f := float32(x) - return f, int64Val(f) == x - case intVal: - return ratToFloat32(new(big.Rat).SetFrac(x.val, int1)) - case floatVal: - return ratToFloat32(x.val) - case unknownVal: - return 0, false - } - panic(fmt.Sprintf("%v not a Float", x)) -} - -// Float64Val returns the nearest Go float64 value of x and whether the result is exact; -// x must be numeric but not Complex, or Unknown. For values too small (too close to 0) -// to represent as float64, Float64Val silently underflows to 0. The result sign always -// matches the sign of x, even for 0. -// If x is Unknown, the result is (0, false). -func Float64Val(x Value) (float64, bool) { - switch x := x.(type) { - case int64Val: - f := float64(int64(x)) - return f, int64Val(f) == x - case intVal: - return new(big.Rat).SetFrac(x.val, int1).Float64() - case floatVal: - return x.val.Float64() - case unknownVal: - return 0, false - } - panic(fmt.Sprintf("%v not a Float", x)) -} - -// BitLen returns the number of bits required to represent -// the absolute value x in binary representation; x must be an Int or an Unknown. -// If x is Unknown, the result is 0. -func BitLen(x Value) int { - switch x := x.(type) { - case int64Val: - return new(big.Int).SetInt64(int64(x)).BitLen() - case intVal: - return x.val.BitLen() - case unknownVal: - return 0 - } - panic(fmt.Sprintf("%v not an Int", x)) -} - -// Sign returns -1, 0, or 1 depending on whether x < 0, x == 0, or x > 0; -// x must be numeric or Unknown. For complex values x, the sign is 0 if x == 0, -// otherwise it is != 0. If x is Unknown, the result is 1. -func Sign(x Value) int { - switch x := x.(type) { - case int64Val: - switch { - case x < 0: - return -1 - case x > 0: - return 1 - } - return 0 - case intVal: - return x.val.Sign() - case floatVal: - return x.val.Sign() - case complexVal: - return x.re.Sign() | x.im.Sign() - case unknownVal: - return 1 // avoid spurious division by zero errors - } - panic(fmt.Sprintf("%v not numeric", x)) -} - -// ---------------------------------------------------------------------------- -// Support for serializing/deserializing integers - -const ( - // Compute the size of a Word in bytes. - _m = ^big.Word(0) - _log = _m>>8&1 + _m>>16&1 + _m>>32&1 - wordSize = 1 << _log -) - -// Bytes returns the bytes for the absolute value of x in little- -// endian binary representation; x must be an Int. -func Bytes(x Value) []byte { - var val *big.Int - switch x := x.(type) { - case int64Val: - val = new(big.Int).SetInt64(int64(x)) - case intVal: - val = x.val - default: - panic(fmt.Sprintf("%v not an Int", x)) - } - - words := val.Bits() - bytes := make([]byte, len(words)*wordSize) - - i := 0 - for _, w := range words { - for j := 0; j < wordSize; j++ { - bytes[i] = byte(w) - w >>= 8 - i++ - } - } - // remove leading 0's - for i > 0 && bytes[i-1] == 0 { - i-- - } - - return bytes[:i] -} - -// MakeFromBytes returns the Int value given the bytes of its little-endian -// binary representation. An empty byte slice argument represents 0. -func MakeFromBytes(bytes []byte) Value { - words := make([]big.Word, (len(bytes)+(wordSize-1))/wordSize) - - i := 0 - var w big.Word - var s uint - for _, b := range bytes { - w |= big.Word(b) << s - if s += 8; s == wordSize*8 { - words[i] = w - i++ - w = 0 - s = 0 - } - } - // store last word - if i < len(words) { - words[i] = w - i++ - } - // remove leading 0's - for i > 0 && words[i-1] == 0 { - i-- - } - - return normInt(new(big.Int).SetBits(words[:i])) -} - -// ---------------------------------------------------------------------------- -// Support for disassembling fractions - -// Num returns the numerator of x; x must be Int, Float, or Unknown. -// If x is Unknown, the result is Unknown, otherwise it is an Int -// with the same sign as x. -func Num(x Value) Value { - switch x := x.(type) { - case unknownVal, int64Val, intVal: - return x - case floatVal: - return normInt(x.val.Num()) - } - panic(fmt.Sprintf("%v not Int or Float", x)) -} - -// Denom returns the denominator of x; x must be Int, Float, or Unknown. -// If x is Unknown, the result is Unknown, otherwise it is an Int >= 1. -func Denom(x Value) Value { - switch x := x.(type) { - case unknownVal: - return x - case int64Val, intVal: - return int64Val(1) - case floatVal: - return normInt(x.val.Denom()) - } - panic(fmt.Sprintf("%v not Int or Float", x)) -} - -// ---------------------------------------------------------------------------- -// Support for assembling/disassembling complex numbers - -// MakeImag returns the numeric value x*i (possibly 0); -// x must be Int, Float, or Unknown. -// If x is Unknown, the result is Unknown. -func MakeImag(x Value) Value { - var im *big.Rat - switch x := x.(type) { - case unknownVal: - return x - case int64Val: - im = big.NewRat(int64(x), 1) - case intVal: - im = new(big.Rat).SetFrac(x.val, int1) - case floatVal: - im = x.val - default: - panic(fmt.Sprintf("%v not Int or Float", x)) - } - return normComplex(rat0, im) -} - -// Real returns the real part of x, which must be a numeric or unknown value. -// If x is Unknown, the result is Unknown. -func Real(x Value) Value { - switch x := x.(type) { - case unknownVal, int64Val, intVal, floatVal: - return x - case complexVal: - return normFloat(x.re) - } - panic(fmt.Sprintf("%v not numeric", x)) -} - -// Imag returns the imaginary part of x, which must be a numeric or unknown value. -// If x is Unknown, the result is Unknown. -func Imag(x Value) Value { - switch x := x.(type) { - case unknownVal: - return x - case int64Val, intVal, floatVal: - return int64Val(0) - case complexVal: - return normFloat(x.im) - } - panic(fmt.Sprintf("%v not numeric", x)) -} - -// ---------------------------------------------------------------------------- -// Operations - -// is32bit reports whether x can be represented using 32 bits. -func is32bit(x int64) bool { - const s = 32 - return -1<<(s-1) <= x && x <= 1<<(s-1)-1 -} - -// is63bit reports whether x can be represented using 63 bits. -func is63bit(x int64) bool { - const s = 63 - return -1<<(s-1) <= x && x <= 1<<(s-1)-1 -} - -// UnaryOp returns the result of the unary expression op y. -// The operation must be defined for the operand. -// If prec > 0 it specifies the ^ (xor) result size in bits. -// If y is Unknown, the result is Unknown. -// -func UnaryOp(op token.Token, y Value, prec uint) Value { - switch op { - case token.ADD: - switch y.(type) { - case unknownVal, int64Val, intVal, floatVal, complexVal: - return y - } - - case token.SUB: - switch y := y.(type) { - case unknownVal: - return y - case int64Val: - if z := -y; z != y { - return z // no overflow - } - return normInt(new(big.Int).Neg(big.NewInt(int64(y)))) - case intVal: - return normInt(new(big.Int).Neg(y.val)) - case floatVal: - return normFloat(new(big.Rat).Neg(y.val)) - case complexVal: - return normComplex(new(big.Rat).Neg(y.re), new(big.Rat).Neg(y.im)) - } - - case token.XOR: - var z big.Int - switch y := y.(type) { - case unknownVal: - return y - case int64Val: - z.Not(big.NewInt(int64(y))) - case intVal: - z.Not(y.val) - default: - goto Error - } - // For unsigned types, the result will be negative and - // thus "too large": We must limit the result precision - // to the type's precision. - if prec > 0 { - z.AndNot(&z, new(big.Int).Lsh(big.NewInt(-1), prec)) // z &^= (-1)< ord(y) { - y, x = match(y, x) - return x, y - } - // ord(x) <= ord(y) - - switch x := x.(type) { - case unknownVal: - return x, x - - case boolVal, stringVal, complexVal: - return x, y - - case int64Val: - switch y := y.(type) { - case int64Val: - return x, y - case intVal: - return intVal{big.NewInt(int64(x))}, y - case floatVal: - return floatVal{big.NewRat(int64(x), 1)}, y - case complexVal: - return complexVal{big.NewRat(int64(x), 1), rat0}, y - } - - case intVal: - switch y := y.(type) { - case intVal: - return x, y - case floatVal: - return floatVal{new(big.Rat).SetFrac(x.val, int1)}, y - case complexVal: - return complexVal{new(big.Rat).SetFrac(x.val, int1), rat0}, y - } - - case floatVal: - switch y := y.(type) { - case floatVal: - return x, y - case complexVal: - return complexVal{x.val, rat0}, y - } - } - - panic("unreachable") -} - -// BinaryOp returns the result of the binary expression x op y. -// The operation must be defined for the operands. If one of the -// operands is Unknown, the result is Unknown. -// To force integer division of Int operands, use op == token.QUO_ASSIGN -// instead of token.QUO; the result is guaranteed to be Int in this case. -// Division by zero leads to a run-time panic. -// -func BinaryOp(x Value, op token.Token, y Value) Value { - x, y = match(x, y) - - switch x := x.(type) { - case unknownVal: - return x - - case boolVal: - y := y.(boolVal) - switch op { - case token.LAND: - return x && y - case token.LOR: - return x || y - } - - case int64Val: - a := int64(x) - b := int64(y.(int64Val)) - var c int64 - switch op { - case token.ADD: - if !is63bit(a) || !is63bit(b) { - return normInt(new(big.Int).Add(big.NewInt(a), big.NewInt(b))) - } - c = a + b - case token.SUB: - if !is63bit(a) || !is63bit(b) { - return normInt(new(big.Int).Sub(big.NewInt(a), big.NewInt(b))) - } - c = a - b - case token.MUL: - if !is32bit(a) || !is32bit(b) { - return normInt(new(big.Int).Mul(big.NewInt(a), big.NewInt(b))) - } - c = a * b - case token.QUO: - return normFloat(new(big.Rat).SetFrac(big.NewInt(a), big.NewInt(b))) - case token.QUO_ASSIGN: // force integer division - c = a / b - case token.REM: - c = a % b - case token.AND: - c = a & b - case token.OR: - c = a | b - case token.XOR: - c = a ^ b - case token.AND_NOT: - c = a &^ b - default: - goto Error - } - return int64Val(c) - - case intVal: - a := x.val - b := y.(intVal).val - var c big.Int - switch op { - case token.ADD: - c.Add(a, b) - case token.SUB: - c.Sub(a, b) - case token.MUL: - c.Mul(a, b) - case token.QUO: - return normFloat(new(big.Rat).SetFrac(a, b)) - case token.QUO_ASSIGN: // force integer division - c.Quo(a, b) - case token.REM: - c.Rem(a, b) - case token.AND: - c.And(a, b) - case token.OR: - c.Or(a, b) - case token.XOR: - c.Xor(a, b) - case token.AND_NOT: - c.AndNot(a, b) - default: - goto Error - } - return normInt(&c) - - case floatVal: - a := x.val - b := y.(floatVal).val - var c big.Rat - switch op { - case token.ADD: - c.Add(a, b) - case token.SUB: - c.Sub(a, b) - case token.MUL: - c.Mul(a, b) - case token.QUO: - c.Quo(a, b) - default: - goto Error - } - return normFloat(&c) - - case complexVal: - y := y.(complexVal) - a, b := x.re, x.im - c, d := y.re, y.im - var re, im big.Rat - switch op { - case token.ADD: - // (a+c) + i(b+d) - re.Add(a, c) - im.Add(b, d) - case token.SUB: - // (a-c) + i(b-d) - re.Sub(a, c) - im.Sub(b, d) - case token.MUL: - // (ac-bd) + i(bc+ad) - var ac, bd, bc, ad big.Rat - ac.Mul(a, c) - bd.Mul(b, d) - bc.Mul(b, c) - ad.Mul(a, d) - re.Sub(&ac, &bd) - im.Add(&bc, &ad) - case token.QUO: - // (ac+bd)/s + i(bc-ad)/s, with s = cc + dd - var ac, bd, bc, ad, s, cc, dd big.Rat - ac.Mul(a, c) - bd.Mul(b, d) - bc.Mul(b, c) - ad.Mul(a, d) - cc.Mul(c, c) - dd.Mul(d, d) - s.Add(&cc, &dd) - re.Add(&ac, &bd) - re.Quo(&re, &s) - im.Sub(&bc, &ad) - im.Quo(&im, &s) - default: - goto Error - } - return normComplex(&re, &im) - - case stringVal: - if op == token.ADD { - return x + y.(stringVal) - } - } - -Error: - panic(fmt.Sprintf("invalid binary operation %v %s %v", x, op, y)) -} - -// Shift returns the result of the shift expression x op s -// with op == token.SHL or token.SHR (<< or >>). x must be -// an Int or an Unknown. If x is Unknown, the result is x. -// -func Shift(x Value, op token.Token, s uint) Value { - switch x := x.(type) { - case unknownVal: - return x - - case int64Val: - if s == 0 { - return x - } - switch op { - case token.SHL: - z := big.NewInt(int64(x)) - return normInt(z.Lsh(z, s)) - case token.SHR: - return x >> s - } - - case intVal: - if s == 0 { - return x - } - var z big.Int - switch op { - case token.SHL: - return normInt(z.Lsh(x.val, s)) - case token.SHR: - return normInt(z.Rsh(x.val, s)) - } - } - - panic(fmt.Sprintf("invalid shift %v %s %d", x, op, s)) -} - -func cmpZero(x int, op token.Token) bool { - switch op { - case token.EQL: - return x == 0 - case token.NEQ: - return x != 0 - case token.LSS: - return x < 0 - case token.LEQ: - return x <= 0 - case token.GTR: - return x > 0 - case token.GEQ: - return x >= 0 - } - panic("unreachable") -} - -// Compare returns the result of the comparison x op y. -// The comparison must be defined for the operands. -// If one of the operands is Unknown, the result is -// false. -// -func Compare(x Value, op token.Token, y Value) bool { - x, y = match(x, y) - - switch x := x.(type) { - case unknownVal: - return false - - case boolVal: - y := y.(boolVal) - switch op { - case token.EQL: - return x == y - case token.NEQ: - return x != y - } - - case int64Val: - y := y.(int64Val) - switch op { - case token.EQL: - return x == y - case token.NEQ: - return x != y - case token.LSS: - return x < y - case token.LEQ: - return x <= y - case token.GTR: - return x > y - case token.GEQ: - return x >= y - } - - case intVal: - return cmpZero(x.val.Cmp(y.(intVal).val), op) - - case floatVal: - return cmpZero(x.val.Cmp(y.(floatVal).val), op) - - case complexVal: - y := y.(complexVal) - re := x.re.Cmp(y.re) - im := x.im.Cmp(y.im) - switch op { - case token.EQL: - return re == 0 && im == 0 - case token.NEQ: - return re != 0 || im != 0 - } - - case stringVal: - y := y.(stringVal) - switch op { - case token.EQL: - return x == y - case token.NEQ: - return x != y - case token.LSS: - return x < y - case token.LEQ: - return x <= y - case token.GTR: - return x > y - case token.GEQ: - return x >= y - } - } - - panic(fmt.Sprintf("invalid comparison %v %s %v", x, op, y)) -} diff --git a/third_party/golang/go/constant/value_test.go b/third_party/golang/go/constant/value_test.go deleted file mode 100644 index d3fd47f99bbd9..0000000000000 --- a/third_party/golang/go/constant/value_test.go +++ /dev/null @@ -1,375 +0,0 @@ -// Copyright 2013 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package constant - -import ( - "k8s.io/kubernetes/third_party/golang/go/token" - "strings" - "testing" -) - -// TODO(gri) expand this test framework - -var opTests = []string{ - // unary operations - `+ 0 = 0`, - `+ ? = ?`, - `- 1 = -1`, - `- ? = ?`, - `^ 0 = -1`, - `^ ? = ?`, - - `! true = false`, - `! false = true`, - `! ? = ?`, - - // etc. - - // binary operations - `"" + "" = ""`, - `"foo" + "" = "foo"`, - `"" + "bar" = "bar"`, - `"foo" + "bar" = "foobar"`, - - `0 + 0 = 0`, - `0 + 0.1 = 0.1`, - `0 + 0.1i = 0.1i`, - `0.1 + 0.9 = 1`, - `1e100 + 1e100 = 2e100`, - `? + 0 = ?`, - `0 + ? = ?`, - - `0 - 0 = 0`, - `0 - 0.1 = -0.1`, - `0 - 0.1i = -0.1i`, - `1e100 - 1e100 = 0`, - `? - 0 = ?`, - `0 - ? = ?`, - - `0 * 0 = 0`, - `1 * 0.1 = 0.1`, - `1 * 0.1i = 0.1i`, - `1i * 1i = -1`, - `? * 0 = ?`, - `0 * ? = ?`, - - `0 / 0 = "division_by_zero"`, - `10 / 2 = 5`, - `5 / 3 = 5/3`, - `5i / 3i = 5/3`, - `? / 0 = ?`, - `0 / ? = ?`, - - `0 % 0 = "runtime_error:_integer_divide_by_zero"`, // TODO(gri) should be the same as for / - `10 % 3 = 1`, - `? % 0 = ?`, - `0 % ? = ?`, - - `0 & 0 = 0`, - `12345 & 0 = 0`, - `0xff & 0xf = 0xf`, - `? & 0 = ?`, - `0 & ? = ?`, - - `0 | 0 = 0`, - `12345 | 0 = 12345`, - `0xb | 0xa0 = 0xab`, - `? | 0 = ?`, - `0 | ? = ?`, - - `0 ^ 0 = 0`, - `1 ^ -1 = -2`, - `? ^ 0 = ?`, - `0 ^ ? = ?`, - - `0 &^ 0 = 0`, - `0xf &^ 1 = 0xe`, - `1 &^ 0xf = 0`, - // etc. - - // shifts - `0 << 0 = 0`, - `1 << 10 = 1024`, - `0 >> 0 = 0`, - `1024 >> 10 == 1`, - `? << 0 == ?`, - `? >> 10 == ?`, - // etc. - - // comparisons - `false == false = true`, - `false == true = false`, - `true == false = false`, - `true == true = true`, - - `false != false = false`, - `false != true = true`, - `true != false = true`, - `true != true = false`, - - `"foo" == "bar" = false`, - `"foo" != "bar" = true`, - `"foo" < "bar" = false`, - `"foo" <= "bar" = false`, - `"foo" > "bar" = true`, - `"foo" >= "bar" = true`, - - `0 == 0 = true`, - `0 != 0 = false`, - `0 < 10 = true`, - `10 <= 10 = true`, - `0 > 10 = false`, - `10 >= 10 = true`, - - `1/123456789 == 1/123456789 == true`, - `1/123456789 != 1/123456789 == false`, - `1/123456789 < 1/123456788 == true`, - `1/123456788 <= 1/123456789 == false`, - `0.11 > 0.11 = false`, - `0.11 >= 0.11 = true`, - - `? == 0 = false`, - `? != 0 = false`, - `? < 10 = false`, - `? <= 10 = false`, - `? > 10 = false`, - `? >= 10 = false`, - - `0 == ? = false`, - `0 != ? = false`, - `0 < ? = false`, - `10 <= ? = false`, - `0 > ? = false`, - `10 >= ? = false`, - - // etc. -} - -func TestOps(t *testing.T) { - for _, test := range opTests { - a := strings.Split(test, " ") - i := 0 // operator index - - var x, x0 Value - switch len(a) { - case 4: - // unary operation - case 5: - // binary operation - x, x0 = val(a[0]), val(a[0]) - i = 1 - default: - t.Errorf("invalid test case: %s", test) - continue - } - - op, ok := optab[a[i]] - if !ok { - panic("missing optab entry for " + a[i]) - } - - y, y0 := val(a[i+1]), val(a[i+1]) - - got := doOp(x, op, y) - want := val(a[i+3]) - if !eql(got, want) { - t.Errorf("%s: got %s; want %s", test, got, want) - } - if x0 != nil && !eql(x, x0) { - t.Errorf("%s: x changed to %s", test, x) - } - if !eql(y, y0) { - t.Errorf("%s: y changed to %s", test, y) - } - } -} - -func eql(x, y Value) bool { - _, ux := x.(unknownVal) - _, uy := y.(unknownVal) - if ux || uy { - return ux == uy - } - return Compare(x, token.EQL, y) -} - -// ---------------------------------------------------------------------------- -// Support functions - -func val(lit string) Value { - if len(lit) == 0 { - return MakeUnknown() - } - - switch lit { - case "?": - return MakeUnknown() - case "true": - return MakeBool(true) - case "false": - return MakeBool(false) - } - - tok := token.INT - switch first, last := lit[0], lit[len(lit)-1]; { - case first == '"' || first == '`': - tok = token.STRING - lit = strings.Replace(lit, "_", " ", -1) - case first == '\'': - tok = token.CHAR - case last == 'i': - tok = token.IMAG - default: - if !strings.HasPrefix(lit, "0x") && strings.ContainsAny(lit, "./Ee") { - tok = token.FLOAT - } - } - - return MakeFromLiteral(lit, tok, 0) -} - -var optab = map[string]token.Token{ - "!": token.NOT, - - "+": token.ADD, - "-": token.SUB, - "*": token.MUL, - "/": token.QUO, - "%": token.REM, - - "<<": token.SHL, - ">>": token.SHR, - - "&": token.AND, - "|": token.OR, - "^": token.XOR, - "&^": token.AND_NOT, - - "==": token.EQL, - "!=": token.NEQ, - "<": token.LSS, - "<=": token.LEQ, - ">": token.GTR, - ">=": token.GEQ, -} - -func panicHandler(v *Value) { - switch p := recover().(type) { - case nil: - // nothing to do - case string: - *v = MakeString(p) - case error: - *v = MakeString(p.Error()) - default: - panic(p) - } -} - -func doOp(x Value, op token.Token, y Value) (z Value) { - defer panicHandler(&z) - - if x == nil { - return UnaryOp(op, y, 0) - } - - switch op { - case token.EQL, token.NEQ, token.LSS, token.LEQ, token.GTR, token.GEQ: - return MakeBool(Compare(x, op, y)) - case token.SHL, token.SHR: - s, _ := Int64Val(y) - return Shift(x, op, uint(s)) - default: - return BinaryOp(x, op, y) - } -} - -// ---------------------------------------------------------------------------- -// Other tests - -var fracTests = []string{ - "0 0 1", - "1 1 1", - "-1 -1 1", - "1.2 6 5", - "-0.991 -991 1000", - "1e100 1e100 1", -} - -func TestFractions(t *testing.T) { - for _, test := range fracTests { - a := strings.Split(test, " ") - if len(a) != 3 { - t.Errorf("invalid test case: %s", test) - continue - } - - x := val(a[0]) - n := val(a[1]) - d := val(a[2]) - - if got := Num(x); !eql(got, n) { - t.Errorf("%s: got num = %s; want %s", test, got, n) - } - - if got := Denom(x); !eql(got, d) { - t.Errorf("%s: got denom = %s; want %s", test, got, d) - } - } -} - -var bytesTests = []string{ - "0", - "1", - "123456789", - "123456789012345678901234567890123456789012345678901234567890", -} - -func TestBytes(t *testing.T) { - for _, test := range bytesTests { - x := val(test) - bytes := Bytes(x) - - // special case 0 - if Sign(x) == 0 && len(bytes) != 0 { - t.Errorf("%s: got %v; want empty byte slice", test, bytes) - } - - if n := len(bytes); n > 0 && bytes[n-1] == 0 { - t.Errorf("%s: got %v; want no leading 0 byte", test, bytes) - } - - if got := MakeFromBytes(bytes); !eql(got, x) { - t.Errorf("%s: got %s; want %s (bytes = %v)", test, got, x, bytes) - } - } -} - -func TestUnknown(t *testing.T) { - u := MakeUnknown() - var values = []Value{ - u, - MakeBool(false), // token.ADD ok below, operation is never considered - MakeString(""), - MakeInt64(1), - MakeFromLiteral("-1234567890123456789012345678901234567890", token.INT, 0), - MakeFloat64(1.2), - MakeImag(MakeFloat64(1.2)), - } - for _, val := range values { - x, y := val, u - for i := range [2]int{} { - if i == 1 { - x, y = y, x - } - if got := BinaryOp(x, token.ADD, y); got.Kind() != Unknown { - t.Errorf("%s + %s: got %s; want %s", x, y, got, u) - } - if got := Compare(x, token.EQL, y); got { - t.Errorf("%s == %s: got true; want false", x, y) - } - } - } -} diff --git a/third_party/golang/go/doc/Makefile b/third_party/golang/go/doc/Makefile deleted file mode 100644 index ca4948f91c255..0000000000000 --- a/third_party/golang/go/doc/Makefile +++ /dev/null @@ -1,7 +0,0 @@ -# Copyright 2009 The Go Authors. All rights reserved. -# Use of this source code is governed by a BSD-style -# license that can be found in the LICENSE file. - -# Script to test heading detection heuristic -headscan: headscan.go - go build headscan.go diff --git a/third_party/golang/go/doc/comment.go b/third_party/golang/go/doc/comment.go deleted file mode 100644 index f414ca4090e27..0000000000000 --- a/third_party/golang/go/doc/comment.go +++ /dev/null @@ -1,480 +0,0 @@ -// Copyright 2009 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// Godoc comment extraction and comment -> HTML formatting. - -package doc - -import ( - "io" - "regexp" - "strings" - "text/template" // for HTMLEscape - "unicode" - "unicode/utf8" -) - -var ( - ldquo = []byte("“") - rdquo = []byte("”") -) - -// Escape comment text for HTML. If nice is set, -// also turn `` into “ and '' into ”. -func commentEscape(w io.Writer, text string, nice bool) { - last := 0 - if nice { - for i := 0; i < len(text)-1; i++ { - ch := text[i] - if ch == text[i+1] && (ch == '`' || ch == '\'') { - template.HTMLEscape(w, []byte(text[last:i])) - last = i + 2 - switch ch { - case '`': - w.Write(ldquo) - case '\'': - w.Write(rdquo) - } - i++ // loop will add one more - } - } - } - template.HTMLEscape(w, []byte(text[last:])) -} - -const ( - // Regexp for Go identifiers - identRx = `[\pL_][\pL_0-9]*` - - // Regexp for URLs - protocol = `https?|ftp|file|gopher|mailto|news|nntp|telnet|wais|prospero` - hostPart = `[a-zA-Z0-9_@\-]+` - filePart = `[a-zA-Z0-9_?%#~&/\-+=()]+` // parentheses may not be matching; see pairedParensPrefixLen - urlRx = `(` + protocol + `)://` + // http:// - hostPart + `([.:]` + hostPart + `)*/?` + // //www.google.com:8080/ - filePart + `([:.,]` + filePart + `)*` -) - -var matchRx = regexp.MustCompile(`(` + urlRx + `)|(` + identRx + `)`) - -var ( - html_a = []byte(``) - html_enda = []byte("") - html_i = []byte("") - html_endi = []byte("") - html_p = []byte("

\n") - html_endp = []byte("

\n") - html_pre = []byte("
")
-	html_endpre = []byte("
\n") - html_h = []byte(`

`) - html_endh = []byte("

\n") -) - -// pairedParensPrefixLen returns the length of the longest prefix of s containing paired parentheses. -func pairedParensPrefixLen(s string) int { - parens := 0 - l := len(s) - for i, ch := range s { - switch ch { - case '(': - if parens == 0 { - l = i - } - parens++ - case ')': - parens-- - if parens == 0 { - l = len(s) - } else if parens < 0 { - return i - } - } - } - return l -} - -// Emphasize and escape a line of text for HTML. URLs are converted into links; -// if the URL also appears in the words map, the link is taken from the map (if -// the corresponding map value is the empty string, the URL is not converted -// into a link). Go identifiers that appear in the words map are italicized; if -// the corresponding map value is not the empty string, it is considered a URL -// and the word is converted into a link. If nice is set, the remaining text's -// appearance is improved where it makes sense (e.g., `` is turned into “ -// and '' into ”). -func emphasize(w io.Writer, line string, words map[string]string, nice bool) { - for { - m := matchRx.FindStringSubmatchIndex(line) - if m == nil { - break - } - // m >= 6 (two parenthesized sub-regexps in matchRx, 1st one is urlRx) - - // write text before match - commentEscape(w, line[0:m[0]], nice) - - // adjust match if necessary - match := line[m[0]:m[1]] - if n := pairedParensPrefixLen(match); n < len(match) { - // match contains unpaired parentheses (rare); - // redo matching with shortened line for correct indices - m = matchRx.FindStringSubmatchIndex(line[:m[0]+n]) - match = match[:n] - } - - // analyze match - url := "" - italics := false - if words != nil { - url, italics = words[match] - } - if m[2] >= 0 { - // match against first parenthesized sub-regexp; must be match against urlRx - if !italics { - // no alternative URL in words list, use match instead - url = match - } - italics = false // don't italicize URLs - } - - // write match - if len(url) > 0 { - w.Write(html_a) - template.HTMLEscape(w, []byte(url)) - w.Write(html_aq) - } - if italics { - w.Write(html_i) - } - commentEscape(w, match, nice) - if italics { - w.Write(html_endi) - } - if len(url) > 0 { - w.Write(html_enda) - } - - // advance - line = line[m[1]:] - } - commentEscape(w, line, nice) -} - -func indentLen(s string) int { - i := 0 - for i < len(s) && (s[i] == ' ' || s[i] == '\t') { - i++ - } - return i -} - -func isBlank(s string) bool { - return len(s) == 0 || (len(s) == 1 && s[0] == '\n') -} - -func commonPrefix(a, b string) string { - i := 0 - for i < len(a) && i < len(b) && a[i] == b[i] { - i++ - } - return a[0:i] -} - -func unindent(block []string) { - if len(block) == 0 { - return - } - - // compute maximum common white prefix - prefix := block[0][0:indentLen(block[0])] - for _, line := range block { - if !isBlank(line) { - prefix = commonPrefix(prefix, line[0:indentLen(line)]) - } - } - n := len(prefix) - - // remove - for i, line := range block { - if !isBlank(line) { - block[i] = line[n:] - } - } -} - -// heading returns the trimmed line if it passes as a section heading; -// otherwise it returns the empty string. -func heading(line string) string { - line = strings.TrimSpace(line) - if len(line) == 0 { - return "" - } - - // a heading must start with an uppercase letter - r, _ := utf8.DecodeRuneInString(line) - if !unicode.IsLetter(r) || !unicode.IsUpper(r) { - return "" - } - - // it must end in a letter or digit: - r, _ = utf8.DecodeLastRuneInString(line) - if !unicode.IsLetter(r) && !unicode.IsDigit(r) { - return "" - } - - // exclude lines with illegal characters - if strings.IndexAny(line, ",.;:!?+*/=()[]{}_^°&§~%#@<\">\\") >= 0 { - return "" - } - - // allow "'" for possessive "'s" only - for b := line; ; { - i := strings.IndexRune(b, '\'') - if i < 0 { - break - } - if i+1 >= len(b) || b[i+1] != 's' || (i+2 < len(b) && b[i+2] != ' ') { - return "" // not followed by "s " - } - b = b[i+2:] - } - - return line -} - -type op int - -const ( - opPara op = iota - opHead - opPre -) - -type block struct { - op op - lines []string -} - -var nonAlphaNumRx = regexp.MustCompile(`[^a-zA-Z0-9]`) - -func anchorID(line string) string { - // Add a "hdr-" prefix to avoid conflicting with IDs used for package symbols. - return "hdr-" + nonAlphaNumRx.ReplaceAllString(line, "_") -} - -// ToHTML converts comment text to formatted HTML. -// The comment was prepared by DocReader, -// so it is known not to have leading, trailing blank lines -// nor to have trailing spaces at the end of lines. -// The comment markers have already been removed. -// -// Each span of unindented non-blank lines is converted into -// a single paragraph. There is one exception to the rule: a span that -// consists of a single line, is followed by another paragraph span, -// begins with a capital letter, and contains no punctuation -// is formatted as a heading. -// -// A span of indented lines is converted into a 
 block,
-// with the common indent prefix removed.
-//
-// URLs in the comment text are converted into links; if the URL also appears
-// in the words map, the link is taken from the map (if the corresponding map
-// value is the empty string, the URL is not converted into a link).
-//
-// Go identifiers that appear in the words map are italicized; if the corresponding
-// map value is not the empty string, it is considered a URL and the word is converted
-// into a link.
-func ToHTML(w io.Writer, text string, words map[string]string) {
-	for _, b := range blocks(text) {
-		switch b.op {
-		case opPara:
-			w.Write(html_p)
-			for _, line := range b.lines {
-				emphasize(w, line, words, true)
-			}
-			w.Write(html_endp)
-		case opHead:
-			w.Write(html_h)
-			id := ""
-			for _, line := range b.lines {
-				if id == "" {
-					id = anchorID(line)
-					w.Write([]byte(id))
-					w.Write(html_hq)
-				}
-				commentEscape(w, line, true)
-			}
-			if id == "" {
-				w.Write(html_hq)
-			}
-			w.Write(html_endh)
-		case opPre:
-			w.Write(html_pre)
-			for _, line := range b.lines {
-				emphasize(w, line, nil, false)
-			}
-			w.Write(html_endpre)
-		}
-	}
-}
-
-func blocks(text string) []block {
-	var (
-		out  []block
-		para []string
-
-		lastWasBlank   = false
-		lastWasHeading = false
-	)
-
-	close := func() {
-		if para != nil {
-			out = append(out, block{opPara, para})
-			para = nil
-		}
-	}
-
-	lines := strings.SplitAfter(text, "\n")
-	unindent(lines)
-	for i := 0; i < len(lines); {
-		line := lines[i]
-		if isBlank(line) {
-			// close paragraph
-			close()
-			i++
-			lastWasBlank = true
-			continue
-		}
-		if indentLen(line) > 0 {
-			// close paragraph
-			close()
-
-			// count indented or blank lines
-			j := i + 1
-			for j < len(lines) && (isBlank(lines[j]) || indentLen(lines[j]) > 0) {
-				j++
-			}
-			// but not trailing blank lines
-			for j > i && isBlank(lines[j-1]) {
-				j--
-			}
-			pre := lines[i:j]
-			i = j
-
-			unindent(pre)
-
-			// put those lines in a pre block
-			out = append(out, block{opPre, pre})
-			lastWasHeading = false
-			continue
-		}
-
-		if lastWasBlank && !lastWasHeading && i+2 < len(lines) &&
-			isBlank(lines[i+1]) && !isBlank(lines[i+2]) && indentLen(lines[i+2]) == 0 {
-			// current line is non-blank, surrounded by blank lines
-			// and the next non-blank line is not indented: this
-			// might be a heading.
-			if head := heading(line); head != "" {
-				close()
-				out = append(out, block{opHead, []string{head}})
-				i += 2
-				lastWasHeading = true
-				continue
-			}
-		}
-
-		// open paragraph
-		lastWasBlank = false
-		lastWasHeading = false
-		para = append(para, lines[i])
-		i++
-	}
-	close()
-
-	return out
-}
-
-// ToText prepares comment text for presentation in textual output.
-// It wraps paragraphs of text to width or fewer Unicode code points
-// and then prefixes each line with the indent.  In preformatted sections
-// (such as program text), it prefixes each non-blank line with preIndent.
-func ToText(w io.Writer, text string, indent, preIndent string, width int) {
-	l := lineWrapper{
-		out:    w,
-		width:  width,
-		indent: indent,
-	}
-	for _, b := range blocks(text) {
-		switch b.op {
-		case opPara:
-			// l.write will add leading newline if required
-			for _, line := range b.lines {
-				l.write(line)
-			}
-			l.flush()
-		case opHead:
-			w.Write(nl)
-			for _, line := range b.lines {
-				l.write(line + "\n")
-			}
-			l.flush()
-		case opPre:
-			w.Write(nl)
-			for _, line := range b.lines {
-				if isBlank(line) {
-					w.Write([]byte("\n"))
-				} else {
-					w.Write([]byte(preIndent))
-					w.Write([]byte(line))
-				}
-			}
-		}
-	}
-}
-
-type lineWrapper struct {
-	out       io.Writer
-	printed   bool
-	width     int
-	indent    string
-	n         int
-	pendSpace int
-}
-
-var nl = []byte("\n")
-var space = []byte(" ")
-
-func (l *lineWrapper) write(text string) {
-	if l.n == 0 && l.printed {
-		l.out.Write(nl) // blank line before new paragraph
-	}
-	l.printed = true
-
-	for _, f := range strings.Fields(text) {
-		w := utf8.RuneCountInString(f)
-		// wrap if line is too long
-		if l.n > 0 && l.n+l.pendSpace+w > l.width {
-			l.out.Write(nl)
-			l.n = 0
-			l.pendSpace = 0
-		}
-		if l.n == 0 {
-			l.out.Write([]byte(l.indent))
-		}
-		l.out.Write(space[:l.pendSpace])
-		l.out.Write([]byte(f))
-		l.n += l.pendSpace + w
-		l.pendSpace = 1
-	}
-}
-
-func (l *lineWrapper) flush() {
-	if l.n == 0 {
-		return
-	}
-	l.out.Write(nl)
-	l.pendSpace = 0
-	l.n = 0
-}
diff --git a/third_party/golang/go/doc/comment_test.go b/third_party/golang/go/doc/comment_test.go
deleted file mode 100644
index ad65c2a27f8a0..0000000000000
--- a/third_party/golang/go/doc/comment_test.go
+++ /dev/null
@@ -1,207 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package doc
-
-import (
-	"bytes"
-	"reflect"
-	"testing"
-)
-
-var headingTests = []struct {
-	line string
-	ok   bool
-}{
-	{"Section", true},
-	{"A typical usage", true},
-	{"ΔΛΞ is Greek", true},
-	{"Foo 42", true},
-	{"", false},
-	{"section", false},
-	{"A typical usage:", false},
-	{"This code:", false},
-	{"δ is Greek", false},
-	{"Foo §", false},
-	{"Fermat's Last Sentence", true},
-	{"Fermat's", true},
-	{"'sX", false},
-	{"Ted 'Too' Bar", false},
-	{"Use n+m", false},
-	{"Scanning:", false},
-	{"N:M", false},
-}
-
-func TestIsHeading(t *testing.T) {
-	for _, tt := range headingTests {
-		if h := heading(tt.line); (len(h) > 0) != tt.ok {
-			t.Errorf("isHeading(%q) = %v, want %v", tt.line, h, tt.ok)
-		}
-	}
-}
-
-var blocksTests = []struct {
-	in   string
-	out  []block
-	text string
-}{
-	{
-		in: `Para 1.
-Para 1 line 2.
-
-Para 2.
-
-Section
-
-Para 3.
-
-	pre
-	pre1
-
-Para 4.
-
-	pre
-	pre1
-
-	pre2
-
-Para 5.
-
-
-	pre
-
-
-	pre1
-	pre2
-
-Para 6.
-	pre
-	pre2
-`,
-		out: []block{
-			{opPara, []string{"Para 1.\n", "Para 1 line 2.\n"}},
-			{opPara, []string{"Para 2.\n"}},
-			{opHead, []string{"Section"}},
-			{opPara, []string{"Para 3.\n"}},
-			{opPre, []string{"pre\n", "pre1\n"}},
-			{opPara, []string{"Para 4.\n"}},
-			{opPre, []string{"pre\n", "pre1\n", "\n", "pre2\n"}},
-			{opPara, []string{"Para 5.\n"}},
-			{opPre, []string{"pre\n", "\n", "\n", "pre1\n", "pre2\n"}},
-			{opPara, []string{"Para 6.\n"}},
-			{opPre, []string{"pre\n", "pre2\n"}},
-		},
-		text: `.   Para 1. Para 1 line 2.
-
-.   Para 2.
-
-
-.   Section
-
-.   Para 3.
-
-$	pre
-$	pre1
-
-.   Para 4.
-
-$	pre
-$	pre1
-
-$	pre2
-
-.   Para 5.
-
-$	pre
-
-
-$	pre1
-$	pre2
-
-.   Para 6.
-
-$	pre
-$	pre2
-`,
-	},
-}
-
-func TestBlocks(t *testing.T) {
-	for i, tt := range blocksTests {
-		b := blocks(tt.in)
-		if !reflect.DeepEqual(b, tt.out) {
-			t.Errorf("#%d: mismatch\nhave: %v\nwant: %v", i, b, tt.out)
-		}
-	}
-}
-
-func TestToText(t *testing.T) {
-	var buf bytes.Buffer
-	for i, tt := range blocksTests {
-		ToText(&buf, tt.in, ".   ", "$\t", 40)
-		if have := buf.String(); have != tt.text {
-			t.Errorf("#%d: mismatch\nhave: %s\nwant: %s\nhave vs want:\n%q\n%q", i, have, tt.text, have, tt.text)
-		}
-		buf.Reset()
-	}
-}
-
-var emphasizeTests = []struct {
-	in, out string
-}{
-	{"http://www.google.com/", `http://www.google.com/`},
-	{"https://www.google.com/", `https://www.google.com/`},
-	{"http://www.google.com/path.", `http://www.google.com/path.`},
-	{"http://en.wikipedia.org/wiki/Camellia_(cipher)", `http://en.wikipedia.org/wiki/Camellia_(cipher)`},
-	{"(http://www.google.com/)", `(http://www.google.com/)`},
-	{"http://gmail.com)", `http://gmail.com)`},
-	{"((http://gmail.com))", `((http://gmail.com))`},
-	{"http://gmail.com ((http://gmail.com)) ()", `http://gmail.com ((http://gmail.com)) ()`},
-	{"Foo bar http://example.com/ quux!", `Foo bar http://example.com/ quux!`},
-	{"Hello http://example.com/%2f/ /world.", `Hello http://example.com/%2f/ /world.`},
-	{"Lorem http: ipsum //host/path", "Lorem http: ipsum //host/path"},
-	{"javascript://is/not/linked", "javascript://is/not/linked"},
-}
-
-func TestEmphasize(t *testing.T) {
-	for i, tt := range emphasizeTests {
-		var buf bytes.Buffer
-		emphasize(&buf, tt.in, nil, true)
-		out := buf.String()
-		if out != tt.out {
-			t.Errorf("#%d: mismatch\nhave: %v\nwant: %v", i, out, tt.out)
-		}
-	}
-}
-
-var pairedParensPrefixLenTests = []struct {
-	in, out string
-}{
-	{"", ""},
-	{"foo", "foo"},
-	{"()", "()"},
-	{"foo()", "foo()"},
-	{"foo()()()", "foo()()()"},
-	{"foo()((()()))", "foo()((()()))"},
-	{"foo()((()()))bar", "foo()((()()))bar"},
-	{"foo)", "foo"},
-	{"foo))", "foo"},
-	{"foo)))))", "foo"},
-	{"(foo", ""},
-	{"((foo", ""},
-	{"(((((foo", ""},
-	{"(foo)", "(foo)"},
-	{"((((foo))))", "((((foo))))"},
-	{"foo()())", "foo()()"},
-	{"foo((()())", "foo"},
-	{"foo((()())) (() foo ", "foo((()())) "},
-}
-
-func TestPairedParensPrefixLen(t *testing.T) {
-	for i, tt := range pairedParensPrefixLenTests {
-		if out := tt.in[:pairedParensPrefixLen(tt.in)]; out != tt.out {
-			t.Errorf("#%d: mismatch\nhave: %q\nwant: %q", i, out, tt.out)
-		}
-	}
-}
diff --git a/third_party/golang/go/doc/doc.go b/third_party/golang/go/doc/doc.go
deleted file mode 100644
index 009e637899fe1..0000000000000
--- a/third_party/golang/go/doc/doc.go
+++ /dev/null
@@ -1,112 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package doc extracts source code documentation from a Go AST.
-package doc
-
-import (
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-)
-
-// Package is the documentation for an entire package.
-type Package struct {
-	Doc        string
-	Name       string
-	ImportPath string
-	Imports    []string
-	Filenames  []string
-	Notes      map[string][]*Note
-
-	// Deprecated: For backward compatibility Bugs is still populated,
-	// but all new code should use Notes instead.
-	Bugs []string
-
-	// declarations
-	Consts []*Value
-	Types  []*Type
-	Vars   []*Value
-	Funcs  []*Func
-}
-
-// Value is the documentation for a (possibly grouped) var or const declaration.
-type Value struct {
-	Doc   string
-	Names []string // var or const names in declaration order
-	Decl  *ast.GenDecl
-
-	order int
-}
-
-// Type is the documentation for a type declaration.
-type Type struct {
-	Doc  string
-	Name string
-	Decl *ast.GenDecl
-
-	// associated declarations
-	Consts  []*Value // sorted list of constants of (mostly) this type
-	Vars    []*Value // sorted list of variables of (mostly) this type
-	Funcs   []*Func  // sorted list of functions returning this type
-	Methods []*Func  // sorted list of methods (including embedded ones) of this type
-}
-
-// Func is the documentation for a func declaration.
-type Func struct {
-	Doc  string
-	Name string
-	Decl *ast.FuncDecl
-
-	// methods
-	// (for functions, these fields have the respective zero value)
-	Recv  string // actual   receiver "T" or "*T"
-	Orig  string // original receiver "T" or "*T"
-	Level int    // embedding level; 0 means not embedded
-}
-
-// A Note represents a marked comment starting with "MARKER(uid): note body".
-// Any note with a marker of 2 or more upper case [A-Z] letters and a uid of
-// at least one character is recognized. The ":" following the uid is optional.
-// Notes are collected in the Package.Notes map indexed by the notes marker.
-type Note struct {
-	Pos, End token.Pos // position range of the comment containing the marker
-	UID      string    // uid found with the marker
-	Body     string    // note body text
-}
-
-// Mode values control the operation of New.
-type Mode int
-
-const (
-	// extract documentation for all package-level declarations,
-	// not just exported ones
-	AllDecls Mode = 1 << iota
-
-	// show all embedded methods, not just the ones of
-	// invisible (unexported) anonymous fields
-	AllMethods
-)
-
-// New computes the package documentation for the given package AST.
-// New takes ownership of the AST pkg and may edit or overwrite it.
-//
-func New(pkg *ast.Package, importPath string, mode Mode) *Package {
-	var r reader
-	r.readPackage(pkg, mode)
-	r.computeMethodSets()
-	r.cleanupTypes()
-	return &Package{
-		Doc:        r.doc,
-		Name:       pkg.Name,
-		ImportPath: importPath,
-		Imports:    sortedKeys(r.imports),
-		Filenames:  r.filenames,
-		Notes:      r.notes,
-		Bugs:       noteBodies(r.notes["BUG"]),
-		Consts:     sortedValues(r.values, token.CONST),
-		Types:      sortedTypes(r.types, mode&AllMethods != 0),
-		Vars:       sortedValues(r.values, token.VAR),
-		Funcs:      sortedFuncs(r.funcs, true),
-	}
-}
diff --git a/third_party/golang/go/doc/doc_test.go b/third_party/golang/go/doc/doc_test.go
deleted file mode 100644
index 2677c14faf698..0000000000000
--- a/third_party/golang/go/doc/doc_test.go
+++ /dev/null
@@ -1,147 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package doc
-
-import (
-	"bytes"
-	"flag"
-	"fmt"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"regexp"
-	"strings"
-	"testing"
-	"text/template"
-
-	"k8s.io/kubernetes/third_party/golang/go/parser"
-	"k8s.io/kubernetes/third_party/golang/go/printer"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-)
-
-var update = flag.Bool("update", false, "update golden (.out) files")
-var files = flag.String("files", "", "consider only Go test files matching this regular expression")
-
-const dataDir = "testdata"
-
-var templateTxt = readTemplate("template.txt")
-
-func readTemplate(filename string) *template.Template {
-	t := template.New(filename)
-	t.Funcs(template.FuncMap{
-		"node":     nodeFmt,
-		"synopsis": synopsisFmt,
-		"indent":   indentFmt,
-	})
-	return template.Must(t.ParseFiles(filepath.Join(dataDir, filename)))
-}
-
-func nodeFmt(node interface{}, fset *token.FileSet) string {
-	var buf bytes.Buffer
-	printer.Fprint(&buf, fset, node)
-	return strings.Replace(strings.TrimSpace(buf.String()), "\n", "\n\t", -1)
-}
-
-func synopsisFmt(s string) string {
-	const n = 64
-	if len(s) > n {
-		// cut off excess text and go back to a word boundary
-		s = s[0:n]
-		if i := strings.LastIndexAny(s, "\t\n "); i >= 0 {
-			s = s[0:i]
-		}
-		s = strings.TrimSpace(s) + " ..."
-	}
-	return "// " + strings.Replace(s, "\n", " ", -1)
-}
-
-func indentFmt(indent, s string) string {
-	end := ""
-	if strings.HasSuffix(s, "\n") {
-		end = "\n"
-		s = s[:len(s)-1]
-	}
-	return indent + strings.Replace(s, "\n", "\n"+indent, -1) + end
-}
-
-func isGoFile(fi os.FileInfo) bool {
-	name := fi.Name()
-	return !fi.IsDir() &&
-		len(name) > 0 && name[0] != '.' && // ignore .files
-		filepath.Ext(name) == ".go"
-}
-
-type bundle struct {
-	*Package
-	FSet *token.FileSet
-}
-
-func test(t *testing.T, mode Mode) {
-	// determine file filter
-	filter := isGoFile
-	if *files != "" {
-		rx, err := regexp.Compile(*files)
-		if err != nil {
-			t.Fatal(err)
-		}
-		filter = func(fi os.FileInfo) bool {
-			return isGoFile(fi) && rx.MatchString(fi.Name())
-		}
-	}
-
-	// get packages
-	fset := token.NewFileSet()
-	pkgs, err := parser.ParseDir(fset, dataDir, filter, parser.ParseComments)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// test packages
-	for _, pkg := range pkgs {
-		importpath := dataDir + "/" + pkg.Name
-		doc := New(pkg, importpath, mode)
-
-		// golden files always use / in filenames - canonicalize them
-		for i, filename := range doc.Filenames {
-			doc.Filenames[i] = filepath.ToSlash(filename)
-		}
-
-		// print documentation
-		var buf bytes.Buffer
-		if err := templateTxt.Execute(&buf, bundle{doc, fset}); err != nil {
-			t.Error(err)
-			continue
-		}
-		got := buf.Bytes()
-
-		// update golden file if necessary
-		golden := filepath.Join(dataDir, fmt.Sprintf("%s.%d.golden", pkg.Name, mode))
-		if *update {
-			err := ioutil.WriteFile(golden, got, 0644)
-			if err != nil {
-				t.Error(err)
-			}
-			continue
-		}
-
-		// get golden file
-		want, err := ioutil.ReadFile(golden)
-		if err != nil {
-			t.Error(err)
-			continue
-		}
-
-		// compare
-		if !bytes.Equal(got, want) {
-			t.Errorf("package %s\n\tgot:\n%s\n\twant:\n%s", pkg.Name, got, want)
-		}
-	}
-}
-
-func Test(t *testing.T) {
-	test(t, 0)
-	test(t, AllDecls)
-	test(t, AllMethods)
-}
diff --git a/third_party/golang/go/doc/example.go b/third_party/golang/go/doc/example.go
deleted file mode 100644
index 8c0c987295847..0000000000000
--- a/third_party/golang/go/doc/example.go
+++ /dev/null
@@ -1,355 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Extract example functions from file ASTs.
-
-package doc
-
-import (
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-	"path"
-	"regexp"
-	"sort"
-	"strconv"
-	"strings"
-	"unicode"
-	"unicode/utf8"
-)
-
-// An Example represents an example function found in a source files.
-type Example struct {
-	Name        string // name of the item being exemplified
-	Doc         string // example function doc string
-	Code        ast.Node
-	Play        *ast.File // a whole program version of the example
-	Comments    []*ast.CommentGroup
-	Output      string // expected output
-	EmptyOutput bool   // expect empty output
-	Order       int    // original source code order
-}
-
-// Examples returns the examples found in the files, sorted by Name field.
-// The Order fields record the order in which the examples were encountered.
-//
-// Playable Examples must be in a package whose name ends in "_test".
-// An Example is "playable" (the Play field is non-nil) in either of these
-// circumstances:
-//   - The example function is self-contained: the function references only
-//     identifiers from other packages (or predeclared identifiers, such as
-//     "int") and the test file does not include a dot import.
-//   - The entire test file is the example: the file contains exactly one
-//     example function, zero test or benchmark functions, and at least one
-//     top-level function, type, variable, or constant declaration other
-//     than the example function.
-func Examples(files ...*ast.File) []*Example {
-	var list []*Example
-	for _, file := range files {
-		hasTests := false // file contains tests or benchmarks
-		numDecl := 0      // number of non-import declarations in the file
-		var flist []*Example
-		for _, decl := range file.Decls {
-			if g, ok := decl.(*ast.GenDecl); ok && g.Tok != token.IMPORT {
-				numDecl++
-				continue
-			}
-			f, ok := decl.(*ast.FuncDecl)
-			if !ok {
-				continue
-			}
-			numDecl++
-			name := f.Name.Name
-			if isTest(name, "Test") || isTest(name, "Benchmark") {
-				hasTests = true
-				continue
-			}
-			if !isTest(name, "Example") {
-				continue
-			}
-			var doc string
-			if f.Doc != nil {
-				doc = f.Doc.Text()
-			}
-			output, hasOutput := exampleOutput(f.Body, file.Comments)
-			flist = append(flist, &Example{
-				Name:        name[len("Example"):],
-				Doc:         doc,
-				Code:        f.Body,
-				Play:        playExample(file, f.Body),
-				Comments:    file.Comments,
-				Output:      output,
-				EmptyOutput: output == "" && hasOutput,
-				Order:       len(flist),
-			})
-		}
-		if !hasTests && numDecl > 1 && len(flist) == 1 {
-			// If this file only has one example function, some
-			// other top-level declarations, and no tests or
-			// benchmarks, use the whole file as the example.
-			flist[0].Code = file
-			flist[0].Play = playExampleFile(file)
-		}
-		list = append(list, flist...)
-	}
-	sort.Sort(exampleByName(list))
-	return list
-}
-
-var outputPrefix = regexp.MustCompile(`(?i)^[[:space:]]*output:`)
-
-// Extracts the expected output and whether there was a valid output comment
-func exampleOutput(b *ast.BlockStmt, comments []*ast.CommentGroup) (output string, ok bool) {
-	if _, last := lastComment(b, comments); last != nil {
-		// test that it begins with the correct prefix
-		text := last.Text()
-		if loc := outputPrefix.FindStringIndex(text); loc != nil {
-			text = text[loc[1]:]
-			// Strip zero or more spaces followed by \n or a single space.
-			text = strings.TrimLeft(text, " ")
-			if len(text) > 0 && text[0] == '\n' {
-				text = text[1:]
-			}
-			return text, true
-		}
-	}
-	return "", false // no suitable comment found
-}
-
-// isTest tells whether name looks like a test, example, or benchmark.
-// It is a Test (say) if there is a character after Test that is not a
-// lower-case letter. (We don't want Testiness.)
-func isTest(name, prefix string) bool {
-	if !strings.HasPrefix(name, prefix) {
-		return false
-	}
-	if len(name) == len(prefix) { // "Test" is ok
-		return true
-	}
-	rune, _ := utf8.DecodeRuneInString(name[len(prefix):])
-	return !unicode.IsLower(rune)
-}
-
-type exampleByName []*Example
-
-func (s exampleByName) Len() int           { return len(s) }
-func (s exampleByName) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
-func (s exampleByName) Less(i, j int) bool { return s[i].Name < s[j].Name }
-
-// playExample synthesizes a new *ast.File based on the provided
-// file with the provided function body as the body of main.
-func playExample(file *ast.File, body *ast.BlockStmt) *ast.File {
-	if !strings.HasSuffix(file.Name.Name, "_test") {
-		// We don't support examples that are part of the
-		// greater package (yet).
-		return nil
-	}
-
-	// Find top-level declarations in the file.
-	topDecls := make(map[*ast.Object]bool)
-	for _, decl := range file.Decls {
-		switch d := decl.(type) {
-		case *ast.FuncDecl:
-			topDecls[d.Name.Obj] = true
-		case *ast.GenDecl:
-			for _, spec := range d.Specs {
-				switch s := spec.(type) {
-				case *ast.TypeSpec:
-					topDecls[s.Name.Obj] = true
-				case *ast.ValueSpec:
-					for _, id := range s.Names {
-						topDecls[id.Obj] = true
-					}
-				}
-			}
-		}
-	}
-
-	// Find unresolved identifiers and uses of top-level declarations.
-	unresolved := make(map[string]bool)
-	usesTopDecl := false
-	var inspectFunc func(ast.Node) bool
-	inspectFunc = func(n ast.Node) bool {
-		// For selector expressions, only inspect the left hand side.
-		// (For an expression like fmt.Println, only add "fmt" to the
-		// set of unresolved names, not "Println".)
-		if e, ok := n.(*ast.SelectorExpr); ok {
-			ast.Inspect(e.X, inspectFunc)
-			return false
-		}
-		// For key value expressions, only inspect the value
-		// as the key should be resolved by the type of the
-		// composite literal.
-		if e, ok := n.(*ast.KeyValueExpr); ok {
-			ast.Inspect(e.Value, inspectFunc)
-			return false
-		}
-		if id, ok := n.(*ast.Ident); ok {
-			if id.Obj == nil {
-				unresolved[id.Name] = true
-			} else if topDecls[id.Obj] {
-				usesTopDecl = true
-			}
-		}
-		return true
-	}
-	ast.Inspect(body, inspectFunc)
-	if usesTopDecl {
-		// We don't support examples that are not self-contained (yet).
-		return nil
-	}
-
-	// Remove predeclared identifiers from unresolved list.
-	for n := range unresolved {
-		if predeclaredTypes[n] || predeclaredConstants[n] || predeclaredFuncs[n] {
-			delete(unresolved, n)
-		}
-	}
-
-	// Use unresolved identifiers to determine the imports used by this
-	// example. The heuristic assumes package names match base import
-	// paths for imports w/o renames (should be good enough most of the time).
-	namedImports := make(map[string]string) // [name]path
-	var blankImports []ast.Spec             // _ imports
-	for _, s := range file.Imports {
-		p, err := strconv.Unquote(s.Path.Value)
-		if err != nil {
-			continue
-		}
-		n := path.Base(p)
-		if s.Name != nil {
-			n = s.Name.Name
-			switch n {
-			case "_":
-				blankImports = append(blankImports, s)
-				continue
-			case ".":
-				// We can't resolve dot imports (yet).
-				return nil
-			}
-		}
-		if unresolved[n] {
-			namedImports[n] = p
-			delete(unresolved, n)
-		}
-	}
-
-	// If there are other unresolved identifiers, give up because this
-	// synthesized file is not going to build.
-	if len(unresolved) > 0 {
-		return nil
-	}
-
-	// Include documentation belonging to blank imports.
-	var comments []*ast.CommentGroup
-	for _, s := range blankImports {
-		if c := s.(*ast.ImportSpec).Doc; c != nil {
-			comments = append(comments, c)
-		}
-	}
-
-	// Include comments that are inside the function body.
-	for _, c := range file.Comments {
-		if body.Pos() <= c.Pos() && c.End() <= body.End() {
-			comments = append(comments, c)
-		}
-	}
-
-	// Strip "Output:" comment and adjust body end position.
-	body, comments = stripOutputComment(body, comments)
-
-	// Synthesize import declaration.
-	importDecl := &ast.GenDecl{
-		Tok:    token.IMPORT,
-		Lparen: 1, // Need non-zero Lparen and Rparen so that printer
-		Rparen: 1, // treats this as a factored import.
-	}
-	for n, p := range namedImports {
-		s := &ast.ImportSpec{Path: &ast.BasicLit{Value: strconv.Quote(p)}}
-		if path.Base(p) != n {
-			s.Name = ast.NewIdent(n)
-		}
-		importDecl.Specs = append(importDecl.Specs, s)
-	}
-	importDecl.Specs = append(importDecl.Specs, blankImports...)
-
-	// Synthesize main function.
-	funcDecl := &ast.FuncDecl{
-		Name: ast.NewIdent("main"),
-		Type: &ast.FuncType{Params: &ast.FieldList{}}, // FuncType.Params must be non-nil
-		Body: body,
-	}
-
-	// Synthesize file.
-	return &ast.File{
-		Name:     ast.NewIdent("main"),
-		Decls:    []ast.Decl{importDecl, funcDecl},
-		Comments: comments,
-	}
-}
-
-// playExampleFile takes a whole file example and synthesizes a new *ast.File
-// such that the example is function main in package main.
-func playExampleFile(file *ast.File) *ast.File {
-	// Strip copyright comment if present.
-	comments := file.Comments
-	if len(comments) > 0 && strings.HasPrefix(comments[0].Text(), "Copyright") {
-		comments = comments[1:]
-	}
-
-	// Copy declaration slice, rewriting the ExampleX function to main.
-	var decls []ast.Decl
-	for _, d := range file.Decls {
-		if f, ok := d.(*ast.FuncDecl); ok && isTest(f.Name.Name, "Example") {
-			// Copy the FuncDecl, as it may be used elsewhere.
-			newF := *f
-			newF.Name = ast.NewIdent("main")
-			newF.Body, comments = stripOutputComment(f.Body, comments)
-			d = &newF
-		}
-		decls = append(decls, d)
-	}
-
-	// Copy the File, as it may be used elsewhere.
-	f := *file
-	f.Name = ast.NewIdent("main")
-	f.Decls = decls
-	f.Comments = comments
-	return &f
-}
-
-// stripOutputComment finds and removes an "Output:" comment from body
-// and comments, and adjusts the body block's end position.
-func stripOutputComment(body *ast.BlockStmt, comments []*ast.CommentGroup) (*ast.BlockStmt, []*ast.CommentGroup) {
-	// Do nothing if no "Output:" comment found.
-	i, last := lastComment(body, comments)
-	if last == nil || !outputPrefix.MatchString(last.Text()) {
-		return body, comments
-	}
-
-	// Copy body and comments, as the originals may be used elsewhere.
-	newBody := &ast.BlockStmt{
-		Lbrace: body.Lbrace,
-		List:   body.List,
-		Rbrace: last.Pos(),
-	}
-	newComments := make([]*ast.CommentGroup, len(comments)-1)
-	copy(newComments, comments[:i])
-	copy(newComments[i:], comments[i+1:])
-	return newBody, newComments
-}
-
-// lastComment returns the last comment inside the provided block.
-func lastComment(b *ast.BlockStmt, c []*ast.CommentGroup) (i int, last *ast.CommentGroup) {
-	pos, end := b.Pos(), b.End()
-	for j, cg := range c {
-		if cg.Pos() < pos {
-			continue
-		}
-		if cg.End() > end {
-			break
-		}
-		i, last = j, cg
-	}
-	return
-}
diff --git a/third_party/golang/go/doc/example_test.go b/third_party/golang/go/doc/example_test.go
deleted file mode 100644
index e154ea8bfc5be..0000000000000
--- a/third_party/golang/go/doc/example_test.go
+++ /dev/null
@@ -1,191 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package doc_test
-
-import (
-	"bytes"
-	"go/doc"
-	"go/format"
-	"go/parser"
-	"go/token"
-	"strings"
-	"testing"
-)
-
-const exampleTestFile = `
-package foo_test
-
-import (
-	"flag"
-	"fmt"
-	"log"
-	"os/exec"
-)
-
-func ExampleHello() {
-	fmt.Println("Hello, world!")
-	// Output: Hello, world!
-}
-
-func ExampleImport() {
-	out, err := exec.Command("date").Output()
-	if err != nil {
-		log.Fatal(err)
-	}
-	fmt.Printf("The date is %s\n", out)
-}
-
-func ExampleKeyValue() {
-	v := struct {
-		a string
-		b int
-	}{
-		a: "A",
-		b: 1,
-	}
-	fmt.Print(v)
-	// Output: a: "A", b: 1
-}
-
-func ExampleKeyValueImport() {
-	f := flag.Flag{
-		Name: "play",
-	}
-	fmt.Print(f)
-	// Output: Name: "play"
-}
-
-var keyValueTopDecl = struct {
-	a string
-	b int
-}{
-	a: "B",
-	b: 2,
-}
-
-func ExampleKeyValueTopDecl() {
-	fmt.Print(keyValueTopDecl)
-}
-`
-
-var exampleTestCases = []struct {
-	Name, Play, Output string
-}{
-	{
-		Name:   "Hello",
-		Play:   exampleHelloPlay,
-		Output: "Hello, world!\n",
-	},
-	{
-		Name: "Import",
-		Play: exampleImportPlay,
-	},
-	{
-		Name:   "KeyValue",
-		Play:   exampleKeyValuePlay,
-		Output: "a: \"A\", b: 1\n",
-	},
-	{
-		Name:   "KeyValueImport",
-		Play:   exampleKeyValueImportPlay,
-		Output: "Name: \"play\"\n",
-	},
-	{
-		Name: "KeyValueTopDecl",
-		Play: "",
-	},
-}
-
-const exampleHelloPlay = `package main
-
-import (
-	"fmt"
-)
-
-func main() {
-	fmt.Println("Hello, world!")
-}
-`
-const exampleImportPlay = `package main
-
-import (
-	"fmt"
-	"log"
-	"os/exec"
-)
-
-func main() {
-	out, err := exec.Command("date").Output()
-	if err != nil {
-		log.Fatal(err)
-	}
-	fmt.Printf("The date is %s\n", out)
-}
-`
-
-const exampleKeyValuePlay = `package main
-
-import (
-	"fmt"
-)
-
-func main() {
-	v := struct {
-		a string
-		b int
-	}{
-		a: "A",
-		b: 1,
-	}
-	fmt.Print(v)
-}
-`
-
-const exampleKeyValueImportPlay = `package main
-
-import (
-	"flag"
-	"fmt"
-)
-
-func main() {
-	f := flag.Flag{
-		Name: "play",
-	}
-	fmt.Print(f)
-}
-`
-
-func TestExamples(t *testing.T) {
-	fset := token.NewFileSet()
-	file, err := parser.ParseFile(fset, "test.go", strings.NewReader(exampleTestFile), parser.ParseComments)
-	if err != nil {
-		t.Fatal(err)
-	}
-	for i, e := range doc.Examples(file) {
-		c := exampleTestCases[i]
-		if e.Name != c.Name {
-			t.Errorf("got Name == %q, want %q", e.Name, c.Name)
-		}
-		if w := c.Play; w != "" {
-			var g string // hah
-			if e.Play == nil {
-				g = ""
-			} else {
-				var buf bytes.Buffer
-				if err := format.Node(&buf, fset, e.Play); err != nil {
-					t.Fatal(err)
-				}
-				g = buf.String()
-			}
-			if g != w {
-				t.Errorf("%s: got Play == %q, want %q", c.Name, g, w)
-			}
-		}
-		if g, w := e.Output, c.Output; g != w {
-			t.Errorf("%s: got Output == %q, want %q", c.Name, g, w)
-		}
-	}
-}
diff --git a/third_party/golang/go/doc/exports.go b/third_party/golang/go/doc/exports.go
deleted file mode 100644
index a65f4f31c8e7f..0000000000000
--- a/third_party/golang/go/doc/exports.go
+++ /dev/null
@@ -1,252 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements export filtering of an AST.
-
-package doc
-
-import (
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-)
-
-// filterIdentList removes unexported names from list in place
-// and returns the resulting list.
-//
-func filterIdentList(list []*ast.Ident) []*ast.Ident {
-	j := 0
-	for _, x := range list {
-		if ast.IsExported(x.Name) {
-			list[j] = x
-			j++
-		}
-	}
-	return list[0:j]
-}
-
-// hasExportedName reports whether list contains any exported names.
-//
-func hasExportedName(list []*ast.Ident) bool {
-	for _, x := range list {
-		if x.IsExported() {
-			return true
-		}
-	}
-	return false
-}
-
-// removeErrorField removes anonymous fields named "error" from an interface.
-// This is called when "error" has been determined to be a local name,
-// not the predeclared type.
-//
-func removeErrorField(ityp *ast.InterfaceType) {
-	list := ityp.Methods.List // we know that ityp.Methods != nil
-	j := 0
-	for _, field := range list {
-		keepField := true
-		if n := len(field.Names); n == 0 {
-			// anonymous field
-			if fname, _ := baseTypeName(field.Type); fname == "error" {
-				keepField = false
-			}
-		}
-		if keepField {
-			list[j] = field
-			j++
-		}
-	}
-	if j < len(list) {
-		ityp.Incomplete = true
-	}
-	ityp.Methods.List = list[0:j]
-}
-
-// filterFieldList removes unexported fields (field names) from the field list
-// in place and reports whether fields were removed. Anonymous fields are
-// recorded with the parent type. filterType is called with the types of
-// all remaining fields.
-//
-func (r *reader) filterFieldList(parent *namedType, fields *ast.FieldList, ityp *ast.InterfaceType) (removedFields bool) {
-	if fields == nil {
-		return
-	}
-	list := fields.List
-	j := 0
-	for _, field := range list {
-		keepField := false
-		if n := len(field.Names); n == 0 {
-			// anonymous field
-			fname := r.recordAnonymousField(parent, field.Type)
-			if ast.IsExported(fname) {
-				keepField = true
-			} else if ityp != nil && fname == "error" {
-				// possibly the predeclared error interface; keep
-				// it for now but remember this interface so that
-				// it can be fixed if error is also defined locally
-				keepField = true
-				r.remember(ityp)
-			}
-		} else {
-			field.Names = filterIdentList(field.Names)
-			if len(field.Names) < n {
-				removedFields = true
-			}
-			if len(field.Names) > 0 {
-				keepField = true
-			}
-		}
-		if keepField {
-			r.filterType(nil, field.Type)
-			list[j] = field
-			j++
-		}
-	}
-	if j < len(list) {
-		removedFields = true
-	}
-	fields.List = list[0:j]
-	return
-}
-
-// filterParamList applies filterType to each parameter type in fields.
-//
-func (r *reader) filterParamList(fields *ast.FieldList) {
-	if fields != nil {
-		for _, f := range fields.List {
-			r.filterType(nil, f.Type)
-		}
-	}
-}
-
-// filterType strips any unexported struct fields or method types from typ
-// in place. If fields (or methods) have been removed, the corresponding
-// struct or interface type has the Incomplete field set to true.
-//
-func (r *reader) filterType(parent *namedType, typ ast.Expr) {
-	switch t := typ.(type) {
-	case *ast.Ident:
-		// nothing to do
-	case *ast.ParenExpr:
-		r.filterType(nil, t.X)
-	case *ast.ArrayType:
-		r.filterType(nil, t.Elt)
-	case *ast.StructType:
-		if r.filterFieldList(parent, t.Fields, nil) {
-			t.Incomplete = true
-		}
-	case *ast.FuncType:
-		r.filterParamList(t.Params)
-		r.filterParamList(t.Results)
-	case *ast.InterfaceType:
-		if r.filterFieldList(parent, t.Methods, t) {
-			t.Incomplete = true
-		}
-	case *ast.MapType:
-		r.filterType(nil, t.Key)
-		r.filterType(nil, t.Value)
-	case *ast.ChanType:
-		r.filterType(nil, t.Value)
-	}
-}
-
-func (r *reader) filterSpec(spec ast.Spec, tok token.Token) bool {
-	switch s := spec.(type) {
-	case *ast.ImportSpec:
-		// always keep imports so we can collect them
-		return true
-	case *ast.ValueSpec:
-		s.Names = filterIdentList(s.Names)
-		if len(s.Names) > 0 {
-			r.filterType(nil, s.Type)
-			return true
-		}
-	case *ast.TypeSpec:
-		if name := s.Name.Name; ast.IsExported(name) {
-			r.filterType(r.lookupType(s.Name.Name), s.Type)
-			return true
-		} else if name == "error" {
-			// special case: remember that error is declared locally
-			r.errorDecl = true
-		}
-	}
-	return false
-}
-
-// copyConstType returns a copy of typ with position pos.
-// typ must be a valid constant type.
-// In practice, only (possibly qualified) identifiers are possible.
-//
-func copyConstType(typ ast.Expr, pos token.Pos) ast.Expr {
-	switch typ := typ.(type) {
-	case *ast.Ident:
-		return &ast.Ident{Name: typ.Name, NamePos: pos}
-	case *ast.SelectorExpr:
-		if id, ok := typ.X.(*ast.Ident); ok {
-			// presumably a qualified identifier
-			return &ast.SelectorExpr{
-				Sel: ast.NewIdent(typ.Sel.Name),
-				X:   &ast.Ident{Name: id.Name, NamePos: pos},
-			}
-		}
-	}
-	return nil // shouldn't happen, but be conservative and don't panic
-}
-
-func (r *reader) filterSpecList(list []ast.Spec, tok token.Token) []ast.Spec {
-	if tok == token.CONST {
-		// Propagate any type information that would get lost otherwise
-		// when unexported constants are filtered.
-		var prevType ast.Expr
-		for _, spec := range list {
-			spec := spec.(*ast.ValueSpec)
-			if spec.Type == nil && prevType != nil {
-				// provide current spec with an explicit type
-				spec.Type = copyConstType(prevType, spec.Pos())
-			}
-			if hasExportedName(spec.Names) {
-				// exported names are preserved so there's no need to propagate the type
-				prevType = nil
-			} else {
-				prevType = spec.Type
-			}
-		}
-	}
-
-	j := 0
-	for _, s := range list {
-		if r.filterSpec(s, tok) {
-			list[j] = s
-			j++
-		}
-	}
-	return list[0:j]
-}
-
-func (r *reader) filterDecl(decl ast.Decl) bool {
-	switch d := decl.(type) {
-	case *ast.GenDecl:
-		d.Specs = r.filterSpecList(d.Specs, d.Tok)
-		return len(d.Specs) > 0
-	case *ast.FuncDecl:
-		// ok to filter these methods early because any
-		// conflicting method will be filtered here, too -
-		// thus, removing these methods early will not lead
-		// to the false removal of possible conflicts
-		return ast.IsExported(d.Name.Name)
-	}
-	return false
-}
-
-// fileExports removes unexported declarations from src in place.
-//
-func (r *reader) fileExports(src *ast.File) {
-	j := 0
-	for _, d := range src.Decls {
-		if r.filterDecl(d) {
-			src.Decls[j] = d
-			j++
-		}
-	}
-	src.Decls = src.Decls[0:j]
-}
diff --git a/third_party/golang/go/doc/filter.go b/third_party/golang/go/doc/filter.go
deleted file mode 100644
index 132a529a45765..0000000000000
--- a/third_party/golang/go/doc/filter.go
+++ /dev/null
@@ -1,105 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package doc
-
-import "k8s.io/kubernetes/third_party/golang/go/ast"
-
-type Filter func(string) bool
-
-func matchFields(fields *ast.FieldList, f Filter) bool {
-	if fields != nil {
-		for _, field := range fields.List {
-			for _, name := range field.Names {
-				if f(name.Name) {
-					return true
-				}
-			}
-		}
-	}
-	return false
-}
-
-func matchDecl(d *ast.GenDecl, f Filter) bool {
-	for _, d := range d.Specs {
-		switch v := d.(type) {
-		case *ast.ValueSpec:
-			for _, name := range v.Names {
-				if f(name.Name) {
-					return true
-				}
-			}
-		case *ast.TypeSpec:
-			if f(v.Name.Name) {
-				return true
-			}
-			switch t := v.Type.(type) {
-			case *ast.StructType:
-				if matchFields(t.Fields, f) {
-					return true
-				}
-			case *ast.InterfaceType:
-				if matchFields(t.Methods, f) {
-					return true
-				}
-			}
-		}
-	}
-	return false
-}
-
-func filterValues(a []*Value, f Filter) []*Value {
-	w := 0
-	for _, vd := range a {
-		if matchDecl(vd.Decl, f) {
-			a[w] = vd
-			w++
-		}
-	}
-	return a[0:w]
-}
-
-func filterFuncs(a []*Func, f Filter) []*Func {
-	w := 0
-	for _, fd := range a {
-		if f(fd.Name) {
-			a[w] = fd
-			w++
-		}
-	}
-	return a[0:w]
-}
-
-func filterTypes(a []*Type, f Filter) []*Type {
-	w := 0
-	for _, td := range a {
-		n := 0 // number of matches
-		if matchDecl(td.Decl, f) {
-			n = 1
-		} else {
-			// type name doesn't match, but we may have matching consts, vars, factories or methods
-			td.Consts = filterValues(td.Consts, f)
-			td.Vars = filterValues(td.Vars, f)
-			td.Funcs = filterFuncs(td.Funcs, f)
-			td.Methods = filterFuncs(td.Methods, f)
-			n += len(td.Consts) + len(td.Vars) + len(td.Funcs) + len(td.Methods)
-		}
-		if n > 0 {
-			a[w] = td
-			w++
-		}
-	}
-	return a[0:w]
-}
-
-// Filter eliminates documentation for names that don't pass through the filter f.
-// TODO(gri): Recognize "Type.Method" as a name.
-//
-func (p *Package) Filter(f Filter) {
-	p.Consts = filterValues(p.Consts, f)
-	p.Vars = filterValues(p.Vars, f)
-	p.Types = filterTypes(p.Types, f)
-	p.Funcs = filterFuncs(p.Funcs, f)
-	p.Doc = "" // don't show top-level package doc
-}
diff --git a/third_party/golang/go/doc/headscan.go b/third_party/golang/go/doc/headscan.go
deleted file mode 100644
index 5e292a1af6eba..0000000000000
--- a/third_party/golang/go/doc/headscan.go
+++ /dev/null
@@ -1,114 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build ignore
-
-/*
-	The headscan command extracts comment headings from package files;
-	it is used to detect false positives which may require an adjustment
-	to the comment formatting heuristics in comment.go.
-
-	Usage: headscan [-root root_directory]
-
-	By default, the $GOROOT/src directory is scanned.
-*/
-package main
-
-import (
-	"bytes"
-	"flag"
-	"fmt"
-	"k8s.io/kubernetes/third_party/golang/go/doc"
-	"k8s.io/kubernetes/third_party/golang/go/parser"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-	"os"
-	"path/filepath"
-	"regexp"
-	"runtime"
-	"strings"
-)
-
-var (
-	root    = flag.String("root", filepath.Join(runtime.GOROOT(), "src"), "root of filesystem tree to scan")
-	verbose = flag.Bool("v", false, "verbose mode")
-)
-
-// ToHTML in comment.go assigns a (possibly blank) ID to each heading
-var html_h = regexp.MustCompile(`
`)
-
-const html_endh = "
\n"
-
-func isGoFile(fi os.FileInfo) bool {
-	return strings.HasSuffix(fi.Name(), ".go") &&
-		!strings.HasSuffix(fi.Name(), "_test.go")
-}
-
-func appendHeadings(list []string, comment string) []string {
-	var buf bytes.Buffer
-	doc.ToHTML(&buf, comment, nil)
-	for s := buf.String(); ; {
-		loc := html_h.FindStringIndex(s)
-		if len(loc) == 0 {
-			break
-		}
-		i := loc[1]
-		j := strings.Index(s, html_endh)
-		if j < 0 {
-			list = append(list, s[i:]) // incorrect HTML
-			break
-		}
-		list = append(list, s[i:j])
-		s = s[j+len(html_endh):]
-	}
-	return list
-}
-
-func main() {
-	flag.Parse()
-	fset := token.NewFileSet()
-	nheadings := 0
-	err := filepath.Walk(*root, func(path string, fi os.FileInfo, err error) error {
-		if !fi.IsDir() {
-			return nil
-		}
-		pkgs, err := parser.ParseDir(fset, path, isGoFile, parser.ParseComments)
-		if err != nil {
-			if *verbose {
-				fmt.Fprintln(os.Stderr, err)
-			}
-			return nil
-		}
-		for _, pkg := range pkgs {
-			d := doc.New(pkg, path, doc.Mode(0))
-			list := appendHeadings(nil, d.Doc)
-			for _, d := range d.Consts {
-				list = appendHeadings(list, d.Doc)
-			}
-			for _, d := range d.Types {
-				list = appendHeadings(list, d.Doc)
-			}
-			for _, d := range d.Vars {
-				list = appendHeadings(list, d.Doc)
-			}
-			for _, d := range d.Funcs {
-				list = appendHeadings(list, d.Doc)
-			}
-			if len(list) > 0 {
-				// directories may contain multiple packages;
-				// print path and package name
-				fmt.Printf("%s (package %s)\n", path, pkg.Name)
-				for _, h := range list {
-					fmt.Printf("\t%s\n", h)
-				}
-				nheadings += len(list)
-			}
-		}
-		return nil
-	})
-	if err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
-	}
-	fmt.Println(nheadings, "headings found")
-}
diff --git a/third_party/golang/go/doc/reader.go b/third_party/golang/go/doc/reader.go
deleted file mode 100644
index 989c9a2d54bb9..0000000000000
--- a/third_party/golang/go/doc/reader.go
+++ /dev/null
@@ -1,853 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package doc
-
-import (
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-	"regexp"
-	"sort"
-	"strconv"
-)
-
-// ----------------------------------------------------------------------------
-// function/method sets
-//
-// Internally, we treat functions like methods and collect them in method sets.
-
-// A methodSet describes a set of methods. Entries where Decl == nil are conflict
-// entries (more then one method with the same name at the same embedding level).
-//
-type methodSet map[string]*Func
-
-// recvString returns a string representation of recv of the
-// form "T", "*T", or "BADRECV" (if not a proper receiver type).
-//
-func recvString(recv ast.Expr) string {
-	switch t := recv.(type) {
-	case *ast.Ident:
-		return t.Name
-	case *ast.StarExpr:
-		return "*" + recvString(t.X)
-	}
-	return "BADRECV"
-}
-
-// set creates the corresponding Func for f and adds it to mset.
-// If there are multiple f's with the same name, set keeps the first
-// one with documentation; conflicts are ignored.
-//
-func (mset methodSet) set(f *ast.FuncDecl) {
-	name := f.Name.Name
-	if g := mset[name]; g != nil && g.Doc != "" {
-		// A function with the same name has already been registered;
-		// since it has documentation, assume f is simply another
-		// implementation and ignore it. This does not happen if the
-		// caller is using go/build.ScanDir to determine the list of
-		// files implementing a package.
-		return
-	}
-	// function doesn't exist or has no documentation; use f
-	recv := ""
-	if f.Recv != nil {
-		var typ ast.Expr
-		// be careful in case of incorrect ASTs
-		if list := f.Recv.List; len(list) == 1 {
-			typ = list[0].Type
-		}
-		recv = recvString(typ)
-	}
-	mset[name] = &Func{
-		Doc:  f.Doc.Text(),
-		Name: name,
-		Decl: f,
-		Recv: recv,
-		Orig: recv,
-	}
-	f.Doc = nil // doc consumed - remove from AST
-}
-
-// add adds method m to the method set; m is ignored if the method set
-// already contains a method with the same name at the same or a higher
-// level then m.
-//
-func (mset methodSet) add(m *Func) {
-	old := mset[m.Name]
-	if old == nil || m.Level < old.Level {
-		mset[m.Name] = m
-		return
-	}
-	if old != nil && m.Level == old.Level {
-		// conflict - mark it using a method with nil Decl
-		mset[m.Name] = &Func{
-			Name:  m.Name,
-			Level: m.Level,
-		}
-	}
-}
-
-// ----------------------------------------------------------------------------
-// Named types
-
-// baseTypeName returns the name of the base type of x (or "")
-// and whether the type is imported or not.
-//
-func baseTypeName(x ast.Expr) (name string, imported bool) {
-	switch t := x.(type) {
-	case *ast.Ident:
-		return t.Name, false
-	case *ast.SelectorExpr:
-		if _, ok := t.X.(*ast.Ident); ok {
-			// only possible for qualified type names;
-			// assume type is imported
-			return t.Sel.Name, true
-		}
-	case *ast.StarExpr:
-		return baseTypeName(t.X)
-	}
-	return
-}
-
-// An embeddedSet describes a set of embedded types.
-type embeddedSet map[*namedType]bool
-
-// A namedType represents a named unqualified (package local, or possibly
-// predeclared) type. The namedType for a type name is always found via
-// reader.lookupType.
-//
-type namedType struct {
-	doc  string       // doc comment for type
-	name string       // type name
-	decl *ast.GenDecl // nil if declaration hasn't been seen yet
-
-	isEmbedded bool        // true if this type is embedded
-	isStruct   bool        // true if this type is a struct
-	embedded   embeddedSet // true if the embedded type is a pointer
-
-	// associated declarations
-	values  []*Value // consts and vars
-	funcs   methodSet
-	methods methodSet
-}
-
-// ----------------------------------------------------------------------------
-// AST reader
-
-// reader accumulates documentation for a single package.
-// It modifies the AST: Comments (declaration documentation)
-// that have been collected by the reader are set to nil
-// in the respective AST nodes so that they are not printed
-// twice (once when printing the documentation and once when
-// printing the corresponding AST node).
-//
-type reader struct {
-	mode Mode
-
-	// package properties
-	doc       string // package documentation, if any
-	filenames []string
-	notes     map[string][]*Note
-
-	// declarations
-	imports map[string]int
-	values  []*Value // consts and vars
-	types   map[string]*namedType
-	funcs   methodSet
-
-	// support for package-local error type declarations
-	errorDecl bool                 // if set, type "error" was declared locally
-	fixlist   []*ast.InterfaceType // list of interfaces containing anonymous field "error"
-}
-
-func (r *reader) isVisible(name string) bool {
-	return r.mode&AllDecls != 0 || ast.IsExported(name)
-}
-
-// lookupType returns the base type with the given name.
-// If the base type has not been encountered yet, a new
-// type with the given name but no associated declaration
-// is added to the type map.
-//
-func (r *reader) lookupType(name string) *namedType {
-	if name == "" || name == "_" {
-		return nil // no type docs for anonymous types
-	}
-	if typ, found := r.types[name]; found {
-		return typ
-	}
-	// type not found - add one without declaration
-	typ := &namedType{
-		name:     name,
-		embedded: make(embeddedSet),
-		funcs:    make(methodSet),
-		methods:  make(methodSet),
-	}
-	r.types[name] = typ
-	return typ
-}
-
-// recordAnonymousField registers fieldType as the type of an
-// anonymous field in the parent type. If the field is imported
-// (qualified name) or the parent is nil, the field is ignored.
-// The function returns the field name.
-//
-func (r *reader) recordAnonymousField(parent *namedType, fieldType ast.Expr) (fname string) {
-	fname, imp := baseTypeName(fieldType)
-	if parent == nil || imp {
-		return
-	}
-	if ftype := r.lookupType(fname); ftype != nil {
-		ftype.isEmbedded = true
-		_, ptr := fieldType.(*ast.StarExpr)
-		parent.embedded[ftype] = ptr
-	}
-	return
-}
-
-func (r *reader) readDoc(comment *ast.CommentGroup) {
-	// By convention there should be only one package comment
-	// but collect all of them if there are more then one.
-	text := comment.Text()
-	if r.doc == "" {
-		r.doc = text
-		return
-	}
-	r.doc += "\n" + text
-}
-
-func (r *reader) remember(typ *ast.InterfaceType) {
-	r.fixlist = append(r.fixlist, typ)
-}
-
-func specNames(specs []ast.Spec) []string {
-	names := make([]string, 0, len(specs)) // reasonable estimate
-	for _, s := range specs {
-		// s guaranteed to be an *ast.ValueSpec by readValue
-		for _, ident := range s.(*ast.ValueSpec).Names {
-			names = append(names, ident.Name)
-		}
-	}
-	return names
-}
-
-// readValue processes a const or var declaration.
-//
-func (r *reader) readValue(decl *ast.GenDecl) {
-	// determine if decl should be associated with a type
-	// Heuristic: For each typed entry, determine the type name, if any.
-	//            If there is exactly one type name that is sufficiently
-	//            frequent, associate the decl with the respective type.
-	domName := ""
-	domFreq := 0
-	prev := ""
-	n := 0
-	for _, spec := range decl.Specs {
-		s, ok := spec.(*ast.ValueSpec)
-		if !ok {
-			continue // should not happen, but be conservative
-		}
-		name := ""
-		switch {
-		case s.Type != nil:
-			// a type is present; determine its name
-			if n, imp := baseTypeName(s.Type); !imp {
-				name = n
-			}
-		case decl.Tok == token.CONST:
-			// no type is present but we have a constant declaration;
-			// use the previous type name (w/o more type information
-			// we cannot handle the case of unnamed variables with
-			// initializer expressions except for some trivial cases)
-			name = prev
-		}
-		if name != "" {
-			// entry has a named type
-			if domName != "" && domName != name {
-				// more than one type name - do not associate
-				// with any type
-				domName = ""
-				break
-			}
-			domName = name
-			domFreq++
-		}
-		prev = name
-		n++
-	}
-
-	// nothing to do w/o a legal declaration
-	if n == 0 {
-		return
-	}
-
-	// determine values list with which to associate the Value for this decl
-	values := &r.values
-	const threshold = 0.75
-	if domName != "" && r.isVisible(domName) && domFreq >= int(float64(len(decl.Specs))*threshold) {
-		// typed entries are sufficiently frequent
-		if typ := r.lookupType(domName); typ != nil {
-			values = &typ.values // associate with that type
-		}
-	}
-
-	*values = append(*values, &Value{
-		Doc:   decl.Doc.Text(),
-		Names: specNames(decl.Specs),
-		Decl:  decl,
-		order: len(*values),
-	})
-	decl.Doc = nil // doc consumed - remove from AST
-}
-
-// fields returns a struct's fields or an interface's methods.
-//
-func fields(typ ast.Expr) (list []*ast.Field, isStruct bool) {
-	var fields *ast.FieldList
-	switch t := typ.(type) {
-	case *ast.StructType:
-		fields = t.Fields
-		isStruct = true
-	case *ast.InterfaceType:
-		fields = t.Methods
-	}
-	if fields != nil {
-		list = fields.List
-	}
-	return
-}
-
-// readType processes a type declaration.
-//
-func (r *reader) readType(decl *ast.GenDecl, spec *ast.TypeSpec) {
-	typ := r.lookupType(spec.Name.Name)
-	if typ == nil {
-		return // no name or blank name - ignore the type
-	}
-
-	// A type should be added at most once, so typ.decl
-	// should be nil - if it is not, simply overwrite it.
-	typ.decl = decl
-
-	// compute documentation
-	doc := spec.Doc
-	spec.Doc = nil // doc consumed - remove from AST
-	if doc == nil {
-		// no doc associated with the spec, use the declaration doc, if any
-		doc = decl.Doc
-	}
-	decl.Doc = nil // doc consumed - remove from AST
-	typ.doc = doc.Text()
-
-	// record anonymous fields (they may contribute methods)
-	// (some fields may have been recorded already when filtering
-	// exports, but that's ok)
-	var list []*ast.Field
-	list, typ.isStruct = fields(spec.Type)
-	for _, field := range list {
-		if len(field.Names) == 0 {
-			r.recordAnonymousField(typ, field.Type)
-		}
-	}
-}
-
-// readFunc processes a func or method declaration.
-//
-func (r *reader) readFunc(fun *ast.FuncDecl) {
-	// strip function body
-	fun.Body = nil
-
-	// associate methods with the receiver type, if any
-	if fun.Recv != nil {
-		// method
-		recvTypeName, imp := baseTypeName(fun.Recv.List[0].Type)
-		if imp {
-			// should not happen (incorrect AST);
-			// don't show this method
-			return
-		}
-		if typ := r.lookupType(recvTypeName); typ != nil {
-			typ.methods.set(fun)
-		}
-		// otherwise ignore the method
-		// TODO(gri): There may be exported methods of non-exported types
-		// that can be called because of exported values (consts, vars, or
-		// function results) of that type. Could determine if that is the
-		// case and then show those methods in an appropriate section.
-		return
-	}
-
-	// associate factory functions with the first visible result type, if any
-	if fun.Type.Results.NumFields() >= 1 {
-		res := fun.Type.Results.List[0]
-		if len(res.Names) <= 1 {
-			// exactly one (named or anonymous) result associated
-			// with the first type in result signature (there may
-			// be more than one result)
-			if n, imp := baseTypeName(res.Type); !imp && r.isVisible(n) {
-				if typ := r.lookupType(n); typ != nil {
-					// associate function with typ
-					typ.funcs.set(fun)
-					return
-				}
-			}
-		}
-	}
-
-	// just an ordinary function
-	r.funcs.set(fun)
-}
-
-var (
-	noteMarker    = `([A-Z][A-Z]+)\(([^)]+)\):?`                    // MARKER(uid), MARKER at least 2 chars, uid at least 1 char
-	noteMarkerRx  = regexp.MustCompile(`^[ \t]*` + noteMarker)      // MARKER(uid) at text start
-	noteCommentRx = regexp.MustCompile(`^/[/*][ \t]*` + noteMarker) // MARKER(uid) at comment start
-)
-
-// readNote collects a single note from a sequence of comments.
-//
-func (r *reader) readNote(list []*ast.Comment) {
-	text := (&ast.CommentGroup{List: list}).Text()
-	if m := noteMarkerRx.FindStringSubmatchIndex(text); m != nil {
-		// The note body starts after the marker.
-		// We remove any formatting so that we don't
-		// get spurious line breaks/indentation when
-		// showing the TODO body.
-		body := clean(text[m[1]:], keepNL)
-		if body != "" {
-			marker := text[m[2]:m[3]]
-			r.notes[marker] = append(r.notes[marker], &Note{
-				Pos:  list[0].Pos(),
-				End:  list[len(list)-1].End(),
-				UID:  text[m[4]:m[5]],
-				Body: body,
-			})
-		}
-	}
-}
-
-// readNotes extracts notes from comments.
-// A note must start at the beginning of a comment with "MARKER(uid):"
-// and is followed by the note body (e.g., "// BUG(gri): fix this").
-// The note ends at the end of the comment group or at the start of
-// another note in the same comment group, whichever comes first.
-//
-func (r *reader) readNotes(comments []*ast.CommentGroup) {
-	for _, group := range comments {
-		i := -1 // comment index of most recent note start, valid if >= 0
-		list := group.List
-		for j, c := range list {
-			if noteCommentRx.MatchString(c.Text) {
-				if i >= 0 {
-					r.readNote(list[i:j])
-				}
-				i = j
-			}
-		}
-		if i >= 0 {
-			r.readNote(list[i:])
-		}
-	}
-}
-
-// readFile adds the AST for a source file to the reader.
-//
-func (r *reader) readFile(src *ast.File) {
-	// add package documentation
-	if src.Doc != nil {
-		r.readDoc(src.Doc)
-		src.Doc = nil // doc consumed - remove from AST
-	}
-
-	// add all declarations
-	for _, decl := range src.Decls {
-		switch d := decl.(type) {
-		case *ast.GenDecl:
-			switch d.Tok {
-			case token.IMPORT:
-				// imports are handled individually
-				for _, spec := range d.Specs {
-					if s, ok := spec.(*ast.ImportSpec); ok {
-						if import_, err := strconv.Unquote(s.Path.Value); err == nil {
-							r.imports[import_] = 1
-						}
-					}
-				}
-			case token.CONST, token.VAR:
-				// constants and variables are always handled as a group
-				r.readValue(d)
-			case token.TYPE:
-				// types are handled individually
-				if len(d.Specs) == 1 && !d.Lparen.IsValid() {
-					// common case: single declaration w/o parentheses
-					// (if a single declaration is parenthesized,
-					// create a new fake declaration below, so that
-					// go/doc type declarations always appear w/o
-					// parentheses)
-					if s, ok := d.Specs[0].(*ast.TypeSpec); ok {
-						r.readType(d, s)
-					}
-					break
-				}
-				for _, spec := range d.Specs {
-					if s, ok := spec.(*ast.TypeSpec); ok {
-						// use an individual (possibly fake) declaration
-						// for each type; this also ensures that each type
-						// gets to (re-)use the declaration documentation
-						// if there's none associated with the spec itself
-						fake := &ast.GenDecl{
-							Doc: d.Doc,
-							// don't use the existing TokPos because it
-							// will lead to the wrong selection range for
-							// the fake declaration if there are more
-							// than one type in the group (this affects
-							// src/cmd/godoc/godoc.go's posLink_urlFunc)
-							TokPos: s.Pos(),
-							Tok:    token.TYPE,
-							Specs:  []ast.Spec{s},
-						}
-						r.readType(fake, s)
-					}
-				}
-			}
-		case *ast.FuncDecl:
-			r.readFunc(d)
-		}
-	}
-
-	// collect MARKER(...): annotations
-	r.readNotes(src.Comments)
-	src.Comments = nil // consumed unassociated comments - remove from AST
-}
-
-func (r *reader) readPackage(pkg *ast.Package, mode Mode) {
-	// initialize reader
-	r.filenames = make([]string, len(pkg.Files))
-	r.imports = make(map[string]int)
-	r.mode = mode
-	r.types = make(map[string]*namedType)
-	r.funcs = make(methodSet)
-	r.notes = make(map[string][]*Note)
-
-	// sort package files before reading them so that the
-	// result does not depend on map iteration order
-	i := 0
-	for filename := range pkg.Files {
-		r.filenames[i] = filename
-		i++
-	}
-	sort.Strings(r.filenames)
-
-	// process files in sorted order
-	for _, filename := range r.filenames {
-		f := pkg.Files[filename]
-		if mode&AllDecls == 0 {
-			r.fileExports(f)
-		}
-		r.readFile(f)
-	}
-}
-
-// ----------------------------------------------------------------------------
-// Types
-
-func customizeRecv(f *Func, recvTypeName string, embeddedIsPtr bool, level int) *Func {
-	if f == nil || f.Decl == nil || f.Decl.Recv == nil || len(f.Decl.Recv.List) != 1 {
-		return f // shouldn't happen, but be safe
-	}
-
-	// copy existing receiver field and set new type
-	newField := *f.Decl.Recv.List[0]
-	origPos := newField.Type.Pos()
-	_, origRecvIsPtr := newField.Type.(*ast.StarExpr)
-	newIdent := &ast.Ident{NamePos: origPos, Name: recvTypeName}
-	var typ ast.Expr = newIdent
-	if !embeddedIsPtr && origRecvIsPtr {
-		newIdent.NamePos++ // '*' is one character
-		typ = &ast.StarExpr{Star: origPos, X: newIdent}
-	}
-	newField.Type = typ
-
-	// copy existing receiver field list and set new receiver field
-	newFieldList := *f.Decl.Recv
-	newFieldList.List = []*ast.Field{&newField}
-
-	// copy existing function declaration and set new receiver field list
-	newFuncDecl := *f.Decl
-	newFuncDecl.Recv = &newFieldList
-
-	// copy existing function documentation and set new declaration
-	newF := *f
-	newF.Decl = &newFuncDecl
-	newF.Recv = recvString(typ)
-	// the Orig field never changes
-	newF.Level = level
-
-	return &newF
-}
-
-// collectEmbeddedMethods collects the embedded methods of typ in mset.
-//
-func (r *reader) collectEmbeddedMethods(mset methodSet, typ *namedType, recvTypeName string, embeddedIsPtr bool, level int, visited embeddedSet) {
-	visited[typ] = true
-	for embedded, isPtr := range typ.embedded {
-		// Once an embedded type is embedded as a pointer type
-		// all embedded types in those types are treated like
-		// pointer types for the purpose of the receiver type
-		// computation; i.e., embeddedIsPtr is sticky for this
-		// embedding hierarchy.
-		thisEmbeddedIsPtr := embeddedIsPtr || isPtr
-		for _, m := range embedded.methods {
-			// only top-level methods are embedded
-			if m.Level == 0 {
-				mset.add(customizeRecv(m, recvTypeName, thisEmbeddedIsPtr, level))
-			}
-		}
-		if !visited[embedded] {
-			r.collectEmbeddedMethods(mset, embedded, recvTypeName, thisEmbeddedIsPtr, level+1, visited)
-		}
-	}
-	delete(visited, typ)
-}
-
-// computeMethodSets determines the actual method sets for each type encountered.
-//
-func (r *reader) computeMethodSets() {
-	for _, t := range r.types {
-		// collect embedded methods for t
-		if t.isStruct {
-			// struct
-			r.collectEmbeddedMethods(t.methods, t, t.name, false, 1, make(embeddedSet))
-		} else {
-			// interface
-			// TODO(gri) fix this
-		}
-	}
-
-	// if error was declared locally, don't treat it as exported field anymore
-	if r.errorDecl {
-		for _, ityp := range r.fixlist {
-			removeErrorField(ityp)
-		}
-	}
-}
-
-// cleanupTypes removes the association of functions and methods with
-// types that have no declaration. Instead, these functions and methods
-// are shown at the package level. It also removes types with missing
-// declarations or which are not visible.
-//
-func (r *reader) cleanupTypes() {
-	for _, t := range r.types {
-		visible := r.isVisible(t.name)
-		if t.decl == nil && (predeclaredTypes[t.name] || t.isEmbedded && visible) {
-			// t.name is a predeclared type (and was not redeclared in this package),
-			// or it was embedded somewhere but its declaration is missing (because
-			// the AST is incomplete): move any associated values, funcs, and methods
-			// back to the top-level so that they are not lost.
-			// 1) move values
-			r.values = append(r.values, t.values...)
-			// 2) move factory functions
-			for name, f := range t.funcs {
-				// in a correct AST, package-level function names
-				// are all different - no need to check for conflicts
-				r.funcs[name] = f
-			}
-			// 3) move methods
-			for name, m := range t.methods {
-				// don't overwrite functions with the same name - drop them
-				if _, found := r.funcs[name]; !found {
-					r.funcs[name] = m
-				}
-			}
-		}
-		// remove types w/o declaration or which are not visible
-		if t.decl == nil || !visible {
-			delete(r.types, t.name)
-		}
-	}
-}
-
-// ----------------------------------------------------------------------------
-// Sorting
-
-type data struct {
-	n    int
-	swap func(i, j int)
-	less func(i, j int) bool
-}
-
-func (d *data) Len() int           { return d.n }
-func (d *data) Swap(i, j int)      { d.swap(i, j) }
-func (d *data) Less(i, j int) bool { return d.less(i, j) }
-
-// sortBy is a helper function for sorting
-func sortBy(less func(i, j int) bool, swap func(i, j int), n int) {
-	sort.Sort(&data{n, swap, less})
-}
-
-func sortedKeys(m map[string]int) []string {
-	list := make([]string, len(m))
-	i := 0
-	for key := range m {
-		list[i] = key
-		i++
-	}
-	sort.Strings(list)
-	return list
-}
-
-// sortingName returns the name to use when sorting d into place.
-//
-func sortingName(d *ast.GenDecl) string {
-	if len(d.Specs) == 1 {
-		if s, ok := d.Specs[0].(*ast.ValueSpec); ok {
-			return s.Names[0].Name
-		}
-	}
-	return ""
-}
-
-func sortedValues(m []*Value, tok token.Token) []*Value {
-	list := make([]*Value, len(m)) // big enough in any case
-	i := 0
-	for _, val := range m {
-		if val.Decl.Tok == tok {
-			list[i] = val
-			i++
-		}
-	}
-	list = list[0:i]
-
-	sortBy(
-		func(i, j int) bool {
-			if ni, nj := sortingName(list[i].Decl), sortingName(list[j].Decl); ni != nj {
-				return ni < nj
-			}
-			return list[i].order < list[j].order
-		},
-		func(i, j int) { list[i], list[j] = list[j], list[i] },
-		len(list),
-	)
-
-	return list
-}
-
-func sortedTypes(m map[string]*namedType, allMethods bool) []*Type {
-	list := make([]*Type, len(m))
-	i := 0
-	for _, t := range m {
-		list[i] = &Type{
-			Doc:     t.doc,
-			Name:    t.name,
-			Decl:    t.decl,
-			Consts:  sortedValues(t.values, token.CONST),
-			Vars:    sortedValues(t.values, token.VAR),
-			Funcs:   sortedFuncs(t.funcs, true),
-			Methods: sortedFuncs(t.methods, allMethods),
-		}
-		i++
-	}
-
-	sortBy(
-		func(i, j int) bool { return list[i].Name < list[j].Name },
-		func(i, j int) { list[i], list[j] = list[j], list[i] },
-		len(list),
-	)
-
-	return list
-}
-
-func removeStar(s string) string {
-	if len(s) > 0 && s[0] == '*' {
-		return s[1:]
-	}
-	return s
-}
-
-func sortedFuncs(m methodSet, allMethods bool) []*Func {
-	list := make([]*Func, len(m))
-	i := 0
-	for _, m := range m {
-		// determine which methods to include
-		switch {
-		case m.Decl == nil:
-			// exclude conflict entry
-		case allMethods, m.Level == 0, !ast.IsExported(removeStar(m.Orig)):
-			// forced inclusion, method not embedded, or method
-			// embedded but original receiver type not exported
-			list[i] = m
-			i++
-		}
-	}
-	list = list[0:i]
-	sortBy(
-		func(i, j int) bool { return list[i].Name < list[j].Name },
-		func(i, j int) { list[i], list[j] = list[j], list[i] },
-		len(list),
-	)
-	return list
-}
-
-// noteBodies returns a list of note body strings given a list of notes.
-// This is only used to populate the deprecated Package.Bugs field.
-//
-func noteBodies(notes []*Note) []string {
-	var list []string
-	for _, n := range notes {
-		list = append(list, n.Body)
-	}
-	return list
-}
-
-// ----------------------------------------------------------------------------
-// Predeclared identifiers
-
-var predeclaredTypes = map[string]bool{
-	"bool":       true,
-	"byte":       true,
-	"complex64":  true,
-	"complex128": true,
-	"error":      true,
-	"float32":    true,
-	"float64":    true,
-	"int":        true,
-	"int8":       true,
-	"int16":      true,
-	"int32":      true,
-	"int64":      true,
-	"rune":       true,
-	"string":     true,
-	"uint":       true,
-	"uint8":      true,
-	"uint16":     true,
-	"uint32":     true,
-	"uint64":     true,
-	"uintptr":    true,
-}
-
-var predeclaredFuncs = map[string]bool{
-	"append":  true,
-	"cap":     true,
-	"close":   true,
-	"complex": true,
-	"copy":    true,
-	"delete":  true,
-	"imag":    true,
-	"len":     true,
-	"make":    true,
-	"new":     true,
-	"panic":   true,
-	"print":   true,
-	"println": true,
-	"real":    true,
-	"recover": true,
-}
-
-var predeclaredConstants = map[string]bool{
-	"false": true,
-	"iota":  true,
-	"nil":   true,
-	"true":  true,
-}
diff --git a/third_party/golang/go/doc/synopsis.go b/third_party/golang/go/doc/synopsis.go
deleted file mode 100644
index c90080b7cc175..0000000000000
--- a/third_party/golang/go/doc/synopsis.go
+++ /dev/null
@@ -1,82 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package doc
-
-import (
-	"strings"
-	"unicode"
-)
-
-// firstSentenceLen returns the length of the first sentence in s.
-// The sentence ends after the first period followed by space and
-// not preceded by exactly one uppercase letter.
-//
-func firstSentenceLen(s string) int {
-	var ppp, pp, p rune
-	for i, q := range s {
-		if q == '\n' || q == '\r' || q == '\t' {
-			q = ' '
-		}
-		if q == ' ' && p == '.' && (!unicode.IsUpper(pp) || unicode.IsUpper(ppp)) {
-			return i
-		}
-		if p == '。' || p == '．' {
-			return i
-		}
-		ppp, pp, p = pp, p, q
-	}
-	return len(s)
-}
-
-const (
-	keepNL = 1 << iota
-)
-
-// clean replaces each sequence of space, \n, \r, or \t characters
-// with a single space and removes any trailing and leading spaces.
-// If the keepNL flag is set, newline characters are passed through
-// instead of being change to spaces.
-func clean(s string, flags int) string {
-	var b []byte
-	p := byte(' ')
-	for i := 0; i < len(s); i++ {
-		q := s[i]
-		if (flags&keepNL) == 0 && q == '\n' || q == '\r' || q == '\t' {
-			q = ' '
-		}
-		if q != ' ' || p != ' ' {
-			b = append(b, q)
-			p = q
-		}
-	}
-	// remove trailing blank, if any
-	if n := len(b); n > 0 && p == ' ' {
-		b = b[0 : n-1]
-	}
-	return string(b)
-}
-
-// Synopsis returns a cleaned version of the first sentence in s.
-// That sentence ends after the first period followed by space and
-// not preceded by exactly one uppercase letter. The result string
-// has no \n, \r, or \t characters and uses only single spaces between
-// words. If s starts with any of the IllegalPrefixes, the result
-// is the empty string.
-//
-func Synopsis(s string) string {
-	s = clean(s[0:firstSentenceLen(s)], 0)
-	for _, prefix := range IllegalPrefixes {
-		if strings.HasPrefix(strings.ToLower(s), prefix) {
-			return ""
-		}
-	}
-	return s
-}
-
-var IllegalPrefixes = []string{
-	"copyright",
-	"all rights",
-	"author",
-}
diff --git a/third_party/golang/go/doc/synopsis_test.go b/third_party/golang/go/doc/synopsis_test.go
deleted file mode 100644
index 59b253cb8dcea..0000000000000
--- a/third_party/golang/go/doc/synopsis_test.go
+++ /dev/null
@@ -1,51 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package doc
-
-import "testing"
-
-var tests = []struct {
-	txt string
-	fsl int
-	syn string
-}{
-	{"", 0, ""},
-	{"foo", 3, "foo"},
-	{"foo.", 4, "foo."},
-	{"foo.bar", 7, "foo.bar"},
-	{"  foo.  ", 6, "foo."},
-	{"  foo\t  bar.\n", 12, "foo bar."},
-	{"  foo\t  bar.\n", 12, "foo bar."},
-	{"a  b\n\nc\r\rd\t\t", 12, "a b c d"},
-	{"a  b\n\nc\r\rd\t\t  . BLA", 15, "a b c d ."},
-	{"Package poems by T.S.Eliot. To rhyme...", 27, "Package poems by T.S.Eliot."},
-	{"Package poems by T. S. Eliot. To rhyme...", 29, "Package poems by T. S. Eliot."},
-	{"foo implements the foo ABI. The foo ABI is...", 27, "foo implements the foo ABI."},
-	{"Package\nfoo. ..", 12, "Package foo."},
-	{"P . Q.", 3, "P ."},
-	{"P. Q.   ", 8, "P. Q."},
-	{"Package Καλημέρα κόσμε.", 36, "Package Καλημέρα κόσμε."},
-	{"Package こんにちは 世界\n", 31, "Package こんにちは 世界"},
-	{"Package こんにちは。世界", 26, "Package こんにちは。"},
-	{"Package 안녕．世界", 17, "Package 안녕．"},
-	{"Package foo does bar.", 21, "Package foo does bar."},
-	{"Copyright 2012 Google, Inc. Package foo does bar.", 27, ""},
-	{"All Rights reserved. Package foo does bar.", 20, ""},
-	{"All rights reserved. Package foo does bar.", 20, ""},
-	{"Authors: foo@bar.com. Package foo does bar.", 21, ""},
-}
-
-func TestSynopsis(t *testing.T) {
-	for _, e := range tests {
-		fsl := firstSentenceLen(e.txt)
-		if fsl != e.fsl {
-			t.Errorf("got fsl = %d; want %d for %q\n", fsl, e.fsl, e.txt)
-		}
-		syn := Synopsis(e.txt)
-		if syn != e.syn {
-			t.Errorf("got syn = %q; want %q for %q\n", syn, e.syn, e.txt)
-		}
-	}
-}
diff --git a/third_party/golang/go/doc/testdata/a.0.golden b/third_party/golang/go/doc/testdata/a.0.golden
deleted file mode 100644
index 7e680b80b4c56..0000000000000
--- a/third_party/golang/go/doc/testdata/a.0.golden
+++ /dev/null
@@ -1,52 +0,0 @@
-// comment 0  comment 1 
-PACKAGE a
-
-IMPORTPATH
-	testdata/a
-
-FILENAMES
-	testdata/a0.go
-	testdata/a1.go
-
-BUGS .Bugs is now deprecated, please use .Notes instead
-	bug0
-
-	bug1
-
-
-BUGS
-BUG(uid)	bug0
-
-BUG(uid)	bug1
-
-
-NOTES
-NOTE(uid)	
-
-NOTE(foo)	1 of 4 - this is the first line of note 1
-	- note 1 continues on this 2nd line
-	- note 1 continues on this 3rd line
-
-NOTE(foo)	2 of 4
-
-NOTE(bar)	3 of 4
-
-NOTE(bar)	4 of 4
-	- this is the last line of note 4
-
-NOTE(bam)	This note which contains a (parenthesized) subphrase
-	 must appear in its entirety.
-
-NOTE(xxx)	The ':' after the marker and uid is optional.
-
-
-SECBUGS
-SECBUG(uid)	sec hole 0
-	need to fix asap
-
-
-TODOS
-TODO(uid)	todo0
-
-TODO(uid)	todo1
-
diff --git a/third_party/golang/go/doc/testdata/a.1.golden b/third_party/golang/go/doc/testdata/a.1.golden
deleted file mode 100644
index 7e680b80b4c56..0000000000000
--- a/third_party/golang/go/doc/testdata/a.1.golden
+++ /dev/null
@@ -1,52 +0,0 @@
-// comment 0  comment 1 
-PACKAGE a
-
-IMPORTPATH
-	testdata/a
-
-FILENAMES
-	testdata/a0.go
-	testdata/a1.go
-
-BUGS .Bugs is now deprecated, please use .Notes instead
-	bug0
-
-	bug1
-
-
-BUGS
-BUG(uid)	bug0
-
-BUG(uid)	bug1
-
-
-NOTES
-NOTE(uid)	
-
-NOTE(foo)	1 of 4 - this is the first line of note 1
-	- note 1 continues on this 2nd line
-	- note 1 continues on this 3rd line
-
-NOTE(foo)	2 of 4
-
-NOTE(bar)	3 of 4
-
-NOTE(bar)	4 of 4
-	- this is the last line of note 4
-
-NOTE(bam)	This note which contains a (parenthesized) subphrase
-	 must appear in its entirety.
-
-NOTE(xxx)	The ':' after the marker and uid is optional.
-
-
-SECBUGS
-SECBUG(uid)	sec hole 0
-	need to fix asap
-
-
-TODOS
-TODO(uid)	todo0
-
-TODO(uid)	todo1
-
diff --git a/third_party/golang/go/doc/testdata/a.2.golden b/third_party/golang/go/doc/testdata/a.2.golden
deleted file mode 100644
index 7e680b80b4c56..0000000000000
--- a/third_party/golang/go/doc/testdata/a.2.golden
+++ /dev/null
@@ -1,52 +0,0 @@
-// comment 0  comment 1 
-PACKAGE a
-
-IMPORTPATH
-	testdata/a
-
-FILENAMES
-	testdata/a0.go
-	testdata/a1.go
-
-BUGS .Bugs is now deprecated, please use .Notes instead
-	bug0
-
-	bug1
-
-
-BUGS
-BUG(uid)	bug0
-
-BUG(uid)	bug1
-
-
-NOTES
-NOTE(uid)	
-
-NOTE(foo)	1 of 4 - this is the first line of note 1
-	- note 1 continues on this 2nd line
-	- note 1 continues on this 3rd line
-
-NOTE(foo)	2 of 4
-
-NOTE(bar)	3 of 4
-
-NOTE(bar)	4 of 4
-	- this is the last line of note 4
-
-NOTE(bam)	This note which contains a (parenthesized) subphrase
-	 must appear in its entirety.
-
-NOTE(xxx)	The ':' after the marker and uid is optional.
-
-
-SECBUGS
-SECBUG(uid)	sec hole 0
-	need to fix asap
-
-
-TODOS
-TODO(uid)	todo0
-
-TODO(uid)	todo1
-
diff --git a/third_party/golang/go/doc/testdata/a0.go b/third_party/golang/go/doc/testdata/a0.go
deleted file mode 100644
index 2420c8a483a26..0000000000000
--- a/third_party/golang/go/doc/testdata/a0.go
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// comment 0
-package a
-
-//BUG(uid): bug0
-
-//TODO(uid): todo0
-
-// A note with some spaces after it, should be ignored (watch out for
-// emacs modes that remove trailing whitespace).
-//NOTE(uid):
-
-// SECBUG(uid): sec hole 0
-// need to fix asap
-
-// Multiple notes may be in the same comment group and should be
-// recognized individually. Notes may start in the middle of a
-// comment group as long as they start at the beginning of an
-// individual comment.
-//
-// NOTE(foo): 1 of 4 - this is the first line of note 1
-// - note 1 continues on this 2nd line
-// - note 1 continues on this 3rd line
-// NOTE(foo): 2 of 4
-// NOTE(bar): 3 of 4
-/* NOTE(bar): 4 of 4 */
-// - this is the last line of note 4
-//
-//
-
-// NOTE(bam): This note which contains a (parenthesized) subphrase
-//            must appear in its entirety.
-
-// NOTE(xxx) The ':' after the marker and uid is optional.
-
-// NOTE(): NO uid - should not show up.
-// NOTE()  NO uid - should not show up.
diff --git a/third_party/golang/go/doc/testdata/a1.go b/third_party/golang/go/doc/testdata/a1.go
deleted file mode 100644
index 9fad1e09bc44b..0000000000000
--- a/third_party/golang/go/doc/testdata/a1.go
+++ /dev/null
@@ -1,12 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// comment 1
-package a
-
-//BUG(uid): bug1
-
-//TODO(uid): todo1
-
-//TODO(): ignored
diff --git a/third_party/golang/go/doc/testdata/b.0.golden b/third_party/golang/go/doc/testdata/b.0.golden
deleted file mode 100644
index 9d93392eaa593..0000000000000
--- a/third_party/golang/go/doc/testdata/b.0.golden
+++ /dev/null
@@ -1,71 +0,0 @@
-// 
-PACKAGE b
-
-IMPORTPATH
-	testdata/b
-
-IMPORTS
-	a
-
-FILENAMES
-	testdata/b.go
-
-CONSTANTS
-	// 
-	const (
-		C1	notExported	= iota
-		C2
-	
-		C4
-		C5
-	)
-
-	// 
-	const C notExported = 0
-
-	// 
-	const Pi = 3.14	// Pi
-
-
-VARIABLES
-	// 
-	var (
-		U1, U2, U4, U5	notExported
-	
-		U7	notExported	= 7
-	)
-
-	// 
-	var MaxInt int	// MaxInt
-
-	// 
-	var V notExported
-
-	// 
-	var V1, V2, V4, V5 notExported
-
-
-FUNCTIONS
-	// 
-	func F(x int) int
-
-	// 
-	func F1() notExported
-
-	// Always under the package functions list. 
-	func NotAFactory() int
-
-	// Associated with uint type if AllDecls is set. 
-	func UintFactory() uint
-
-
-TYPES
-	// 
-	type T struct{}	// T
-
-	// 
-	var V T	// v
-
-	// 
-	func (x *T) M()
-
diff --git a/third_party/golang/go/doc/testdata/b.1.golden b/third_party/golang/go/doc/testdata/b.1.golden
deleted file mode 100644
index 66c47b5c2a717..0000000000000
--- a/third_party/golang/go/doc/testdata/b.1.golden
+++ /dev/null
@@ -1,83 +0,0 @@
-// 
-PACKAGE b
-
-IMPORTPATH
-	testdata/b
-
-IMPORTS
-	a
-
-FILENAMES
-	testdata/b.go
-
-CONSTANTS
-	// 
-	const Pi = 3.14	// Pi
-
-
-VARIABLES
-	// 
-	var MaxInt int	// MaxInt
-
-
-FUNCTIONS
-	// 
-	func F(x int) int
-
-	// Always under the package functions list. 
-	func NotAFactory() int
-
-
-TYPES
-	// 
-	type T struct{}	// T
-
-	// 
-	var V T	// v
-
-	// 
-	func (x *T) M()
-
-	// 
-	type notExported int
-
-	// 
-	const (
-		C1	notExported	= iota
-		C2
-		c3
-		C4
-		C5
-	)
-
-	// 
-	const C notExported = 0
-
-	// 
-	var (
-		U1, U2, u3, U4, U5	notExported
-		u6			notExported
-		U7			notExported	= 7
-	)
-
-	// 
-	var V notExported
-
-	// 
-	var V1, V2, v3, V4, V5 notExported
-
-	// 
-	func F1() notExported
-
-	// 
-	func f2() notExported
-
-	// Should only appear if AllDecls is set. 
-	type uint struct{}	// overrides a predeclared type uint
-
-	// Associated with uint type if AllDecls is set. 
-	func UintFactory() uint
-
-	// Associated with uint type if AllDecls is set. 
-	func uintFactory() uint
-
diff --git a/third_party/golang/go/doc/testdata/b.2.golden b/third_party/golang/go/doc/testdata/b.2.golden
deleted file mode 100644
index 9d93392eaa593..0000000000000
--- a/third_party/golang/go/doc/testdata/b.2.golden
+++ /dev/null
@@ -1,71 +0,0 @@
-// 
-PACKAGE b
-
-IMPORTPATH
-	testdata/b
-
-IMPORTS
-	a
-
-FILENAMES
-	testdata/b.go
-
-CONSTANTS
-	// 
-	const (
-		C1	notExported	= iota
-		C2
-	
-		C4
-		C5
-	)
-
-	// 
-	const C notExported = 0
-
-	// 
-	const Pi = 3.14	// Pi
-
-
-VARIABLES
-	// 
-	var (
-		U1, U2, U4, U5	notExported
-	
-		U7	notExported	= 7
-	)
-
-	// 
-	var MaxInt int	// MaxInt
-
-	// 
-	var V notExported
-
-	// 
-	var V1, V2, V4, V5 notExported
-
-
-FUNCTIONS
-	// 
-	func F(x int) int
-
-	// 
-	func F1() notExported
-
-	// Always under the package functions list. 
-	func NotAFactory() int
-
-	// Associated with uint type if AllDecls is set. 
-	func UintFactory() uint
-
-
-TYPES
-	// 
-	type T struct{}	// T
-
-	// 
-	var V T	// v
-
-	// 
-	func (x *T) M()
-
diff --git a/third_party/golang/go/doc/testdata/b.go b/third_party/golang/go/doc/testdata/b.go
deleted file mode 100644
index e50663b3dfaa8..0000000000000
--- a/third_party/golang/go/doc/testdata/b.go
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package b
-
-import "a"
-
-// ----------------------------------------------------------------------------
-// Basic declarations
-
-const Pi = 3.14   // Pi
-var MaxInt int    // MaxInt
-type T struct{}   // T
-var V T           // v
-func F(x int) int {} // F
-func (x *T) M()   {} // M
-
-// Corner cases: association with (presumed) predeclared types
-
-// Always under the package functions list.
-func NotAFactory() int {}
-
-// Associated with uint type if AllDecls is set.
-func UintFactory() uint {}
-
-// Associated with uint type if AllDecls is set.
-func uintFactory() uint {}
-
-// Should only appear if AllDecls is set.
-type uint struct{} // overrides a predeclared type uint
-
-// ----------------------------------------------------------------------------
-// Exported declarations associated with non-exported types must always be shown.
-
-type notExported int
-
-const C notExported = 0
-
-const (
-	C1 notExported = iota
-	C2
-	c3
-	C4
-	C5
-)
-
-var V notExported
-var V1, V2, v3, V4, V5 notExported
-
-var (
-	U1, U2, u3, U4, U5 notExported
-	u6                 notExported
-	U7                 notExported = 7
-)
-
-func F1() notExported {}
-func f2() notExported {}
diff --git a/third_party/golang/go/doc/testdata/benchmark.go b/third_party/golang/go/doc/testdata/benchmark.go
deleted file mode 100644
index 905e49644ad14..0000000000000
--- a/third_party/golang/go/doc/testdata/benchmark.go
+++ /dev/null
@@ -1,293 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package testing
-
-import (
-	"flag"
-	"fmt"
-	"os"
-	"runtime"
-	"time"
-)
-
-var matchBenchmarks = flag.String("test.bench", "", "regular expression to select benchmarks to run")
-var benchTime = flag.Duration("test.benchtime", 1*time.Second, "approximate run time for each benchmark")
-
-// An internal type but exported because it is cross-package; part of the implementation
-// of go test.
-type InternalBenchmark struct {
-	Name string
-	F    func(b *B)
-}
-
-// B is a type passed to Benchmark functions to manage benchmark
-// timing and to specify the number of iterations to run.
-type B struct {
-	common
-	N         int
-	benchmark InternalBenchmark
-	bytes     int64
-	timerOn   bool
-	result    BenchmarkResult
-}
-
-// StartTimer starts timing a test.  This function is called automatically
-// before a benchmark starts, but it can also used to resume timing after
-// a call to StopTimer.
-func (b *B) StartTimer() {
-	if !b.timerOn {
-		b.start = time.Now()
-		b.timerOn = true
-	}
-}
-
-// StopTimer stops timing a test.  This can be used to pause the timer
-// while performing complex initialization that you don't
-// want to measure.
-func (b *B) StopTimer() {
-	if b.timerOn {
-		b.duration += time.Now().Sub(b.start)
-		b.timerOn = false
-	}
-}
-
-// ResetTimer sets the elapsed benchmark time to zero.
-// It does not affect whether the timer is running.
-func (b *B) ResetTimer() {
-	if b.timerOn {
-		b.start = time.Now()
-	}
-	b.duration = 0
-}
-
-// SetBytes records the number of bytes processed in a single operation.
-// If this is called, the benchmark will report ns/op and MB/s.
-func (b *B) SetBytes(n int64) { b.bytes = n }
-
-func (b *B) nsPerOp() int64 {
-	if b.N <= 0 {
-		return 0
-	}
-	return b.duration.Nanoseconds() / int64(b.N)
-}
-
-// runN runs a single benchmark for the specified number of iterations.
-func (b *B) runN(n int) {
-	// Try to get a comparable environment for each run
-	// by clearing garbage from previous runs.
-	runtime.GC()
-	b.N = n
-	b.ResetTimer()
-	b.StartTimer()
-	b.benchmark.F(b)
-	b.StopTimer()
-}
-
-func min(x, y int) int {
-	if x > y {
-		return y
-	}
-	return x
-}
-
-func max(x, y int) int {
-	if x < y {
-		return y
-	}
-	return x
-}
-
-// roundDown10 rounds a number down to the nearest power of 10.
-func roundDown10(n int) int {
-	var tens = 0
-	// tens = floor(log_10(n))
-	for n > 10 {
-		n = n / 10
-		tens++
-	}
-	// result = 10^tens
-	result := 1
-	for i := 0; i < tens; i++ {
-		result *= 10
-	}
-	return result
-}
-
-// roundUp rounds x up to a number of the form [1eX, 2eX, 5eX].
-func roundUp(n int) int {
-	base := roundDown10(n)
-	if n < (2 * base) {
-		return 2 * base
-	}
-	if n < (5 * base) {
-		return 5 * base
-	}
-	return 10 * base
-}
-
-// run times the benchmark function in a separate goroutine.
-func (b *B) run() BenchmarkResult {
-	go b.launch()
-	<-b.signal
-	return b.result
-}
-
-// launch launches the benchmark function.  It gradually increases the number
-// of benchmark iterations until the benchmark runs for a second in order
-// to get a reasonable measurement.  It prints timing information in this form
-//		testing.BenchmarkHello	100000		19 ns/op
-// launch is run by the fun function as a separate goroutine.
-func (b *B) launch() {
-	// Run the benchmark for a single iteration in case it's expensive.
-	n := 1
-
-	// Signal that we're done whether we return normally
-	// or by FailNow's runtime.Goexit.
-	defer func() {
-		b.signal <- b
-	}()
-
-	b.runN(n)
-	// Run the benchmark for at least the specified amount of time.
-	d := *benchTime
-	for !b.failed && b.duration < d && n < 1e9 {
-		last := n
-		// Predict iterations/sec.
-		if b.nsPerOp() == 0 {
-			n = 1e9
-		} else {
-			n = int(d.Nanoseconds() / b.nsPerOp())
-		}
-		// Run more iterations than we think we'll need for a second (1.5x).
-		// Don't grow too fast in case we had timing errors previously.
-		// Be sure to run at least one more than last time.
-		n = max(min(n+n/2, 100*last), last+1)
-		// Round up to something easy to read.
-		n = roundUp(n)
-		b.runN(n)
-	}
-	b.result = BenchmarkResult{b.N, b.duration, b.bytes}
-}
-
-// The results of a benchmark run.
-type BenchmarkResult struct {
-	N     int           // The number of iterations.
-	T     time.Duration // The total time taken.
-	Bytes int64         // Bytes processed in one iteration.
-}
-
-func (r BenchmarkResult) NsPerOp() int64 {
-	if r.N <= 0 {
-		return 0
-	}
-	return r.T.Nanoseconds() / int64(r.N)
-}
-
-func (r BenchmarkResult) mbPerSec() float64 {
-	if r.Bytes <= 0 || r.T <= 0 || r.N <= 0 {
-		return 0
-	}
-	return (float64(r.Bytes) * float64(r.N) / 1e6) / r.T.Seconds()
-}
-
-func (r BenchmarkResult) String() string {
-	mbs := r.mbPerSec()
-	mb := ""
-	if mbs != 0 {
-		mb = fmt.Sprintf("\t%7.2f MB/s", mbs)
-	}
-	nsop := r.NsPerOp()
-	ns := fmt.Sprintf("%10d ns/op", nsop)
-	if r.N > 0 && nsop < 100 {
-		// The format specifiers here make sure that
-		// the ones digits line up for all three possible formats.
-		if nsop < 10 {
-			ns = fmt.Sprintf("%13.2f ns/op", float64(r.T.Nanoseconds())/float64(r.N))
-		} else {
-			ns = fmt.Sprintf("%12.1f ns/op", float64(r.T.Nanoseconds())/float64(r.N))
-		}
-	}
-	return fmt.Sprintf("%8d\t%s%s", r.N, ns, mb)
-}
-
-// An internal function but exported because it is cross-package; part of the implementation
-// of go test.
-func RunBenchmarks(matchString func(pat, str string) (bool, error), benchmarks []InternalBenchmark) {
-	// If no flag was specified, don't run benchmarks.
-	if len(*matchBenchmarks) == 0 {
-		return
-	}
-	for _, Benchmark := range benchmarks {
-		matched, err := matchString(*matchBenchmarks, Benchmark.Name)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "testing: invalid regexp for -test.bench: %s\n", err)
-			os.Exit(1)
-		}
-		if !matched {
-			continue
-		}
-		for _, procs := range cpuList {
-			runtime.GOMAXPROCS(procs)
-			b := &B{
-				common: common{
-					signal: make(chan interface{}),
-				},
-				benchmark: Benchmark,
-			}
-			benchName := Benchmark.Name
-			if procs != 1 {
-				benchName = fmt.Sprintf("%s-%d", Benchmark.Name, procs)
-			}
-			fmt.Printf("%s\t", benchName)
-			r := b.run()
-			if b.failed {
-				// The output could be very long here, but probably isn't.
-				// We print it all, regardless, because we don't want to trim the reason
-				// the benchmark failed.
-				fmt.Printf("--- FAIL: %s\n%s", benchName, b.output)
-				continue
-			}
-			fmt.Printf("%v\n", r)
-			// Unlike with tests, we ignore the -chatty flag and always print output for
-			// benchmarks since the output generation time will skew the results.
-			if len(b.output) > 0 {
-				b.trimOutput()
-				fmt.Printf("--- BENCH: %s\n%s", benchName, b.output)
-			}
-			if p := runtime.GOMAXPROCS(-1); p != procs {
-				fmt.Fprintf(os.Stderr, "testing: %s left GOMAXPROCS set to %d\n", benchName, p)
-			}
-		}
-	}
-}
-
-// trimOutput shortens the output from a benchmark, which can be very long.
-func (b *B) trimOutput() {
-	// The output is likely to appear multiple times because the benchmark
-	// is run multiple times, but at least it will be seen. This is not a big deal
-	// because benchmarks rarely print, but just in case, we trim it if it's too long.
-	const maxNewlines = 10
-	for nlCount, j := 0, 0; j < len(b.output); j++ {
-		if b.output[j] == '\n' {
-			nlCount++
-			if nlCount >= maxNewlines {
-				b.output = append(b.output[:j], "\n\t... [output truncated]\n"...)
-				break
-			}
-		}
-	}
-}
-
-// Benchmark benchmarks a single function. Useful for creating
-// custom benchmarks that do not use go test.
-func Benchmark(f func(b *B)) BenchmarkResult {
-	b := &B{
-		common: common{
-			signal: make(chan interface{}),
-		},
-		benchmark: InternalBenchmark{"", f},
-	}
-	return b.run()
-}
diff --git a/third_party/golang/go/doc/testdata/blank.0.golden b/third_party/golang/go/doc/testdata/blank.0.golden
deleted file mode 100644
index c2987cf140ec4..0000000000000
--- a/third_party/golang/go/doc/testdata/blank.0.golden
+++ /dev/null
@@ -1,55 +0,0 @@
-// Package blank is a go/doc test for the handling of _. See issue ...
-PACKAGE blank
-
-IMPORTPATH
-	testdata/blank
-
-IMPORTS
-	os
-
-FILENAMES
-	testdata/blank.go
-
-CONSTANTS
-	// T constants counting from unexported constants. 
-	const (
-		C1	T
-		C2
-	
-		C3
-	
-		C4	int
-	)
-
-	// Constants with an imported type that needs to be propagated. 
-	const (
-		Default		os.FileMode	= 0644
-		Useless				= 0312
-		WideOpen			= 0777
-	)
-
-	// Package constants. 
-	const (
-		I1	int
-		I2
-	)
-
-
-TYPES
-	// S has a padding field. 
-	type S struct {
-		H	uint32
-	
-		A	uint8
-		// contains filtered or unexported fields
-	}
-
-	// 
-	type T int
-
-	// T constants counting from a blank constant. 
-	const (
-		T1	T
-		T2
-	)
-
diff --git a/third_party/golang/go/doc/testdata/blank.1.golden b/third_party/golang/go/doc/testdata/blank.1.golden
deleted file mode 100644
index ee5054a4ed616..0000000000000
--- a/third_party/golang/go/doc/testdata/blank.1.golden
+++ /dev/null
@@ -1,75 +0,0 @@
-// Package blank is a go/doc test for the handling of _. See issue ...
-PACKAGE blank
-
-IMPORTPATH
-	testdata/blank
-
-IMPORTS
-	os
-
-FILENAMES
-	testdata/blank.go
-
-CONSTANTS
-	// T constants counting from unexported constants. 
-	const (
-		tweedledee	T	= iota
-		tweedledum
-		C1
-		C2
-		alice
-		C3
-		redQueen	int	= iota
-		C4
-	)
-
-	// Package constants. 
-	const (
-		_	int	= iota
-		I1
-		I2
-	)
-
-	// Constants with an imported type that needs to be propagated. 
-	const (
-		zero		os.FileMode	= 0
-		Default				= 0644
-		Useless				= 0312
-		WideOpen			= 0777
-	)
-
-	// Unexported constants counting from blank iota. See issue 9615. 
-	const (
-		_	= iota
-		one	= iota + 1
-	)
-
-
-VARIABLES
-	// 
-	var _ = T(55)
-
-
-FUNCTIONS
-	// 
-	func _()
-
-
-TYPES
-	// S has a padding field. 
-	type S struct {
-		H	uint32
-		_	uint8
-		A	uint8
-	}
-
-	// 
-	type T int
-
-	// T constants counting from a blank constant. 
-	const (
-		_	T	= iota
-		T1
-		T2
-	)
-
diff --git a/third_party/golang/go/doc/testdata/blank.2.golden b/third_party/golang/go/doc/testdata/blank.2.golden
deleted file mode 100644
index c2987cf140ec4..0000000000000
--- a/third_party/golang/go/doc/testdata/blank.2.golden
+++ /dev/null
@@ -1,55 +0,0 @@
-// Package blank is a go/doc test for the handling of _. See issue ...
-PACKAGE blank
-
-IMPORTPATH
-	testdata/blank
-
-IMPORTS
-	os
-
-FILENAMES
-	testdata/blank.go
-
-CONSTANTS
-	// T constants counting from unexported constants. 
-	const (
-		C1	T
-		C2
-	
-		C3
-	
-		C4	int
-	)
-
-	// Constants with an imported type that needs to be propagated. 
-	const (
-		Default		os.FileMode	= 0644
-		Useless				= 0312
-		WideOpen			= 0777
-	)
-
-	// Package constants. 
-	const (
-		I1	int
-		I2
-	)
-
-
-TYPES
-	// S has a padding field. 
-	type S struct {
-		H	uint32
-	
-		A	uint8
-		// contains filtered or unexported fields
-	}
-
-	// 
-	type T int
-
-	// T constants counting from a blank constant. 
-	const (
-		T1	T
-		T2
-	)
-
diff --git a/third_party/golang/go/doc/testdata/blank.go b/third_party/golang/go/doc/testdata/blank.go
deleted file mode 100644
index 419a78f7d5116..0000000000000
--- a/third_party/golang/go/doc/testdata/blank.go
+++ /dev/null
@@ -1,67 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package blank is a go/doc test for the handling of _.
-// See issue 5397.
-package blank
-
-import "os"
-
-type T int
-
-// T constants counting from a blank constant.
-const (
-	_ T = iota
-	T1
-	T2
-)
-
-// T constants counting from unexported constants.
-const (
-	tweedledee T = iota
-	tweedledum
-	C1
-	C2
-	alice
-	C3
-	redQueen int = iota
-	C4
-)
-
-// Constants with an imported type that needs to be propagated.
-const (
-	zero     os.FileMode = 0
-	Default              = 0644
-	Useless              = 0312
-	WideOpen             = 0777
-)
-
-// Package constants.
-const (
-	_ int = iota
-	I1
-	I2
-)
-
-// Unexported constants counting from blank iota.
-// See issue 9615.
-const (
-	_   = iota
-	one = iota + 1
-)
-
-// Blanks not in doc output:
-
-// S has a padding field.
-type S struct {
-	H uint32
-	_ uint8
-	A uint8
-}
-
-func _() {}
-
-type _ T
-
-var _ = T(55)
diff --git a/third_party/golang/go/doc/testdata/bugpara.0.golden b/third_party/golang/go/doc/testdata/bugpara.0.golden
deleted file mode 100644
index 5804859501edc..0000000000000
--- a/third_party/golang/go/doc/testdata/bugpara.0.golden
+++ /dev/null
@@ -1,20 +0,0 @@
-// 
-PACKAGE bugpara
-
-IMPORTPATH
-	testdata/bugpara
-
-FILENAMES
-	testdata/bugpara.go
-
-BUGS .Bugs is now deprecated, please use .Notes instead
-	Sometimes bugs have multiple paragraphs.
-	
-	Like this one.
-
-
-BUGS
-BUG(rsc)	Sometimes bugs have multiple paragraphs.
-	
-	Like this one.
-
diff --git a/third_party/golang/go/doc/testdata/bugpara.1.golden b/third_party/golang/go/doc/testdata/bugpara.1.golden
deleted file mode 100644
index 5804859501edc..0000000000000
--- a/third_party/golang/go/doc/testdata/bugpara.1.golden
+++ /dev/null
@@ -1,20 +0,0 @@
-// 
-PACKAGE bugpara
-
-IMPORTPATH
-	testdata/bugpara
-
-FILENAMES
-	testdata/bugpara.go
-
-BUGS .Bugs is now deprecated, please use .Notes instead
-	Sometimes bugs have multiple paragraphs.
-	
-	Like this one.
-
-
-BUGS
-BUG(rsc)	Sometimes bugs have multiple paragraphs.
-	
-	Like this one.
-
diff --git a/third_party/golang/go/doc/testdata/bugpara.2.golden b/third_party/golang/go/doc/testdata/bugpara.2.golden
deleted file mode 100644
index 5804859501edc..0000000000000
--- a/third_party/golang/go/doc/testdata/bugpara.2.golden
+++ /dev/null
@@ -1,20 +0,0 @@
-// 
-PACKAGE bugpara
-
-IMPORTPATH
-	testdata/bugpara
-
-FILENAMES
-	testdata/bugpara.go
-
-BUGS .Bugs is now deprecated, please use .Notes instead
-	Sometimes bugs have multiple paragraphs.
-	
-	Like this one.
-
-
-BUGS
-BUG(rsc)	Sometimes bugs have multiple paragraphs.
-	
-	Like this one.
-
diff --git a/third_party/golang/go/doc/testdata/bugpara.go b/third_party/golang/go/doc/testdata/bugpara.go
deleted file mode 100644
index f5345a797532b..0000000000000
--- a/third_party/golang/go/doc/testdata/bugpara.go
+++ /dev/null
@@ -1,5 +0,0 @@
-package bugpara
-
-// BUG(rsc): Sometimes bugs have multiple paragraphs.
-//
-// Like this one.
diff --git a/third_party/golang/go/doc/testdata/c.0.golden b/third_party/golang/go/doc/testdata/c.0.golden
deleted file mode 100644
index e21959b1950dc..0000000000000
--- a/third_party/golang/go/doc/testdata/c.0.golden
+++ /dev/null
@@ -1,48 +0,0 @@
-// 
-PACKAGE c
-
-IMPORTPATH
-	testdata/c
-
-IMPORTS
-	a
-
-FILENAMES
-	testdata/c.go
-
-TYPES
-	// A (should see this) 
-	type A struct{}
-
-	// B (should see this) 
-	type B struct{}
-
-	// C (should see this) 
-	type C struct{}
-
-	// D (should see this) 
-	type D struct{}
-
-	// E1 (should see this) 
-	type E1 struct{}
-
-	// E (should see this for E2 and E3) 
-	type E2 struct{}
-
-	// E (should see this for E2 and E3) 
-	type E3 struct{}
-
-	// E4 (should see this) 
-	type E4 struct{}
-
-	// 
-	type T1 struct{}
-
-	// 
-	func (t1 *T1) M()
-
-	// T2 must not show methods of local T1 
-	type T2 struct {
-		a.T1	// not the same as locally declared T1
-	}
-
diff --git a/third_party/golang/go/doc/testdata/c.1.golden b/third_party/golang/go/doc/testdata/c.1.golden
deleted file mode 100644
index e21959b1950dc..0000000000000
--- a/third_party/golang/go/doc/testdata/c.1.golden
+++ /dev/null
@@ -1,48 +0,0 @@
-// 
-PACKAGE c
-
-IMPORTPATH
-	testdata/c
-
-IMPORTS
-	a
-
-FILENAMES
-	testdata/c.go
-
-TYPES
-	// A (should see this) 
-	type A struct{}
-
-	// B (should see this) 
-	type B struct{}
-
-	// C (should see this) 
-	type C struct{}
-
-	// D (should see this) 
-	type D struct{}
-
-	// E1 (should see this) 
-	type E1 struct{}
-
-	// E (should see this for E2 and E3) 
-	type E2 struct{}
-
-	// E (should see this for E2 and E3) 
-	type E3 struct{}
-
-	// E4 (should see this) 
-	type E4 struct{}
-
-	// 
-	type T1 struct{}
-
-	// 
-	func (t1 *T1) M()
-
-	// T2 must not show methods of local T1 
-	type T2 struct {
-		a.T1	// not the same as locally declared T1
-	}
-
diff --git a/third_party/golang/go/doc/testdata/c.2.golden b/third_party/golang/go/doc/testdata/c.2.golden
deleted file mode 100644
index e21959b1950dc..0000000000000
--- a/third_party/golang/go/doc/testdata/c.2.golden
+++ /dev/null
@@ -1,48 +0,0 @@
-// 
-PACKAGE c
-
-IMPORTPATH
-	testdata/c
-
-IMPORTS
-	a
-
-FILENAMES
-	testdata/c.go
-
-TYPES
-	// A (should see this) 
-	type A struct{}
-
-	// B (should see this) 
-	type B struct{}
-
-	// C (should see this) 
-	type C struct{}
-
-	// D (should see this) 
-	type D struct{}
-
-	// E1 (should see this) 
-	type E1 struct{}
-
-	// E (should see this for E2 and E3) 
-	type E2 struct{}
-
-	// E (should see this for E2 and E3) 
-	type E3 struct{}
-
-	// E4 (should see this) 
-	type E4 struct{}
-
-	// 
-	type T1 struct{}
-
-	// 
-	func (t1 *T1) M()
-
-	// T2 must not show methods of local T1 
-	type T2 struct {
-		a.T1	// not the same as locally declared T1
-	}
-
diff --git a/third_party/golang/go/doc/testdata/c.go b/third_party/golang/go/doc/testdata/c.go
deleted file mode 100644
index e0f39196deea8..0000000000000
--- a/third_party/golang/go/doc/testdata/c.go
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package c
-
-import "a"
-
-// ----------------------------------------------------------------------------
-// Test that empty declarations don't cause problems
-
-const ()
-
-type ()
-
-var ()
-
-// ----------------------------------------------------------------------------
-// Test that types with documentation on both, the Decl and the Spec node
-// are handled correctly.
-
-// A (should see this)
-type A struct{}
-
-// B (should see this)
-type (
-	B struct{}
-)
-
-type (
-	// C (should see this)
-	C struct{}
-)
-
-// D (should not see this)
-type (
-	// D (should see this)
-	D struct{}
-)
-
-// E (should see this for E2 and E3)
-type (
-	// E1 (should see this)
-	E1 struct{}
-	E2 struct{}
-	E3 struct{}
-	// E4 (should see this)
-	E4 struct{}
-)
-
-// ----------------------------------------------------------------------------
-// Test that local and imported types are different when
-// handling anonymous fields.
-
-type T1 struct{}
-
-func (t1 *T1) M() {}
-
-// T2 must not show methods of local T1
-type T2 struct {
-	a.T1 // not the same as locally declared T1
-}
diff --git a/third_party/golang/go/doc/testdata/d.0.golden b/third_party/golang/go/doc/testdata/d.0.golden
deleted file mode 100644
index c0051995334af..0000000000000
--- a/third_party/golang/go/doc/testdata/d.0.golden
+++ /dev/null
@@ -1,104 +0,0 @@
-// 
-PACKAGE d
-
-IMPORTPATH
-	testdata/d
-
-FILENAMES
-	testdata/d1.go
-	testdata/d2.go
-
-CONSTANTS
-	// CBx constants should appear before CAx constants. 
-	const (
-		CB2	= iota	// before CB1
-		CB1		// before CB0
-		CB0		// at end
-	)
-
-	// CAx constants should appear after CBx constants. 
-	const (
-		CA2	= iota	// before CA1
-		CA1		// before CA0
-		CA0		// at end
-	)
-
-	// C0 should be first. 
-	const C0 = 0
-
-	// C1 should be second. 
-	const C1 = 1
-
-	// C2 should be third. 
-	const C2 = 2
-
-	// 
-	const (
-		// Single const declarations inside ()'s are considered ungrouped
-		// and show up in sorted order.
-		Cungrouped = 0
-	)
-
-
-VARIABLES
-	// VBx variables should appear before VAx variables. 
-	var (
-		VB2	int	// before VB1
-		VB1	int	// before VB0
-		VB0	int	// at end
-	)
-
-	// VAx variables should appear after VBx variables. 
-	var (
-		VA2	int	// before VA1
-		VA1	int	// before VA0
-		VA0	int	// at end
-	)
-
-	// V0 should be first. 
-	var V0 uintptr
-
-	// V1 should be second. 
-	var V1 uint
-
-	// V2 should be third. 
-	var V2 int
-
-	// 
-	var (
-		// Single var declarations inside ()'s are considered ungrouped
-		// and show up in sorted order.
-		Vungrouped = 0
-	)
-
-
-FUNCTIONS
-	// F0 should be first. 
-	func F0()
-
-	// F1 should be second. 
-	func F1()
-
-	// F2 should be third. 
-	func F2()
-
-
-TYPES
-	// T0 should be first. 
-	type T0 struct{}
-
-	// T1 should be second. 
-	type T1 struct{}
-
-	// T2 should be third. 
-	type T2 struct{}
-
-	// TG0 should be first. 
-	type TG0 struct{}
-
-	// TG1 should be second. 
-	type TG1 struct{}
-
-	// TG2 should be third. 
-	type TG2 struct{}
-
diff --git a/third_party/golang/go/doc/testdata/d.1.golden b/third_party/golang/go/doc/testdata/d.1.golden
deleted file mode 100644
index c0051995334af..0000000000000
--- a/third_party/golang/go/doc/testdata/d.1.golden
+++ /dev/null
@@ -1,104 +0,0 @@
-// 
-PACKAGE d
-
-IMPORTPATH
-	testdata/d
-
-FILENAMES
-	testdata/d1.go
-	testdata/d2.go
-
-CONSTANTS
-	// CBx constants should appear before CAx constants. 
-	const (
-		CB2	= iota	// before CB1
-		CB1		// before CB0
-		CB0		// at end
-	)
-
-	// CAx constants should appear after CBx constants. 
-	const (
-		CA2	= iota	// before CA1
-		CA1		// before CA0
-		CA0		// at end
-	)
-
-	// C0 should be first. 
-	const C0 = 0
-
-	// C1 should be second. 
-	const C1 = 1
-
-	// C2 should be third. 
-	const C2 = 2
-
-	// 
-	const (
-		// Single const declarations inside ()'s are considered ungrouped
-		// and show up in sorted order.
-		Cungrouped = 0
-	)
-
-
-VARIABLES
-	// VBx variables should appear before VAx variables. 
-	var (
-		VB2	int	// before VB1
-		VB1	int	// before VB0
-		VB0	int	// at end
-	)
-
-	// VAx variables should appear after VBx variables. 
-	var (
-		VA2	int	// before VA1
-		VA1	int	// before VA0
-		VA0	int	// at end
-	)
-
-	// V0 should be first. 
-	var V0 uintptr
-
-	// V1 should be second. 
-	var V1 uint
-
-	// V2 should be third. 
-	var V2 int
-
-	// 
-	var (
-		// Single var declarations inside ()'s are considered ungrouped
-		// and show up in sorted order.
-		Vungrouped = 0
-	)
-
-
-FUNCTIONS
-	// F0 should be first. 
-	func F0()
-
-	// F1 should be second. 
-	func F1()
-
-	// F2 should be third. 
-	func F2()
-
-
-TYPES
-	// T0 should be first. 
-	type T0 struct{}
-
-	// T1 should be second. 
-	type T1 struct{}
-
-	// T2 should be third. 
-	type T2 struct{}
-
-	// TG0 should be first. 
-	type TG0 struct{}
-
-	// TG1 should be second. 
-	type TG1 struct{}
-
-	// TG2 should be third. 
-	type TG2 struct{}
-
diff --git a/third_party/golang/go/doc/testdata/d.2.golden b/third_party/golang/go/doc/testdata/d.2.golden
deleted file mode 100644
index c0051995334af..0000000000000
--- a/third_party/golang/go/doc/testdata/d.2.golden
+++ /dev/null
@@ -1,104 +0,0 @@
-// 
-PACKAGE d
-
-IMPORTPATH
-	testdata/d
-
-FILENAMES
-	testdata/d1.go
-	testdata/d2.go
-
-CONSTANTS
-	// CBx constants should appear before CAx constants. 
-	const (
-		CB2	= iota	// before CB1
-		CB1		// before CB0
-		CB0		// at end
-	)
-
-	// CAx constants should appear after CBx constants. 
-	const (
-		CA2	= iota	// before CA1
-		CA1		// before CA0
-		CA0		// at end
-	)
-
-	// C0 should be first. 
-	const C0 = 0
-
-	// C1 should be second. 
-	const C1 = 1
-
-	// C2 should be third. 
-	const C2 = 2
-
-	// 
-	const (
-		// Single const declarations inside ()'s are considered ungrouped
-		// and show up in sorted order.
-		Cungrouped = 0
-	)
-
-
-VARIABLES
-	// VBx variables should appear before VAx variables. 
-	var (
-		VB2	int	// before VB1
-		VB1	int	// before VB0
-		VB0	int	// at end
-	)
-
-	// VAx variables should appear after VBx variables. 
-	var (
-		VA2	int	// before VA1
-		VA1	int	// before VA0
-		VA0	int	// at end
-	)
-
-	// V0 should be first. 
-	var V0 uintptr
-
-	// V1 should be second. 
-	var V1 uint
-
-	// V2 should be third. 
-	var V2 int
-
-	// 
-	var (
-		// Single var declarations inside ()'s are considered ungrouped
-		// and show up in sorted order.
-		Vungrouped = 0
-	)
-
-
-FUNCTIONS
-	// F0 should be first. 
-	func F0()
-
-	// F1 should be second. 
-	func F1()
-
-	// F2 should be third. 
-	func F2()
-
-
-TYPES
-	// T0 should be first. 
-	type T0 struct{}
-
-	// T1 should be second. 
-	type T1 struct{}
-
-	// T2 should be third. 
-	type T2 struct{}
-
-	// TG0 should be first. 
-	type TG0 struct{}
-
-	// TG1 should be second. 
-	type TG1 struct{}
-
-	// TG2 should be third. 
-	type TG2 struct{}
-
diff --git a/third_party/golang/go/doc/testdata/d1.go b/third_party/golang/go/doc/testdata/d1.go
deleted file mode 100644
index ebd69419589f1..0000000000000
--- a/third_party/golang/go/doc/testdata/d1.go
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Test cases for sort order of declarations.
-
-package d
-
-// C2 should be third.
-const C2 = 2
-
-// V2 should be third.
-var V2 int
-
-// CBx constants should appear before CAx constants.
-const (
-	CB2 = iota // before CB1
-	CB1        // before CB0
-	CB0        // at end
-)
-
-// VBx variables should appear before VAx variables.
-var (
-	VB2 int // before VB1
-	VB1 int // before VB0
-	VB0 int // at end
-)
-
-const (
-	// Single const declarations inside ()'s are considered ungrouped
-	// and show up in sorted order.
-	Cungrouped = 0
-)
-
-var (
-	// Single var declarations inside ()'s are considered ungrouped
-	// and show up in sorted order.
-	Vungrouped = 0
-)
-
-// T2 should be third.
-type T2 struct{}
-
-// Grouped types are sorted nevertheless.
-type (
-	// TG2 should be third.
-	TG2 struct{}
-
-	// TG1 should be second.
-	TG1 struct{}
-
-	// TG0 should be first.
-	TG0 struct{}
-)
-
-// F2 should be third.
-func F2() {}
diff --git a/third_party/golang/go/doc/testdata/d2.go b/third_party/golang/go/doc/testdata/d2.go
deleted file mode 100644
index 2f56f4fa4ca3a..0000000000000
--- a/third_party/golang/go/doc/testdata/d2.go
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Test cases for sort order of declarations.
-
-package d
-
-// C1 should be second.
-const C1 = 1
-
-// C0 should be first.
-const C0 = 0
-
-// V1 should be second.
-var V1 uint
-
-// V0 should be first.
-var V0 uintptr
-
-// CAx constants should appear after CBx constants.
-const (
-	CA2 = iota // before CA1
-	CA1        // before CA0
-	CA0        // at end
-)
-
-// VAx variables should appear after VBx variables.
-var (
-	VA2 int // before VA1
-	VA1 int // before VA0
-	VA0 int // at end
-)
-
-// T1 should be second.
-type T1 struct{}
-
-// T0 should be first.
-type T0 struct{}
-
-// F1 should be second.
-func F1() {}
-
-// F0 should be first.
-func F0() {}
diff --git a/third_party/golang/go/doc/testdata/e.0.golden b/third_party/golang/go/doc/testdata/e.0.golden
deleted file mode 100644
index 6987e5867cffc..0000000000000
--- a/third_party/golang/go/doc/testdata/e.0.golden
+++ /dev/null
@@ -1,109 +0,0 @@
-// The package e is a go/doc test for embedded methods. 
-PACKAGE e
-
-IMPORTPATH
-	testdata/e
-
-FILENAMES
-	testdata/e.go
-
-TYPES
-	// T1 has no embedded (level 1) M method due to conflict. 
-	type T1 struct {
-		// contains filtered or unexported fields
-	}
-
-	// T2 has only M as top-level method. 
-	type T2 struct {
-		// contains filtered or unexported fields
-	}
-
-	// T2.M should appear as method of T2. 
-	func (T2) M()
-
-	// T3 has only M as top-level method. 
-	type T3 struct {
-		// contains filtered or unexported fields
-	}
-
-	// T3.M should appear as method of T3. 
-	func (T3) M()
-
-	// 
-	type T4 struct{}
-
-	// T4.M should appear as method of T5 only if AllMethods is set. 
-	func (*T4) M()
-
-	// 
-	type T5 struct {
-		T4
-	}
-
-	// 
-	type U1 struct {
-		*U1
-	}
-
-	// U1.M should appear as method of U1. 
-	func (*U1) M()
-
-	// 
-	type U2 struct {
-		*U3
-	}
-
-	// U2.M should appear as method of U2 and as method of U3 only if ...
-	func (*U2) M()
-
-	// 
-	type U3 struct {
-		*U2
-	}
-
-	// U3.N should appear as method of U3 and as method of U2 only if ...
-	func (*U3) N()
-
-	// 
-	type U4 struct {
-		// contains filtered or unexported fields
-	}
-
-	// U4.M should appear as method of U4. 
-	func (*U4) M()
-
-	// 
-	type V1 struct {
-		*V2
-		*V5
-	}
-
-	// 
-	type V2 struct {
-		*V3
-	}
-
-	// 
-	type V3 struct {
-		*V4
-	}
-
-	// 
-	type V4 struct {
-		*V5
-	}
-
-	// V4.M should appear as method of V2 and V3 if AllMethods is set. 
-	func (*V4) M()
-
-	// 
-	type V5 struct {
-		*V6
-	}
-
-	// 
-	type V6 struct{}
-
-	// V6.M should appear as method of V1 and V5 if AllMethods is set. 
-	func (*V6) M()
-
diff --git a/third_party/golang/go/doc/testdata/e.1.golden b/third_party/golang/go/doc/testdata/e.1.golden
deleted file mode 100644
index cbe22e0bf63e7..0000000000000
--- a/third_party/golang/go/doc/testdata/e.1.golden
+++ /dev/null
@@ -1,144 +0,0 @@
-// The package e is a go/doc test for embedded methods. 
-PACKAGE e
-
-IMPORTPATH
-	testdata/e
-
-FILENAMES
-	testdata/e.go
-
-TYPES
-	// T1 has no embedded (level 1) M method due to conflict. 
-	type T1 struct {
-		t1
-		t2
-	}
-
-	// T2 has only M as top-level method. 
-	type T2 struct {
-		t1
-	}
-
-	// T2.M should appear as method of T2. 
-	func (T2) M()
-
-	// T3 has only M as top-level method. 
-	type T3 struct {
-		t1e
-		t2e
-	}
-
-	// T3.M should appear as method of T3. 
-	func (T3) M()
-
-	// 
-	type T4 struct{}
-
-	// T4.M should appear as method of T5 only if AllMethods is set. 
-	func (*T4) M()
-
-	// 
-	type T5 struct {
-		T4
-	}
-
-	// 
-	type U1 struct {
-		*U1
-	}
-
-	// U1.M should appear as method of U1. 
-	func (*U1) M()
-
-	// 
-	type U2 struct {
-		*U3
-	}
-
-	// U2.M should appear as method of U2 and as method of U3 only if ...
-	func (*U2) M()
-
-	// 
-	type U3 struct {
-		*U2
-	}
-
-	// U3.N should appear as method of U3 and as method of U2 only if ...
-	func (*U3) N()
-
-	// 
-	type U4 struct {
-		*u5
-	}
-
-	// U4.M should appear as method of U4. 
-	func (*U4) M()
-
-	// 
-	type V1 struct {
-		*V2
-		*V5
-	}
-
-	// 
-	type V2 struct {
-		*V3
-	}
-
-	// 
-	type V3 struct {
-		*V4
-	}
-
-	// 
-	type V4 struct {
-		*V5
-	}
-
-	// V4.M should appear as method of V2 and V3 if AllMethods is set. 
-	func (*V4) M()
-
-	// 
-	type V5 struct {
-		*V6
-	}
-
-	// 
-	type V6 struct{}
-
-	// V6.M should appear as method of V1 and V5 if AllMethods is set. 
-	func (*V6) M()
-
-	// 
-	type t1 struct{}
-
-	// t1.M should not appear as method in a Tx type. 
-	func (t1) M()
-
-	// 
-	type t1e struct {
-		t1
-	}
-
-	// t1.M should not appear as method in a Tx type. 
-	func (t1e) M()
-
-	// 
-	type t2 struct{}
-
-	// t2.M should not appear as method in a Tx type. 
-	func (t2) M()
-
-	// 
-	type t2e struct {
-		t2
-	}
-
-	// t2.M should not appear as method in a Tx type. 
-	func (t2e) M()
-
-	// 
-	type u5 struct {
-		*U4
-	}
-
diff --git a/third_party/golang/go/doc/testdata/e.2.golden b/third_party/golang/go/doc/testdata/e.2.golden
deleted file mode 100644
index e7b05e80faf20..0000000000000
--- a/third_party/golang/go/doc/testdata/e.2.golden
+++ /dev/null
@@ -1,130 +0,0 @@
-// The package e is a go/doc test for embedded methods. 
-PACKAGE e
-
-IMPORTPATH
-	testdata/e
-
-FILENAMES
-	testdata/e.go
-
-TYPES
-	// T1 has no embedded (level 1) M method due to conflict. 
-	type T1 struct {
-		// contains filtered or unexported fields
-	}
-
-	// T2 has only M as top-level method. 
-	type T2 struct {
-		// contains filtered or unexported fields
-	}
-
-	// T2.M should appear as method of T2. 
-	func (T2) M()
-
-	// T3 has only M as top-level method. 
-	type T3 struct {
-		// contains filtered or unexported fields
-	}
-
-	// T3.M should appear as method of T3. 
-	func (T3) M()
-
-	// 
-	type T4 struct{}
-
-	// T4.M should appear as method of T5 only if AllMethods is set. 
-	func (*T4) M()
-
-	// 
-	type T5 struct {
-		T4
-	}
-
-	// T4.M should appear as method of T5 only if AllMethods is set. 
-	func (*T5) M()
-
-	// 
-	type U1 struct {
-		*U1
-	}
-
-	// U1.M should appear as method of U1. 
-	func (*U1) M()
-
-	// 
-	type U2 struct {
-		*U3
-	}
-
-	// U2.M should appear as method of U2 and as method of U3 only if ...
-	func (*U2) M()
-
-	// U3.N should appear as method of U3 and as method of U2 only if ...
-	func (U2) N()
-
-	// 
-	type U3 struct {
-		*U2
-	}
-
-	// U2.M should appear as method of U2 and as method of U3 only if ...
-	func (U3) M()
-
-	// U3.N should appear as method of U3 and as method of U2 only if ...
-	func (*U3) N()
-
-	// 
-	type U4 struct {
-		// contains filtered or unexported fields
-	}
-
-	// U4.M should appear as method of U4. 
-	func (*U4) M()
-
-	// 
-	type V1 struct {
-		*V2
-		*V5
-	}
-
-	// V6.M should appear as method of V1 and V5 if AllMethods is set. 
-	func (V1) M()
-
-	// 
-	type V2 struct {
-		*V3
-	}
-
-	// V4.M should appear as method of V2 and V3 if AllMethods is set. 
-	func (V2) M()
-
-	// 
-	type V3 struct {
-		*V4
-	}
-
-	// V4.M should appear as method of V2 and V3 if AllMethods is set. 
-	func (V3) M()
-
-	// 
-	type V4 struct {
-		*V5
-	}
-
-	// V4.M should appear as method of V2 and V3 if AllMethods is set. 
-	func (*V4) M()
-
-	// 
-	type V5 struct {
-		*V6
-	}
-
-	// V6.M should appear as method of V1 and V5 if AllMethods is set. 
-	func (V5) M()
-
-	// 
-	type V6 struct{}
-
-	// V6.M should appear as method of V1 and V5 if AllMethods is set. 
-	func (*V6) M()
-
diff --git a/third_party/golang/go/doc/testdata/e.go b/third_party/golang/go/doc/testdata/e.go
deleted file mode 100644
index ec432e3e527f1..0000000000000
--- a/third_party/golang/go/doc/testdata/e.go
+++ /dev/null
@@ -1,147 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// The package e is a go/doc test for embedded methods.
-package e
-
-// ----------------------------------------------------------------------------
-// Conflicting methods M must not show up.
-
-type t1 struct{}
-
-// t1.M should not appear as method in a Tx type.
-func (t1) M() {}
-
-type t2 struct{}
-
-// t2.M should not appear as method in a Tx type.
-func (t2) M() {}
-
-// T1 has no embedded (level 1) M method due to conflict.
-type T1 struct {
-	t1
-	t2
-}
-
-// ----------------------------------------------------------------------------
-// Higher-level method M wins over lower-level method M.
-
-// T2 has only M as top-level method.
-type T2 struct {
-	t1
-}
-
-// T2.M should appear as method of T2.
-func (T2) M() {}
-
-// ----------------------------------------------------------------------------
-// Higher-level method M wins over lower-level conflicting methods M.
-
-type t1e struct {
-	t1
-}
-
-type t2e struct {
-	t2
-}
-
-// T3 has only M as top-level method.
-type T3 struct {
-	t1e
-	t2e
-}
-
-// T3.M should appear as method of T3.
-func (T3) M() {}
-
-// ----------------------------------------------------------------------------
-// Don't show conflicting methods M embedded via an exported and non-exported
-// type.
-
-// T1 has no embedded (level 1) M method due to conflict.
-type T4 struct {
-	t2
-	T2
-}
-
-// ----------------------------------------------------------------------------
-// Don't show embedded methods of exported anonymous fields unless AllMethods
-// is set.
-
-type T4 struct{}
-
-// T4.M should appear as method of T5 only if AllMethods is set.
-func (*T4) M() {}
-
-type T5 struct {
-	T4
-}
-
-// ----------------------------------------------------------------------------
-// Recursive type declarations must not lead to endless recursion.
-
-type U1 struct {
-	*U1
-}
-
-// U1.M should appear as method of U1.
-func (*U1) M() {}
-
-type U2 struct {
-	*U3
-}
-
-// U2.M should appear as method of U2 and as method of U3 only if AllMethods is set.
-func (*U2) M() {}
-
-type U3 struct {
-	*U2
-}
-
-// U3.N should appear as method of U3 and as method of U2 only if AllMethods is set.
-func (*U3) N() {}
-
-type U4 struct {
-	*u5
-}
-
-// U4.M should appear as method of U4.
-func (*U4) M() {}
-
-type u5 struct {
-	*U4
-}
-
-// ----------------------------------------------------------------------------
-// A higher-level embedded type (and its methods) wins over the same type (and
-// its methods) embedded at a lower level.
-
-type V1 struct {
-	*V2
-	*V5
-}
-
-type V2 struct {
-	*V3
-}
-
-type V3 struct {
-	*V4
-}
-
-type V4 struct {
-	*V5
-}
-
-type V5 struct {
-	*V6
-}
-
-type V6 struct{}
-
-// V4.M should appear as method of V2 and V3 if AllMethods is set.
-func (*V4) M() {}
-
-// V6.M should appear as method of V1 and V5 if AllMethods is set.
-func (*V6) M() {}
diff --git a/third_party/golang/go/doc/testdata/error1.0.golden b/third_party/golang/go/doc/testdata/error1.0.golden
deleted file mode 100644
index 6c6fe5d49bdf0..0000000000000
--- a/third_party/golang/go/doc/testdata/error1.0.golden
+++ /dev/null
@@ -1,30 +0,0 @@
-// 
-PACKAGE error1
-
-IMPORTPATH
-	testdata/error1
-
-FILENAMES
-	testdata/error1.go
-
-TYPES
-	// 
-	type I0 interface {
-		// When embedded, the predeclared error interface
-		// must remain visible in interface types.
-		error
-	}
-
-	// 
-	type S0 struct {
-		// contains filtered or unexported fields
-	}
-
-	// 
-	type T0 struct {
-		ExportedField interface {
-			// error should be visible
-			error
-		}
-	}
-
diff --git a/third_party/golang/go/doc/testdata/error1.1.golden b/third_party/golang/go/doc/testdata/error1.1.golden
deleted file mode 100644
index a8dc2e71dc31f..0000000000000
--- a/third_party/golang/go/doc/testdata/error1.1.golden
+++ /dev/null
@@ -1,32 +0,0 @@
-// 
-PACKAGE error1
-
-IMPORTPATH
-	testdata/error1
-
-FILENAMES
-	testdata/error1.go
-
-TYPES
-	// 
-	type I0 interface {
-		// When embedded, the predeclared error interface
-		// must remain visible in interface types.
-		error
-	}
-
-	// 
-	type S0 struct {
-		// In struct types, an embedded error must only be visible
-		// if AllDecls is set.
-		error
-	}
-
-	// 
-	type T0 struct {
-		ExportedField interface {
-			// error should be visible
-			error
-		}
-	}
-
diff --git a/third_party/golang/go/doc/testdata/error1.2.golden b/third_party/golang/go/doc/testdata/error1.2.golden
deleted file mode 100644
index 6c6fe5d49bdf0..0000000000000
--- a/third_party/golang/go/doc/testdata/error1.2.golden
+++ /dev/null
@@ -1,30 +0,0 @@
-// 
-PACKAGE error1
-
-IMPORTPATH
-	testdata/error1
-
-FILENAMES
-	testdata/error1.go
-
-TYPES
-	// 
-	type I0 interface {
-		// When embedded, the predeclared error interface
-		// must remain visible in interface types.
-		error
-	}
-
-	// 
-	type S0 struct {
-		// contains filtered or unexported fields
-	}
-
-	// 
-	type T0 struct {
-		ExportedField interface {
-			// error should be visible
-			error
-		}
-	}
-
diff --git a/third_party/golang/go/doc/testdata/error1.go b/third_party/golang/go/doc/testdata/error1.go
deleted file mode 100644
index 3c777a78005a0..0000000000000
--- a/third_party/golang/go/doc/testdata/error1.go
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package error1
-
-type I0 interface {
-	// When embedded, the predeclared error interface
-	// must remain visible in interface types.
-	error
-}
-
-type T0 struct {
-	ExportedField interface {
-		// error should be visible
-		error
-	}
-}
-
-type S0 struct {
-	// In struct types, an embedded error must only be visible
-	// if AllDecls is set.
-	error
-}
diff --git a/third_party/golang/go/doc/testdata/error2.0.golden b/third_party/golang/go/doc/testdata/error2.0.golden
deleted file mode 100644
index dedfe412a0fcb..0000000000000
--- a/third_party/golang/go/doc/testdata/error2.0.golden
+++ /dev/null
@@ -1,27 +0,0 @@
-// 
-PACKAGE error2
-
-IMPORTPATH
-	testdata/error2
-
-FILENAMES
-	testdata/error2.go
-
-TYPES
-	// 
-	type I0 interface {
-		// contains filtered or unexported methods
-	}
-
-	// 
-	type S0 struct {
-		// contains filtered or unexported fields
-	}
-
-	// 
-	type T0 struct {
-		ExportedField interface {
-			// contains filtered or unexported methods
-		}
-	}
-
diff --git a/third_party/golang/go/doc/testdata/error2.1.golden b/third_party/golang/go/doc/testdata/error2.1.golden
deleted file mode 100644
index dbcc1b03e7891..0000000000000
--- a/third_party/golang/go/doc/testdata/error2.1.golden
+++ /dev/null
@@ -1,37 +0,0 @@
-// 
-PACKAGE error2
-
-IMPORTPATH
-	testdata/error2
-
-FILENAMES
-	testdata/error2.go
-
-TYPES
-	// 
-	type I0 interface {
-		// When embedded, the locally-declared error interface
-		// is only visible if all declarations are shown.
-		error
-	}
-
-	// 
-	type S0 struct {
-		// In struct types, an embedded error must only be visible
-		// if AllDecls is set.
-		error
-	}
-
-	// 
-	type T0 struct {
-		ExportedField interface {
-			// error should not be visible
-			error
-		}
-	}
-
-	// This error declaration shadows the predeclared error type. 
-	type error interface {
-		Error() string
-	}
-
diff --git a/third_party/golang/go/doc/testdata/error2.2.golden b/third_party/golang/go/doc/testdata/error2.2.golden
deleted file mode 100644
index dedfe412a0fcb..0000000000000
--- a/third_party/golang/go/doc/testdata/error2.2.golden
+++ /dev/null
@@ -1,27 +0,0 @@
-// 
-PACKAGE error2
-
-IMPORTPATH
-	testdata/error2
-
-FILENAMES
-	testdata/error2.go
-
-TYPES
-	// 
-	type I0 interface {
-		// contains filtered or unexported methods
-	}
-
-	// 
-	type S0 struct {
-		// contains filtered or unexported fields
-	}
-
-	// 
-	type T0 struct {
-		ExportedField interface {
-			// contains filtered or unexported methods
-		}
-	}
-
diff --git a/third_party/golang/go/doc/testdata/error2.go b/third_party/golang/go/doc/testdata/error2.go
deleted file mode 100644
index 6ee96c2450bce..0000000000000
--- a/third_party/golang/go/doc/testdata/error2.go
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package error2
-
-type I0 interface {
-	// When embedded, the locally-declared error interface
-	// is only visible if all declarations are shown.
-	error
-}
-
-type T0 struct {
-	ExportedField interface {
-		// error should not be visible
-		error
-	}
-}
-
-type S0 struct {
-	// In struct types, an embedded error must only be visible
-	// if AllDecls is set.
-	error
-}
-
-// This error declaration shadows the predeclared error type.
-type error interface {
-	Error() string
-}
diff --git a/third_party/golang/go/doc/testdata/example.go b/third_party/golang/go/doc/testdata/example.go
deleted file mode 100644
index fdeda137e7614..0000000000000
--- a/third_party/golang/go/doc/testdata/example.go
+++ /dev/null
@@ -1,81 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package testing
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"os"
-	"strings"
-	"time"
-)
-
-type InternalExample struct {
-	Name   string
-	F      func()
-	Output string
-}
-
-func RunExamples(examples []InternalExample) (ok bool) {
-	ok = true
-
-	var eg InternalExample
-
-	stdout, stderr := os.Stdout, os.Stderr
-	defer func() {
-		os.Stdout, os.Stderr = stdout, stderr
-		if e := recover(); e != nil {
-			fmt.Printf("--- FAIL: %s\npanic: %v\n", eg.Name, e)
-			os.Exit(1)
-		}
-	}()
-
-	for _, eg = range examples {
-		if *chatty {
-			fmt.Printf("=== RUN: %s\n", eg.Name)
-		}
-
-		// capture stdout and stderr
-		r, w, err := os.Pipe()
-		if err != nil {
-			fmt.Fprintln(os.Stderr, err)
-			os.Exit(1)
-		}
-		os.Stdout, os.Stderr = w, w
-		outC := make(chan string)
-		go func() {
-			buf := new(bytes.Buffer)
-			_, err := io.Copy(buf, r)
-			if err != nil {
-				fmt.Fprintf(stderr, "testing: copying pipe: %v\n", err)
-				os.Exit(1)
-			}
-			outC <- buf.String()
-		}()
-
-		// run example
-		t0 := time.Now()
-		eg.F()
-		dt := time.Now().Sub(t0)
-
-		// close pipe, restore stdout/stderr, get output
-		w.Close()
-		os.Stdout, os.Stderr = stdout, stderr
-		out := <-outC
-
-		// report any errors
-		tstr := fmt.Sprintf("(%.2f seconds)", dt.Seconds())
-		if g, e := strings.TrimSpace(out), strings.TrimSpace(eg.Output); g != e {
-			fmt.Printf("--- FAIL: %s %s\ngot:\n%s\nwant:\n%s\n",
-				eg.Name, tstr, g, e)
-			ok = false
-		} else if *chatty {
-			fmt.Printf("--- PASS: %s %s\n", eg.Name, tstr)
-		}
-	}
-
-	return
-}
diff --git a/third_party/golang/go/doc/testdata/f.0.golden b/third_party/golang/go/doc/testdata/f.0.golden
deleted file mode 100644
index 81759018613d0..0000000000000
--- a/third_party/golang/go/doc/testdata/f.0.golden
+++ /dev/null
@@ -1,13 +0,0 @@
-// The package f is a go/doc test for functions and factory ...
-PACKAGE f
-
-IMPORTPATH
-	testdata/f
-
-FILENAMES
-	testdata/f.go
-
-FUNCTIONS
-	// Exported must always be visible. Was issue 2824. 
-	func Exported() private
-
diff --git a/third_party/golang/go/doc/testdata/f.1.golden b/third_party/golang/go/doc/testdata/f.1.golden
deleted file mode 100644
index ba68e884c2b0a..0000000000000
--- a/third_party/golang/go/doc/testdata/f.1.golden
+++ /dev/null
@@ -1,16 +0,0 @@
-// The package f is a go/doc test for functions and factory ...
-PACKAGE f
-
-IMPORTPATH
-	testdata/f
-
-FILENAMES
-	testdata/f.go
-
-TYPES
-	// 
-	type private struct{}
-
-	// Exported must always be visible. Was issue 2824. 
-	func Exported() private
-
diff --git a/third_party/golang/go/doc/testdata/f.2.golden b/third_party/golang/go/doc/testdata/f.2.golden
deleted file mode 100644
index 81759018613d0..0000000000000
--- a/third_party/golang/go/doc/testdata/f.2.golden
+++ /dev/null
@@ -1,13 +0,0 @@
-// The package f is a go/doc test for functions and factory ...
-PACKAGE f
-
-IMPORTPATH
-	testdata/f
-
-FILENAMES
-	testdata/f.go
-
-FUNCTIONS
-	// Exported must always be visible. Was issue 2824. 
-	func Exported() private
-
diff --git a/third_party/golang/go/doc/testdata/f.go b/third_party/golang/go/doc/testdata/f.go
deleted file mode 100644
index 7e9add90784ca..0000000000000
--- a/third_party/golang/go/doc/testdata/f.go
+++ /dev/null
@@ -1,14 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// The package f is a go/doc test for functions and factory methods.
-package f
-
-// ----------------------------------------------------------------------------
-// Factory functions for non-exported types must not get lost.
-
-type private struct{}
-
-// Exported must always be visible. Was issue 2824.
-func Exported() private {}
diff --git a/third_party/golang/go/doc/testdata/template.txt b/third_party/golang/go/doc/testdata/template.txt
deleted file mode 100644
index 1b07382611660..0000000000000
--- a/third_party/golang/go/doc/testdata/template.txt
+++ /dev/null
@@ -1,68 +0,0 @@
-{{synopsis .Doc}}
-PACKAGE {{.Name}}
-
-IMPORTPATH
-	{{.ImportPath}}
-
-{{with .Imports}}IMPORTS
-{{range .}}	{{.}}
-{{end}}
-{{end}}{{/*
-
-*/}}FILENAMES
-{{range .Filenames}}	{{.}}
-{{end}}{{/*
-
-*/}}{{with .Consts}}
-CONSTANTS
-{{range .}}	{{synopsis .Doc}}
-	{{node .Decl $.FSet}}
-
-{{end}}{{end}}{{/*
-
-*/}}{{with .Vars}}
-VARIABLES
-{{range .}}	{{synopsis .Doc}}
-	{{node .Decl $.FSet}}
-
-{{end}}{{end}}{{/*
-
-*/}}{{with .Funcs}}
-FUNCTIONS
-{{range .}}	{{synopsis .Doc}}
-	{{node .Decl $.FSet}}
-
-{{end}}{{end}}{{/*
-
-*/}}{{with .Types}}
-TYPES
-{{range .}}	{{synopsis .Doc}}
-	{{node .Decl $.FSet}}
-
-{{range .Consts}}	{{synopsis .Doc}}
-	{{node .Decl $.FSet}}
-
-{{end}}{{/*
-
-*/}}{{range .Vars}}	{{synopsis .Doc}}
-	{{node .Decl $.FSet}}
-
-{{end}}{{/*
-
-*/}}{{range .Funcs}}	{{synopsis .Doc}}
-	{{node .Decl $.FSet}}
-
-{{end}}{{/*
-
-*/}}{{range .Methods}}	{{synopsis .Doc}}
-	{{node .Decl $.FSet}}
-
-{{end}}{{end}}{{end}}{{/*
-
-*/}}{{with .Bugs}}
-BUGS .Bugs is now deprecated, please use .Notes instead
-{{range .}}{{indent "\t" .}}
-{{end}}{{end}}{{with .Notes}}{{range $marker, $content := .}}
-{{$marker}}S
-{{range $content}}{{$marker}}({{.UID}}){{indent "\t" .Body}}
-{{end}}{{end}}{{end}}
\ No newline at end of file
diff --git a/third_party/golang/go/doc/testdata/testing.0.golden b/third_party/golang/go/doc/testdata/testing.0.golden
deleted file mode 100644
index f8348f1ac34a4..0000000000000
--- a/third_party/golang/go/doc/testdata/testing.0.golden
+++ /dev/null
@@ -1,156 +0,0 @@
-// Package testing provides support for automated testing of Go ...
-PACKAGE testing
-
-IMPORTPATH
-	testdata/testing
-
-IMPORTS
-	bytes
-	flag
-	fmt
-	io
-	os
-	runtime
-	runtime/pprof
-	strconv
-	strings
-	time
-
-FILENAMES
-	testdata/benchmark.go
-	testdata/example.go
-	testdata/testing.go
-
-FUNCTIONS
-	// An internal function but exported because it is cross-package; ...
-	func Main(matchString func(pat, str string) (bool, error), tests []InternalTest, benchmarks []InternalBenchmark, examples []InternalExample)
-
-	// An internal function but exported because it is cross-package; ...
-	func RunBenchmarks(matchString func(pat, str string) (bool, error), benchmarks []InternalBenchmark)
-
-	// 
-	func RunExamples(examples []InternalExample) (ok bool)
-
-	// 
-	func RunTests(matchString func(pat, str string) (bool, error), tests []InternalTest) (ok bool)
-
-	// Short reports whether the -test.short flag is set. 
-	func Short() bool
-
-
-TYPES
-	// B is a type passed to Benchmark functions to manage benchmark ...
-	type B struct {
-		N int
-		// contains filtered or unexported fields
-	}
-
-	// Error is equivalent to Log() followed by Fail(). 
-	func (c *B) Error(args ...interface{})
-
-	// Errorf is equivalent to Logf() followed by Fail(). 
-	func (c *B) Errorf(format string, args ...interface{})
-
-	// Fail marks the function as having failed but continues ...
-	func (c *B) Fail()
-
-	// FailNow marks the function as having failed and stops its ...
-	func (c *B) FailNow()
-
-	// Failed reports whether the function has failed. 
-	func (c *B) Failed() bool
-
-	// Fatal is equivalent to Log() followed by FailNow(). 
-	func (c *B) Fatal(args ...interface{})
-
-	// Fatalf is equivalent to Logf() followed by FailNow(). 
-	func (c *B) Fatalf(format string, args ...interface{})
-
-	// Log formats its arguments using default formatting, analogous ...
-	func (c *B) Log(args ...interface{})
-
-	// Logf formats its arguments according to the format, analogous ...
-	func (c *B) Logf(format string, args ...interface{})
-
-	// ResetTimer sets the elapsed benchmark time to zero. It does not ...
-	func (b *B) ResetTimer()
-
-	// SetBytes records the number of bytes processed in a single ...
-	func (b *B) SetBytes(n int64)
-
-	// StartTimer starts timing a test.  This function is called ...
-	func (b *B) StartTimer()
-
-	// StopTimer stops timing a test.  This can be used to pause the ...
-	func (b *B) StopTimer()
-
-	// The results of a benchmark run. 
-	type BenchmarkResult struct {
-		N	int		// The number of iterations.
-		T	time.Duration	// The total time taken.
-		Bytes	int64		// Bytes processed in one iteration.
-	}
-
-	// Benchmark benchmarks a single function. Useful for creating ...
-	func Benchmark(f func(b *B)) BenchmarkResult
-
-	// 
-	func (r BenchmarkResult) NsPerOp() int64
-
-	// 
-	func (r BenchmarkResult) String() string
-
-	// An internal type but exported because it is cross-package; part ...
-	type InternalBenchmark struct {
-		Name	string
-		F	func(b *B)
-	}
-
-	// 
-	type InternalExample struct {
-		Name	string
-		F	func()
-		Output	string
-	}
-
-	// An internal type but exported because it is cross-package; part ...
-	type InternalTest struct {
-		Name	string
-		F	func(*T)
-	}
-
-	// T is a type passed to Test functions to manage test state and ...
-	type T struct {
-		// contains filtered or unexported fields
-	}
-
-	// Error is equivalent to Log() followed by Fail(). 
-	func (c *T) Error(args ...interface{})
-
-	// Errorf is equivalent to Logf() followed by Fail(). 
-	func (c *T) Errorf(format string, args ...interface{})
-
-	// Fail marks the function as having failed but continues ...
-	func (c *T) Fail()
-
-	// FailNow marks the function as having failed and stops its ...
-	func (c *T) FailNow()
-
-	// Failed reports whether the function has failed. 
-	func (c *T) Failed() bool
-
-	// Fatal is equivalent to Log() followed by FailNow(). 
-	func (c *T) Fatal(args ...interface{})
-
-	// Fatalf is equivalent to Logf() followed by FailNow(). 
-	func (c *T) Fatalf(format string, args ...interface{})
-
-	// Log formats its arguments using default formatting, analogous ...
-	func (c *T) Log(args ...interface{})
-
-	// Logf formats its arguments according to the format, analogous ...
-	func (c *T) Logf(format string, args ...interface{})
-
-	// Parallel signals that this test is to be run in parallel with ...
-	func (t *T) Parallel()
-
diff --git a/third_party/golang/go/doc/testdata/testing.1.golden b/third_party/golang/go/doc/testdata/testing.1.golden
deleted file mode 100644
index 282bb1015ad57..0000000000000
--- a/third_party/golang/go/doc/testdata/testing.1.golden
+++ /dev/null
@@ -1,298 +0,0 @@
-// Package testing provides support for automated testing of Go ...
-PACKAGE testing
-
-IMPORTPATH
-	testdata/testing
-
-IMPORTS
-	bytes
-	flag
-	fmt
-	io
-	os
-	runtime
-	runtime/pprof
-	strconv
-	strings
-	time
-
-FILENAMES
-	testdata/benchmark.go
-	testdata/example.go
-	testdata/testing.go
-
-VARIABLES
-	// 
-	var (
-		// The short flag requests that tests run more quickly, but its functionality
-		// is provided by test writers themselves.  The testing package is just its
-		// home.  The all.bash installation script sets it to make installation more
-		// efficient, but by default the flag is off so a plain "go test" will do a
-		// full test of the package.
-		short	= flag.Bool("test.short", false, "run smaller test suite to save time")
-	
-		// Report as tests are run; default is silent for success.
-		chatty		= flag.Bool("test.v", false, "verbose: print additional output")
-		match		= flag.String("test.run", "", "regular expression to select tests to run")
-		memProfile	= flag.String("test.memprofile", "", "write a memory profile to the named file after execution")
-		memProfileRate	= flag.Int("test.memprofilerate", 0, "if >=0, sets runtime.MemProfileRate")
-		cpuProfile	= flag.String("test.cpuprofile", "", "write a cpu profile to the named file during execution")
-		timeout		= flag.Duration("test.timeout", 0, "if positive, sets an aggregate time limit for all tests")
-		cpuListStr	= flag.String("test.cpu", "", "comma-separated list of number of CPUs to use for each test")
-		parallel	= flag.Int("test.parallel", runtime.GOMAXPROCS(0), "maximum test parallelism")
-	
-		cpuList	[]int
-	)
-
-	// 
-	var benchTime = flag.Duration("test.benchtime", 1*time.Second, "approximate run time for each benchmark")
-
-	// 
-	var matchBenchmarks = flag.String("test.bench", "", "regular expression to select benchmarks to run")
-
-	// 
-	var timer *time.Timer
-
-
-FUNCTIONS
-	// An internal function but exported because it is cross-package; ...
-	func Main(matchString func(pat, str string) (bool, error), tests []InternalTest, benchmarks []InternalBenchmark, examples []InternalExample)
-
-	// An internal function but exported because it is cross-package; ...
-	func RunBenchmarks(matchString func(pat, str string) (bool, error), benchmarks []InternalBenchmark)
-
-	// 
-	func RunExamples(examples []InternalExample) (ok bool)
-
-	// 
-	func RunTests(matchString func(pat, str string) (bool, error), tests []InternalTest) (ok bool)
-
-	// Short reports whether the -test.short flag is set. 
-	func Short() bool
-
-	// after runs after all testing. 
-	func after()
-
-	// alarm is called if the timeout expires. 
-	func alarm()
-
-	// before runs before all testing. 
-	func before()
-
-	// decorate inserts the final newline if needed and indentation ...
-	func decorate(s string, addFileLine bool) string
-
-	// 
-	func max(x, y int) int
-
-	// 
-	func min(x, y int) int
-
-	// 
-	func parseCpuList()
-
-	// roundDown10 rounds a number down to the nearest power of 10. 
-	func roundDown10(n int) int
-
-	// roundUp rounds x up to a number of the form [1eX, 2eX, 5eX]. 
-	func roundUp(n int) int
-
-	// startAlarm starts an alarm if requested. 
-	func startAlarm()
-
-	// stopAlarm turns off the alarm. 
-	func stopAlarm()
-
-	// 
-	func tRunner(t *T, test *InternalTest)
-
-
-TYPES
-	// B is a type passed to Benchmark functions to manage benchmark ...
-	type B struct {
-		common
-		N		int
-		benchmark	InternalBenchmark
-		bytes		int64
-		timerOn		bool
-		result		BenchmarkResult
-	}
-
-	// Error is equivalent to Log() followed by Fail(). 
-	func (c *B) Error(args ...interface{})
-
-	// Errorf is equivalent to Logf() followed by Fail(). 
-	func (c *B) Errorf(format string, args ...interface{})
-
-	// Fail marks the function as having failed but continues ...
-	func (c *B) Fail()
-
-	// FailNow marks the function as having failed and stops its ...
-	func (c *B) FailNow()
-
-	// Failed reports whether the function has failed. 
-	func (c *B) Failed() bool
-
-	// Fatal is equivalent to Log() followed by FailNow(). 
-	func (c *B) Fatal(args ...interface{})
-
-	// Fatalf is equivalent to Logf() followed by FailNow(). 
-	func (c *B) Fatalf(format string, args ...interface{})
-
-	// Log formats its arguments using default formatting, analogous ...
-	func (c *B) Log(args ...interface{})
-
-	// Logf formats its arguments according to the format, analogous ...
-	func (c *B) Logf(format string, args ...interface{})
-
-	// ResetTimer sets the elapsed benchmark time to zero. It does not ...
-	func (b *B) ResetTimer()
-
-	// SetBytes records the number of bytes processed in a single ...
-	func (b *B) SetBytes(n int64)
-
-	// StartTimer starts timing a test.  This function is called ...
-	func (b *B) StartTimer()
-
-	// StopTimer stops timing a test.  This can be used to pause the ...
-	func (b *B) StopTimer()
-
-	// launch launches the benchmark function.  It gradually increases ...
-	func (b *B) launch()
-
-	// log generates the output. It's always at the same stack depth. 
-	func (c *B) log(s string)
-
-	// 
-	func (b *B) nsPerOp() int64
-
-	// run times the benchmark function in a separate goroutine. 
-	func (b *B) run() BenchmarkResult
-
-	// runN runs a single benchmark for the specified number of ...
-	func (b *B) runN(n int)
-
-	// trimOutput shortens the output from a benchmark, which can be ...
-	func (b *B) trimOutput()
-
-	// The results of a benchmark run. 
-	type BenchmarkResult struct {
-		N	int		// The number of iterations.
-		T	time.Duration	// The total time taken.
-		Bytes	int64		// Bytes processed in one iteration.
-	}
-
-	// Benchmark benchmarks a single function. Useful for creating ...
-	func Benchmark(f func(b *B)) BenchmarkResult
-
-	// 
-	func (r BenchmarkResult) NsPerOp() int64
-
-	// 
-	func (r BenchmarkResult) String() string
-
-	// 
-	func (r BenchmarkResult) mbPerSec() float64
-
-	// An internal type but exported because it is cross-package; part ...
-	type InternalBenchmark struct {
-		Name	string
-		F	func(b *B)
-	}
-
-	// 
-	type InternalExample struct {
-		Name	string
-		F	func()
-		Output	string
-	}
-
-	// An internal type but exported because it is cross-package; part ...
-	type InternalTest struct {
-		Name	string
-		F	func(*T)
-	}
-
-	// T is a type passed to Test functions to manage test state and ...
-	type T struct {
-		common
-		name		string		// Name of test.
-		startParallel	chan bool	// Parallel tests will wait on this.
-	}
-
-	// Error is equivalent to Log() followed by Fail(). 
-	func (c *T) Error(args ...interface{})
-
-	// Errorf is equivalent to Logf() followed by Fail(). 
-	func (c *T) Errorf(format string, args ...interface{})
-
-	// Fail marks the function as having failed but continues ...
-	func (c *T) Fail()
-
-	// FailNow marks the function as having failed and stops its ...
-	func (c *T) FailNow()
-
-	// Failed reports whether the function has failed. 
-	func (c *T) Failed() bool
-
-	// Fatal is equivalent to Log() followed by FailNow(). 
-	func (c *T) Fatal(args ...interface{})
-
-	// Fatalf is equivalent to Logf() followed by FailNow(). 
-	func (c *T) Fatalf(format string, args ...interface{})
-
-	// Log formats its arguments using default formatting, analogous ...
-	func (c *T) Log(args ...interface{})
-
-	// Logf formats its arguments according to the format, analogous ...
-	func (c *T) Logf(format string, args ...interface{})
-
-	// Parallel signals that this test is to be run in parallel with ...
-	func (t *T) Parallel()
-
-	// log generates the output. It's always at the same stack depth. 
-	func (c *T) log(s string)
-
-	// 
-	func (t *T) report()
-
-	// common holds the elements common between T and B and captures ...
-	type common struct {
-		output		[]byte		// Output generated by test or benchmark.
-		failed		bool		// Test or benchmark has failed.
-		start		time.Time	// Time test or benchmark started
-		duration	time.Duration
-		self		interface{}		// To be sent on signal channel when done.
-		signal		chan interface{}	// Output for serial tests.
-	}
-
-	// Error is equivalent to Log() followed by Fail(). 
-	func (c *common) Error(args ...interface{})
-
-	// Errorf is equivalent to Logf() followed by Fail(). 
-	func (c *common) Errorf(format string, args ...interface{})
-
-	// Fail marks the function as having failed but continues ...
-	func (c *common) Fail()
-
-	// FailNow marks the function as having failed and stops its ...
-	func (c *common) FailNow()
-
-	// Failed reports whether the function has failed. 
-	func (c *common) Failed() bool
-
-	// Fatal is equivalent to Log() followed by FailNow(). 
-	func (c *common) Fatal(args ...interface{})
-
-	// Fatalf is equivalent to Logf() followed by FailNow(). 
-	func (c *common) Fatalf(format string, args ...interface{})
-
-	// Log formats its arguments using default formatting, analogous ...
-	func (c *common) Log(args ...interface{})
-
-	// Logf formats its arguments according to the format, analogous ...
-	func (c *common) Logf(format string, args ...interface{})
-
-	// log generates the output. It's always at the same stack depth. 
-	func (c *common) log(s string)
-
diff --git a/third_party/golang/go/doc/testdata/testing.2.golden b/third_party/golang/go/doc/testdata/testing.2.golden
deleted file mode 100644
index f8348f1ac34a4..0000000000000
--- a/third_party/golang/go/doc/testdata/testing.2.golden
+++ /dev/null
@@ -1,156 +0,0 @@
-// Package testing provides support for automated testing of Go ...
-PACKAGE testing
-
-IMPORTPATH
-	testdata/testing
-
-IMPORTS
-	bytes
-	flag
-	fmt
-	io
-	os
-	runtime
-	runtime/pprof
-	strconv
-	strings
-	time
-
-FILENAMES
-	testdata/benchmark.go
-	testdata/example.go
-	testdata/testing.go
-
-FUNCTIONS
-	// An internal function but exported because it is cross-package; ...
-	func Main(matchString func(pat, str string) (bool, error), tests []InternalTest, benchmarks []InternalBenchmark, examples []InternalExample)
-
-	// An internal function but exported because it is cross-package; ...
-	func RunBenchmarks(matchString func(pat, str string) (bool, error), benchmarks []InternalBenchmark)
-
-	// 
-	func RunExamples(examples []InternalExample) (ok bool)
-
-	// 
-	func RunTests(matchString func(pat, str string) (bool, error), tests []InternalTest) (ok bool)
-
-	// Short reports whether the -test.short flag is set. 
-	func Short() bool
-
-
-TYPES
-	// B is a type passed to Benchmark functions to manage benchmark ...
-	type B struct {
-		N int
-		// contains filtered or unexported fields
-	}
-
-	// Error is equivalent to Log() followed by Fail(). 
-	func (c *B) Error(args ...interface{})
-
-	// Errorf is equivalent to Logf() followed by Fail(). 
-	func (c *B) Errorf(format string, args ...interface{})
-
-	// Fail marks the function as having failed but continues ...
-	func (c *B) Fail()
-
-	// FailNow marks the function as having failed and stops its ...
-	func (c *B) FailNow()
-
-	// Failed reports whether the function has failed. 
-	func (c *B) Failed() bool
-
-	// Fatal is equivalent to Log() followed by FailNow(). 
-	func (c *B) Fatal(args ...interface{})
-
-	// Fatalf is equivalent to Logf() followed by FailNow(). 
-	func (c *B) Fatalf(format string, args ...interface{})
-
-	// Log formats its arguments using default formatting, analogous ...
-	func (c *B) Log(args ...interface{})
-
-	// Logf formats its arguments according to the format, analogous ...
-	func (c *B) Logf(format string, args ...interface{})
-
-	// ResetTimer sets the elapsed benchmark time to zero. It does not ...
-	func (b *B) ResetTimer()
-
-	// SetBytes records the number of bytes processed in a single ...
-	func (b *B) SetBytes(n int64)
-
-	// StartTimer starts timing a test.  This function is called ...
-	func (b *B) StartTimer()
-
-	// StopTimer stops timing a test.  This can be used to pause the ...
-	func (b *B) StopTimer()
-
-	// The results of a benchmark run. 
-	type BenchmarkResult struct {
-		N	int		// The number of iterations.
-		T	time.Duration	// The total time taken.
-		Bytes	int64		// Bytes processed in one iteration.
-	}
-
-	// Benchmark benchmarks a single function. Useful for creating ...
-	func Benchmark(f func(b *B)) BenchmarkResult
-
-	// 
-	func (r BenchmarkResult) NsPerOp() int64
-
-	// 
-	func (r BenchmarkResult) String() string
-
-	// An internal type but exported because it is cross-package; part ...
-	type InternalBenchmark struct {
-		Name	string
-		F	func(b *B)
-	}
-
-	// 
-	type InternalExample struct {
-		Name	string
-		F	func()
-		Output	string
-	}
-
-	// An internal type but exported because it is cross-package; part ...
-	type InternalTest struct {
-		Name	string
-		F	func(*T)
-	}
-
-	// T is a type passed to Test functions to manage test state and ...
-	type T struct {
-		// contains filtered or unexported fields
-	}
-
-	// Error is equivalent to Log() followed by Fail(). 
-	func (c *T) Error(args ...interface{})
-
-	// Errorf is equivalent to Logf() followed by Fail(). 
-	func (c *T) Errorf(format string, args ...interface{})
-
-	// Fail marks the function as having failed but continues ...
-	func (c *T) Fail()
-
-	// FailNow marks the function as having failed and stops its ...
-	func (c *T) FailNow()
-
-	// Failed reports whether the function has failed. 
-	func (c *T) Failed() bool
-
-	// Fatal is equivalent to Log() followed by FailNow(). 
-	func (c *T) Fatal(args ...interface{})
-
-	// Fatalf is equivalent to Logf() followed by FailNow(). 
-	func (c *T) Fatalf(format string, args ...interface{})
-
-	// Log formats its arguments using default formatting, analogous ...
-	func (c *T) Log(args ...interface{})
-
-	// Logf formats its arguments according to the format, analogous ...
-	func (c *T) Logf(format string, args ...interface{})
-
-	// Parallel signals that this test is to be run in parallel with ...
-	func (t *T) Parallel()
-
diff --git a/third_party/golang/go/doc/testdata/testing.go b/third_party/golang/go/doc/testdata/testing.go
deleted file mode 100644
index 93ed494c32b16..0000000000000
--- a/third_party/golang/go/doc/testdata/testing.go
+++ /dev/null
@@ -1,404 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package testing provides support for automated testing of Go packages.
-// It is intended to be used in concert with the ``go test'' utility, which automates
-// execution of any function of the form
-//     func TestXxx(*testing.T)
-// where Xxx can be any alphanumeric string (but the first letter must not be in
-// [a-z]) and serves to identify the test routine.
-// These TestXxx routines should be declared within the package they are testing.
-//
-// Functions of the form
-//     func BenchmarkXxx(*testing.B)
-// are considered benchmarks, and are executed by go test when the -test.bench
-// flag is provided.
-//
-// A sample benchmark function looks like this:
-//     func BenchmarkHello(b *testing.B) {
-//         for i := 0; i < b.N; i++ {
-//             fmt.Sprintf("hello")
-//         }
-//     }
-// The benchmark package will vary b.N until the benchmark function lasts
-// long enough to be timed reliably.  The output
-//     testing.BenchmarkHello    10000000    282 ns/op
-// means that the loop ran 10000000 times at a speed of 282 ns per loop.
-//
-// If a benchmark needs some expensive setup before running, the timer
-// may be stopped:
-//     func BenchmarkBigLen(b *testing.B) {
-//         b.StopTimer()
-//         big := NewBig()
-//         b.StartTimer()
-//         for i := 0; i < b.N; i++ {
-//             big.Len()
-//         }
-//     }
-package testing
-
-import (
-	"flag"
-	"fmt"
-	"os"
-	"runtime"
-	"runtime/pprof"
-	"strconv"
-	"strings"
-	"time"
-)
-
-var (
-	// The short flag requests that tests run more quickly, but its functionality
-	// is provided by test writers themselves.  The testing package is just its
-	// home.  The all.bash installation script sets it to make installation more
-	// efficient, but by default the flag is off so a plain "go test" will do a
-	// full test of the package.
-	short = flag.Bool("test.short", false, "run smaller test suite to save time")
-
-	// Report as tests are run; default is silent for success.
-	chatty         = flag.Bool("test.v", false, "verbose: print additional output")
-	match          = flag.String("test.run", "", "regular expression to select tests to run")
-	memProfile     = flag.String("test.memprofile", "", "write a memory profile to the named file after execution")
-	memProfileRate = flag.Int("test.memprofilerate", 0, "if >=0, sets runtime.MemProfileRate")
-	cpuProfile     = flag.String("test.cpuprofile", "", "write a cpu profile to the named file during execution")
-	timeout        = flag.Duration("test.timeout", 0, "if positive, sets an aggregate time limit for all tests")
-	cpuListStr     = flag.String("test.cpu", "", "comma-separated list of number of CPUs to use for each test")
-	parallel       = flag.Int("test.parallel", runtime.GOMAXPROCS(0), "maximum test parallelism")
-
-	cpuList []int
-)
-
-// common holds the elements common between T and B and
-// captures common methods such as Errorf.
-type common struct {
-	output   []byte    // Output generated by test or benchmark.
-	failed   bool      // Test or benchmark has failed.
-	start    time.Time // Time test or benchmark started
-	duration time.Duration
-	self     interface{}      // To be sent on signal channel when done.
-	signal   chan interface{} // Output for serial tests.
-}
-
-// Short reports whether the -test.short flag is set.
-func Short() bool {
-	return *short
-}
-
-// decorate inserts the final newline if needed and indentation tabs for formatting.
-// If addFileLine is true, it also prefixes the string with the file and line of the call site.
-func decorate(s string, addFileLine bool) string {
-	if addFileLine {
-		_, file, line, ok := runtime.Caller(3) // decorate + log + public function.
-		if ok {
-			// Truncate file name at last file name separator.
-			if index := strings.LastIndex(file, "/"); index >= 0 {
-				file = file[index+1:]
-			} else if index = strings.LastIndex(file, "\\"); index >= 0 {
-				file = file[index+1:]
-			}
-		} else {
-			file = "???"
-			line = 1
-		}
-		s = fmt.Sprintf("%s:%d: %s", file, line, s)
-	}
-	s = "\t" + s // Every line is indented at least one tab.
-	n := len(s)
-	if n > 0 && s[n-1] != '\n' {
-		s += "\n"
-		n++
-	}
-	for i := 0; i < n-1; i++ { // -1 to avoid final newline
-		if s[i] == '\n' {
-			// Second and subsequent lines are indented an extra tab.
-			return s[0:i+1] + "\t" + decorate(s[i+1:n], false)
-		}
-	}
-	return s
-}
-
-// T is a type passed to Test functions to manage test state and support formatted test logs.
-// Logs are accumulated during execution and dumped to standard error when done.
-type T struct {
-	common
-	name          string    // Name of test.
-	startParallel chan bool // Parallel tests will wait on this.
-}
-
-// Fail marks the function as having failed but continues execution.
-func (c *common) Fail() { c.failed = true }
-
-// Failed reports whether the function has failed.
-func (c *common) Failed() bool { return c.failed }
-
-// FailNow marks the function as having failed and stops its execution.
-// Execution will continue at the next Test.
-func (c *common) FailNow() {
-	c.Fail()
-
-	// Calling runtime.Goexit will exit the goroutine, which
-	// will run the deferred functions in this goroutine,
-	// which will eventually run the deferred lines in tRunner,
-	// which will signal to the test loop that this test is done.
-	//
-	// A previous version of this code said:
-	//
-	//	c.duration = ...
-	//	c.signal <- c.self
-	//	runtime.Goexit()
-	//
-	// This previous version duplicated code (those lines are in
-	// tRunner no matter what), but worse the goroutine teardown
-	// implicit in runtime.Goexit was not guaranteed to complete
-	// before the test exited.  If a test deferred an important cleanup
-	// function (like removing temporary files), there was no guarantee
-	// it would run on a test failure.  Because we send on c.signal during
-	// a top-of-stack deferred function now, we know that the send
-	// only happens after any other stacked defers have completed.
-	runtime.Goexit()
-}
-
-// log generates the output. It's always at the same stack depth.
-func (c *common) log(s string) {
-	c.output = append(c.output, decorate(s, true)...)
-}
-
-// Log formats its arguments using default formatting, analogous to Println(),
-// and records the text in the error log.
-func (c *common) Log(args ...interface{}) { c.log(fmt.Sprintln(args...)) }
-
-// Logf formats its arguments according to the format, analogous to Printf(),
-// and records the text in the error log.
-func (c *common) Logf(format string, args ...interface{}) { c.log(fmt.Sprintf(format, args...)) }
-
-// Error is equivalent to Log() followed by Fail().
-func (c *common) Error(args ...interface{}) {
-	c.log(fmt.Sprintln(args...))
-	c.Fail()
-}
-
-// Errorf is equivalent to Logf() followed by Fail().
-func (c *common) Errorf(format string, args ...interface{}) {
-	c.log(fmt.Sprintf(format, args...))
-	c.Fail()
-}
-
-// Fatal is equivalent to Log() followed by FailNow().
-func (c *common) Fatal(args ...interface{}) {
-	c.log(fmt.Sprintln(args...))
-	c.FailNow()
-}
-
-// Fatalf is equivalent to Logf() followed by FailNow().
-func (c *common) Fatalf(format string, args ...interface{}) {
-	c.log(fmt.Sprintf(format, args...))
-	c.FailNow()
-}
-
-// Parallel signals that this test is to be run in parallel with (and only with)
-// other parallel tests in this CPU group.
-func (t *T) Parallel() {
-	t.signal <- (*T)(nil) // Release main testing loop
-	<-t.startParallel     // Wait for serial tests to finish
-}
-
-// An internal type but exported because it is cross-package; part of the implementation
-// of go test.
-type InternalTest struct {
-	Name string
-	F    func(*T)
-}
-
-func tRunner(t *T, test *InternalTest) {
-	t.start = time.Now()
-
-	// When this goroutine is done, either because test.F(t)
-	// returned normally or because a test failure triggered
-	// a call to runtime.Goexit, record the duration and send
-	// a signal saying that the test is done.
-	defer func() {
-		t.duration = time.Now().Sub(t.start)
-		t.signal <- t
-	}()
-
-	test.F(t)
-}
-
-// An internal function but exported because it is cross-package; part of the implementation
-// of go test.
-func Main(matchString func(pat, str string) (bool, error), tests []InternalTest, benchmarks []InternalBenchmark, examples []InternalExample) {
-	flag.Parse()
-	parseCpuList()
-
-	before()
-	startAlarm()
-	testOk := RunTests(matchString, tests)
-	exampleOk := RunExamples(examples)
-	if !testOk || !exampleOk {
-		fmt.Println("FAIL")
-		os.Exit(1)
-	}
-	fmt.Println("PASS")
-	stopAlarm()
-	RunBenchmarks(matchString, benchmarks)
-	after()
-}
-
-func (t *T) report() {
-	tstr := fmt.Sprintf("(%.2f seconds)", t.duration.Seconds())
-	format := "--- %s: %s %s\n%s"
-	if t.failed {
-		fmt.Printf(format, "FAIL", t.name, tstr, t.output)
-	} else if *chatty {
-		fmt.Printf(format, "PASS", t.name, tstr, t.output)
-	}
-}
-
-func RunTests(matchString func(pat, str string) (bool, error), tests []InternalTest) (ok bool) {
-	ok = true
-	if len(tests) == 0 {
-		fmt.Fprintln(os.Stderr, "testing: warning: no tests to run")
-		return
-	}
-	for _, procs := range cpuList {
-		runtime.GOMAXPROCS(procs)
-		// We build a new channel tree for each run of the loop.
-		// collector merges in one channel all the upstream signals from parallel tests.
-		// If all tests pump to the same channel, a bug can occur where a test
-		// kicks off a goroutine that Fails, yet the test still delivers a completion signal,
-		// which skews the counting.
-		var collector = make(chan interface{})
-
-		numParallel := 0
-		startParallel := make(chan bool)
-
-		for i := 0; i < len(tests); i++ {
-			matched, err := matchString(*match, tests[i].Name)
-			if err != nil {
-				fmt.Fprintf(os.Stderr, "testing: invalid regexp for -test.run: %s\n", err)
-				os.Exit(1)
-			}
-			if !matched {
-				continue
-			}
-			testName := tests[i].Name
-			if procs != 1 {
-				testName = fmt.Sprintf("%s-%d", tests[i].Name, procs)
-			}
-			t := &T{
-				common: common{
-					signal: make(chan interface{}),
-				},
-				name:          testName,
-				startParallel: startParallel,
-			}
-			t.self = t
-			if *chatty {
-				fmt.Printf("=== RUN %s\n", t.name)
-			}
-			go tRunner(t, &tests[i])
-			out := (<-t.signal).(*T)
-			if out == nil { // Parallel run.
-				go func() {
-					collector <- <-t.signal
-				}()
-				numParallel++
-				continue
-			}
-			t.report()
-			ok = ok && !out.failed
-		}
-
-		running := 0
-		for numParallel+running > 0 {
-			if running < *parallel && numParallel > 0 {
-				startParallel <- true
-				running++
-				numParallel--
-				continue
-			}
-			t := (<-collector).(*T)
-			t.report()
-			ok = ok && !t.failed
-			running--
-		}
-	}
-	return
-}
-
-// before runs before all testing.
-func before() {
-	if *memProfileRate > 0 {
-		runtime.MemProfileRate = *memProfileRate
-	}
-	if *cpuProfile != "" {
-		f, err := os.Create(*cpuProfile)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "testing: %s", err)
-			return
-		}
-		if err := pprof.StartCPUProfile(f); err != nil {
-			fmt.Fprintf(os.Stderr, "testing: can't start cpu profile: %s", err)
-			f.Close()
-			return
-		}
-		// Could save f so after can call f.Close; not worth the effort.
-	}
-
-}
-
-// after runs after all testing.
-func after() {
-	if *cpuProfile != "" {
-		pprof.StopCPUProfile() // flushes profile to disk
-	}
-	if *memProfile != "" {
-		f, err := os.Create(*memProfile)
-		if err != nil {
-			fmt.Fprintf(os.Stderr, "testing: %s", err)
-			return
-		}
-		if err = pprof.WriteHeapProfile(f); err != nil {
-			fmt.Fprintf(os.Stderr, "testing: can't write %s: %s", *memProfile, err)
-		}
-		f.Close()
-	}
-}
-
-var timer *time.Timer
-
-// startAlarm starts an alarm if requested.
-func startAlarm() {
-	if *timeout > 0 {
-		timer = time.AfterFunc(*timeout, alarm)
-	}
-}
-
-// stopAlarm turns off the alarm.
-func stopAlarm() {
-	if *timeout > 0 {
-		timer.Stop()
-	}
-}
-
-// alarm is called if the timeout expires.
-func alarm() {
-	panic("test timed out")
-}
-
-func parseCpuList() {
-	if len(*cpuListStr) == 0 {
-		cpuList = append(cpuList, runtime.GOMAXPROCS(-1))
-	} else {
-		for _, val := range strings.Split(*cpuListStr, ",") {
-			cpu, err := strconv.Atoi(val)
-			if err != nil || cpu <= 0 {
-				fmt.Fprintf(os.Stderr, "testing: invalid value %q for -test.cpu", val)
-				os.Exit(1)
-			}
-			cpuList = append(cpuList, cpu)
-		}
-	}
-}
diff --git a/third_party/golang/go/parser/error_test.go b/third_party/golang/go/parser/error_test.go
deleted file mode 100644
index c249950db6fd9..0000000000000
--- a/third_party/golang/go/parser/error_test.go
+++ /dev/null
@@ -1,182 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements a parser test harness. The files in the testdata
-// directory are parsed and the errors reported are compared against the
-// error messages expected in the test files. The test files must end in
-// .src rather than .go so that they are not disturbed by gofmt runs.
-//
-// Expected errors are indicated in the test files by putting a comment
-// of the form /* ERROR "rx" */ immediately following an offending token.
-// The harness will verify that an error matching the regular expression
-// rx is reported at that source position.
-//
-// For instance, the following test file indicates that a "not declared"
-// error should be reported for the undeclared variable x:
-//
-//	package p
-//	func f() {
-//		_ = x /* ERROR "not declared" */ + 1
-//	}
-
-package parser
-
-import (
-	"io/ioutil"
-	"path/filepath"
-	"regexp"
-	"strings"
-	"testing"
-
-	"k8s.io/kubernetes/third_party/golang/go/scanner"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-)
-
-const testdata = "testdata"
-
-// getFile assumes that each filename occurs at most once
-func getFile(fset *token.FileSet, filename string) (file *token.File) {
-	fset.Iterate(func(f *token.File) bool {
-		if f.Name() == filename {
-			if file != nil {
-				panic(filename + " used multiple times")
-			}
-			file = f
-		}
-		return true
-	})
-	return file
-}
-
-func getPos(fset *token.FileSet, filename string, offset int) token.Pos {
-	if f := getFile(fset, filename); f != nil {
-		return f.Pos(offset)
-	}
-	return token.NoPos
-}
-
-// ERROR comments must be of the form /* ERROR "rx" */ and rx is
-// a regular expression that matches the expected error message.
-// The special form /* ERROR HERE "rx" */ must be used for error
-// messages that appear immediately after a token, rather than at
-// a token's position.
-//
-var errRx = regexp.MustCompile(`^/\* *ERROR *(HERE)? *"([^"]*)" *\*/$`)
-
-// expectedErrors collects the regular expressions of ERROR comments found
-// in files and returns them as a map of error positions to error messages.
-//
-func expectedErrors(t *testing.T, fset *token.FileSet, filename string, src []byte) map[token.Pos]string {
-	errors := make(map[token.Pos]string)
-
-	var s scanner.Scanner
-	// file was parsed already - do not add it again to the file
-	// set otherwise the position information returned here will
-	// not match the position information collected by the parser
-	s.Init(getFile(fset, filename), src, nil, scanner.ScanComments)
-	var prev token.Pos // position of last non-comment, non-semicolon token
-	var here token.Pos // position immediately after the token at position prev
-
-	for {
-		pos, tok, lit := s.Scan()
-		switch tok {
-		case token.EOF:
-			return errors
-		case token.COMMENT:
-			s := errRx.FindStringSubmatch(lit)
-			if len(s) == 3 {
-				pos := prev
-				if s[1] == "HERE" {
-					pos = here
-				}
-				errors[pos] = string(s[2])
-			}
-		default:
-			prev = pos
-			var l int // token length
-			if tok.IsLiteral() {
-				l = len(lit)
-			} else {
-				l = len(tok.String())
-			}
-			here = prev + token.Pos(l)
-		}
-	}
-}
-
-// compareErrors compares the map of expected error messages with the list
-// of found errors and reports discrepancies.
-//
-func compareErrors(t *testing.T, fset *token.FileSet, expected map[token.Pos]string, found scanner.ErrorList) {
-	for _, error := range found {
-		// error.Pos is a token.Position, but we want
-		// a token.Pos so we can do a map lookup
-		pos := getPos(fset, error.Pos.Filename, error.Pos.Offset)
-		if msg, found := expected[pos]; found {
-			// we expect a message at pos; check if it matches
-			rx, err := regexp.Compile(msg)
-			if err != nil {
-				t.Errorf("%s: %v", error.Pos, err)
-				continue
-			}
-			if match := rx.MatchString(error.Msg); !match {
-				t.Errorf("%s: %q does not match %q", error.Pos, error.Msg, msg)
-				continue
-			}
-			// we have a match - eliminate this error
-			delete(expected, pos)
-		} else {
-			// To keep in mind when analyzing failed test output:
-			// If the same error position occurs multiple times in errors,
-			// this message will be triggered (because the first error at
-			// the position removes this position from the expected errors).
-			t.Errorf("%s: unexpected error: %s", error.Pos, error.Msg)
-		}
-	}
-
-	// there should be no expected errors left
-	if len(expected) > 0 {
-		t.Errorf("%d errors not reported:", len(expected))
-		for pos, msg := range expected {
-			t.Errorf("%s: %s\n", fset.Position(pos), msg)
-		}
-	}
-}
-
-func checkErrors(t *testing.T, filename string, input interface{}) {
-	src, err := readSource(filename, input)
-	if err != nil {
-		t.Error(err)
-		return
-	}
-
-	fset := token.NewFileSet()
-	_, err = ParseFile(fset, filename, src, DeclarationErrors|AllErrors)
-	found, ok := err.(scanner.ErrorList)
-	if err != nil && !ok {
-		t.Error(err)
-		return
-	}
-	found.RemoveMultiples()
-
-	// we are expecting the following errors
-	// (collect these after parsing a file so that it is found in the file set)
-	expected := expectedErrors(t, fset, filename, src)
-
-	// verify errors returned by the parser
-	compareErrors(t, fset, expected, found)
-}
-
-func TestErrors(t *testing.T) {
-	list, err := ioutil.ReadDir(testdata)
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, fi := range list {
-		name := fi.Name()
-		if !fi.IsDir() && !strings.HasPrefix(name, ".") && strings.HasSuffix(name, ".src") {
-			checkErrors(t, filepath.Join(testdata, name), nil)
-		}
-	}
-}
diff --git a/third_party/golang/go/parser/example_test.go b/third_party/golang/go/parser/example_test.go
deleted file mode 100644
index 99cfbb6c3713c..0000000000000
--- a/third_party/golang/go/parser/example_test.go
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package parser_test
-
-import (
-	"fmt"
-	"k8s.io/kubernetes/third_party/golang/go/parser"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-)
-
-func ExampleParseFile() {
-	fset := token.NewFileSet() // positions are relative to fset
-
-	// Parse the file containing this very example
-	// but stop after processing the imports.
-	f, err := parser.ParseFile(fset, "example_test.go", nil, parser.ImportsOnly)
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
-
-	// Print the imports from the file's AST.
-	for _, s := range f.Imports {
-		fmt.Println(s.Path.Value)
-	}
-
-	// output:
-	//
-	// "fmt"
-	// "k8s.io/kubernetes/third_party/golang/go/parser"
-	// "k8s.io/kubernetes/third_party/golang/go/token"
-}
diff --git a/third_party/golang/go/parser/interface.go b/third_party/golang/go/parser/interface.go
deleted file mode 100644
index 414096242ae1f..0000000000000
--- a/third_party/golang/go/parser/interface.go
+++ /dev/null
@@ -1,227 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file contains the exported entry points for invoking the parser.
-
-package parser
-
-import (
-	"bytes"
-	"errors"
-	"io"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-)
-
-// If src != nil, readSource converts src to a []byte if possible;
-// otherwise it returns an error. If src == nil, readSource returns
-// the result of reading the file specified by filename.
-//
-func readSource(filename string, src interface{}) ([]byte, error) {
-	if src != nil {
-		switch s := src.(type) {
-		case string:
-			return []byte(s), nil
-		case []byte:
-			return s, nil
-		case *bytes.Buffer:
-			// is io.Reader, but src is already available in []byte form
-			if s != nil {
-				return s.Bytes(), nil
-			}
-		case io.Reader:
-			var buf bytes.Buffer
-			if _, err := io.Copy(&buf, s); err != nil {
-				return nil, err
-			}
-			return buf.Bytes(), nil
-		}
-		return nil, errors.New("invalid source")
-	}
-	return ioutil.ReadFile(filename)
-}
-
-// A Mode value is a set of flags (or 0).
-// They control the amount of source code parsed and other optional
-// parser functionality.
-//
-type Mode uint
-
-const (
-	PackageClauseOnly Mode             = 1 << iota // stop parsing after package clause
-	ImportsOnly                                    // stop parsing after import declarations
-	ParseComments                                  // parse comments and add them to AST
-	Trace                                          // print a trace of parsed productions
-	DeclarationErrors                              // report declaration errors
-	SpuriousErrors                                 // same as AllErrors, for backward-compatibility
-	AllErrors         = SpuriousErrors             // report all errors (not just the first 10 on different lines)
-)
-
-// ParseFile parses the source code of a single Go source file and returns
-// the corresponding ast.File node. The source code may be provided via
-// the filename of the source file, or via the src parameter.
-//
-// If src != nil, ParseFile parses the source from src and the filename is
-// only used when recording position information. The type of the argument
-// for the src parameter must be string, []byte, or io.Reader.
-// If src == nil, ParseFile parses the file specified by filename.
-//
-// The mode parameter controls the amount of source text parsed and other
-// optional parser functionality. Position information is recorded in the
-// file set fset.
-//
-// If the source couldn't be read, the returned AST is nil and the error
-// indicates the specific failure. If the source was read but syntax
-// errors were found, the result is a partial AST (with ast.Bad* nodes
-// representing the fragments of erroneous source code). Multiple errors
-// are returned via a scanner.ErrorList which is sorted by file position.
-//
-func ParseFile(fset *token.FileSet, filename string, src interface{}, mode Mode) (f *ast.File, err error) {
-	// get source
-	text, err := readSource(filename, src)
-	if err != nil {
-		return nil, err
-	}
-
-	var p parser
-	defer func() {
-		if e := recover(); e != nil {
-			// resume same panic if it's not a bailout
-			if _, ok := e.(bailout); !ok {
-				panic(e)
-			}
-		}
-
-		// set result values
-		if f == nil {
-			// source is not a valid Go source file - satisfy
-			// ParseFile API and return a valid (but) empty
-			// *ast.File
-			f = &ast.File{
-				Name:  new(ast.Ident),
-				Scope: ast.NewScope(nil),
-			}
-		}
-
-		p.errors.Sort()
-		err = p.errors.Err()
-	}()
-
-	// parse source
-	p.init(fset, filename, text, mode)
-	f = p.parseFile()
-
-	return
-}
-
-// ParseDir calls ParseFile for all files with names ending in ".go" in the
-// directory specified by path and returns a map of package name -> package
-// AST with all the packages found.
-//
-// If filter != nil, only the files with os.FileInfo entries passing through
-// the filter (and ending in ".go") are considered. The mode bits are passed
-// to ParseFile unchanged. Position information is recorded in fset.
-//
-// If the directory couldn't be read, a nil map and the respective error are
-// returned. If a parse error occurred, a non-nil but incomplete map and the
-// first error encountered are returned.
-//
-func ParseDir(fset *token.FileSet, path string, filter func(os.FileInfo) bool, mode Mode) (pkgs map[string]*ast.Package, first error) {
-	fd, err := os.Open(path)
-	if err != nil {
-		return nil, err
-	}
-	defer fd.Close()
-
-	list, err := fd.Readdir(-1)
-	if err != nil {
-		return nil, err
-	}
-
-	pkgs = make(map[string]*ast.Package)
-	for _, d := range list {
-		if strings.HasSuffix(d.Name(), ".go") && (filter == nil || filter(d)) {
-			filename := filepath.Join(path, d.Name())
-			if src, err := ParseFile(fset, filename, nil, mode); err == nil {
-				name := src.Name.Name
-				pkg, found := pkgs[name]
-				if !found {
-					pkg = &ast.Package{
-						Name:  name,
-						Files: make(map[string]*ast.File),
-					}
-					pkgs[name] = pkg
-				}
-				pkg.Files[filename] = src
-			} else if first == nil {
-				first = err
-			}
-		}
-	}
-
-	return
-}
-
-// ParseExprFrom is a convenience function for parsing an expression.
-// The arguments have the same meaning as for Parse, but the source must
-// be a valid Go (type or value) expression.
-//
-func ParseExprFrom(fset *token.FileSet, filename string, src interface{}, mode Mode) (ast.Expr, error) {
-	// get source
-	text, err := readSource(filename, src)
-	if err != nil {
-		return nil, err
-	}
-
-	var p parser
-	defer func() {
-		if e := recover(); e != nil {
-			// resume same panic if it's not a bailout
-			if _, ok := e.(bailout); !ok {
-				panic(e)
-			}
-		}
-		p.errors.Sort()
-		err = p.errors.Err()
-	}()
-
-	// parse expr
-	p.init(fset, filename, text, mode)
-	// Set up pkg-level scopes to avoid nil-pointer errors.
-	// This is not needed for a correct expression x as the
-	// parser will be ok with a nil topScope, but be cautious
-	// in case of an erroneous x.
-	p.openScope()
-	p.pkgScope = p.topScope
-	e := p.parseRhsOrType()
-	p.closeScope()
-	assert(p.topScope == nil, "unbalanced scopes")
-
-	// If a semicolon was inserted, consume it;
-	// report an error if there's more tokens.
-	if p.tok == token.SEMICOLON && p.lit == "\n" {
-		p.next()
-	}
-	p.expect(token.EOF)
-
-	if p.errors.Len() > 0 {
-		p.errors.Sort()
-		return nil, p.errors.Err()
-	}
-
-	return e, nil
-}
-
-// ParseExpr is a convenience function for obtaining the AST of an expression x.
-// The position information recorded in the AST is undefined. The filename used
-// in error messages is the empty string.
-//
-func ParseExpr(x string) (ast.Expr, error) {
-	return ParseExprFrom(token.NewFileSet(), "", []byte(x), 0)
-}
diff --git a/third_party/golang/go/parser/parser.go b/third_party/golang/go/parser/parser.go
deleted file mode 100644
index 7979f126e3309..0000000000000
--- a/third_party/golang/go/parser/parser.go
+++ /dev/null
@@ -1,2502 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package parser implements a parser for Go source files. Input may be
-// provided in a variety of forms (see the various Parse* functions); the
-// output is an abstract syntax tree (AST) representing the Go source. The
-// parser is invoked through one of the Parse* functions.
-//
-// The parser accepts a larger language than is syntactically permitted by
-// the Go spec, for simplicity, and for improved robustness in the presence
-// of syntax errors. For instance, in method declarations, the receiver is
-// treated like an ordinary parameter list and thus may contain multiple
-// entries where the spec permits exactly one. Consequently, the corresponding
-// field in the AST (ast.FuncDecl.Recv) field is not restricted to one entry.
-//
-package parser
-
-import (
-	"fmt"
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"k8s.io/kubernetes/third_party/golang/go/scanner"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-	"strconv"
-	"strings"
-	"unicode"
-)
-
-// The parser structure holds the parser's internal state.
-type parser struct {
-	file    *token.File
-	errors  scanner.ErrorList
-	scanner scanner.Scanner
-
-	// Tracing/debugging
-	mode   Mode // parsing mode
-	trace  bool // == (mode & Trace != 0)
-	indent int  // indentation used for tracing output
-
-	// Comments
-	comments    []*ast.CommentGroup
-	leadComment *ast.CommentGroup // last lead comment
-	lineComment *ast.CommentGroup // last line comment
-
-	// Next token
-	pos token.Pos   // token position
-	tok token.Token // one token look-ahead
-	lit string      // token literal
-
-	// Error recovery
-	// (used to limit the number of calls to syncXXX functions
-	// w/o making scanning progress - avoids potential endless
-	// loops across multiple parser functions during error recovery)
-	syncPos token.Pos // last synchronization position
-	syncCnt int       // number of calls to syncXXX without progress
-
-	// Non-syntactic parser control
-	exprLev int  // < 0: in control clause, >= 0: in expression
-	inRhs   bool // if set, the parser is parsing a rhs expression
-
-	// Ordinary identifier scopes
-	pkgScope   *ast.Scope        // pkgScope.Outer == nil
-	topScope   *ast.Scope        // top-most scope; may be pkgScope
-	unresolved []*ast.Ident      // unresolved identifiers
-	imports    []*ast.ImportSpec // list of imports
-
-	// Label scopes
-	// (maintained by open/close LabelScope)
-	labelScope  *ast.Scope     // label scope for current function
-	targetStack [][]*ast.Ident // stack of unresolved labels
-}
-
-func (p *parser) init(fset *token.FileSet, filename string, src []byte, mode Mode) {
-	p.file = fset.AddFile(filename, -1, len(src))
-	var m scanner.Mode
-	if mode&ParseComments != 0 {
-		m = scanner.ScanComments
-	}
-	eh := func(pos token.Position, msg string) { p.errors.Add(pos, msg) }
-	p.scanner.Init(p.file, src, eh, m)
-
-	p.mode = mode
-	p.trace = mode&Trace != 0 // for convenience (p.trace is used frequently)
-
-	p.next()
-}
-
-// ----------------------------------------------------------------------------
-// Scoping support
-
-func (p *parser) openScope() {
-	p.topScope = ast.NewScope(p.topScope)
-}
-
-func (p *parser) closeScope() {
-	p.topScope = p.topScope.Outer
-}
-
-func (p *parser) openLabelScope() {
-	p.labelScope = ast.NewScope(p.labelScope)
-	p.targetStack = append(p.targetStack, nil)
-}
-
-func (p *parser) closeLabelScope() {
-	// resolve labels
-	n := len(p.targetStack) - 1
-	scope := p.labelScope
-	for _, ident := range p.targetStack[n] {
-		ident.Obj = scope.Lookup(ident.Name)
-		if ident.Obj == nil && p.mode&DeclarationErrors != 0 {
-			p.error(ident.Pos(), fmt.Sprintf("label %s undefined", ident.Name))
-		}
-	}
-	// pop label scope
-	p.targetStack = p.targetStack[0:n]
-	p.labelScope = p.labelScope.Outer
-}
-
-func (p *parser) declare(decl, data interface{}, scope *ast.Scope, kind ast.ObjKind, idents ...*ast.Ident) {
-	for _, ident := range idents {
-		assert(ident.Obj == nil, "identifier already declared or resolved")
-		obj := ast.NewObj(kind, ident.Name)
-		// remember the corresponding declaration for redeclaration
-		// errors and global variable resolution/typechecking phase
-		obj.Decl = decl
-		obj.Data = data
-		ident.Obj = obj
-		if ident.Name != "_" {
-			if alt := scope.Insert(obj); alt != nil && p.mode&DeclarationErrors != 0 {
-				prevDecl := ""
-				if pos := alt.Pos(); pos.IsValid() {
-					prevDecl = fmt.Sprintf("\n\tprevious declaration at %s", p.file.Position(pos))
-				}
-				p.error(ident.Pos(), fmt.Sprintf("%s redeclared in this block%s", ident.Name, prevDecl))
-			}
-		}
-	}
-}
-
-func (p *parser) shortVarDecl(decl *ast.AssignStmt, list []ast.Expr) {
-	// Go spec: A short variable declaration may redeclare variables
-	// provided they were originally declared in the same block with
-	// the same type, and at least one of the non-blank variables is new.
-	n := 0 // number of new variables
-	for _, x := range list {
-		if ident, isIdent := x.(*ast.Ident); isIdent {
-			assert(ident.Obj == nil, "identifier already declared or resolved")
-			obj := ast.NewObj(ast.Var, ident.Name)
-			// remember corresponding assignment for other tools
-			obj.Decl = decl
-			ident.Obj = obj
-			if ident.Name != "_" {
-				if alt := p.topScope.Insert(obj); alt != nil {
-					ident.Obj = alt // redeclaration
-				} else {
-					n++ // new declaration
-				}
-			}
-		} else {
-			p.errorExpected(x.Pos(), "identifier on left side of :=")
-		}
-	}
-	if n == 0 && p.mode&DeclarationErrors != 0 {
-		p.error(list[0].Pos(), "no new variables on left side of :=")
-	}
-}
-
-// The unresolved object is a sentinel to mark identifiers that have been added
-// to the list of unresolved identifiers. The sentinel is only used for verifying
-// internal consistency.
-var unresolved = new(ast.Object)
-
-// If x is an identifier, tryResolve attempts to resolve x by looking up
-// the object it denotes. If no object is found and collectUnresolved is
-// set, x is marked as unresolved and collected in the list of unresolved
-// identifiers.
-//
-func (p *parser) tryResolve(x ast.Expr, collectUnresolved bool) {
-	// nothing to do if x is not an identifier or the blank identifier
-	ident, _ := x.(*ast.Ident)
-	if ident == nil {
-		return
-	}
-	assert(ident.Obj == nil, "identifier already declared or resolved")
-	if ident.Name == "_" {
-		return
-	}
-	// try to resolve the identifier
-	for s := p.topScope; s != nil; s = s.Outer {
-		if obj := s.Lookup(ident.Name); obj != nil {
-			ident.Obj = obj
-			return
-		}
-	}
-	// all local scopes are known, so any unresolved identifier
-	// must be found either in the file scope, package scope
-	// (perhaps in another file), or universe scope --- collect
-	// them so that they can be resolved later
-	if collectUnresolved {
-		ident.Obj = unresolved
-		p.unresolved = append(p.unresolved, ident)
-	}
-}
-
-func (p *parser) resolve(x ast.Expr) {
-	p.tryResolve(x, true)
-}
-
-// ----------------------------------------------------------------------------
-// Parsing support
-
-func (p *parser) printTrace(a ...interface{}) {
-	const dots = ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . "
-	const n = len(dots)
-	pos := p.file.Position(p.pos)
-	fmt.Printf("%5d:%3d: ", pos.Line, pos.Column)
-	i := 2 * p.indent
-	for i > n {
-		fmt.Print(dots)
-		i -= n
-	}
-	// i <= n
-	fmt.Print(dots[0:i])
-	fmt.Println(a...)
-}
-
-func trace(p *parser, msg string) *parser {
-	p.printTrace(msg, "(")
-	p.indent++
-	return p
-}
-
-// Usage pattern: defer un(trace(p, "..."))
-func un(p *parser) {
-	p.indent--
-	p.printTrace(")")
-}
-
-// Advance to the next token.
-func (p *parser) next0() {
-	// Because of one-token look-ahead, print the previous token
-	// when tracing as it provides a more readable output. The
-	// very first token (!p.pos.IsValid()) is not initialized
-	// (it is token.ILLEGAL), so don't print it .
-	if p.trace && p.pos.IsValid() {
-		s := p.tok.String()
-		switch {
-		case p.tok.IsLiteral():
-			p.printTrace(s, p.lit)
-		case p.tok.IsOperator(), p.tok.IsKeyword():
-			p.printTrace("\"" + s + "\"")
-		default:
-			p.printTrace(s)
-		}
-	}
-
-	p.pos, p.tok, p.lit = p.scanner.Scan()
-}
-
-// Consume a comment and return it and the line on which it ends.
-func (p *parser) consumeComment() (comment *ast.Comment, endline int) {
-	// /*-style comments may end on a different line than where they start.
-	// Scan the comment for '\n' chars and adjust endline accordingly.
-	endline = p.file.Line(p.pos)
-	if p.lit[1] == '*' {
-		// don't use range here - no need to decode Unicode code points
-		for i := 0; i < len(p.lit); i++ {
-			if p.lit[i] == '\n' {
-				endline++
-			}
-		}
-	}
-
-	comment = &ast.Comment{Slash: p.pos, Text: p.lit}
-	p.next0()
-
-	return
-}
-
-// Consume a group of adjacent comments, add it to the parser's
-// comments list, and return it together with the line at which
-// the last comment in the group ends. A non-comment token or n
-// empty lines terminate a comment group.
-//
-func (p *parser) consumeCommentGroup(n int) (comments *ast.CommentGroup, endline int) {
-	var list []*ast.Comment
-	endline = p.file.Line(p.pos)
-	for p.tok == token.COMMENT && p.file.Line(p.pos) <= endline+n {
-		var comment *ast.Comment
-		comment, endline = p.consumeComment()
-		list = append(list, comment)
-	}
-
-	// add comment group to the comments list
-	comments = &ast.CommentGroup{List: list}
-	p.comments = append(p.comments, comments)
-
-	return
-}
-
-// Advance to the next non-comment token. In the process, collect
-// any comment groups encountered, and remember the last lead and
-// and line comments.
-//
-// A lead comment is a comment group that starts and ends in a
-// line without any other tokens and that is followed by a non-comment
-// token on the line immediately after the comment group.
-//
-// A line comment is a comment group that follows a non-comment
-// token on the same line, and that has no tokens after it on the line
-// where it ends.
-//
-// Lead and line comments may be considered documentation that is
-// stored in the AST.
-//
-func (p *parser) next() {
-	p.leadComment = nil
-	p.lineComment = nil
-	prev := p.pos
-	p.next0()
-
-	if p.tok == token.COMMENT {
-		var comment *ast.CommentGroup
-		var endline int
-
-		if p.file.Line(p.pos) == p.file.Line(prev) {
-			// The comment is on same line as the previous token; it
-			// cannot be a lead comment but may be a line comment.
-			comment, endline = p.consumeCommentGroup(0)
-			if p.file.Line(p.pos) != endline {
-				// The next token is on a different line, thus
-				// the last comment group is a line comment.
-				p.lineComment = comment
-			}
-		}
-
-		// consume successor comments, if any
-		endline = -1
-		for p.tok == token.COMMENT {
-			comment, endline = p.consumeCommentGroup(1)
-		}
-
-		if endline+1 == p.file.Line(p.pos) {
-			// The next token is following on the line immediately after the
-			// comment group, thus the last comment group is a lead comment.
-			p.leadComment = comment
-		}
-	}
-}
-
-// A bailout panic is raised to indicate early termination.
-type bailout struct{}
-
-func (p *parser) error(pos token.Pos, msg string) {
-	epos := p.file.Position(pos)
-
-	// If AllErrors is not set, discard errors reported on the same line
-	// as the last recorded error and stop parsing if there are more than
-	// 10 errors.
-	if p.mode&AllErrors == 0 {
-		n := len(p.errors)
-		if n > 0 && p.errors[n-1].Pos.Line == epos.Line {
-			return // discard - likely a spurious error
-		}
-		if n > 10 {
-			panic(bailout{})
-		}
-	}
-
-	p.errors.Add(epos, msg)
-}
-
-func (p *parser) errorExpected(pos token.Pos, msg string) {
-	msg = "expected " + msg
-	if pos == p.pos {
-		// the error happened at the current position;
-		// make the error message more specific
-		if p.tok == token.SEMICOLON && p.lit == "\n" {
-			msg += ", found newline"
-		} else {
-			msg += ", found '" + p.tok.String() + "'"
-			if p.tok.IsLiteral() {
-				msg += " " + p.lit
-			}
-		}
-	}
-	p.error(pos, msg)
-}
-
-func (p *parser) expect(tok token.Token) token.Pos {
-	pos := p.pos
-	if p.tok != tok {
-		p.errorExpected(pos, "'"+tok.String()+"'")
-	}
-	p.next() // make progress
-	return pos
-}
-
-// expectClosing is like expect but provides a better error message
-// for the common case of a missing comma before a newline.
-//
-func (p *parser) expectClosing(tok token.Token, context string) token.Pos {
-	if p.tok != tok && p.tok == token.SEMICOLON && p.lit == "\n" {
-		p.error(p.pos, "missing ',' before newline in "+context)
-		p.next()
-	}
-	return p.expect(tok)
-}
-
-func (p *parser) expectSemi() {
-	// semicolon is optional before a closing ')' or '}'
-	if p.tok != token.RPAREN && p.tok != token.RBRACE {
-		if p.tok == token.SEMICOLON {
-			p.next()
-		} else {
-			p.errorExpected(p.pos, "';'")
-			syncStmt(p)
-		}
-	}
-}
-
-func (p *parser) atComma(context string, follow token.Token) bool {
-	if p.tok == token.COMMA {
-		return true
-	}
-	if p.tok != follow {
-		msg := "missing ','"
-		if p.tok == token.SEMICOLON && p.lit == "\n" {
-			msg += " before newline"
-		}
-		p.error(p.pos, msg+" in "+context)
-		return true // "insert" comma and continue
-	}
-	return false
-}
-
-func assert(cond bool, msg string) {
-	if !cond {
-		panic("go/parser internal error: " + msg)
-	}
-}
-
-// syncStmt advances to the next statement.
-// Used for synchronization after an error.
-//
-func syncStmt(p *parser) {
-	for {
-		switch p.tok {
-		case token.BREAK, token.CONST, token.CONTINUE, token.DEFER,
-			token.FALLTHROUGH, token.FOR, token.GO, token.GOTO,
-			token.IF, token.RETURN, token.SELECT, token.SWITCH,
-			token.TYPE, token.VAR:
-			// Return only if parser made some progress since last
-			// sync or if it has not reached 10 sync calls without
-			// progress. Otherwise consume at least one token to
-			// avoid an endless parser loop (it is possible that
-			// both parseOperand and parseStmt call syncStmt and
-			// correctly do not advance, thus the need for the
-			// invocation limit p.syncCnt).
-			if p.pos == p.syncPos && p.syncCnt < 10 {
-				p.syncCnt++
-				return
-			}
-			if p.pos > p.syncPos {
-				p.syncPos = p.pos
-				p.syncCnt = 0
-				return
-			}
-			// Reaching here indicates a parser bug, likely an
-			// incorrect token list in this function, but it only
-			// leads to skipping of possibly correct code if a
-			// previous error is present, and thus is preferred
-			// over a non-terminating parse.
-		case token.EOF:
-			return
-		}
-		p.next()
-	}
-}
-
-// syncDecl advances to the next declaration.
-// Used for synchronization after an error.
-//
-func syncDecl(p *parser) {
-	for {
-		switch p.tok {
-		case token.CONST, token.TYPE, token.VAR:
-			// see comments in syncStmt
-			if p.pos == p.syncPos && p.syncCnt < 10 {
-				p.syncCnt++
-				return
-			}
-			if p.pos > p.syncPos {
-				p.syncPos = p.pos
-				p.syncCnt = 0
-				return
-			}
-		case token.EOF:
-			return
-		}
-		p.next()
-	}
-}
-
-// safePos returns a valid file position for a given position: If pos
-// is valid to begin with, safePos returns pos. If pos is out-of-range,
-// safePos returns the EOF position.
-//
-// This is hack to work around "artificial" end positions in the AST which
-// are computed by adding 1 to (presumably valid) token positions. If the
-// token positions are invalid due to parse errors, the resulting end position
-// may be past the file's EOF position, which would lead to panics if used
-// later on.
-//
-func (p *parser) safePos(pos token.Pos) (res token.Pos) {
-	defer func() {
-		if recover() != nil {
-			res = token.Pos(p.file.Base() + p.file.Size()) // EOF position
-		}
-	}()
-	_ = p.file.Offset(pos) // trigger a panic if position is out-of-range
-	return pos
-}
-
-// ----------------------------------------------------------------------------
-// Identifiers
-
-func (p *parser) parseIdent() *ast.Ident {
-	pos := p.pos
-	name := "_"
-	if p.tok == token.IDENT {
-		name = p.lit
-		p.next()
-	} else {
-		p.expect(token.IDENT) // use expect() error handling
-	}
-	return &ast.Ident{NamePos: pos, Name: name}
-}
-
-func (p *parser) parseIdentList() (list []*ast.Ident) {
-	if p.trace {
-		defer un(trace(p, "IdentList"))
-	}
-
-	list = append(list, p.parseIdent())
-	for p.tok == token.COMMA {
-		p.next()
-		list = append(list, p.parseIdent())
-	}
-
-	return
-}
-
-// ----------------------------------------------------------------------------
-// Common productions
-
-// If lhs is set, result list elements which are identifiers are not resolved.
-func (p *parser) parseExprList(lhs bool) (list []ast.Expr) {
-	if p.trace {
-		defer un(trace(p, "ExpressionList"))
-	}
-
-	list = append(list, p.checkExpr(p.parseExpr(lhs)))
-	for p.tok == token.COMMA {
-		p.next()
-		list = append(list, p.checkExpr(p.parseExpr(lhs)))
-	}
-
-	return
-}
-
-func (p *parser) parseLhsList() []ast.Expr {
-	old := p.inRhs
-	p.inRhs = false
-	list := p.parseExprList(true)
-	switch p.tok {
-	case token.DEFINE:
-		// lhs of a short variable declaration
-		// but doesn't enter scope until later:
-		// caller must call p.shortVarDecl(p.makeIdentList(list))
-		// at appropriate time.
-	case token.COLON:
-		// lhs of a label declaration or a communication clause of a select
-		// statement (parseLhsList is not called when parsing the case clause
-		// of a switch statement):
-		// - labels are declared by the caller of parseLhsList
-		// - for communication clauses, if there is a stand-alone identifier
-		//   followed by a colon, we have a syntax error; there is no need
-		//   to resolve the identifier in that case
-	default:
-		// identifiers must be declared elsewhere
-		for _, x := range list {
-			p.resolve(x)
-		}
-	}
-	p.inRhs = old
-	return list
-}
-
-func (p *parser) parseRhsList() []ast.Expr {
-	old := p.inRhs
-	p.inRhs = true
-	list := p.parseExprList(false)
-	p.inRhs = old
-	return list
-}
-
-// ----------------------------------------------------------------------------
-// Types
-
-func (p *parser) parseType() ast.Expr {
-	if p.trace {
-		defer un(trace(p, "Type"))
-	}
-
-	typ := p.tryType()
-
-	if typ == nil {
-		pos := p.pos
-		p.errorExpected(pos, "type")
-		p.next() // make progress
-		return &ast.BadExpr{From: pos, To: p.pos}
-	}
-
-	return typ
-}
-
-// If the result is an identifier, it is not resolved.
-func (p *parser) parseTypeName() ast.Expr {
-	if p.trace {
-		defer un(trace(p, "TypeName"))
-	}
-
-	ident := p.parseIdent()
-	// don't resolve ident yet - it may be a parameter or field name
-
-	if p.tok == token.PERIOD {
-		// ident is a package name
-		p.next()
-		p.resolve(ident)
-		sel := p.parseIdent()
-		return &ast.SelectorExpr{X: ident, Sel: sel}
-	}
-
-	return ident
-}
-
-func (p *parser) parseArrayType() ast.Expr {
-	if p.trace {
-		defer un(trace(p, "ArrayType"))
-	}
-
-	lbrack := p.expect(token.LBRACK)
-	p.exprLev++
-	var len ast.Expr
-	// always permit ellipsis for more fault-tolerant parsing
-	if p.tok == token.ELLIPSIS {
-		len = &ast.Ellipsis{Ellipsis: p.pos}
-		p.next()
-	} else if p.tok != token.RBRACK {
-		len = p.parseRhs()
-	}
-	p.exprLev--
-	p.expect(token.RBRACK)
-	elt := p.parseType()
-
-	return &ast.ArrayType{Lbrack: lbrack, Len: len, Elt: elt}
-}
-
-func (p *parser) makeIdentList(list []ast.Expr) []*ast.Ident {
-	idents := make([]*ast.Ident, len(list))
-	for i, x := range list {
-		ident, isIdent := x.(*ast.Ident)
-		if !isIdent {
-			if _, isBad := x.(*ast.BadExpr); !isBad {
-				// only report error if it's a new one
-				p.errorExpected(x.Pos(), "identifier")
-			}
-			ident = &ast.Ident{NamePos: x.Pos(), Name: "_"}
-		}
-		idents[i] = ident
-	}
-	return idents
-}
-
-func (p *parser) parseFieldDecl(scope *ast.Scope) *ast.Field {
-	if p.trace {
-		defer un(trace(p, "FieldDecl"))
-	}
-
-	doc := p.leadComment
-
-	// FieldDecl
-	list, typ := p.parseVarList(false)
-
-	// Tag
-	var tag *ast.BasicLit
-	if p.tok == token.STRING {
-		tag = &ast.BasicLit{ValuePos: p.pos, Kind: p.tok, Value: p.lit}
-		p.next()
-	}
-
-	// analyze case
-	var idents []*ast.Ident
-	if typ != nil {
-		// IdentifierList Type
-		idents = p.makeIdentList(list)
-	} else {
-		// ["*"] TypeName (AnonymousField)
-		typ = list[0] // we always have at least one element
-		if n := len(list); n > 1 || !isTypeName(deref(typ)) {
-			pos := typ.Pos()
-			p.errorExpected(pos, "anonymous field")
-			typ = &ast.BadExpr{From: pos, To: p.safePos(list[n-1].End())}
-		}
-	}
-
-	p.expectSemi() // call before accessing p.linecomment
-
-	field := &ast.Field{Doc: doc, Names: idents, Type: typ, Tag: tag, Comment: p.lineComment}
-	p.declare(field, nil, scope, ast.Var, idents...)
-	p.resolve(typ)
-
-	return field
-}
-
-func (p *parser) parseStructType() *ast.StructType {
-	if p.trace {
-		defer un(trace(p, "StructType"))
-	}
-
-	pos := p.expect(token.STRUCT)
-	lbrace := p.expect(token.LBRACE)
-	scope := ast.NewScope(nil) // struct scope
-	var list []*ast.Field
-	for p.tok == token.IDENT || p.tok == token.MUL || p.tok == token.LPAREN {
-		// a field declaration cannot start with a '(' but we accept
-		// it here for more robust parsing and better error messages
-		// (parseFieldDecl will check and complain if necessary)
-		list = append(list, p.parseFieldDecl(scope))
-	}
-	rbrace := p.expect(token.RBRACE)
-
-	return &ast.StructType{
-		Struct: pos,
-		Fields: &ast.FieldList{
-			Opening: lbrace,
-			List:    list,
-			Closing: rbrace,
-		},
-	}
-}
-
-func (p *parser) parsePointerType() *ast.StarExpr {
-	if p.trace {
-		defer un(trace(p, "PointerType"))
-	}
-
-	star := p.expect(token.MUL)
-	base := p.parseType()
-
-	return &ast.StarExpr{Star: star, X: base}
-}
-
-// If the result is an identifier, it is not resolved.
-func (p *parser) tryVarType(isParam bool) ast.Expr {
-	if isParam && p.tok == token.ELLIPSIS {
-		pos := p.pos
-		p.next()
-		typ := p.tryIdentOrType() // don't use parseType so we can provide better error message
-		if typ != nil {
-			p.resolve(typ)
-		} else {
-			p.error(pos, "'...' parameter is missing type")
-			typ = &ast.BadExpr{From: pos, To: p.pos}
-		}
-		return &ast.Ellipsis{Ellipsis: pos, Elt: typ}
-	}
-	return p.tryIdentOrType()
-}
-
-// If the result is an identifier, it is not resolved.
-func (p *parser) parseVarType(isParam bool) ast.Expr {
-	typ := p.tryVarType(isParam)
-	if typ == nil {
-		pos := p.pos
-		p.errorExpected(pos, "type")
-		p.next() // make progress
-		typ = &ast.BadExpr{From: pos, To: p.pos}
-	}
-	return typ
-}
-
-// If any of the results are identifiers, they are not resolved.
-func (p *parser) parseVarList(isParam bool) (list []ast.Expr, typ ast.Expr) {
-	if p.trace {
-		defer un(trace(p, "VarList"))
-	}
-
-	// a list of identifiers looks like a list of type names
-	//
-	// parse/tryVarType accepts any type (including parenthesized
-	// ones) even though the syntax does not permit them here: we
-	// accept them all for more robust parsing and complain later
-	for typ := p.parseVarType(isParam); typ != nil; {
-		list = append(list, typ)
-		if p.tok != token.COMMA {
-			break
-		}
-		p.next()
-		typ = p.tryVarType(isParam) // maybe nil as in: func f(int,) {}
-	}
-
-	// if we had a list of identifiers, it must be followed by a type
-	typ = p.tryVarType(isParam)
-
-	return
-}
-
-func (p *parser) parseParameterList(scope *ast.Scope, ellipsisOk bool) (params []*ast.Field) {
-	if p.trace {
-		defer un(trace(p, "ParameterList"))
-	}
-
-	// ParameterDecl
-	list, typ := p.parseVarList(ellipsisOk)
-
-	// analyze case
-	if typ != nil {
-		// IdentifierList Type
-		idents := p.makeIdentList(list)
-		field := &ast.Field{Names: idents, Type: typ}
-		params = append(params, field)
-		// Go spec: The scope of an identifier denoting a function
-		// parameter or result variable is the function body.
-		p.declare(field, nil, scope, ast.Var, idents...)
-		p.resolve(typ)
-		if !p.atComma("parameter list", token.RPAREN) {
-			return
-		}
-		p.next()
-		for p.tok != token.RPAREN && p.tok != token.EOF {
-			idents := p.parseIdentList()
-			typ := p.parseVarType(ellipsisOk)
-			field := &ast.Field{Names: idents, Type: typ}
-			params = append(params, field)
-			// Go spec: The scope of an identifier denoting a function
-			// parameter or result variable is the function body.
-			p.declare(field, nil, scope, ast.Var, idents...)
-			p.resolve(typ)
-			if !p.atComma("parameter list", token.RPAREN) {
-				break
-			}
-			p.next()
-		}
-		return
-	}
-
-	// Type { "," Type } (anonymous parameters)
-	params = make([]*ast.Field, len(list))
-	for i, typ := range list {
-		p.resolve(typ)
-		params[i] = &ast.Field{Type: typ}
-	}
-	return
-}
-
-func (p *parser) parseParameters(scope *ast.Scope, ellipsisOk bool) *ast.FieldList {
-	if p.trace {
-		defer un(trace(p, "Parameters"))
-	}
-
-	var params []*ast.Field
-	lparen := p.expect(token.LPAREN)
-	if p.tok != token.RPAREN {
-		params = p.parseParameterList(scope, ellipsisOk)
-	}
-	rparen := p.expect(token.RPAREN)
-
-	return &ast.FieldList{Opening: lparen, List: params, Closing: rparen}
-}
-
-func (p *parser) parseResult(scope *ast.Scope) *ast.FieldList {
-	if p.trace {
-		defer un(trace(p, "Result"))
-	}
-
-	if p.tok == token.LPAREN {
-		return p.parseParameters(scope, false)
-	}
-
-	typ := p.tryType()
-	if typ != nil {
-		list := make([]*ast.Field, 1)
-		list[0] = &ast.Field{Type: typ}
-		return &ast.FieldList{List: list}
-	}
-
-	return nil
-}
-
-func (p *parser) parseSignature(scope *ast.Scope) (params, results *ast.FieldList) {
-	if p.trace {
-		defer un(trace(p, "Signature"))
-	}
-
-	params = p.parseParameters(scope, true)
-	results = p.parseResult(scope)
-
-	return
-}
-
-func (p *parser) parseFuncType() (*ast.FuncType, *ast.Scope) {
-	if p.trace {
-		defer un(trace(p, "FuncType"))
-	}
-
-	pos := p.expect(token.FUNC)
-	scope := ast.NewScope(p.topScope) // function scope
-	params, results := p.parseSignature(scope)
-
-	return &ast.FuncType{Func: pos, Params: params, Results: results}, scope
-}
-
-func (p *parser) parseMethodSpec(scope *ast.Scope) *ast.Field {
-	if p.trace {
-		defer un(trace(p, "MethodSpec"))
-	}
-
-	doc := p.leadComment
-	var idents []*ast.Ident
-	var typ ast.Expr
-	x := p.parseTypeName()
-	if ident, isIdent := x.(*ast.Ident); isIdent && p.tok == token.LPAREN {
-		// method
-		idents = []*ast.Ident{ident}
-		scope := ast.NewScope(nil) // method scope
-		params, results := p.parseSignature(scope)
-		typ = &ast.FuncType{Func: token.NoPos, Params: params, Results: results}
-	} else {
-		// embedded interface
-		typ = x
-		p.resolve(typ)
-	}
-	p.expectSemi() // call before accessing p.linecomment
-
-	spec := &ast.Field{Doc: doc, Names: idents, Type: typ, Comment: p.lineComment}
-	p.declare(spec, nil, scope, ast.Fun, idents...)
-
-	return spec
-}
-
-func (p *parser) parseInterfaceType() *ast.InterfaceType {
-	if p.trace {
-		defer un(trace(p, "InterfaceType"))
-	}
-
-	pos := p.expect(token.INTERFACE)
-	lbrace := p.expect(token.LBRACE)
-	scope := ast.NewScope(nil) // interface scope
-	var list []*ast.Field
-	for p.tok == token.IDENT {
-		list = append(list, p.parseMethodSpec(scope))
-	}
-	rbrace := p.expect(token.RBRACE)
-
-	return &ast.InterfaceType{
-		Interface: pos,
-		Methods: &ast.FieldList{
-			Opening: lbrace,
-			List:    list,
-			Closing: rbrace,
-		},
-	}
-}
-
-func (p *parser) parseMapType() *ast.MapType {
-	if p.trace {
-		defer un(trace(p, "MapType"))
-	}
-
-	pos := p.expect(token.MAP)
-	p.expect(token.LBRACK)
-	key := p.parseType()
-	p.expect(token.RBRACK)
-	value := p.parseType()
-
-	return &ast.MapType{Map: pos, Key: key, Value: value}
-}
-
-func (p *parser) parseChanType() *ast.ChanType {
-	if p.trace {
-		defer un(trace(p, "ChanType"))
-	}
-
-	pos := p.pos
-	dir := ast.SEND | ast.RECV
-	var arrow token.Pos
-	if p.tok == token.CHAN {
-		p.next()
-		if p.tok == token.ARROW {
-			arrow = p.pos
-			p.next()
-			dir = ast.SEND
-		}
-	} else {
-		arrow = p.expect(token.ARROW)
-		p.expect(token.CHAN)
-		dir = ast.RECV
-	}
-	value := p.parseType()
-
-	return &ast.ChanType{Begin: pos, Arrow: arrow, Dir: dir, Value: value}
-}
-
-// If the result is an identifier, it is not resolved.
-func (p *parser) tryIdentOrType() ast.Expr {
-	switch p.tok {
-	case token.IDENT:
-		return p.parseTypeName()
-	case token.LBRACK:
-		return p.parseArrayType()
-	case token.STRUCT:
-		return p.parseStructType()
-	case token.MUL:
-		return p.parsePointerType()
-	case token.FUNC:
-		typ, _ := p.parseFuncType()
-		return typ
-	case token.INTERFACE:
-		return p.parseInterfaceType()
-	case token.MAP:
-		return p.parseMapType()
-	case token.CHAN, token.ARROW:
-		return p.parseChanType()
-	case token.LPAREN:
-		lparen := p.pos
-		p.next()
-		typ := p.parseType()
-		rparen := p.expect(token.RPAREN)
-		return &ast.ParenExpr{Lparen: lparen, X: typ, Rparen: rparen}
-	}
-
-	// no type found
-	return nil
-}
-
-func (p *parser) tryType() ast.Expr {
-	typ := p.tryIdentOrType()
-	if typ != nil {
-		p.resolve(typ)
-	}
-	return typ
-}
-
-// ----------------------------------------------------------------------------
-// Blocks
-
-func (p *parser) parseStmtList() (list []ast.Stmt) {
-	if p.trace {
-		defer un(trace(p, "StatementList"))
-	}
-
-	for p.tok != token.CASE && p.tok != token.DEFAULT && p.tok != token.RBRACE && p.tok != token.EOF {
-		list = append(list, p.parseStmt())
-	}
-
-	return
-}
-
-func (p *parser) parseBody(scope *ast.Scope) *ast.BlockStmt {
-	if p.trace {
-		defer un(trace(p, "Body"))
-	}
-
-	lbrace := p.expect(token.LBRACE)
-	p.topScope = scope // open function scope
-	p.openLabelScope()
-	list := p.parseStmtList()
-	p.closeLabelScope()
-	p.closeScope()
-	rbrace := p.expect(token.RBRACE)
-
-	return &ast.BlockStmt{Lbrace: lbrace, List: list, Rbrace: rbrace}
-}
-
-func (p *parser) parseBlockStmt() *ast.BlockStmt {
-	if p.trace {
-		defer un(trace(p, "BlockStmt"))
-	}
-
-	lbrace := p.expect(token.LBRACE)
-	p.openScope()
-	list := p.parseStmtList()
-	p.closeScope()
-	rbrace := p.expect(token.RBRACE)
-
-	return &ast.BlockStmt{Lbrace: lbrace, List: list, Rbrace: rbrace}
-}
-
-// ----------------------------------------------------------------------------
-// Expressions
-
-func (p *parser) parseFuncTypeOrLit() ast.Expr {
-	if p.trace {
-		defer un(trace(p, "FuncTypeOrLit"))
-	}
-
-	typ, scope := p.parseFuncType()
-	if p.tok != token.LBRACE {
-		// function type only
-		return typ
-	}
-
-	p.exprLev++
-	body := p.parseBody(scope)
-	p.exprLev--
-
-	return &ast.FuncLit{Type: typ, Body: body}
-}
-
-// parseOperand may return an expression or a raw type (incl. array
-// types of the form [...]T. Callers must verify the result.
-// If lhs is set and the result is an identifier, it is not resolved.
-//
-func (p *parser) parseOperand(lhs bool) ast.Expr {
-	if p.trace {
-		defer un(trace(p, "Operand"))
-	}
-
-	switch p.tok {
-	case token.IDENT:
-		x := p.parseIdent()
-		if !lhs {
-			p.resolve(x)
-		}
-		return x
-
-	case token.INT, token.FLOAT, token.IMAG, token.CHAR, token.STRING:
-		x := &ast.BasicLit{ValuePos: p.pos, Kind: p.tok, Value: p.lit}
-		p.next()
-		return x
-
-	case token.LPAREN:
-		lparen := p.pos
-		p.next()
-		p.exprLev++
-		x := p.parseRhsOrType() // types may be parenthesized: (some type)
-		p.exprLev--
-		rparen := p.expect(token.RPAREN)
-		return &ast.ParenExpr{Lparen: lparen, X: x, Rparen: rparen}
-
-	case token.FUNC:
-		return p.parseFuncTypeOrLit()
-	}
-
-	if typ := p.tryIdentOrType(); typ != nil {
-		// could be type for composite literal or conversion
-		_, isIdent := typ.(*ast.Ident)
-		assert(!isIdent, "type cannot be identifier")
-		return typ
-	}
-
-	// we have an error
-	pos := p.pos
-	p.errorExpected(pos, "operand")
-	syncStmt(p)
-	return &ast.BadExpr{From: pos, To: p.pos}
-}
-
-func (p *parser) parseSelector(x ast.Expr) ast.Expr {
-	if p.trace {
-		defer un(trace(p, "Selector"))
-	}
-
-	sel := p.parseIdent()
-
-	return &ast.SelectorExpr{X: x, Sel: sel}
-}
-
-func (p *parser) parseTypeAssertion(x ast.Expr) ast.Expr {
-	if p.trace {
-		defer un(trace(p, "TypeAssertion"))
-	}
-
-	lparen := p.expect(token.LPAREN)
-	var typ ast.Expr
-	if p.tok == token.TYPE {
-		// type switch: typ == nil
-		p.next()
-	} else {
-		typ = p.parseType()
-	}
-	rparen := p.expect(token.RPAREN)
-
-	return &ast.TypeAssertExpr{X: x, Type: typ, Lparen: lparen, Rparen: rparen}
-}
-
-func (p *parser) parseIndexOrSlice(x ast.Expr) ast.Expr {
-	if p.trace {
-		defer un(trace(p, "IndexOrSlice"))
-	}
-
-	const N = 3 // change the 3 to 2 to disable 3-index slices
-	lbrack := p.expect(token.LBRACK)
-	p.exprLev++
-	var index [N]ast.Expr
-	var colons [N - 1]token.Pos
-	if p.tok != token.COLON {
-		index[0] = p.parseRhs()
-	}
-	ncolons := 0
-	for p.tok == token.COLON && ncolons < len(colons) {
-		colons[ncolons] = p.pos
-		ncolons++
-		p.next()
-		if p.tok != token.COLON && p.tok != token.RBRACK && p.tok != token.EOF {
-			index[ncolons] = p.parseRhs()
-		}
-	}
-	p.exprLev--
-	rbrack := p.expect(token.RBRACK)
-
-	if ncolons > 0 {
-		// slice expression
-		slice3 := false
-		if ncolons == 2 {
-			slice3 = true
-			// Check presence of 2nd and 3rd index here rather than during type-checking
-			// to prevent erroneous programs from passing through gofmt (was issue 7305).
-			if index[1] == nil {
-				p.error(colons[0], "2nd index required in 3-index slice")
-				index[1] = &ast.BadExpr{From: colons[0] + 1, To: colons[1]}
-			}
-			if index[2] == nil {
-				p.error(colons[1], "3rd index required in 3-index slice")
-				index[2] = &ast.BadExpr{From: colons[1] + 1, To: rbrack}
-			}
-		}
-		return &ast.SliceExpr{X: x, Lbrack: lbrack, Low: index[0], High: index[1], Max: index[2], Slice3: slice3, Rbrack: rbrack}
-	}
-
-	return &ast.IndexExpr{X: x, Lbrack: lbrack, Index: index[0], Rbrack: rbrack}
-}
-
-func (p *parser) parseCallOrConversion(fun ast.Expr) *ast.CallExpr {
-	if p.trace {
-		defer un(trace(p, "CallOrConversion"))
-	}
-
-	lparen := p.expect(token.LPAREN)
-	p.exprLev++
-	var list []ast.Expr
-	var ellipsis token.Pos
-	for p.tok != token.RPAREN && p.tok != token.EOF && !ellipsis.IsValid() {
-		list = append(list, p.parseRhsOrType()) // builtins may expect a type: make(some type, ...)
-		if p.tok == token.ELLIPSIS {
-			ellipsis = p.pos
-			p.next()
-		}
-		if !p.atComma("argument list", token.RPAREN) {
-			break
-		}
-		p.next()
-	}
-	p.exprLev--
-	rparen := p.expectClosing(token.RPAREN, "argument list")
-
-	return &ast.CallExpr{Fun: fun, Lparen: lparen, Args: list, Ellipsis: ellipsis, Rparen: rparen}
-}
-
-func (p *parser) parseValue(keyOk bool) ast.Expr {
-	if p.trace {
-		defer un(trace(p, "Element"))
-	}
-
-	if p.tok == token.LBRACE {
-		return p.parseLiteralValue(nil)
-	}
-
-	// Because the parser doesn't know the composite literal type, it cannot
-	// know if a key that's an identifier is a struct field name or a name
-	// denoting a value. The former is not resolved by the parser or the
-	// resolver.
-	//
-	// Instead, _try_ to resolve such a key if possible. If it resolves,
-	// it a) has correctly resolved, or b) incorrectly resolved because
-	// the key is a struct field with a name matching another identifier.
-	// In the former case we are done, and in the latter case we don't
-	// care because the type checker will do a separate field lookup.
-	//
-	// If the key does not resolve, it a) must be defined at the top
-	// level in another file of the same package, the universe scope, or be
-	// undeclared; or b) it is a struct field. In the former case, the type
-	// checker can do a top-level lookup, and in the latter case it will do
-	// a separate field lookup.
-	x := p.checkExpr(p.parseExpr(keyOk))
-	if keyOk {
-		if p.tok == token.COLON {
-			// Try to resolve the key but don't collect it
-			// as unresolved identifier if it fails so that
-			// we don't get (possibly false) errors about
-			// undeclared names.
-			p.tryResolve(x, false)
-		} else {
-			// not a key
-			p.resolve(x)
-		}
-	}
-
-	return x
-}
-
-func (p *parser) parseElement() ast.Expr {
-	if p.trace {
-		defer un(trace(p, "Element"))
-	}
-
-	x := p.parseValue(true)
-	if p.tok == token.COLON {
-		colon := p.pos
-		p.next()
-		x = &ast.KeyValueExpr{Key: x, Colon: colon, Value: p.parseValue(false)}
-	}
-
-	return x
-}
-
-func (p *parser) parseElementList() (list []ast.Expr) {
-	if p.trace {
-		defer un(trace(p, "ElementList"))
-	}
-
-	for p.tok != token.RBRACE && p.tok != token.EOF {
-		list = append(list, p.parseElement())
-		if !p.atComma("composite literal", token.RBRACE) {
-			break
-		}
-		p.next()
-	}
-
-	return
-}
-
-func (p *parser) parseLiteralValue(typ ast.Expr) ast.Expr {
-	if p.trace {
-		defer un(trace(p, "LiteralValue"))
-	}
-
-	lbrace := p.expect(token.LBRACE)
-	var elts []ast.Expr
-	p.exprLev++
-	if p.tok != token.RBRACE {
-		elts = p.parseElementList()
-	}
-	p.exprLev--
-	rbrace := p.expectClosing(token.RBRACE, "composite literal")
-	return &ast.CompositeLit{Type: typ, Lbrace: lbrace, Elts: elts, Rbrace: rbrace}
-}
-
-// checkExpr checks that x is an expression (and not a type).
-func (p *parser) checkExpr(x ast.Expr) ast.Expr {
-	switch unparen(x).(type) {
-	case *ast.BadExpr:
-	case *ast.Ident:
-	case *ast.BasicLit:
-	case *ast.FuncLit:
-	case *ast.CompositeLit:
-	case *ast.ParenExpr:
-		panic("unreachable")
-	case *ast.SelectorExpr:
-	case *ast.IndexExpr:
-	case *ast.SliceExpr:
-	case *ast.TypeAssertExpr:
-		// If t.Type == nil we have a type assertion of the form
-		// y.(type), which is only allowed in type switch expressions.
-		// It's hard to exclude those but for the case where we are in
-		// a type switch. Instead be lenient and test this in the type
-		// checker.
-	case *ast.CallExpr:
-	case *ast.StarExpr:
-	case *ast.UnaryExpr:
-	case *ast.BinaryExpr:
-	default:
-		// all other nodes are not proper expressions
-		p.errorExpected(x.Pos(), "expression")
-		x = &ast.BadExpr{From: x.Pos(), To: p.safePos(x.End())}
-	}
-	return x
-}
-
-// isTypeName reports whether x is a (qualified) TypeName.
-func isTypeName(x ast.Expr) bool {
-	switch t := x.(type) {
-	case *ast.BadExpr:
-	case *ast.Ident:
-	case *ast.SelectorExpr:
-		_, isIdent := t.X.(*ast.Ident)
-		return isIdent
-	default:
-		return false // all other nodes are not type names
-	}
-	return true
-}
-
-// isLiteralType reports whether x is a legal composite literal type.
-func isLiteralType(x ast.Expr) bool {
-	switch t := x.(type) {
-	case *ast.BadExpr:
-	case *ast.Ident:
-	case *ast.SelectorExpr:
-		_, isIdent := t.X.(*ast.Ident)
-		return isIdent
-	case *ast.ArrayType:
-	case *ast.StructType:
-	case *ast.MapType:
-	default:
-		return false // all other nodes are not legal composite literal types
-	}
-	return true
-}
-
-// If x is of the form *T, deref returns T, otherwise it returns x.
-func deref(x ast.Expr) ast.Expr {
-	if p, isPtr := x.(*ast.StarExpr); isPtr {
-		x = p.X
-	}
-	return x
-}
-
-// If x is of the form (T), unparen returns unparen(T), otherwise it returns x.
-func unparen(x ast.Expr) ast.Expr {
-	if p, isParen := x.(*ast.ParenExpr); isParen {
-		x = unparen(p.X)
-	}
-	return x
-}
-
-// checkExprOrType checks that x is an expression or a type
-// (and not a raw type such as [...]T).
-//
-func (p *parser) checkExprOrType(x ast.Expr) ast.Expr {
-	switch t := unparen(x).(type) {
-	case *ast.ParenExpr:
-		panic("unreachable")
-	case *ast.UnaryExpr:
-	case *ast.ArrayType:
-		if len, isEllipsis := t.Len.(*ast.Ellipsis); isEllipsis {
-			p.error(len.Pos(), "expected array length, found '...'")
-			x = &ast.BadExpr{From: x.Pos(), To: p.safePos(x.End())}
-		}
-	}
-
-	// all other nodes are expressions or types
-	return x
-}
-
-// If lhs is set and the result is an identifier, it is not resolved.
-func (p *parser) parsePrimaryExpr(lhs bool) ast.Expr {
-	if p.trace {
-		defer un(trace(p, "PrimaryExpr"))
-	}
-
-	x := p.parseOperand(lhs)
-L:
-	for {
-		switch p.tok {
-		case token.PERIOD:
-			p.next()
-			if lhs {
-				p.resolve(x)
-			}
-			switch p.tok {
-			case token.IDENT:
-				x = p.parseSelector(p.checkExprOrType(x))
-			case token.LPAREN:
-				x = p.parseTypeAssertion(p.checkExpr(x))
-			default:
-				pos := p.pos
-				p.errorExpected(pos, "selector or type assertion")
-				p.next() // make progress
-				sel := &ast.Ident{NamePos: pos, Name: "_"}
-				x = &ast.SelectorExpr{X: x, Sel: sel}
-			}
-		case token.LBRACK:
-			if lhs {
-				p.resolve(x)
-			}
-			x = p.parseIndexOrSlice(p.checkExpr(x))
-		case token.LPAREN:
-			if lhs {
-				p.resolve(x)
-			}
-			x = p.parseCallOrConversion(p.checkExprOrType(x))
-		case token.LBRACE:
-			if isLiteralType(x) && (p.exprLev >= 0 || !isTypeName(x)) {
-				if lhs {
-					p.resolve(x)
-				}
-				x = p.parseLiteralValue(x)
-			} else {
-				break L
-			}
-		default:
-			break L
-		}
-		lhs = false // no need to try to resolve again
-	}
-
-	return x
-}
-
-// If lhs is set and the result is an identifier, it is not resolved.
-func (p *parser) parseUnaryExpr(lhs bool) ast.Expr {
-	if p.trace {
-		defer un(trace(p, "UnaryExpr"))
-	}
-
-	switch p.tok {
-	case token.ADD, token.SUB, token.NOT, token.XOR, token.AND:
-		pos, op := p.pos, p.tok
-		p.next()
-		x := p.parseUnaryExpr(false)
-		return &ast.UnaryExpr{OpPos: pos, Op: op, X: p.checkExpr(x)}
-
-	case token.ARROW:
-		// channel type or receive expression
-		arrow := p.pos
-		p.next()
-
-		// If the next token is token.CHAN we still don't know if it
-		// is a channel type or a receive operation - we only know
-		// once we have found the end of the unary expression. There
-		// are two cases:
-		//
-		//   <- type  => (<-type) must be channel type
-		//   <- expr  => <-(expr) is a receive from an expression
-		//
-		// In the first case, the arrow must be re-associated with
-		// the channel type parsed already:
-		//
-		//   <- (chan type)    =>  (<-chan type)
-		//   <- (chan<- type)  =>  (<-chan (<-type))
-
-		x := p.parseUnaryExpr(false)
-
-		// determine which case we have
-		if typ, ok := x.(*ast.ChanType); ok {
-			// (<-type)
-
-			// re-associate position info and <-
-			dir := ast.SEND
-			for ok && dir == ast.SEND {
-				if typ.Dir == ast.RECV {
-					// error: (<-type) is (<-(<-chan T))
-					p.errorExpected(typ.Arrow, "'chan'")
-				}
-				arrow, typ.Begin, typ.Arrow = typ.Arrow, arrow, arrow
-				dir, typ.Dir = typ.Dir, ast.RECV
-				typ, ok = typ.Value.(*ast.ChanType)
-			}
-			if dir == ast.SEND {
-				p.errorExpected(arrow, "channel type")
-			}
-
-			return x
-		}
-
-		// <-(expr)
-		return &ast.UnaryExpr{OpPos: arrow, Op: token.ARROW, X: p.checkExpr(x)}
-
-	case token.MUL:
-		// pointer type or unary "*" expression
-		pos := p.pos
-		p.next()
-		x := p.parseUnaryExpr(false)
-		return &ast.StarExpr{Star: pos, X: p.checkExprOrType(x)}
-	}
-
-	return p.parsePrimaryExpr(lhs)
-}
-
-func (p *parser) tokPrec() (token.Token, int) {
-	tok := p.tok
-	if p.inRhs && tok == token.ASSIGN {
-		tok = token.EQL
-	}
-	return tok, tok.Precedence()
-}
-
-// If lhs is set and the result is an identifier, it is not resolved.
-func (p *parser) parseBinaryExpr(lhs bool, prec1 int) ast.Expr {
-	if p.trace {
-		defer un(trace(p, "BinaryExpr"))
-	}
-
-	x := p.parseUnaryExpr(lhs)
-	for _, prec := p.tokPrec(); prec >= prec1; prec-- {
-		for {
-			op, oprec := p.tokPrec()
-			if oprec != prec {
-				break
-			}
-			pos := p.expect(op)
-			if lhs {
-				p.resolve(x)
-				lhs = false
-			}
-			y := p.parseBinaryExpr(false, prec+1)
-			x = &ast.BinaryExpr{X: p.checkExpr(x), OpPos: pos, Op: op, Y: p.checkExpr(y)}
-		}
-	}
-
-	return x
-}
-
-// If lhs is set and the result is an identifier, it is not resolved.
-// The result may be a type or even a raw type ([...]int). Callers must
-// check the result (using checkExpr or checkExprOrType), depending on
-// context.
-func (p *parser) parseExpr(lhs bool) ast.Expr {
-	if p.trace {
-		defer un(trace(p, "Expression"))
-	}
-
-	return p.parseBinaryExpr(lhs, token.LowestPrec+1)
-}
-
-func (p *parser) parseRhs() ast.Expr {
-	old := p.inRhs
-	p.inRhs = true
-	x := p.checkExpr(p.parseExpr(false))
-	p.inRhs = old
-	return x
-}
-
-func (p *parser) parseRhsOrType() ast.Expr {
-	old := p.inRhs
-	p.inRhs = true
-	x := p.checkExprOrType(p.parseExpr(false))
-	p.inRhs = old
-	return x
-}
-
-// ----------------------------------------------------------------------------
-// Statements
-
-// Parsing modes for parseSimpleStmt.
-const (
-	basic = iota
-	labelOk
-	rangeOk
-)
-
-// parseSimpleStmt returns true as 2nd result if it parsed the assignment
-// of a range clause (with mode == rangeOk). The returned statement is an
-// assignment with a right-hand side that is a single unary expression of
-// the form "range x". No guarantees are given for the left-hand side.
-func (p *parser) parseSimpleStmt(mode int) (ast.Stmt, bool) {
-	if p.trace {
-		defer un(trace(p, "SimpleStmt"))
-	}
-
-	x := p.parseLhsList()
-
-	switch p.tok {
-	case
-		token.DEFINE, token.ASSIGN, token.ADD_ASSIGN,
-		token.SUB_ASSIGN, token.MUL_ASSIGN, token.QUO_ASSIGN,
-		token.REM_ASSIGN, token.AND_ASSIGN, token.OR_ASSIGN,
-		token.XOR_ASSIGN, token.SHL_ASSIGN, token.SHR_ASSIGN, token.AND_NOT_ASSIGN:
-		// assignment statement, possibly part of a range clause
-		pos, tok := p.pos, p.tok
-		p.next()
-		var y []ast.Expr
-		isRange := false
-		if mode == rangeOk && p.tok == token.RANGE && (tok == token.DEFINE || tok == token.ASSIGN) {
-			pos := p.pos
-			p.next()
-			y = []ast.Expr{&ast.UnaryExpr{OpPos: pos, Op: token.RANGE, X: p.parseRhs()}}
-			isRange = true
-		} else {
-			y = p.parseRhsList()
-		}
-		as := &ast.AssignStmt{Lhs: x, TokPos: pos, Tok: tok, Rhs: y}
-		if tok == token.DEFINE {
-			p.shortVarDecl(as, x)
-		}
-		return as, isRange
-	}
-
-	if len(x) > 1 {
-		p.errorExpected(x[0].Pos(), "1 expression")
-		// continue with first expression
-	}
-
-	switch p.tok {
-	case token.COLON:
-		// labeled statement
-		colon := p.pos
-		p.next()
-		if label, isIdent := x[0].(*ast.Ident); mode == labelOk && isIdent {
-			// Go spec: The scope of a label is the body of the function
-			// in which it is declared and excludes the body of any nested
-			// function.
-			stmt := &ast.LabeledStmt{Label: label, Colon: colon, Stmt: p.parseStmt()}
-			p.declare(stmt, nil, p.labelScope, ast.Lbl, label)
-			return stmt, false
-		}
-		// The label declaration typically starts at x[0].Pos(), but the label
-		// declaration may be erroneous due to a token after that position (and
-		// before the ':'). If SpuriousErrors is not set, the (only) error re-
-		// ported for the line is the illegal label error instead of the token
-		// before the ':' that caused the problem. Thus, use the (latest) colon
-		// position for error reporting.
-		p.error(colon, "illegal label declaration")
-		return &ast.BadStmt{From: x[0].Pos(), To: colon + 1}, false
-
-	case token.ARROW:
-		// send statement
-		arrow := p.pos
-		p.next()
-		y := p.parseRhs()
-		return &ast.SendStmt{Chan: x[0], Arrow: arrow, Value: y}, false
-
-	case token.INC, token.DEC:
-		// increment or decrement
-		s := &ast.IncDecStmt{X: x[0], TokPos: p.pos, Tok: p.tok}
-		p.next()
-		return s, false
-	}
-
-	// expression
-	return &ast.ExprStmt{X: x[0]}, false
-}
-
-func (p *parser) parseCallExpr(callType string) *ast.CallExpr {
-	x := p.parseRhsOrType() // could be a conversion: (some type)(x)
-	if call, isCall := x.(*ast.CallExpr); isCall {
-		return call
-	}
-	if _, isBad := x.(*ast.BadExpr); !isBad {
-		// only report error if it's a new one
-		p.error(p.safePos(x.End()), fmt.Sprintf("function must be invoked in %s statement", callType))
-	}
-	return nil
-}
-
-func (p *parser) parseGoStmt() ast.Stmt {
-	if p.trace {
-		defer un(trace(p, "GoStmt"))
-	}
-
-	pos := p.expect(token.GO)
-	call := p.parseCallExpr("go")
-	p.expectSemi()
-	if call == nil {
-		return &ast.BadStmt{From: pos, To: pos + 2} // len("go")
-	}
-
-	return &ast.GoStmt{Go: pos, Call: call}
-}
-
-func (p *parser) parseDeferStmt() ast.Stmt {
-	if p.trace {
-		defer un(trace(p, "DeferStmt"))
-	}
-
-	pos := p.expect(token.DEFER)
-	call := p.parseCallExpr("defer")
-	p.expectSemi()
-	if call == nil {
-		return &ast.BadStmt{From: pos, To: pos + 5} // len("defer")
-	}
-
-	return &ast.DeferStmt{Defer: pos, Call: call}
-}
-
-func (p *parser) parseReturnStmt() *ast.ReturnStmt {
-	if p.trace {
-		defer un(trace(p, "ReturnStmt"))
-	}
-
-	pos := p.pos
-	p.expect(token.RETURN)
-	var x []ast.Expr
-	if p.tok != token.SEMICOLON && p.tok != token.RBRACE {
-		x = p.parseRhsList()
-	}
-	p.expectSemi()
-
-	return &ast.ReturnStmt{Return: pos, Results: x}
-}
-
-func (p *parser) parseBranchStmt(tok token.Token) *ast.BranchStmt {
-	if p.trace {
-		defer un(trace(p, "BranchStmt"))
-	}
-
-	pos := p.expect(tok)
-	var label *ast.Ident
-	if tok != token.FALLTHROUGH && p.tok == token.IDENT {
-		label = p.parseIdent()
-		// add to list of unresolved targets
-		n := len(p.targetStack) - 1
-		p.targetStack[n] = append(p.targetStack[n], label)
-	}
-	p.expectSemi()
-
-	return &ast.BranchStmt{TokPos: pos, Tok: tok, Label: label}
-}
-
-func (p *parser) makeExpr(s ast.Stmt, kind string) ast.Expr {
-	if s == nil {
-		return nil
-	}
-	if es, isExpr := s.(*ast.ExprStmt); isExpr {
-		return p.checkExpr(es.X)
-	}
-	p.error(s.Pos(), fmt.Sprintf("expected %s, found simple statement (missing parentheses around composite literal?)", kind))
-	return &ast.BadExpr{From: s.Pos(), To: p.safePos(s.End())}
-}
-
-func (p *parser) parseIfStmt() *ast.IfStmt {
-	if p.trace {
-		defer un(trace(p, "IfStmt"))
-	}
-
-	pos := p.expect(token.IF)
-	p.openScope()
-	defer p.closeScope()
-
-	var s ast.Stmt
-	var x ast.Expr
-	{
-		prevLev := p.exprLev
-		p.exprLev = -1
-		if p.tok == token.SEMICOLON {
-			p.next()
-			x = p.parseRhs()
-		} else {
-			s, _ = p.parseSimpleStmt(basic)
-			if p.tok == token.SEMICOLON {
-				p.next()
-				x = p.parseRhs()
-			} else {
-				x = p.makeExpr(s, "boolean expression")
-				s = nil
-			}
-		}
-		p.exprLev = prevLev
-	}
-
-	body := p.parseBlockStmt()
-	var else_ ast.Stmt
-	if p.tok == token.ELSE {
-		p.next()
-		else_ = p.parseStmt()
-	} else {
-		p.expectSemi()
-	}
-
-	return &ast.IfStmt{If: pos, Init: s, Cond: x, Body: body, Else: else_}
-}
-
-func (p *parser) parseTypeList() (list []ast.Expr) {
-	if p.trace {
-		defer un(trace(p, "TypeList"))
-	}
-
-	list = append(list, p.parseType())
-	for p.tok == token.COMMA {
-		p.next()
-		list = append(list, p.parseType())
-	}
-
-	return
-}
-
-func (p *parser) parseCaseClause(typeSwitch bool) *ast.CaseClause {
-	if p.trace {
-		defer un(trace(p, "CaseClause"))
-	}
-
-	pos := p.pos
-	var list []ast.Expr
-	if p.tok == token.CASE {
-		p.next()
-		if typeSwitch {
-			list = p.parseTypeList()
-		} else {
-			list = p.parseRhsList()
-		}
-	} else {
-		p.expect(token.DEFAULT)
-	}
-
-	colon := p.expect(token.COLON)
-	p.openScope()
-	body := p.parseStmtList()
-	p.closeScope()
-
-	return &ast.CaseClause{Case: pos, List: list, Colon: colon, Body: body}
-}
-
-func isTypeSwitchAssert(x ast.Expr) bool {
-	a, ok := x.(*ast.TypeAssertExpr)
-	return ok && a.Type == nil
-}
-
-func isTypeSwitchGuard(s ast.Stmt) bool {
-	switch t := s.(type) {
-	case *ast.ExprStmt:
-		// x.(nil)
-		return isTypeSwitchAssert(t.X)
-	case *ast.AssignStmt:
-		// v := x.(nil)
-		return len(t.Lhs) == 1 && t.Tok == token.DEFINE && len(t.Rhs) == 1 && isTypeSwitchAssert(t.Rhs[0])
-	}
-	return false
-}
-
-func (p *parser) parseSwitchStmt() ast.Stmt {
-	if p.trace {
-		defer un(trace(p, "SwitchStmt"))
-	}
-
-	pos := p.expect(token.SWITCH)
-	p.openScope()
-	defer p.closeScope()
-
-	var s1, s2 ast.Stmt
-	if p.tok != token.LBRACE {
-		prevLev := p.exprLev
-		p.exprLev = -1
-		if p.tok != token.SEMICOLON {
-			s2, _ = p.parseSimpleStmt(basic)
-		}
-		if p.tok == token.SEMICOLON {
-			p.next()
-			s1 = s2
-			s2 = nil
-			if p.tok != token.LBRACE {
-				// A TypeSwitchGuard may declare a variable in addition
-				// to the variable declared in the initial SimpleStmt.
-				// Introduce extra scope to avoid redeclaration errors:
-				//
-				//	switch t := 0; t := x.(T) { ... }
-				//
-				// (this code is not valid Go because the first t
-				// cannot be accessed and thus is never used, the extra
-				// scope is needed for the correct error message).
-				//
-				// If we don't have a type switch, s2 must be an expression.
-				// Having the extra nested but empty scope won't affect it.
-				p.openScope()
-				defer p.closeScope()
-				s2, _ = p.parseSimpleStmt(basic)
-			}
-		}
-		p.exprLev = prevLev
-	}
-
-	typeSwitch := isTypeSwitchGuard(s2)
-	lbrace := p.expect(token.LBRACE)
-	var list []ast.Stmt
-	for p.tok == token.CASE || p.tok == token.DEFAULT {
-		list = append(list, p.parseCaseClause(typeSwitch))
-	}
-	rbrace := p.expect(token.RBRACE)
-	p.expectSemi()
-	body := &ast.BlockStmt{Lbrace: lbrace, List: list, Rbrace: rbrace}
-
-	if typeSwitch {
-		return &ast.TypeSwitchStmt{Switch: pos, Init: s1, Assign: s2, Body: body}
-	}
-
-	return &ast.SwitchStmt{Switch: pos, Init: s1, Tag: p.makeExpr(s2, "switch expression"), Body: body}
-}
-
-func (p *parser) parseCommClause() *ast.CommClause {
-	if p.trace {
-		defer un(trace(p, "CommClause"))
-	}
-
-	p.openScope()
-	pos := p.pos
-	var comm ast.Stmt
-	if p.tok == token.CASE {
-		p.next()
-		lhs := p.parseLhsList()
-		if p.tok == token.ARROW {
-			// SendStmt
-			if len(lhs) > 1 {
-				p.errorExpected(lhs[0].Pos(), "1 expression")
-				// continue with first expression
-			}
-			arrow := p.pos
-			p.next()
-			rhs := p.parseRhs()
-			comm = &ast.SendStmt{Chan: lhs[0], Arrow: arrow, Value: rhs}
-		} else {
-			// RecvStmt
-			if tok := p.tok; tok == token.ASSIGN || tok == token.DEFINE {
-				// RecvStmt with assignment
-				if len(lhs) > 2 {
-					p.errorExpected(lhs[0].Pos(), "1 or 2 expressions")
-					// continue with first two expressions
-					lhs = lhs[0:2]
-				}
-				pos := p.pos
-				p.next()
-				rhs := p.parseRhs()
-				as := &ast.AssignStmt{Lhs: lhs, TokPos: pos, Tok: tok, Rhs: []ast.Expr{rhs}}
-				if tok == token.DEFINE {
-					p.shortVarDecl(as, lhs)
-				}
-				comm = as
-			} else {
-				// lhs must be single receive operation
-				if len(lhs) > 1 {
-					p.errorExpected(lhs[0].Pos(), "1 expression")
-					// continue with first expression
-				}
-				comm = &ast.ExprStmt{X: lhs[0]}
-			}
-		}
-	} else {
-		p.expect(token.DEFAULT)
-	}
-
-	colon := p.expect(token.COLON)
-	body := p.parseStmtList()
-	p.closeScope()
-
-	return &ast.CommClause{Case: pos, Comm: comm, Colon: colon, Body: body}
-}
-
-func (p *parser) parseSelectStmt() *ast.SelectStmt {
-	if p.trace {
-		defer un(trace(p, "SelectStmt"))
-	}
-
-	pos := p.expect(token.SELECT)
-	lbrace := p.expect(token.LBRACE)
-	var list []ast.Stmt
-	for p.tok == token.CASE || p.tok == token.DEFAULT {
-		list = append(list, p.parseCommClause())
-	}
-	rbrace := p.expect(token.RBRACE)
-	p.expectSemi()
-	body := &ast.BlockStmt{Lbrace: lbrace, List: list, Rbrace: rbrace}
-
-	return &ast.SelectStmt{Select: pos, Body: body}
-}
-
-func (p *parser) parseForStmt() ast.Stmt {
-	if p.trace {
-		defer un(trace(p, "ForStmt"))
-	}
-
-	pos := p.expect(token.FOR)
-	p.openScope()
-	defer p.closeScope()
-
-	var s1, s2, s3 ast.Stmt
-	var isRange bool
-	if p.tok != token.LBRACE {
-		prevLev := p.exprLev
-		p.exprLev = -1
-		if p.tok != token.SEMICOLON {
-			if p.tok == token.RANGE {
-				// "for range x" (nil lhs in assignment)
-				pos := p.pos
-				p.next()
-				y := []ast.Expr{&ast.UnaryExpr{OpPos: pos, Op: token.RANGE, X: p.parseRhs()}}
-				s2 = &ast.AssignStmt{Rhs: y}
-				isRange = true
-			} else {
-				s2, isRange = p.parseSimpleStmt(rangeOk)
-			}
-		}
-		if !isRange && p.tok == token.SEMICOLON {
-			p.next()
-			s1 = s2
-			s2 = nil
-			if p.tok != token.SEMICOLON {
-				s2, _ = p.parseSimpleStmt(basic)
-			}
-			p.expectSemi()
-			if p.tok != token.LBRACE {
-				s3, _ = p.parseSimpleStmt(basic)
-			}
-		}
-		p.exprLev = prevLev
-	}
-
-	body := p.parseBlockStmt()
-	p.expectSemi()
-
-	if isRange {
-		as := s2.(*ast.AssignStmt)
-		// check lhs
-		var key, value ast.Expr
-		switch len(as.Lhs) {
-		case 0:
-			// nothing to do
-		case 1:
-			key = as.Lhs[0]
-		case 2:
-			key, value = as.Lhs[0], as.Lhs[1]
-		default:
-			p.errorExpected(as.Lhs[len(as.Lhs)-1].Pos(), "at most 2 expressions")
-			return &ast.BadStmt{From: pos, To: p.safePos(body.End())}
-		}
-		// parseSimpleStmt returned a right-hand side that
-		// is a single unary expression of the form "range x"
-		x := as.Rhs[0].(*ast.UnaryExpr).X
-		return &ast.RangeStmt{
-			For:    pos,
-			Key:    key,
-			Value:  value,
-			TokPos: as.TokPos,
-			Tok:    as.Tok,
-			X:      x,
-			Body:   body,
-		}
-	}
-
-	// regular for statement
-	return &ast.ForStmt{
-		For:  pos,
-		Init: s1,
-		Cond: p.makeExpr(s2, "boolean or range expression"),
-		Post: s3,
-		Body: body,
-	}
-}
-
-func (p *parser) parseStmt() (s ast.Stmt) {
-	if p.trace {
-		defer un(trace(p, "Statement"))
-	}
-
-	switch p.tok {
-	case token.CONST, token.TYPE, token.VAR:
-		s = &ast.DeclStmt{Decl: p.parseDecl(syncStmt)}
-	case
-		// tokens that may start an expression
-		token.IDENT, token.INT, token.FLOAT, token.IMAG, token.CHAR, token.STRING, token.FUNC, token.LPAREN, // operands
-		token.LBRACK, token.STRUCT, token.MAP, token.CHAN, token.INTERFACE, // composite types
-		token.ADD, token.SUB, token.MUL, token.AND, token.XOR, token.ARROW, token.NOT: // unary operators
-		s, _ = p.parseSimpleStmt(labelOk)
-		// because of the required look-ahead, labeled statements are
-		// parsed by parseSimpleStmt - don't expect a semicolon after
-		// them
-		if _, isLabeledStmt := s.(*ast.LabeledStmt); !isLabeledStmt {
-			p.expectSemi()
-		}
-	case token.GO:
-		s = p.parseGoStmt()
-	case token.DEFER:
-		s = p.parseDeferStmt()
-	case token.RETURN:
-		s = p.parseReturnStmt()
-	case token.BREAK, token.CONTINUE, token.GOTO, token.FALLTHROUGH:
-		s = p.parseBranchStmt(p.tok)
-	case token.LBRACE:
-		s = p.parseBlockStmt()
-		p.expectSemi()
-	case token.IF:
-		s = p.parseIfStmt()
-	case token.SWITCH:
-		s = p.parseSwitchStmt()
-	case token.SELECT:
-		s = p.parseSelectStmt()
-	case token.FOR:
-		s = p.parseForStmt()
-	case token.SEMICOLON:
-		// Is it ever possible to have an implicit semicolon
-		// producing an empty statement in a valid program?
-		// (handle correctly anyway)
-		s = &ast.EmptyStmt{Semicolon: p.pos, Implicit: p.lit == "\n"}
-		p.next()
-	case token.RBRACE:
-		// a semicolon may be omitted before a closing "}"
-		s = &ast.EmptyStmt{Semicolon: p.pos, Implicit: true}
-	default:
-		// no statement found
-		pos := p.pos
-		p.errorExpected(pos, "statement")
-		syncStmt(p)
-		s = &ast.BadStmt{From: pos, To: p.pos}
-	}
-
-	return
-}
-
-// ----------------------------------------------------------------------------
-// Declarations
-
-type parseSpecFunction func(doc *ast.CommentGroup, keyword token.Token, iota int) ast.Spec
-
-func isValidImport(lit string) bool {
-	const illegalChars = `!"#$%&'()*,:;<=>?[\]^{|}` + "`\uFFFD"
-	s, _ := strconv.Unquote(lit) // go/scanner returns a legal string literal
-	for _, r := range s {
-		if !unicode.IsGraphic(r) || unicode.IsSpace(r) || strings.ContainsRune(illegalChars, r) {
-			return false
-		}
-	}
-	return s != ""
-}
-
-func (p *parser) parseImportSpec(doc *ast.CommentGroup, _ token.Token, _ int) ast.Spec {
-	if p.trace {
-		defer un(trace(p, "ImportSpec"))
-	}
-
-	var ident *ast.Ident
-	switch p.tok {
-	case token.PERIOD:
-		ident = &ast.Ident{NamePos: p.pos, Name: "."}
-		p.next()
-	case token.IDENT:
-		ident = p.parseIdent()
-	}
-
-	pos := p.pos
-	var path string
-	if p.tok == token.STRING {
-		path = p.lit
-		if !isValidImport(path) {
-			p.error(pos, "invalid import path: "+path)
-		}
-		p.next()
-	} else {
-		p.expect(token.STRING) // use expect() error handling
-	}
-	p.expectSemi() // call before accessing p.linecomment
-
-	// collect imports
-	spec := &ast.ImportSpec{
-		Doc:     doc,
-		Name:    ident,
-		Path:    &ast.BasicLit{ValuePos: pos, Kind: token.STRING, Value: path},
-		Comment: p.lineComment,
-	}
-	p.imports = append(p.imports, spec)
-
-	return spec
-}
-
-func (p *parser) parseValueSpec(doc *ast.CommentGroup, keyword token.Token, iota int) ast.Spec {
-	if p.trace {
-		defer un(trace(p, keyword.String()+"Spec"))
-	}
-
-	pos := p.pos
-	idents := p.parseIdentList()
-	typ := p.tryType()
-	var values []ast.Expr
-	// always permit optional initialization for more tolerant parsing
-	if p.tok == token.ASSIGN {
-		p.next()
-		values = p.parseRhsList()
-	}
-	p.expectSemi() // call before accessing p.linecomment
-
-	switch keyword {
-	case token.VAR:
-		if typ == nil && values == nil {
-			p.error(pos, "missing variable type or initialization")
-		}
-	case token.CONST:
-		if values == nil && (iota == 0 || typ != nil) {
-			p.error(pos, "missing constant value")
-		}
-	}
-
-	// Go spec: The scope of a constant or variable identifier declared inside
-	// a function begins at the end of the ConstSpec or VarSpec and ends at
-	// the end of the innermost containing block.
-	// (Global identifiers are resolved in a separate phase after parsing.)
-	spec := &ast.ValueSpec{
-		Doc:     doc,
-		Names:   idents,
-		Type:    typ,
-		Values:  values,
-		Comment: p.lineComment,
-	}
-	kind := ast.Con
-	if keyword == token.VAR {
-		kind = ast.Var
-	}
-	p.declare(spec, iota, p.topScope, kind, idents...)
-
-	return spec
-}
-
-func (p *parser) parseTypeSpec(doc *ast.CommentGroup, _ token.Token, _ int) ast.Spec {
-	if p.trace {
-		defer un(trace(p, "TypeSpec"))
-	}
-
-	ident := p.parseIdent()
-
-	// Go spec: The scope of a type identifier declared inside a function begins
-	// at the identifier in the TypeSpec and ends at the end of the innermost
-	// containing block.
-	// (Global identifiers are resolved in a separate phase after parsing.)
-	spec := &ast.TypeSpec{Doc: doc, Name: ident}
-	p.declare(spec, nil, p.topScope, ast.Typ, ident)
-
-	spec.Type = p.parseType()
-	p.expectSemi() // call before accessing p.linecomment
-	spec.Comment = p.lineComment
-
-	return spec
-}
-
-func (p *parser) parseGenDecl(keyword token.Token, f parseSpecFunction) *ast.GenDecl {
-	if p.trace {
-		defer un(trace(p, "GenDecl("+keyword.String()+")"))
-	}
-
-	doc := p.leadComment
-	pos := p.expect(keyword)
-	var lparen, rparen token.Pos
-	var list []ast.Spec
-	if p.tok == token.LPAREN {
-		lparen = p.pos
-		p.next()
-		for iota := 0; p.tok != token.RPAREN && p.tok != token.EOF; iota++ {
-			list = append(list, f(p.leadComment, keyword, iota))
-		}
-		rparen = p.expect(token.RPAREN)
-		p.expectSemi()
-	} else {
-		list = append(list, f(nil, keyword, 0))
-	}
-
-	return &ast.GenDecl{
-		Doc:    doc,
-		TokPos: pos,
-		Tok:    keyword,
-		Lparen: lparen,
-		Specs:  list,
-		Rparen: rparen,
-	}
-}
-
-func (p *parser) parseFuncDecl() *ast.FuncDecl {
-	if p.trace {
-		defer un(trace(p, "FunctionDecl"))
-	}
-
-	doc := p.leadComment
-	pos := p.expect(token.FUNC)
-	scope := ast.NewScope(p.topScope) // function scope
-
-	var recv *ast.FieldList
-	if p.tok == token.LPAREN {
-		recv = p.parseParameters(scope, false)
-	}
-
-	ident := p.parseIdent()
-
-	params, results := p.parseSignature(scope)
-
-	var body *ast.BlockStmt
-	if p.tok == token.LBRACE {
-		body = p.parseBody(scope)
-	}
-	p.expectSemi()
-
-	decl := &ast.FuncDecl{
-		Doc:  doc,
-		Recv: recv,
-		Name: ident,
-		Type: &ast.FuncType{
-			Func:    pos,
-			Params:  params,
-			Results: results,
-		},
-		Body: body,
-	}
-	if recv == nil {
-		// Go spec: The scope of an identifier denoting a constant, type,
-		// variable, or function (but not method) declared at top level
-		// (outside any function) is the package block.
-		//
-		// init() functions cannot be referred to and there may
-		// be more than one - don't put them in the pkgScope
-		if ident.Name != "init" {
-			p.declare(decl, nil, p.pkgScope, ast.Fun, ident)
-		}
-	}
-
-	return decl
-}
-
-func (p *parser) parseDecl(sync func(*parser)) ast.Decl {
-	if p.trace {
-		defer un(trace(p, "Declaration"))
-	}
-
-	var f parseSpecFunction
-	switch p.tok {
-	case token.CONST, token.VAR:
-		f = p.parseValueSpec
-
-	case token.TYPE:
-		f = p.parseTypeSpec
-
-	case token.FUNC:
-		return p.parseFuncDecl()
-
-	default:
-		pos := p.pos
-		p.errorExpected(pos, "declaration")
-		sync(p)
-		return &ast.BadDecl{From: pos, To: p.pos}
-	}
-
-	return p.parseGenDecl(p.tok, f)
-}
-
-// ----------------------------------------------------------------------------
-// Source files
-
-func (p *parser) parseFile() *ast.File {
-	if p.trace {
-		defer un(trace(p, "File"))
-	}
-
-	// Don't bother parsing the rest if we had errors scanning the first token.
-	// Likely not a Go source file at all.
-	if p.errors.Len() != 0 {
-		return nil
-	}
-
-	// package clause
-	doc := p.leadComment
-	pos := p.expect(token.PACKAGE)
-	// Go spec: The package clause is not a declaration;
-	// the package name does not appear in any scope.
-	ident := p.parseIdent()
-	if ident.Name == "_" && p.mode&DeclarationErrors != 0 {
-		p.error(p.pos, "invalid package name _")
-	}
-	p.expectSemi()
-
-	// Don't bother parsing the rest if we had errors parsing the package clause.
-	// Likely not a Go source file at all.
-	if p.errors.Len() != 0 {
-		return nil
-	}
-
-	p.openScope()
-	p.pkgScope = p.topScope
-	var decls []ast.Decl
-	if p.mode&PackageClauseOnly == 0 {
-		// import decls
-		for p.tok == token.IMPORT {
-			decls = append(decls, p.parseGenDecl(token.IMPORT, p.parseImportSpec))
-		}
-
-		if p.mode&ImportsOnly == 0 {
-			// rest of package body
-			for p.tok != token.EOF {
-				decls = append(decls, p.parseDecl(syncDecl))
-			}
-		}
-	}
-	p.closeScope()
-	assert(p.topScope == nil, "unbalanced scopes")
-	assert(p.labelScope == nil, "unbalanced label scopes")
-
-	// resolve global identifiers within the same file
-	i := 0
-	for _, ident := range p.unresolved {
-		// i <= index for current ident
-		assert(ident.Obj == unresolved, "object already resolved")
-		ident.Obj = p.pkgScope.Lookup(ident.Name) // also removes unresolved sentinel
-		if ident.Obj == nil {
-			p.unresolved[i] = ident
-			i++
-		}
-	}
-
-	return &ast.File{
-		Doc:        doc,
-		Package:    pos,
-		Name:       ident,
-		Decls:      decls,
-		Scope:      p.pkgScope,
-		Imports:    p.imports,
-		Unresolved: p.unresolved[0:i],
-		Comments:   p.comments,
-	}
-}
diff --git a/third_party/golang/go/parser/parser_test.go b/third_party/golang/go/parser/parser_test.go
deleted file mode 100644
index 126711cae5930..0000000000000
--- a/third_party/golang/go/parser/parser_test.go
+++ /dev/null
@@ -1,533 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package parser
-
-import (
-	"bytes"
-	"fmt"
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-	"os"
-	"strings"
-	"testing"
-)
-
-var validFiles = []string{
-	"parser.go",
-	"parser_test.go",
-	"error_test.go",
-	"short_test.go",
-}
-
-func TestParse(t *testing.T) {
-	for _, filename := range validFiles {
-		_, err := ParseFile(token.NewFileSet(), filename, nil, DeclarationErrors)
-		if err != nil {
-			t.Fatalf("ParseFile(%s): %v", filename, err)
-		}
-	}
-}
-
-func nameFilter(filename string) bool {
-	switch filename {
-	case "parser.go", "interface.go", "parser_test.go":
-		return true
-	case "parser.go.orig":
-		return true // permit but should be ignored by ParseDir
-	}
-	return false
-}
-
-func dirFilter(f os.FileInfo) bool { return nameFilter(f.Name()) }
-
-func TestParseDir(t *testing.T) {
-	path := "."
-	pkgs, err := ParseDir(token.NewFileSet(), path, dirFilter, 0)
-	if err != nil {
-		t.Fatalf("ParseDir(%s): %v", path, err)
-	}
-	if n := len(pkgs); n != 1 {
-		t.Errorf("got %d packages; want 1", n)
-	}
-	pkg := pkgs["parser"]
-	if pkg == nil {
-		t.Errorf(`package "parser" not found`)
-		return
-	}
-	if n := len(pkg.Files); n != 3 {
-		t.Errorf("got %d package files; want 3", n)
-	}
-	for filename := range pkg.Files {
-		if !nameFilter(filename) {
-			t.Errorf("unexpected package file: %s", filename)
-		}
-	}
-}
-
-func TestParseExpr(t *testing.T) {
-	// just kicking the tires:
-	// a valid arithmetic expression
-	src := "a + b"
-	x, err := ParseExpr(src)
-	if err != nil {
-		t.Errorf("ParseExpr(%q): %v", src, err)
-	}
-	// sanity check
-	if _, ok := x.(*ast.BinaryExpr); !ok {
-		t.Errorf("ParseExpr(%q): got %T, want *ast.BinaryExpr", src, x)
-	}
-
-	// a valid type expression
-	src = "struct{x *int}"
-	x, err = ParseExpr(src)
-	if err != nil {
-		t.Errorf("ParseExpr(%q): %v", src, err)
-	}
-	// sanity check
-	if _, ok := x.(*ast.StructType); !ok {
-		t.Errorf("ParseExpr(%q): got %T, want *ast.StructType", src, x)
-	}
-
-	// an invalid expression
-	src = "a + *"
-	if _, err := ParseExpr(src); err == nil {
-		t.Errorf("ParseExpr(%q): got no error", src)
-	}
-
-	// a valid expression followed by extra tokens is invalid
-	src = "a[i] := x"
-	if _, err := ParseExpr(src); err == nil {
-		t.Errorf("ParseExpr(%q): got no error", src)
-	}
-
-	// a semicolon is not permitted unless automatically inserted
-	src = "a + b\n"
-	if _, err := ParseExpr(src); err != nil {
-		t.Errorf("ParseExpr(%q): got error %s", src, err)
-	}
-	src = "a + b;"
-	if _, err := ParseExpr(src); err == nil {
-		t.Errorf("ParseExpr(%q): got no error", src)
-	}
-
-	// various other stuff following a valid expression
-	const validExpr = "a + b"
-	const anything = "dh3*#D)#_"
-	for _, c := range "!)]};," {
-		src := validExpr + string(c) + anything
-		if _, err := ParseExpr(src); err == nil {
-			t.Errorf("ParseExpr(%q): got no error", src)
-		}
-	}
-
-	// ParseExpr must not crash
-	for _, src := range valids {
-		ParseExpr(src)
-	}
-}
-
-func TestColonEqualsScope(t *testing.T) {
-	f, err := ParseFile(token.NewFileSet(), "", `package p; func f() { x, y, z := x, y, z }`, 0)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// RHS refers to undefined globals; LHS does not.
-	as := f.Decls[0].(*ast.FuncDecl).Body.List[0].(*ast.AssignStmt)
-	for _, v := range as.Rhs {
-		id := v.(*ast.Ident)
-		if id.Obj != nil {
-			t.Errorf("rhs %s has Obj, should not", id.Name)
-		}
-	}
-	for _, v := range as.Lhs {
-		id := v.(*ast.Ident)
-		if id.Obj == nil {
-			t.Errorf("lhs %s does not have Obj, should", id.Name)
-		}
-	}
-}
-
-func TestVarScope(t *testing.T) {
-	f, err := ParseFile(token.NewFileSet(), "", `package p; func f() { var x, y, z = x, y, z }`, 0)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// RHS refers to undefined globals; LHS does not.
-	as := f.Decls[0].(*ast.FuncDecl).Body.List[0].(*ast.DeclStmt).Decl.(*ast.GenDecl).Specs[0].(*ast.ValueSpec)
-	for _, v := range as.Values {
-		id := v.(*ast.Ident)
-		if id.Obj != nil {
-			t.Errorf("rhs %s has Obj, should not", id.Name)
-		}
-	}
-	for _, id := range as.Names {
-		if id.Obj == nil {
-			t.Errorf("lhs %s does not have Obj, should", id.Name)
-		}
-	}
-}
-
-func TestObjects(t *testing.T) {
-	const src = `
-package p
-import fmt "fmt"
-const pi = 3.14
-type T struct{}
-var x int
-func f() { L: }
-`
-
-	f, err := ParseFile(token.NewFileSet(), "", src, 0)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	objects := map[string]ast.ObjKind{
-		"p":   ast.Bad, // not in a scope
-		"fmt": ast.Bad, // not resolved yet
-		"pi":  ast.Con,
-		"T":   ast.Typ,
-		"x":   ast.Var,
-		"int": ast.Bad, // not resolved yet
-		"f":   ast.Fun,
-		"L":   ast.Lbl,
-	}
-
-	ast.Inspect(f, func(n ast.Node) bool {
-		if ident, ok := n.(*ast.Ident); ok {
-			obj := ident.Obj
-			if obj == nil {
-				if objects[ident.Name] != ast.Bad {
-					t.Errorf("no object for %s", ident.Name)
-				}
-				return true
-			}
-			if obj.Name != ident.Name {
-				t.Errorf("names don't match: obj.Name = %s, ident.Name = %s", obj.Name, ident.Name)
-			}
-			kind := objects[ident.Name]
-			if obj.Kind != kind {
-				t.Errorf("%s: obj.Kind = %s; want %s", ident.Name, obj.Kind, kind)
-			}
-		}
-		return true
-	})
-}
-
-func TestUnresolved(t *testing.T) {
-	f, err := ParseFile(token.NewFileSet(), "", `
-package p
-//
-func f1a(int)
-func f2a(byte, int, float)
-func f3a(a, b int, c float)
-func f4a(...complex)
-func f5a(a s1a, b ...complex)
-//
-func f1b(*int)
-func f2b([]byte, (int), *float)
-func f3b(a, b *int, c []float)
-func f4b(...*complex)
-func f5b(a s1a, b ...[]complex)
-//
-type s1a struct { int }
-type s2a struct { byte; int; s1a }
-type s3a struct { a, b int; c float }
-//
-type s1b struct { *int }
-type s2b struct { byte; int; *float }
-type s3b struct { a, b *s3b; c []float }
-`, 0)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	want := "int " + // f1a
-		"byte int float " + // f2a
-		"int float " + // f3a
-		"complex " + // f4a
-		"complex " + // f5a
-		//
-		"int " + // f1b
-		"byte int float " + // f2b
-		"int float " + // f3b
-		"complex " + // f4b
-		"complex " + // f5b
-		//
-		"int " + // s1a
-		"byte int " + // s2a
-		"int float " + // s3a
-		//
-		"int " + // s1a
-		"byte int float " + // s2a
-		"float " // s3a
-
-	// collect unresolved identifiers
-	var buf bytes.Buffer
-	for _, u := range f.Unresolved {
-		buf.WriteString(u.Name)
-		buf.WriteByte(' ')
-	}
-	got := buf.String()
-
-	if got != want {
-		t.Errorf("\ngot:  %s\nwant: %s", got, want)
-	}
-}
-
-var imports = map[string]bool{
-	`"a"`:        true,
-	"`a`":        true,
-	`"a/b"`:      true,
-	`"a.b"`:      true,
-	`"m\x61th"`:  true,
-	`"greek/αβ"`: true,
-	`""`:         false,
-
-	// Each of these pairs tests both `` vs "" strings
-	// and also use of invalid characters spelled out as
-	// escape sequences and written directly.
-	// For example `"\x00"` tests import "\x00"
-	// while "`\x00`" tests import ``.
-	`"\x00"`:     false,
-	"`\x00`":     false,
-	`"\x7f"`:     false,
-	"`\x7f`":     false,
-	`"a!"`:       false,
-	"`a!`":       false,
-	`"a b"`:      false,
-	"`a b`":      false,
-	`"a\\b"`:     false,
-	"`a\\b`":     false,
-	"\"`a`\"":    false,
-	"`\"a\"`":    false,
-	`"\x80\x80"`: false,
-	"`\x80\x80`": false,
-	`"\xFFFD"`:   false,
-	"`\xFFFD`":   false,
-}
-
-func TestImports(t *testing.T) {
-	for path, isValid := range imports {
-		src := fmt.Sprintf("package p; import %s", path)
-		_, err := ParseFile(token.NewFileSet(), "", src, 0)
-		switch {
-		case err != nil && isValid:
-			t.Errorf("ParseFile(%s): got %v; expected no error", src, err)
-		case err == nil && !isValid:
-			t.Errorf("ParseFile(%s): got no error; expected one", src)
-		}
-	}
-}
-
-func TestCommentGroups(t *testing.T) {
-	f, err := ParseFile(token.NewFileSet(), "", `
-package p /* 1a */ /* 1b */      /* 1c */ // 1d
-/* 2a
-*/
-// 2b
-const pi = 3.1415
-/* 3a */ // 3b
-/* 3c */ const e = 2.7182
-
-// Example from issue 3139
-func ExampleCount() {
-	fmt.Println(strings.Count("cheese", "e"))
-	fmt.Println(strings.Count("five", "")) // before & after each rune
-	// Output:
-	// 3
-	// 5
-}
-`, ParseComments)
-	if err != nil {
-		t.Fatal(err)
-	}
-	expected := [][]string{
-		{"/* 1a */", "/* 1b */", "/* 1c */", "// 1d"},
-		{"/* 2a\n*/", "// 2b"},
-		{"/* 3a */", "// 3b", "/* 3c */"},
-		{"// Example from issue 3139"},
-		{"// before & after each rune"},
-		{"// Output:", "// 3", "// 5"},
-	}
-	if len(f.Comments) != len(expected) {
-		t.Fatalf("got %d comment groups; expected %d", len(f.Comments), len(expected))
-	}
-	for i, exp := range expected {
-		got := f.Comments[i].List
-		if len(got) != len(exp) {
-			t.Errorf("got %d comments in group %d; expected %d", len(got), i, len(exp))
-			continue
-		}
-		for j, exp := range exp {
-			got := got[j].Text
-			if got != exp {
-				t.Errorf("got %q in group %d; expected %q", got, i, exp)
-			}
-		}
-	}
-}
-
-func getField(file *ast.File, fieldname string) *ast.Field {
-	parts := strings.Split(fieldname, ".")
-	for _, d := range file.Decls {
-		if d, ok := d.(*ast.GenDecl); ok && d.Tok == token.TYPE {
-			for _, s := range d.Specs {
-				if s, ok := s.(*ast.TypeSpec); ok && s.Name.Name == parts[0] {
-					if s, ok := s.Type.(*ast.StructType); ok {
-						for _, f := range s.Fields.List {
-							for _, name := range f.Names {
-								if name.Name == parts[1] {
-									return f
-								}
-							}
-						}
-					}
-				}
-			}
-		}
-	}
-	return nil
-}
-
-// Don't use ast.CommentGroup.Text() - we want to see exact comment text.
-func commentText(c *ast.CommentGroup) string {
-	var buf bytes.Buffer
-	if c != nil {
-		for _, c := range c.List {
-			buf.WriteString(c.Text)
-		}
-	}
-	return buf.String()
-}
-
-func checkFieldComments(t *testing.T, file *ast.File, fieldname, lead, line string) {
-	f := getField(file, fieldname)
-	if f == nil {
-		t.Fatalf("field not found: %s", fieldname)
-	}
-	if got := commentText(f.Doc); got != lead {
-		t.Errorf("got lead comment %q; expected %q", got, lead)
-	}
-	if got := commentText(f.Comment); got != line {
-		t.Errorf("got line comment %q; expected %q", got, line)
-	}
-}
-
-func TestLeadAndLineComments(t *testing.T) {
-	f, err := ParseFile(token.NewFileSet(), "", `
-package p
-type T struct {
-	/* F1 lead comment */
-	//
-	F1 int  /* F1 */ // line comment
-	// F2 lead
-	// comment
-	F2 int  // F2 line comment
-	// f3 lead comment
-	f3 int  // f3 line comment
-}
-`, ParseComments)
-	if err != nil {
-		t.Fatal(err)
-	}
-	checkFieldComments(t, f, "T.F1", "/* F1 lead comment *///", "/* F1 */// line comment")
-	checkFieldComments(t, f, "T.F2", "// F2 lead// comment", "// F2 line comment")
-	checkFieldComments(t, f, "T.f3", "// f3 lead comment", "// f3 line comment")
-	ast.FileExports(f)
-	checkFieldComments(t, f, "T.F1", "/* F1 lead comment *///", "/* F1 */// line comment")
-	checkFieldComments(t, f, "T.F2", "// F2 lead// comment", "// F2 line comment")
-	if getField(f, "T.f3") != nil {
-		t.Error("not expected to find T.f3")
-	}
-}
-
-// TestIssue9979 verifies that empty statements are contained within their enclosing blocks.
-func TestIssue9979(t *testing.T) {
-	for _, src := range []string{
-		"package p; func f() {;}",
-		"package p; func f() {L:}",
-		"package p; func f() {L:;}",
-		"package p; func f() {L:\n}",
-		"package p; func f() {L:\n;}",
-		"package p; func f() { ; }",
-		"package p; func f() { L: }",
-		"package p; func f() { L: ; }",
-		"package p; func f() { L: \n}",
-		"package p; func f() { L: \n; }",
-	} {
-		fset := token.NewFileSet()
-		f, err := ParseFile(fset, "", src, 0)
-		if err != nil {
-			t.Fatal(err)
-		}
-
-		var pos, end token.Pos
-		ast.Inspect(f, func(x ast.Node) bool {
-			switch s := x.(type) {
-			case *ast.BlockStmt:
-				pos, end = s.Pos()+1, s.End()-1 // exclude "{", "}"
-			case *ast.LabeledStmt:
-				pos, end = s.Pos()+2, s.End() // exclude "L:"
-			case *ast.EmptyStmt:
-				// check containment
-				if s.Pos() < pos || s.End() > end {
-					t.Errorf("%s: %T[%d, %d] not inside [%d, %d]", src, s, s.Pos(), s.End(), pos, end)
-				}
-				// check semicolon
-				offs := fset.Position(s.Pos()).Offset
-				if ch := src[offs]; ch != ';' != s.Implicit {
-					want := "want ';'"
-					if s.Implicit {
-						want = "but ';' is implicit"
-					}
-					t.Errorf("%s: found %q at offset %d; %s", src, ch, offs, want)
-				}
-			}
-			return true
-		})
-	}
-}
-
-// TestIncompleteSelection ensures that an incomplete selector
-// expression is parsed as a (blank) *ast.SelectorExpr, not a
-// *ast.BadExpr.
-func TestIncompleteSelection(t *testing.T) {
-	for _, src := range []string{
-		"package p; var _ = fmt.",             // at EOF
-		"package p; var _ = fmt.\ntype X int", // not at EOF
-	} {
-		fset := token.NewFileSet()
-		f, err := ParseFile(fset, "", src, 0)
-		if err == nil {
-			t.Errorf("ParseFile(%s) succeeded unexpectedly", src)
-			continue
-		}
-
-		const wantErr = "expected selector or type assertion"
-		if !strings.Contains(err.Error(), wantErr) {
-			t.Errorf("ParseFile returned wrong error %q, want %q", err, wantErr)
-		}
-
-		var sel *ast.SelectorExpr
-		ast.Inspect(f, func(n ast.Node) bool {
-			if n, ok := n.(*ast.SelectorExpr); ok {
-				sel = n
-			}
-			return true
-		})
-		if sel == nil {
-			t.Error("found no *ast.SelectorExpr")
-			continue
-		}
-		const wantSel = "&{fmt _}"
-		if fmt.Sprint(sel) != wantSel {
-			t.Errorf("found selector %s, want %s", sel, wantSel)
-			continue
-		}
-	}
-}
diff --git a/third_party/golang/go/parser/performance_test.go b/third_party/golang/go/parser/performance_test.go
deleted file mode 100644
index 6737647b82a6f..0000000000000
--- a/third_party/golang/go/parser/performance_test.go
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package parser
-
-import (
-	"io/ioutil"
-	"testing"
-
-	"k8s.io/kubernetes/third_party/golang/go/token"
-)
-
-var src = readFile("parser.go")
-
-func readFile(filename string) []byte {
-	data, err := ioutil.ReadFile(filename)
-	if err != nil {
-		panic(err)
-	}
-	return data
-}
-
-func BenchmarkParse(b *testing.B) {
-	b.SetBytes(int64(len(src)))
-	for i := 0; i < b.N; i++ {
-		if _, err := ParseFile(token.NewFileSet(), "", src, ParseComments); err != nil {
-			b.Fatalf("benchmark failed due to parse error: %s", err)
-		}
-	}
-}
diff --git a/third_party/golang/go/parser/short_test.go b/third_party/golang/go/parser/short_test.go
deleted file mode 100644
index ef2ffadbd981c..0000000000000
--- a/third_party/golang/go/parser/short_test.go
+++ /dev/null
@@ -1,115 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file contains test cases for short valid and invalid programs.
-
-package parser
-
-import "testing"
-
-var valids = []string{
-	"package p\n",
-	`package p;`,
-	`package p; import "fmt"; func f() { fmt.Println("Hello, World!") };`,
-	`package p; func f() { if f(T{}) {} };`,
-	`package p; func f() { _ = <-chan int(nil) };`,
-	`package p; func f() { _ = (<-chan int)(nil) };`,
-	`package p; func f() { _ = (<-chan <-chan int)(nil) };`,
-	`package p; func f() { _ = <-chan <-chan <-chan <-chan <-int(nil) };`,
-	`package p; func f(func() func() func());`,
-	`package p; func f(...T);`,
-	`package p; func f(float, ...int);`,
-	`package p; func f(x int, a ...int) { f(0, a...); f(1, a...,) };`,
-	`package p; func f(int,) {};`,
-	`package p; func f(...int,) {};`,
-	`package p; func f(x ...int,) {};`,
-	`package p; type T []int; var a []bool; func f() { if a[T{42}[0]] {} };`,
-	`package p; type T []int; func g(int) bool { return true }; func f() { if g(T{42}[0]) {} };`,
-	`package p; type T []int; func f() { for _ = range []int{T{42}[0]} {} };`,
-	`package p; var a = T{{1, 2}, {3, 4}}`,
-	`package p; func f() { select { case <- c: case c <- d: case c <- <- d: case <-c <- d: } };`,
-	`package p; func f() { select { case x := (<-c): } };`,
-	`package p; func f() { if ; true {} };`,
-	`package p; func f() { switch ; {} };`,
-	`package p; func f() { for _ = range "foo" + "bar" {} };`,
-	`package p; func f() { var s []int; g(s[:], s[i:], s[:j], s[i:j], s[i:j:k], s[:j:k]) };`,
-	`package p; var ( _ = (struct {*T}).m; _ = (interface {T}).m )`,
-	`package p; func ((T),) m() {}`,
-	`package p; func ((*T),) m() {}`,
-	`package p; func (*(T),) m() {}`,
-	`package p; func _(x []int) { for range x {} }`,
-	`package p; func _() { if [T{}.n]int{} {} }`,
-	`package p; func _() { map[int]int{}[0]++; map[int]int{}[0] += 1 }`,
-	`package p; func _(x interface{f()}) { interface{f()}(x).f() }`,
-	`package p; func _(x chan int) { chan int(x) <- 0 }`,
-	`package p; const (x = 0; y; z)`, // issue 9639
-	`package p; var _ = map[P]int{P{}:0, {}:1}`,
-	`package p; var _ = map[*P]int{&P{}:0, {}:1}`,
-}
-
-func TestValid(t *testing.T) {
-	for _, src := range valids {
-		checkErrors(t, src, src)
-	}
-}
-
-var invalids = []string{
-	`foo /* ERROR "expected 'package'" */ !`,
-	`package p; func f() { if { /* ERROR "expected operand" */ } };`,
-	`package p; func f() { if ; { /* ERROR "expected operand" */ } };`,
-	`package p; func f() { if f(); { /* ERROR "expected operand" */ } };`,
-	`package p; func f() { if _ /* ERROR "expected boolean expression" */ = range x; true {} };`,
-	`package p; func f() { switch _ /* ERROR "expected switch expression" */ = range x; true {} };`,
-	`package p; func f() { for _ = range x ; /* ERROR "expected '{'" */ ; {} };`,
-	`package p; func f() { for ; ; _ = range /* ERROR "expected operand" */ x {} };`,
-	`package p; func f() { for ; _ /* ERROR "expected boolean or range expression" */ = range x ; {} };`,
-	`package p; func f() { switch t /* ERROR "expected switch expression" */ = t.(type) {} };`,
-	`package p; func f() { switch t /* ERROR "expected switch expression" */ , t = t.(type) {} };`,
-	`package p; func f() { switch t /* ERROR "expected switch expression" */ = t.(type), t {} };`,
-	`package p; var a = [ /* ERROR "expected expression" */ 1]int;`,
-	`package p; var a = [ /* ERROR "expected expression" */ ...]int;`,
-	`package p; var a = struct /* ERROR "expected expression" */ {}`,
-	`package p; var a = func /* ERROR "expected expression" */ ();`,
-	`package p; var a = interface /* ERROR "expected expression" */ {}`,
-	`package p; var a = [ /* ERROR "expected expression" */ ]int`,
-	`package p; var a = map /* ERROR "expected expression" */ [int]int`,
-	`package p; var a = chan /* ERROR "expected expression" */ int;`,
-	`package p; var a = []int{[ /* ERROR "expected expression" */ ]int};`,
-	`package p; var a = ( /* ERROR "expected expression" */ []int);`,
-	`package p; var a = a[[ /* ERROR "expected expression" */ ]int:[]int];`,
-	`package p; var a = <- /* ERROR "expected expression" */ chan int;`,
-	`package p; func f() { select { case _ <- chan /* ERROR "expected expression" */ int: } };`,
-	`package p; func f() { _ = (<-<- /* ERROR "expected 'chan'" */ chan int)(nil) };`,
-	`package p; func f() { _ = (<-chan<-chan<-chan<-chan<-chan<- /* ERROR "expected channel type" */ int)(nil) };`,
-	`package p; func f() { var t []int; t /* ERROR "expected identifier on left side of :=" */ [0] := 0 };`,
-	`package p; func f() { if x := g(); x = /* ERROR "expected '=='" */ 0 {}};`,
-	`package p; func f() { _ = x = /* ERROR "expected '=='" */ 0 {}};`,
-	`package p; func f() { _ = 1 == func()int { var x bool; x = x = /* ERROR "expected '=='" */ true; return x }() };`,
-	`package p; func f() { var s []int; _ = s[] /* ERROR "expected operand" */ };`,
-	`package p; func f() { var s []int; _ = s[i:j: /* ERROR "3rd index required" */ ] };`,
-	`package p; func f() { var s []int; _ = s[i: /* ERROR "2nd index required" */ :k] };`,
-	`package p; func f() { var s []int; _ = s[i: /* ERROR "2nd index required" */ :] };`,
-	`package p; func f() { var s []int; _ = s[: /* ERROR "2nd index required" */ :] };`,
-	`package p; func f() { var s []int; _ = s[: /* ERROR "2nd index required" */ ::] };`,
-	`package p; func f() { var s []int; _ = s[i:j:k: /* ERROR "expected ']'" */ l] };`,
-	`package p; func f() { for x /* ERROR "boolean or range expression" */ = []string {} }`,
-	`package p; func f() { for x /* ERROR "boolean or range expression" */ := []string {} }`,
-	`package p; func f() { for i /* ERROR "boolean or range expression" */ , x = []string {} }`,
-	`package p; func f() { for i /* ERROR "boolean or range expression" */ , x := []string {} }`,
-	`package p; func f() { go f /* ERROR HERE "function must be invoked" */ }`,
-	`package p; func f() { defer func() {} /* ERROR HERE "function must be invoked" */ }`,
-	`package p; func f() { go func() { func() { f(x func /* ERROR "missing ','" */ (){}) } } }`,
-	`package p; func f(x func(), u v func /* ERROR "missing ','" */ ()){}`,
-	`package p; func f() (a b string /* ERROR "missing ','" */ , ok bool)`,           // issue 8656
-	`package p; var x /* ERROR "missing variable type or initialization" */ , y, z;`, // issue 9639
-	`package p; const x /* ERROR "missing constant value" */ ;`,                      // issue 9639
-	`package p; const x /* ERROR "missing constant value" */ int;`,                   // issue 9639
-	`package p; const (x = 0; y; z /* ERROR "missing constant value" */ int);`,       // issue 9639
-}
-
-func TestInvalid(t *testing.T) {
-	for _, src := range invalids {
-		checkErrors(t, src, src)
-	}
-}
diff --git a/third_party/golang/go/parser/testdata/commas.src b/third_party/golang/go/parser/testdata/commas.src
deleted file mode 100644
index af6e706450691..0000000000000
--- a/third_party/golang/go/parser/testdata/commas.src
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Test case for error messages/parser synchronization
-// after missing commas.
-
-package p
-
-var _ = []int{
-	0 /* ERROR "missing ','" */
-}
-
-var _ = []int{
-	0,
-	1,
-	2,
-	3 /* ERROR "missing ','" */
-}
diff --git a/third_party/golang/go/parser/testdata/issue3106.src b/third_party/golang/go/parser/testdata/issue3106.src
deleted file mode 100644
index 2db10be23549b..0000000000000
--- a/third_party/golang/go/parser/testdata/issue3106.src
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Test case for issue 3106: Better synchronization of
-// parser after certain syntax errors.
-
-package main
-
-func f() {
-	var m Mutex
-	c := MakeCond(&m)
-	percent := 0
-	const step = 10
-	for i := 0; i < 5; i++ {
-		go func() {
-			for {
-				// Emulates some useful work.
-				time.Sleep(1e8)
-				m.Lock()
-				defer
-				if /* ERROR "expected ';', found 'if'" */ percent == 100 {
-					m.Unlock()
-					break
-				}
-				percent++
-				if percent % step == 0 {
-					//c.Signal()
-				}
-				m.Unlock()
-			}
-		}()
-	}
-	for {
-		m.Lock()
-		if percent == 0 || percent % step != 0 {
-			c.Wait()
-		}
-		fmt.Print(",")
-		if percent == 100 {
-			m.Unlock()
-			break
-		}
-		m.Unlock()
-	}
-}
diff --git a/third_party/golang/go/printer/example_test.go b/third_party/golang/go/printer/example_test.go
deleted file mode 100644
index 7a8f629c698e5..0000000000000
--- a/third_party/golang/go/printer/example_test.go
+++ /dev/null
@@ -1,67 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package printer_test
-
-import (
-	"bytes"
-	"fmt"
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"k8s.io/kubernetes/third_party/golang/go/parser"
-	"k8s.io/kubernetes/third_party/golang/go/printer"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-	"strings"
-	"testing"
-)
-
-// Dummy test function so that godoc does not use the entire file as example.
-func Test(*testing.T) {}
-
-func parseFunc(filename, functionname string) (fun *ast.FuncDecl, fset *token.FileSet) {
-	fset = token.NewFileSet()
-	if file, err := parser.ParseFile(fset, filename, nil, 0); err == nil {
-		for _, d := range file.Decls {
-			if f, ok := d.(*ast.FuncDecl); ok && f.Name.Name == functionname {
-				fun = f
-				return
-			}
-		}
-	}
-	panic("function not found")
-}
-
-func ExampleFprint() {
-	// Parse source file and extract the AST without comments for
-	// this function, with position information referring to the
-	// file set fset.
-	funcAST, fset := parseFunc("example_test.go", "ExampleFprint")
-
-	// Print the function body into buffer buf.
-	// The file set is provided to the printer so that it knows
-	// about the original source formatting and can add additional
-	// line breaks where they were present in the source.
-	var buf bytes.Buffer
-	printer.Fprint(&buf, fset, funcAST.Body)
-
-	// Remove braces {} enclosing the function body, unindent,
-	// and trim leading and trailing white space.
-	s := buf.String()
-	s = s[1 : len(s)-1]
-	s = strings.TrimSpace(strings.Replace(s, "\n\t", "\n", -1))
-
-	// Print the cleaned-up body text to stdout.
-	fmt.Println(s)
-
-	// output:
-	// funcAST, fset := parseFunc("example_test.go", "ExampleFprint")
-	//
-	// var buf bytes.Buffer
-	// printer.Fprint(&buf, fset, funcAST.Body)
-	//
-	// s := buf.String()
-	// s = s[1 : len(s)-1]
-	// s = strings.TrimSpace(strings.Replace(s, "\n\t", "\n", -1))
-	//
-	// fmt.Println(s)
-}
diff --git a/third_party/golang/go/printer/nodes.go b/third_party/golang/go/printer/nodes.go
deleted file mode 100644
index 60b5e2455785e..0000000000000
--- a/third_party/golang/go/printer/nodes.go
+++ /dev/null
@@ -1,1652 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements printing of AST nodes; specifically
-// expressions, statements, declarations, and files. It uses
-// the print functionality implemented in printer.go.
-
-package printer
-
-import (
-	"bytes"
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-	"strconv"
-	"strings"
-	"unicode"
-	"unicode/utf8"
-)
-
-// Formatting issues:
-// - better comment formatting for /*-style comments at the end of a line (e.g. a declaration)
-//   when the comment spans multiple lines; if such a comment is just two lines, formatting is
-//   not idempotent
-// - formatting of expression lists
-// - should use blank instead of tab to separate one-line function bodies from
-//   the function header unless there is a group of consecutive one-liners
-
-// ----------------------------------------------------------------------------
-// Common AST nodes.
-
-// Print as many newlines as necessary (but at least min newlines) to get to
-// the current line. ws is printed before the first line break. If newSection
-// is set, the first line break is printed as formfeed. Returns true if any
-// line break was printed; returns false otherwise.
-//
-// TODO(gri): linebreak may add too many lines if the next statement at "line"
-//            is preceded by comments because the computation of n assumes
-//            the current position before the comment and the target position
-//            after the comment. Thus, after interspersing such comments, the
-//            space taken up by them is not considered to reduce the number of
-//            linebreaks. At the moment there is no easy way to know about
-//            future (not yet interspersed) comments in this function.
-//
-func (p *printer) linebreak(line, min int, ws whiteSpace, newSection bool) (printedBreak bool) {
-	n := nlimit(line - p.pos.Line)
-	if n < min {
-		n = min
-	}
-	if n > 0 {
-		p.print(ws)
-		if newSection {
-			p.print(formfeed)
-			n--
-		}
-		for ; n > 0; n-- {
-			p.print(newline)
-		}
-		printedBreak = true
-	}
-	return
-}
-
-// setComment sets g as the next comment if g != nil and if node comments
-// are enabled - this mode is used when printing source code fragments such
-// as exports only. It assumes that there is no pending comment in p.comments
-// and at most one pending comment in the p.comment cache.
-func (p *printer) setComment(g *ast.CommentGroup) {
-	if g == nil || !p.useNodeComments {
-		return
-	}
-	if p.comments == nil {
-		// initialize p.comments lazily
-		p.comments = make([]*ast.CommentGroup, 1)
-	} else if p.cindex < len(p.comments) {
-		// for some reason there are pending comments; this
-		// should never happen - handle gracefully and flush
-		// all comments up to g, ignore anything after that
-		p.flush(p.posFor(g.List[0].Pos()), token.ILLEGAL)
-		p.comments = p.comments[0:1]
-		// in debug mode, report error
-		p.internalError("setComment found pending comments")
-	}
-	p.comments[0] = g
-	p.cindex = 0
-	// don't overwrite any pending comment in the p.comment cache
-	// (there may be a pending comment when a line comment is
-	// immediately followed by a lead comment with no other
-	// tokens between)
-	if p.commentOffset == infinity {
-		p.nextComment() // get comment ready for use
-	}
-}
-
-type exprListMode uint
-
-const (
-	commaTerm exprListMode = 1 << iota // list is optionally terminated by a comma
-	noIndent                           // no extra indentation in multi-line lists
-)
-
-// If indent is set, a multi-line identifier list is indented after the
-// first linebreak encountered.
-func (p *printer) identList(list []*ast.Ident, indent bool) {
-	// convert into an expression list so we can re-use exprList formatting
-	xlist := make([]ast.Expr, len(list))
-	for i, x := range list {
-		xlist[i] = x
-	}
-	var mode exprListMode
-	if !indent {
-		mode = noIndent
-	}
-	p.exprList(token.NoPos, xlist, 1, mode, token.NoPos)
-}
-
-// Print a list of expressions. If the list spans multiple
-// source lines, the original line breaks are respected between
-// expressions.
-//
-// TODO(gri) Consider rewriting this to be independent of []ast.Expr
-//           so that we can use the algorithm for any kind of list
-//           (e.g., pass list via a channel over which to range).
-func (p *printer) exprList(prev0 token.Pos, list []ast.Expr, depth int, mode exprListMode, next0 token.Pos) {
-	if len(list) == 0 {
-		return
-	}
-
-	prev := p.posFor(prev0)
-	next := p.posFor(next0)
-	line := p.lineFor(list[0].Pos())
-	endLine := p.lineFor(list[len(list)-1].End())
-
-	if prev.IsValid() && prev.Line == line && line == endLine {
-		// all list entries on a single line
-		for i, x := range list {
-			if i > 0 {
-				// use position of expression following the comma as
-				// comma position for correct comment placement
-				p.print(x.Pos(), token.COMMA, blank)
-			}
-			p.expr0(x, depth)
-		}
-		return
-	}
-
-	// list entries span multiple lines;
-	// use source code positions to guide line breaks
-
-	// don't add extra indentation if noIndent is set;
-	// i.e., pretend that the first line is already indented
-	ws := ignore
-	if mode&noIndent == 0 {
-		ws = indent
-	}
-
-	// the first linebreak is always a formfeed since this section must not
-	// depend on any previous formatting
-	prevBreak := -1 // index of last expression that was followed by a linebreak
-	if prev.IsValid() && prev.Line < line && p.linebreak(line, 0, ws, true) {
-		ws = ignore
-		prevBreak = 0
-	}
-
-	// initialize expression/key size: a zero value indicates expr/key doesn't fit on a single line
-	size := 0
-
-	// print all list elements
-	prevLine := prev.Line
-	for i, x := range list {
-		line = p.lineFor(x.Pos())
-
-		// determine if the next linebreak, if any, needs to use formfeed:
-		// in general, use the entire node size to make the decision; for
-		// key:value expressions, use the key size
-		// TODO(gri) for a better result, should probably incorporate both
-		//           the key and the node size into the decision process
-		useFF := true
-
-		// determine element size: all bets are off if we don't have
-		// position information for the previous and next token (likely
-		// generated code - simply ignore the size in this case by setting
-		// it to 0)
-		prevSize := size
-		const infinity = 1e6 // larger than any source line
-		size = p.nodeSize(x, infinity)
-		pair, isPair := x.(*ast.KeyValueExpr)
-		if size <= infinity && prev.IsValid() && next.IsValid() {
-			// x fits on a single line
-			if isPair {
-				size = p.nodeSize(pair.Key, infinity) // size <= infinity
-			}
-		} else {
-			// size too large or we don't have good layout information
-			size = 0
-		}
-
-		// if the previous line and the current line had single-
-		// line-expressions and the key sizes are small or the
-		// the ratio between the key sizes does not exceed a
-		// threshold, align columns and do not use formfeed
-		if prevSize > 0 && size > 0 {
-			const smallSize = 20
-			if prevSize <= smallSize && size <= smallSize {
-				useFF = false
-			} else {
-				const r = 4 // threshold
-				ratio := float64(size) / float64(prevSize)
-				useFF = ratio <= 1.0/r || r <= ratio
-			}
-		}
-
-		needsLinebreak := 0 < prevLine && prevLine < line
-		if i > 0 {
-			// use position of expression following the comma as
-			// comma position for correct comment placement, but
-			// only if the expression is on the same line
-			if !needsLinebreak {
-				p.print(x.Pos())
-			}
-			p.print(token.COMMA)
-			needsBlank := true
-			if needsLinebreak {
-				// lines are broken using newlines so comments remain aligned
-				// unless forceFF is set or there are multiple expressions on
-				// the same line in which case formfeed is used
-				if p.linebreak(line, 0, ws, useFF || prevBreak+1 < i) {
-					ws = ignore
-					prevBreak = i
-					needsBlank = false // we got a line break instead
-				}
-			}
-			if needsBlank {
-				p.print(blank)
-			}
-		}
-
-		if len(list) > 1 && isPair && size > 0 && needsLinebreak {
-			// we have a key:value expression that fits onto one line
-			// and it's not on the same line as the prior expression:
-			// use a column for the key such that consecutive entries
-			// can align if possible
-			// (needsLinebreak is set if we started a new line before)
-			p.expr(pair.Key)
-			p.print(pair.Colon, token.COLON, vtab)
-			p.expr(pair.Value)
-		} else {
-			p.expr0(x, depth)
-		}
-
-		prevLine = line
-	}
-
-	if mode&commaTerm != 0 && next.IsValid() && p.pos.Line < next.Line {
-		// print a terminating comma if the next token is on a new line
-		p.print(token.COMMA)
-		if ws == ignore && mode&noIndent == 0 {
-			// unindent if we indented
-			p.print(unindent)
-		}
-		p.print(formfeed) // terminating comma needs a line break to look good
-		return
-	}
-
-	if ws == ignore && mode&noIndent == 0 {
-		// unindent if we indented
-		p.print(unindent)
-	}
-}
-
-func (p *printer) parameters(fields *ast.FieldList) {
-	p.print(fields.Opening, token.LPAREN)
-	if len(fields.List) > 0 {
-		prevLine := p.lineFor(fields.Opening)
-		ws := indent
-		for i, par := range fields.List {
-			// determine par begin and end line (may be different
-			// if there are multiple parameter names for this par
-			// or the type is on a separate line)
-			var parLineBeg int
-			if len(par.Names) > 0 {
-				parLineBeg = p.lineFor(par.Names[0].Pos())
-			} else {
-				parLineBeg = p.lineFor(par.Type.Pos())
-			}
-			var parLineEnd = p.lineFor(par.Type.End())
-			// separating "," if needed
-			needsLinebreak := 0 < prevLine && prevLine < parLineBeg
-			if i > 0 {
-				// use position of parameter following the comma as
-				// comma position for correct comma placement, but
-				// only if the next parameter is on the same line
-				if !needsLinebreak {
-					p.print(par.Pos())
-				}
-				p.print(token.COMMA)
-			}
-			// separator if needed (linebreak or blank)
-			if needsLinebreak && p.linebreak(parLineBeg, 0, ws, true) {
-				// break line if the opening "(" or previous parameter ended on a different line
-				ws = ignore
-			} else if i > 0 {
-				p.print(blank)
-			}
-			// parameter names
-			if len(par.Names) > 0 {
-				// Very subtle: If we indented before (ws == ignore), identList
-				// won't indent again. If we didn't (ws == indent), identList will
-				// indent if the identList spans multiple lines, and it will outdent
-				// again at the end (and still ws == indent). Thus, a subsequent indent
-				// by a linebreak call after a type, or in the next multi-line identList
-				// will do the right thing.
-				p.identList(par.Names, ws == indent)
-				p.print(blank)
-			}
-			// parameter type
-			p.expr(stripParensAlways(par.Type))
-			prevLine = parLineEnd
-		}
-		// if the closing ")" is on a separate line from the last parameter,
-		// print an additional "," and line break
-		if closing := p.lineFor(fields.Closing); 0 < prevLine && prevLine < closing {
-			p.print(token.COMMA)
-			p.linebreak(closing, 0, ignore, true)
-		}
-		// unindent if we indented
-		if ws == ignore {
-			p.print(unindent)
-		}
-	}
-	p.print(fields.Closing, token.RPAREN)
-}
-
-func (p *printer) signature(params, result *ast.FieldList) {
-	if params != nil {
-		p.parameters(params)
-	} else {
-		p.print(token.LPAREN, token.RPAREN)
-	}
-	n := result.NumFields()
-	if n > 0 {
-		// result != nil
-		p.print(blank)
-		if n == 1 && result.List[0].Names == nil {
-			// single anonymous result; no ()'s
-			p.expr(stripParensAlways(result.List[0].Type))
-			return
-		}
-		p.parameters(result)
-	}
-}
-
-func identListSize(list []*ast.Ident, maxSize int) (size int) {
-	for i, x := range list {
-		if i > 0 {
-			size += len(", ")
-		}
-		size += utf8.RuneCountInString(x.Name)
-		if size >= maxSize {
-			break
-		}
-	}
-	return
-}
-
-func (p *printer) isOneLineFieldList(list []*ast.Field) bool {
-	if len(list) != 1 {
-		return false // allow only one field
-	}
-	f := list[0]
-	if f.Tag != nil || f.Comment != nil {
-		return false // don't allow tags or comments
-	}
-	// only name(s) and type
-	const maxSize = 30 // adjust as appropriate, this is an approximate value
-	namesSize := identListSize(f.Names, maxSize)
-	if namesSize > 0 {
-		namesSize = 1 // blank between names and types
-	}
-	typeSize := p.nodeSize(f.Type, maxSize)
-	return namesSize+typeSize <= maxSize
-}
-
-func (p *printer) setLineComment(text string) {
-	p.setComment(&ast.CommentGroup{List: []*ast.Comment{{Slash: token.NoPos, Text: text}}})
-}
-
-func (p *printer) fieldList(fields *ast.FieldList, isStruct, isIncomplete bool) {
-	lbrace := fields.Opening
-	list := fields.List
-	rbrace := fields.Closing
-	hasComments := isIncomplete || p.commentBefore(p.posFor(rbrace))
-	srcIsOneLine := lbrace.IsValid() && rbrace.IsValid() && p.lineFor(lbrace) == p.lineFor(rbrace)
-
-	if !hasComments && srcIsOneLine {
-		// possibly a one-line struct/interface
-		if len(list) == 0 {
-			// no blank between keyword and {} in this case
-			p.print(lbrace, token.LBRACE, rbrace, token.RBRACE)
-			return
-		} else if isStruct && p.isOneLineFieldList(list) { // for now ignore interfaces
-			// small enough - print on one line
-			// (don't use identList and ignore source line breaks)
-			p.print(lbrace, token.LBRACE, blank)
-			f := list[0]
-			for i, x := range f.Names {
-				if i > 0 {
-					// no comments so no need for comma position
-					p.print(token.COMMA, blank)
-				}
-				p.expr(x)
-			}
-			if len(f.Names) > 0 {
-				p.print(blank)
-			}
-			p.expr(f.Type)
-			p.print(blank, rbrace, token.RBRACE)
-			return
-		}
-	}
-	// hasComments || !srcIsOneLine
-
-	p.print(blank, lbrace, token.LBRACE, indent)
-	if hasComments || len(list) > 0 {
-		p.print(formfeed)
-	}
-
-	if isStruct {
-
-		sep := vtab
-		if len(list) == 1 {
-			sep = blank
-		}
-		var line int
-		for i, f := range list {
-			if i > 0 {
-				p.linebreak(p.lineFor(f.Pos()), 1, ignore, p.linesFrom(line) > 0)
-			}
-			extraTabs := 0
-			p.setComment(f.Doc)
-			p.recordLine(&line)
-			if len(f.Names) > 0 {
-				// named fields
-				p.identList(f.Names, false)
-				p.print(sep)
-				p.expr(f.Type)
-				extraTabs = 1
-			} else {
-				// anonymous field
-				p.expr(f.Type)
-				extraTabs = 2
-			}
-			if f.Tag != nil {
-				if len(f.Names) > 0 && sep == vtab {
-					p.print(sep)
-				}
-				p.print(sep)
-				p.expr(f.Tag)
-				extraTabs = 0
-			}
-			if f.Comment != nil {
-				for ; extraTabs > 0; extraTabs-- {
-					p.print(sep)
-				}
-				p.setComment(f.Comment)
-			}
-		}
-		if isIncomplete {
-			if len(list) > 0 {
-				p.print(formfeed)
-			}
-			p.flush(p.posFor(rbrace), token.RBRACE) // make sure we don't lose the last line comment
-			p.setLineComment("// contains filtered or unexported fields")
-		}
-
-	} else { // interface
-
-		var line int
-		for i, f := range list {
-			if i > 0 {
-				p.linebreak(p.lineFor(f.Pos()), 1, ignore, p.linesFrom(line) > 0)
-			}
-			p.setComment(f.Doc)
-			p.recordLine(&line)
-			if ftyp, isFtyp := f.Type.(*ast.FuncType); isFtyp {
-				// method
-				p.expr(f.Names[0])
-				p.signature(ftyp.Params, ftyp.Results)
-			} else {
-				// embedded interface
-				p.expr(f.Type)
-			}
-			p.setComment(f.Comment)
-		}
-		if isIncomplete {
-			if len(list) > 0 {
-				p.print(formfeed)
-			}
-			p.flush(p.posFor(rbrace), token.RBRACE) // make sure we don't lose the last line comment
-			p.setLineComment("// contains filtered or unexported methods")
-		}
-
-	}
-	p.print(unindent, formfeed, rbrace, token.RBRACE)
-}
-
-// ----------------------------------------------------------------------------
-// Expressions
-
-func walkBinary(e *ast.BinaryExpr) (has4, has5 bool, maxProblem int) {
-	switch e.Op.Precedence() {
-	case 4:
-		has4 = true
-	case 5:
-		has5 = true
-	}
-
-	switch l := e.X.(type) {
-	case *ast.BinaryExpr:
-		if l.Op.Precedence() < e.Op.Precedence() {
-			// parens will be inserted.
-			// pretend this is an *ast.ParenExpr and do nothing.
-			break
-		}
-		h4, h5, mp := walkBinary(l)
-		has4 = has4 || h4
-		has5 = has5 || h5
-		if maxProblem < mp {
-			maxProblem = mp
-		}
-	}
-
-	switch r := e.Y.(type) {
-	case *ast.BinaryExpr:
-		if r.Op.Precedence() <= e.Op.Precedence() {
-			// parens will be inserted.
-			// pretend this is an *ast.ParenExpr and do nothing.
-			break
-		}
-		h4, h5, mp := walkBinary(r)
-		has4 = has4 || h4
-		has5 = has5 || h5
-		if maxProblem < mp {
-			maxProblem = mp
-		}
-
-	case *ast.StarExpr:
-		if e.Op == token.QUO { // `*/`
-			maxProblem = 5
-		}
-
-	case *ast.UnaryExpr:
-		switch e.Op.String() + r.Op.String() {
-		case "/*", "&&", "&^":
-			maxProblem = 5
-		case "++", "--":
-			if maxProblem < 4 {
-				maxProblem = 4
-			}
-		}
-	}
-	return
-}
-
-func cutoff(e *ast.BinaryExpr, depth int) int {
-	has4, has5, maxProblem := walkBinary(e)
-	if maxProblem > 0 {
-		return maxProblem + 1
-	}
-	if has4 && has5 {
-		if depth == 1 {
-			return 5
-		}
-		return 4
-	}
-	if depth == 1 {
-		return 6
-	}
-	return 4
-}
-
-func diffPrec(expr ast.Expr, prec int) int {
-	x, ok := expr.(*ast.BinaryExpr)
-	if !ok || prec != x.Op.Precedence() {
-		return 1
-	}
-	return 0
-}
-
-func reduceDepth(depth int) int {
-	depth--
-	if depth < 1 {
-		depth = 1
-	}
-	return depth
-}
-
-// Format the binary expression: decide the cutoff and then format.
-// Let's call depth == 1 Normal mode, and depth > 1 Compact mode.
-// (Algorithm suggestion by Russ Cox.)
-//
-// The precedences are:
-//	5             *  /  %  <<  >>  &  &^
-//	4             +  -  |  ^
-//	3             ==  !=  <  <=  >  >=
-//	2             &&
-//	1             ||
-//
-// The only decision is whether there will be spaces around levels 4 and 5.
-// There are never spaces at level 6 (unary), and always spaces at levels 3 and below.
-//
-// To choose the cutoff, look at the whole expression but excluding primary
-// expressions (function calls, parenthesized exprs), and apply these rules:
-//
-//	1) If there is a binary operator with a right side unary operand
-//	   that would clash without a space, the cutoff must be (in order):
-//
-//		/*	6
-//		&&	6
-//		&^	6
-//		++	5
-//		--	5
-//
-//         (Comparison operators always have spaces around them.)
-//
-//	2) If there is a mix of level 5 and level 4 operators, then the cutoff
-//	   is 5 (use spaces to distinguish precedence) in Normal mode
-//	   and 4 (never use spaces) in Compact mode.
-//
-//	3) If there are no level 4 operators or no level 5 operators, then the
-//	   cutoff is 6 (always use spaces) in Normal mode
-//	   and 4 (never use spaces) in Compact mode.
-//
-func (p *printer) binaryExpr(x *ast.BinaryExpr, prec1, cutoff, depth int) {
-	prec := x.Op.Precedence()
-	if prec < prec1 {
-		// parenthesis needed
-		// Note: The parser inserts an ast.ParenExpr node; thus this case
-		//       can only occur if the AST is created in a different way.
-		p.print(token.LPAREN)
-		p.expr0(x, reduceDepth(depth)) // parentheses undo one level of depth
-		p.print(token.RPAREN)
-		return
-	}
-
-	printBlank := prec < cutoff
-
-	ws := indent
-	p.expr1(x.X, prec, depth+diffPrec(x.X, prec))
-	if printBlank {
-		p.print(blank)
-	}
-	xline := p.pos.Line // before the operator (it may be on the next line!)
-	yline := p.lineFor(x.Y.Pos())
-	p.print(x.OpPos, x.Op)
-	if xline != yline && xline > 0 && yline > 0 {
-		// at least one line break, but respect an extra empty line
-		// in the source
-		if p.linebreak(yline, 1, ws, true) {
-			ws = ignore
-			printBlank = false // no blank after line break
-		}
-	}
-	if printBlank {
-		p.print(blank)
-	}
-	p.expr1(x.Y, prec+1, depth+1)
-	if ws == ignore {
-		p.print(unindent)
-	}
-}
-
-func isBinary(expr ast.Expr) bool {
-	_, ok := expr.(*ast.BinaryExpr)
-	return ok
-}
-
-func (p *printer) expr1(expr ast.Expr, prec1, depth int) {
-	p.print(expr.Pos())
-
-	switch x := expr.(type) {
-	case *ast.BadExpr:
-		p.print("BadExpr")
-
-	case *ast.Ident:
-		p.print(x)
-
-	case *ast.BinaryExpr:
-		if depth < 1 {
-			p.internalError("depth < 1:", depth)
-			depth = 1
-		}
-		p.binaryExpr(x, prec1, cutoff(x, depth), depth)
-
-	case *ast.KeyValueExpr:
-		p.expr(x.Key)
-		p.print(x.Colon, token.COLON, blank)
-		p.expr(x.Value)
-
-	case *ast.StarExpr:
-		const prec = token.UnaryPrec
-		if prec < prec1 {
-			// parenthesis needed
-			p.print(token.LPAREN)
-			p.print(token.MUL)
-			p.expr(x.X)
-			p.print(token.RPAREN)
-		} else {
-			// no parenthesis needed
-			p.print(token.MUL)
-			p.expr(x.X)
-		}
-
-	case *ast.UnaryExpr:
-		const prec = token.UnaryPrec
-		if prec < prec1 {
-			// parenthesis needed
-			p.print(token.LPAREN)
-			p.expr(x)
-			p.print(token.RPAREN)
-		} else {
-			// no parenthesis needed
-			p.print(x.Op)
-			if x.Op == token.RANGE {
-				// TODO(gri) Remove this code if it cannot be reached.
-				p.print(blank)
-			}
-			p.expr1(x.X, prec, depth)
-		}
-
-	case *ast.BasicLit:
-		p.print(x)
-
-	case *ast.FuncLit:
-		p.expr(x.Type)
-		p.adjBlock(p.distanceFrom(x.Type.Pos()), blank, x.Body)
-
-	case *ast.ParenExpr:
-		if _, hasParens := x.X.(*ast.ParenExpr); hasParens {
-			// don't print parentheses around an already parenthesized expression
-			// TODO(gri) consider making this more general and incorporate precedence levels
-			p.expr0(x.X, depth)
-		} else {
-			p.print(token.LPAREN)
-			p.expr0(x.X, reduceDepth(depth)) // parentheses undo one level of depth
-			p.print(x.Rparen, token.RPAREN)
-		}
-
-	case *ast.SelectorExpr:
-		p.expr1(x.X, token.HighestPrec, depth)
-		p.print(token.PERIOD)
-		if line := p.lineFor(x.Sel.Pos()); p.pos.IsValid() && p.pos.Line < line {
-			p.print(indent, newline, x.Sel.Pos(), x.Sel, unindent)
-		} else {
-			p.print(x.Sel.Pos(), x.Sel)
-		}
-
-	case *ast.TypeAssertExpr:
-		p.expr1(x.X, token.HighestPrec, depth)
-		p.print(token.PERIOD, x.Lparen, token.LPAREN)
-		if x.Type != nil {
-			p.expr(x.Type)
-		} else {
-			p.print(token.TYPE)
-		}
-		p.print(x.Rparen, token.RPAREN)
-
-	case *ast.IndexExpr:
-		// TODO(gri): should treat[] like parentheses and undo one level of depth
-		p.expr1(x.X, token.HighestPrec, 1)
-		p.print(x.Lbrack, token.LBRACK)
-		p.expr0(x.Index, depth+1)
-		p.print(x.Rbrack, token.RBRACK)
-
-	case *ast.SliceExpr:
-		// TODO(gri): should treat[] like parentheses and undo one level of depth
-		p.expr1(x.X, token.HighestPrec, 1)
-		p.print(x.Lbrack, token.LBRACK)
-		indices := []ast.Expr{x.Low, x.High}
-		if x.Max != nil {
-			indices = append(indices, x.Max)
-		}
-		for i, y := range indices {
-			if i > 0 {
-				// blanks around ":" if both sides exist and either side is a binary expression
-				// TODO(gri) once we have committed a variant of a[i:j:k] we may want to fine-
-				//           tune the formatting here
-				x := indices[i-1]
-				if depth <= 1 && x != nil && y != nil && (isBinary(x) || isBinary(y)) {
-					p.print(blank, token.COLON, blank)
-				} else {
-					p.print(token.COLON)
-				}
-			}
-			if y != nil {
-				p.expr0(y, depth+1)
-			}
-		}
-		p.print(x.Rbrack, token.RBRACK)
-
-	case *ast.CallExpr:
-		if len(x.Args) > 1 {
-			depth++
-		}
-		if _, ok := x.Fun.(*ast.FuncType); ok {
-			// conversions to literal function types require parentheses around the type
-			p.print(token.LPAREN)
-			p.expr1(x.Fun, token.HighestPrec, depth)
-			p.print(token.RPAREN)
-		} else {
-			p.expr1(x.Fun, token.HighestPrec, depth)
-		}
-		p.print(x.Lparen, token.LPAREN)
-		if x.Ellipsis.IsValid() {
-			p.exprList(x.Lparen, x.Args, depth, 0, x.Ellipsis)
-			p.print(x.Ellipsis, token.ELLIPSIS)
-			if x.Rparen.IsValid() && p.lineFor(x.Ellipsis) < p.lineFor(x.Rparen) {
-				p.print(token.COMMA, formfeed)
-			}
-		} else {
-			p.exprList(x.Lparen, x.Args, depth, commaTerm, x.Rparen)
-		}
-		p.print(x.Rparen, token.RPAREN)
-
-	case *ast.CompositeLit:
-		// composite literal elements that are composite literals themselves may have the type omitted
-		if x.Type != nil {
-			p.expr1(x.Type, token.HighestPrec, depth)
-		}
-		p.print(x.Lbrace, token.LBRACE)
-		p.exprList(x.Lbrace, x.Elts, 1, commaTerm, x.Rbrace)
-		// do not insert extra line break following a /*-style comment
-		// before the closing '}' as it might break the code if there
-		// is no trailing ','
-		mode := noExtraLinebreak
-		// do not insert extra blank following a /*-style comment
-		// before the closing '}' unless the literal is empty
-		if len(x.Elts) > 0 {
-			mode |= noExtraBlank
-		}
-		p.print(mode, x.Rbrace, token.RBRACE, mode)
-
-	case *ast.Ellipsis:
-		p.print(token.ELLIPSIS)
-		if x.Elt != nil {
-			p.expr(x.Elt)
-		}
-
-	case *ast.ArrayType:
-		p.print(token.LBRACK)
-		if x.Len != nil {
-			p.expr(x.Len)
-		}
-		p.print(token.RBRACK)
-		p.expr(x.Elt)
-
-	case *ast.StructType:
-		p.print(token.STRUCT)
-		p.fieldList(x.Fields, true, x.Incomplete)
-
-	case *ast.FuncType:
-		p.print(token.FUNC)
-		p.signature(x.Params, x.Results)
-
-	case *ast.InterfaceType:
-		p.print(token.INTERFACE)
-		p.fieldList(x.Methods, false, x.Incomplete)
-
-	case *ast.MapType:
-		p.print(token.MAP, token.LBRACK)
-		p.expr(x.Key)
-		p.print(token.RBRACK)
-		p.expr(x.Value)
-
-	case *ast.ChanType:
-		switch x.Dir {
-		case ast.SEND | ast.RECV:
-			p.print(token.CHAN)
-		case ast.RECV:
-			p.print(token.ARROW, token.CHAN) // x.Arrow and x.Pos() are the same
-		case ast.SEND:
-			p.print(token.CHAN, x.Arrow, token.ARROW)
-		}
-		p.print(blank)
-		p.expr(x.Value)
-
-	default:
-		panic("unreachable")
-	}
-
-	return
-}
-
-func (p *printer) expr0(x ast.Expr, depth int) {
-	p.expr1(x, token.LowestPrec, depth)
-}
-
-func (p *printer) expr(x ast.Expr) {
-	const depth = 1
-	p.expr1(x, token.LowestPrec, depth)
-}
-
-// ----------------------------------------------------------------------------
-// Statements
-
-// Print the statement list indented, but without a newline after the last statement.
-// Extra line breaks between statements in the source are respected but at most one
-// empty line is printed between statements.
-func (p *printer) stmtList(list []ast.Stmt, nindent int, nextIsRBrace bool) {
-	if nindent > 0 {
-		p.print(indent)
-	}
-	var line int
-	i := 0
-	for _, s := range list {
-		// ignore empty statements (was issue 3466)
-		if _, isEmpty := s.(*ast.EmptyStmt); !isEmpty {
-			// nindent == 0 only for lists of switch/select case clauses;
-			// in those cases each clause is a new section
-			if len(p.output) > 0 {
-				// only print line break if we are not at the beginning of the output
-				// (i.e., we are not printing only a partial program)
-				p.linebreak(p.lineFor(s.Pos()), 1, ignore, i == 0 || nindent == 0 || p.linesFrom(line) > 0)
-			}
-			p.recordLine(&line)
-			p.stmt(s, nextIsRBrace && i == len(list)-1)
-			// labeled statements put labels on a separate line, but here
-			// we only care about the start line of the actual statement
-			// without label - correct line for each label
-			for t := s; ; {
-				lt, _ := t.(*ast.LabeledStmt)
-				if lt == nil {
-					break
-				}
-				line++
-				t = lt.Stmt
-			}
-			i++
-		}
-	}
-	if nindent > 0 {
-		p.print(unindent)
-	}
-}
-
-// block prints an *ast.BlockStmt; it always spans at least two lines.
-func (p *printer) block(b *ast.BlockStmt, nindent int) {
-	p.print(b.Lbrace, token.LBRACE)
-	p.stmtList(b.List, nindent, true)
-	p.linebreak(p.lineFor(b.Rbrace), 1, ignore, true)
-	p.print(b.Rbrace, token.RBRACE)
-}
-
-func isTypeName(x ast.Expr) bool {
-	switch t := x.(type) {
-	case *ast.Ident:
-		return true
-	case *ast.SelectorExpr:
-		return isTypeName(t.X)
-	}
-	return false
-}
-
-func stripParens(x ast.Expr) ast.Expr {
-	if px, strip := x.(*ast.ParenExpr); strip {
-		// parentheses must not be stripped if there are any
-		// unparenthesized composite literals starting with
-		// a type name
-		ast.Inspect(px.X, func(node ast.Node) bool {
-			switch x := node.(type) {
-			case *ast.ParenExpr:
-				// parentheses protect enclosed composite literals
-				return false
-			case *ast.CompositeLit:
-				if isTypeName(x.Type) {
-					strip = false // do not strip parentheses
-				}
-				return false
-			}
-			// in all other cases, keep inspecting
-			return true
-		})
-		if strip {
-			return stripParens(px.X)
-		}
-	}
-	return x
-}
-
-func stripParensAlways(x ast.Expr) ast.Expr {
-	if x, ok := x.(*ast.ParenExpr); ok {
-		return stripParensAlways(x.X)
-	}
-	return x
-}
-
-func (p *printer) controlClause(isForStmt bool, init ast.Stmt, expr ast.Expr, post ast.Stmt) {
-	p.print(blank)
-	needsBlank := false
-	if init == nil && post == nil {
-		// no semicolons required
-		if expr != nil {
-			p.expr(stripParens(expr))
-			needsBlank = true
-		}
-	} else {
-		// all semicolons required
-		// (they are not separators, print them explicitly)
-		if init != nil {
-			p.stmt(init, false)
-		}
-		p.print(token.SEMICOLON, blank)
-		if expr != nil {
-			p.expr(stripParens(expr))
-			needsBlank = true
-		}
-		if isForStmt {
-			p.print(token.SEMICOLON, blank)
-			needsBlank = false
-			if post != nil {
-				p.stmt(post, false)
-				needsBlank = true
-			}
-		}
-	}
-	if needsBlank {
-		p.print(blank)
-	}
-}
-
-// indentList reports whether an expression list would look better if it
-// were indented wholesale (starting with the very first element, rather
-// than starting at the first line break).
-//
-func (p *printer) indentList(list []ast.Expr) bool {
-	// Heuristic: indentList returns true if there are more than one multi-
-	// line element in the list, or if there is any element that is not
-	// starting on the same line as the previous one ends.
-	if len(list) >= 2 {
-		var b = p.lineFor(list[0].Pos())
-		var e = p.lineFor(list[len(list)-1].End())
-		if 0 < b && b < e {
-			// list spans multiple lines
-			n := 0 // multi-line element count
-			line := b
-			for _, x := range list {
-				xb := p.lineFor(x.Pos())
-				xe := p.lineFor(x.End())
-				if line < xb {
-					// x is not starting on the same
-					// line as the previous one ended
-					return true
-				}
-				if xb < xe {
-					// x is a multi-line element
-					n++
-				}
-				line = xe
-			}
-			return n > 1
-		}
-	}
-	return false
-}
-
-func (p *printer) stmt(stmt ast.Stmt, nextIsRBrace bool) {
-	p.print(stmt.Pos())
-
-	switch s := stmt.(type) {
-	case *ast.BadStmt:
-		p.print("BadStmt")
-
-	case *ast.DeclStmt:
-		p.decl(s.Decl)
-
-	case *ast.EmptyStmt:
-		// nothing to do
-
-	case *ast.LabeledStmt:
-		// a "correcting" unindent immediately following a line break
-		// is applied before the line break if there is no comment
-		// between (see writeWhitespace)
-		p.print(unindent)
-		p.expr(s.Label)
-		p.print(s.Colon, token.COLON, indent)
-		if e, isEmpty := s.Stmt.(*ast.EmptyStmt); isEmpty {
-			if !nextIsRBrace {
-				p.print(newline, e.Pos(), token.SEMICOLON)
-				break
-			}
-		} else {
-			p.linebreak(p.lineFor(s.Stmt.Pos()), 1, ignore, true)
-		}
-		p.stmt(s.Stmt, nextIsRBrace)
-
-	case *ast.ExprStmt:
-		const depth = 1
-		p.expr0(s.X, depth)
-
-	case *ast.SendStmt:
-		const depth = 1
-		p.expr0(s.Chan, depth)
-		p.print(blank, s.Arrow, token.ARROW, blank)
-		p.expr0(s.Value, depth)
-
-	case *ast.IncDecStmt:
-		const depth = 1
-		p.expr0(s.X, depth+1)
-		p.print(s.TokPos, s.Tok)
-
-	case *ast.AssignStmt:
-		var depth = 1
-		if len(s.Lhs) > 1 && len(s.Rhs) > 1 {
-			depth++
-		}
-		p.exprList(s.Pos(), s.Lhs, depth, 0, s.TokPos)
-		p.print(blank, s.TokPos, s.Tok, blank)
-		p.exprList(s.TokPos, s.Rhs, depth, 0, token.NoPos)
-
-	case *ast.GoStmt:
-		p.print(token.GO, blank)
-		p.expr(s.Call)
-
-	case *ast.DeferStmt:
-		p.print(token.DEFER, blank)
-		p.expr(s.Call)
-
-	case *ast.ReturnStmt:
-		p.print(token.RETURN)
-		if s.Results != nil {
-			p.print(blank)
-			// Use indentList heuristic to make corner cases look
-			// better (issue 1207). A more systematic approach would
-			// always indent, but this would cause significant
-			// reformatting of the code base and not necessarily
-			// lead to more nicely formatted code in general.
-			if p.indentList(s.Results) {
-				p.print(indent)
-				p.exprList(s.Pos(), s.Results, 1, noIndent, token.NoPos)
-				p.print(unindent)
-			} else {
-				p.exprList(s.Pos(), s.Results, 1, 0, token.NoPos)
-			}
-		}
-
-	case *ast.BranchStmt:
-		p.print(s.Tok)
-		if s.Label != nil {
-			p.print(blank)
-			p.expr(s.Label)
-		}
-
-	case *ast.BlockStmt:
-		p.block(s, 1)
-
-	case *ast.IfStmt:
-		p.print(token.IF)
-		p.controlClause(false, s.Init, s.Cond, nil)
-		p.block(s.Body, 1)
-		if s.Else != nil {
-			p.print(blank, token.ELSE, blank)
-			switch s.Else.(type) {
-			case *ast.BlockStmt, *ast.IfStmt:
-				p.stmt(s.Else, nextIsRBrace)
-			default:
-				p.print(token.LBRACE, indent, formfeed)
-				p.stmt(s.Else, true)
-				p.print(unindent, formfeed, token.RBRACE)
-			}
-		}
-
-	case *ast.CaseClause:
-		if s.List != nil {
-			p.print(token.CASE, blank)
-			p.exprList(s.Pos(), s.List, 1, 0, s.Colon)
-		} else {
-			p.print(token.DEFAULT)
-		}
-		p.print(s.Colon, token.COLON)
-		p.stmtList(s.Body, 1, nextIsRBrace)
-
-	case *ast.SwitchStmt:
-		p.print(token.SWITCH)
-		p.controlClause(false, s.Init, s.Tag, nil)
-		p.block(s.Body, 0)
-
-	case *ast.TypeSwitchStmt:
-		p.print(token.SWITCH)
-		if s.Init != nil {
-			p.print(blank)
-			p.stmt(s.Init, false)
-			p.print(token.SEMICOLON)
-		}
-		p.print(blank)
-		p.stmt(s.Assign, false)
-		p.print(blank)
-		p.block(s.Body, 0)
-
-	case *ast.CommClause:
-		if s.Comm != nil {
-			p.print(token.CASE, blank)
-			p.stmt(s.Comm, false)
-		} else {
-			p.print(token.DEFAULT)
-		}
-		p.print(s.Colon, token.COLON)
-		p.stmtList(s.Body, 1, nextIsRBrace)
-
-	case *ast.SelectStmt:
-		p.print(token.SELECT, blank)
-		body := s.Body
-		if len(body.List) == 0 && !p.commentBefore(p.posFor(body.Rbrace)) {
-			// print empty select statement w/o comments on one line
-			p.print(body.Lbrace, token.LBRACE, body.Rbrace, token.RBRACE)
-		} else {
-			p.block(body, 0)
-		}
-
-	case *ast.ForStmt:
-		p.print(token.FOR)
-		p.controlClause(true, s.Init, s.Cond, s.Post)
-		p.block(s.Body, 1)
-
-	case *ast.RangeStmt:
-		p.print(token.FOR, blank)
-		if s.Key != nil {
-			p.expr(s.Key)
-			if s.Value != nil {
-				// use position of value following the comma as
-				// comma position for correct comment placement
-				p.print(s.Value.Pos(), token.COMMA, blank)
-				p.expr(s.Value)
-			}
-			p.print(blank, s.TokPos, s.Tok, blank)
-		}
-		p.print(token.RANGE, blank)
-		p.expr(stripParens(s.X))
-		p.print(blank)
-		p.block(s.Body, 1)
-
-	default:
-		panic("unreachable")
-	}
-
-	return
-}
-
-// ----------------------------------------------------------------------------
-// Declarations
-
-// The keepTypeColumn function determines if the type column of a series of
-// consecutive const or var declarations must be kept, or if initialization
-// values (V) can be placed in the type column (T) instead. The i'th entry
-// in the result slice is true if the type column in spec[i] must be kept.
-//
-// For example, the declaration:
-//
-//	const (
-//		foobar int = 42 // comment
-//		x          = 7  // comment
-//		foo
-//              bar = 991
-//	)
-//
-// leads to the type/values matrix below. A run of value columns (V) can
-// be moved into the type column if there is no type for any of the values
-// in that column (we only move entire columns so that they align properly).
-//
-//	matrix        formatted     result
-//                    matrix
-//	T  V    ->    T  V     ->   true      there is a T and so the type
-//	-  V          -  V          true      column must be kept
-//	-  -          -  -          false
-//	-  V          V  -          false     V is moved into T column
-//
-func keepTypeColumn(specs []ast.Spec) []bool {
-	m := make([]bool, len(specs))
-
-	populate := func(i, j int, keepType bool) {
-		if keepType {
-			for ; i < j; i++ {
-				m[i] = true
-			}
-		}
-	}
-
-	i0 := -1 // if i0 >= 0 we are in a run and i0 is the start of the run
-	var keepType bool
-	for i, s := range specs {
-		t := s.(*ast.ValueSpec)
-		if t.Values != nil {
-			if i0 < 0 {
-				// start of a run of ValueSpecs with non-nil Values
-				i0 = i
-				keepType = false
-			}
-		} else {
-			if i0 >= 0 {
-				// end of a run
-				populate(i0, i, keepType)
-				i0 = -1
-			}
-		}
-		if t.Type != nil {
-			keepType = true
-		}
-	}
-	if i0 >= 0 {
-		// end of a run
-		populate(i0, len(specs), keepType)
-	}
-
-	return m
-}
-
-func (p *printer) valueSpec(s *ast.ValueSpec, keepType bool) {
-	p.setComment(s.Doc)
-	p.identList(s.Names, false) // always present
-	extraTabs := 3
-	if s.Type != nil || keepType {
-		p.print(vtab)
-		extraTabs--
-	}
-	if s.Type != nil {
-		p.expr(s.Type)
-	}
-	if s.Values != nil {
-		p.print(vtab, token.ASSIGN, blank)
-		p.exprList(token.NoPos, s.Values, 1, 0, token.NoPos)
-		extraTabs--
-	}
-	if s.Comment != nil {
-		for ; extraTabs > 0; extraTabs-- {
-			p.print(vtab)
-		}
-		p.setComment(s.Comment)
-	}
-}
-
-func sanitizeImportPath(lit *ast.BasicLit) *ast.BasicLit {
-	// Note: An unmodified AST generated by go/parser will already
-	// contain a backward- or double-quoted path string that does
-	// not contain any invalid characters, and most of the work
-	// here is not needed. However, a modified or generated AST
-	// may possibly contain non-canonical paths. Do the work in
-	// all cases since it's not too hard and not speed-critical.
-
-	// if we don't have a proper string, be conservative and return whatever we have
-	if lit.Kind != token.STRING {
-		return lit
-	}
-	s, err := strconv.Unquote(lit.Value)
-	if err != nil {
-		return lit
-	}
-
-	// if the string is an invalid path, return whatever we have
-	//
-	// spec: "Implementation restriction: A compiler may restrict
-	// ImportPaths to non-empty strings using only characters belonging
-	// to Unicode's L, M, N, P, and S general categories (the Graphic
-	// characters without spaces) and may also exclude the characters
-	// !"#$%&'()*,:;<=>?[\]^`{|} and the Unicode replacement character
-	// U+FFFD."
-	if s == "" {
-		return lit
-	}
-	const illegalChars = `!"#$%&'()*,:;<=>?[\]^{|}` + "`\uFFFD"
-	for _, r := range s {
-		if !unicode.IsGraphic(r) || unicode.IsSpace(r) || strings.ContainsRune(illegalChars, r) {
-			return lit
-		}
-	}
-
-	// otherwise, return the double-quoted path
-	s = strconv.Quote(s)
-	if s == lit.Value {
-		return lit // nothing wrong with lit
-	}
-	return &ast.BasicLit{ValuePos: lit.ValuePos, Kind: token.STRING, Value: s}
-}
-
-// The parameter n is the number of specs in the group. If doIndent is set,
-// multi-line identifier lists in the spec are indented when the first
-// linebreak is encountered.
-//
-func (p *printer) spec(spec ast.Spec, n int, doIndent bool) {
-	switch s := spec.(type) {
-	case *ast.ImportSpec:
-		p.setComment(s.Doc)
-		if s.Name != nil {
-			p.expr(s.Name)
-			p.print(blank)
-		}
-		p.expr(sanitizeImportPath(s.Path))
-		p.setComment(s.Comment)
-		p.print(s.EndPos)
-
-	case *ast.ValueSpec:
-		if n != 1 {
-			p.internalError("expected n = 1; got", n)
-		}
-		p.setComment(s.Doc)
-		p.identList(s.Names, doIndent) // always present
-		if s.Type != nil {
-			p.print(blank)
-			p.expr(s.Type)
-		}
-		if s.Values != nil {
-			p.print(blank, token.ASSIGN, blank)
-			p.exprList(token.NoPos, s.Values, 1, 0, token.NoPos)
-		}
-		p.setComment(s.Comment)
-
-	case *ast.TypeSpec:
-		p.setComment(s.Doc)
-		p.expr(s.Name)
-		if n == 1 {
-			p.print(blank)
-		} else {
-			p.print(vtab)
-		}
-		p.expr(s.Type)
-		p.setComment(s.Comment)
-
-	default:
-		panic("unreachable")
-	}
-}
-
-func (p *printer) genDecl(d *ast.GenDecl) {
-	p.setComment(d.Doc)
-	p.print(d.Pos(), d.Tok, blank)
-
-	if d.Lparen.IsValid() {
-		// group of parenthesized declarations
-		p.print(d.Lparen, token.LPAREN)
-		if n := len(d.Specs); n > 0 {
-			p.print(indent, formfeed)
-			if n > 1 && (d.Tok == token.CONST || d.Tok == token.VAR) {
-				// two or more grouped const/var declarations:
-				// determine if the type column must be kept
-				keepType := keepTypeColumn(d.Specs)
-				var line int
-				for i, s := range d.Specs {
-					if i > 0 {
-						p.linebreak(p.lineFor(s.Pos()), 1, ignore, p.linesFrom(line) > 0)
-					}
-					p.recordLine(&line)
-					p.valueSpec(s.(*ast.ValueSpec), keepType[i])
-				}
-			} else {
-				var line int
-				for i, s := range d.Specs {
-					if i > 0 {
-						p.linebreak(p.lineFor(s.Pos()), 1, ignore, p.linesFrom(line) > 0)
-					}
-					p.recordLine(&line)
-					p.spec(s, n, false)
-				}
-			}
-			p.print(unindent, formfeed)
-		}
-		p.print(d.Rparen, token.RPAREN)
-
-	} else {
-		// single declaration
-		p.spec(d.Specs[0], 1, true)
-	}
-}
-
-// nodeSize determines the size of n in chars after formatting.
-// The result is <= maxSize if the node fits on one line with at
-// most maxSize chars and the formatted output doesn't contain
-// any control chars. Otherwise, the result is > maxSize.
-//
-func (p *printer) nodeSize(n ast.Node, maxSize int) (size int) {
-	// nodeSize invokes the printer, which may invoke nodeSize
-	// recursively. For deep composite literal nests, this can
-	// lead to an exponential algorithm. Remember previous
-	// results to prune the recursion (was issue 1628).
-	if size, found := p.nodeSizes[n]; found {
-		return size
-	}
-
-	size = maxSize + 1 // assume n doesn't fit
-	p.nodeSizes[n] = size
-
-	// nodeSize computation must be independent of particular
-	// style so that we always get the same decision; print
-	// in RawFormat
-	cfg := Config{Mode: RawFormat}
-	var buf bytes.Buffer
-	if err := cfg.fprint(&buf, p.fset, n, p.nodeSizes); err != nil {
-		return
-	}
-	if buf.Len() <= maxSize {
-		for _, ch := range buf.Bytes() {
-			if ch < ' ' {
-				return
-			}
-		}
-		size = buf.Len() // n fits
-		p.nodeSizes[n] = size
-	}
-	return
-}
-
-// bodySize is like nodeSize but it is specialized for *ast.BlockStmt's.
-func (p *printer) bodySize(b *ast.BlockStmt, maxSize int) int {
-	pos1 := b.Pos()
-	pos2 := b.Rbrace
-	if pos1.IsValid() && pos2.IsValid() && p.lineFor(pos1) != p.lineFor(pos2) {
-		// opening and closing brace are on different lines - don't make it a one-liner
-		return maxSize + 1
-	}
-	if len(b.List) > 5 {
-		// too many statements - don't make it a one-liner
-		return maxSize + 1
-	}
-	// otherwise, estimate body size
-	bodySize := p.commentSizeBefore(p.posFor(pos2))
-	for i, s := range b.List {
-		if bodySize > maxSize {
-			break // no need to continue
-		}
-		if i > 0 {
-			bodySize += 2 // space for a semicolon and blank
-		}
-		bodySize += p.nodeSize(s, maxSize)
-	}
-	return bodySize
-}
-
-// adjBlock prints an "adjacent" block (e.g., a for-loop or function body) following
-// a header (e.g., a for-loop control clause or function signature) of given headerSize.
-// If the header's and block's size are "small enough" and the block is "simple enough",
-// the block is printed on the current line, without line breaks, spaced from the header
-// by sep. Otherwise the block's opening "{" is printed on the current line, followed by
-// lines for the block's statements and its closing "}".
-//
-func (p *printer) adjBlock(headerSize int, sep whiteSpace, b *ast.BlockStmt) {
-	if b == nil {
-		return
-	}
-
-	const maxSize = 100
-	if headerSize+p.bodySize(b, maxSize) <= maxSize {
-		p.print(sep, b.Lbrace, token.LBRACE)
-		if len(b.List) > 0 {
-			p.print(blank)
-			for i, s := range b.List {
-				if i > 0 {
-					p.print(token.SEMICOLON, blank)
-				}
-				p.stmt(s, i == len(b.List)-1)
-			}
-			p.print(blank)
-		}
-		p.print(noExtraLinebreak, b.Rbrace, token.RBRACE, noExtraLinebreak)
-		return
-	}
-
-	if sep != ignore {
-		p.print(blank) // always use blank
-	}
-	p.block(b, 1)
-}
-
-// distanceFrom returns the column difference between from and p.pos (the current
-// estimated position) if both are on the same line; if they are on different lines
-// (or unknown) the result is infinity.
-func (p *printer) distanceFrom(from token.Pos) int {
-	if from.IsValid() && p.pos.IsValid() {
-		if f := p.posFor(from); f.Line == p.pos.Line {
-			return p.pos.Column - f.Column
-		}
-	}
-	return infinity
-}
-
-func (p *printer) funcDecl(d *ast.FuncDecl) {
-	p.setComment(d.Doc)
-	p.print(d.Pos(), token.FUNC, blank)
-	if d.Recv != nil {
-		p.parameters(d.Recv) // method: print receiver
-		p.print(blank)
-	}
-	p.expr(d.Name)
-	p.signature(d.Type.Params, d.Type.Results)
-	p.adjBlock(p.distanceFrom(d.Pos()), vtab, d.Body)
-}
-
-func (p *printer) decl(decl ast.Decl) {
-	switch d := decl.(type) {
-	case *ast.BadDecl:
-		p.print(d.Pos(), "BadDecl")
-	case *ast.GenDecl:
-		p.genDecl(d)
-	case *ast.FuncDecl:
-		p.funcDecl(d)
-	default:
-		panic("unreachable")
-	}
-}
-
-// ----------------------------------------------------------------------------
-// Files
-
-func declToken(decl ast.Decl) (tok token.Token) {
-	tok = token.ILLEGAL
-	switch d := decl.(type) {
-	case *ast.GenDecl:
-		tok = d.Tok
-	case *ast.FuncDecl:
-		tok = token.FUNC
-	}
-	return
-}
-
-func (p *printer) declList(list []ast.Decl) {
-	tok := token.ILLEGAL
-	for _, d := range list {
-		prev := tok
-		tok = declToken(d)
-		// If the declaration token changed (e.g., from CONST to TYPE)
-		// or the next declaration has documentation associated with it,
-		// print an empty line between top-level declarations.
-		// (because p.linebreak is called with the position of d, which
-		// is past any documentation, the minimum requirement is satisfied
-		// even w/o the extra getDoc(d) nil-check - leave it in case the
-		// linebreak logic improves - there's already a TODO).
-		if len(p.output) > 0 {
-			// only print line break if we are not at the beginning of the output
-			// (i.e., we are not printing only a partial program)
-			min := 1
-			if prev != tok || getDoc(d) != nil {
-				min = 2
-			}
-			p.linebreak(p.lineFor(d.Pos()), min, ignore, false)
-		}
-		p.decl(d)
-	}
-}
-
-func (p *printer) file(src *ast.File) {
-	p.setComment(src.Doc)
-	p.print(src.Pos(), token.PACKAGE, blank)
-	p.expr(src.Name)
-	p.declList(src.Decls)
-	p.print(newline)
-}
diff --git a/third_party/golang/go/printer/performance_test.go b/third_party/golang/go/printer/performance_test.go
deleted file mode 100644
index 4db70cd8c8fb7..0000000000000
--- a/third_party/golang/go/printer/performance_test.go
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements a simple printer performance benchmark:
-// go test -bench=BenchmarkPrint
-
-package printer
-
-import (
-	"bytes"
-	"io"
-	"io/ioutil"
-
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"k8s.io/kubernetes/third_party/golang/go/parser"
-	"log"
-	"testing"
-)
-
-var testfile *ast.File
-
-func testprint(out io.Writer, file *ast.File) {
-	if err := (&Config{TabIndent | UseSpaces, 8, 0}).Fprint(out, fset, file); err != nil {
-		log.Fatalf("print error: %s", err)
-	}
-}
-
-// cannot initialize in init because (printer) Fprint launches goroutines.
-func initialize() {
-	const filename = "testdata/parser.go"
-
-	src, err := ioutil.ReadFile(filename)
-	if err != nil {
-		log.Fatalf("%s", err)
-	}
-
-	file, err := parser.ParseFile(fset, filename, src, parser.ParseComments)
-	if err != nil {
-		log.Fatalf("%s", err)
-	}
-
-	var buf bytes.Buffer
-	testprint(&buf, file)
-	if !bytes.Equal(buf.Bytes(), src) {
-		log.Fatalf("print error: %s not idempotent", filename)
-	}
-
-	testfile = file
-}
-
-func BenchmarkPrint(b *testing.B) {
-	if testfile == nil {
-		initialize()
-	}
-	for i := 0; i < b.N; i++ {
-		testprint(ioutil.Discard, testfile)
-	}
-}
diff --git a/third_party/golang/go/printer/printer.go b/third_party/golang/go/printer/printer.go
deleted file mode 100644
index 1fa244f28430d..0000000000000
--- a/third_party/golang/go/printer/printer.go
+++ /dev/null
@@ -1,1297 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package printer implements printing of AST nodes.
-package printer
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"strconv"
-	"strings"
-	"text/tabwriter"
-	"unicode"
-
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-)
-
-const (
-	maxNewlines = 2     // max. number of newlines between source text
-	debug       = false // enable for debugging
-	infinity    = 1 << 30
-)
-
-type whiteSpace byte
-
-const (
-	ignore   = whiteSpace(0)
-	blank    = whiteSpace(' ')
-	vtab     = whiteSpace('\v')
-	newline  = whiteSpace('\n')
-	formfeed = whiteSpace('\f')
-	indent   = whiteSpace('>')
-	unindent = whiteSpace('<')
-)
-
-// A pmode value represents the current printer mode.
-type pmode int
-
-const (
-	noExtraBlank     pmode = 1 << iota // disables extra blank after /*-style comment
-	noExtraLinebreak                   // disables extra line break after /*-style comment
-)
-
-type commentInfo struct {
-	cindex         int               // current comment index
-	comment        *ast.CommentGroup // = printer.comments[cindex]; or nil
-	commentOffset  int               // = printer.posFor(printer.comments[cindex].List[0].Pos()).Offset; or infinity
-	commentNewline bool              // true if the comment group contains newlines
-}
-
-type printer struct {
-	// Configuration (does not change after initialization)
-	Config
-	fset *token.FileSet
-
-	// Current state
-	output      []byte       // raw printer result
-	indent      int          // current indentation
-	mode        pmode        // current printer mode
-	impliedSemi bool         // if set, a linebreak implies a semicolon
-	lastTok     token.Token  // last token printed (token.ILLEGAL if it's whitespace)
-	prevOpen    token.Token  // previous non-brace "open" token (, [, or token.ILLEGAL
-	wsbuf       []whiteSpace // delayed white space
-
-	// Positions
-	// The out position differs from the pos position when the result
-	// formatting differs from the source formatting (in the amount of
-	// white space). If there's a difference and SourcePos is set in
-	// ConfigMode, //line comments are used in the output to restore
-	// original source positions for a reader.
-	pos     token.Position // current position in AST (source) space
-	out     token.Position // current position in output space
-	last    token.Position // value of pos after calling writeString
-	linePtr *int           // if set, record out.Line for the next token in *linePtr
-
-	// The list of all source comments, in order of appearance.
-	comments        []*ast.CommentGroup // may be nil
-	useNodeComments bool                // if not set, ignore lead and line comments of nodes
-
-	// Information about p.comments[p.cindex]; set up by nextComment.
-	commentInfo
-
-	// Cache of already computed node sizes.
-	nodeSizes map[ast.Node]int
-
-	// Cache of most recently computed line position.
-	cachedPos  token.Pos
-	cachedLine int // line corresponding to cachedPos
-}
-
-func (p *printer) init(cfg *Config, fset *token.FileSet, nodeSizes map[ast.Node]int) {
-	p.Config = *cfg
-	p.fset = fset
-	p.pos = token.Position{Line: 1, Column: 1}
-	p.out = token.Position{Line: 1, Column: 1}
-	p.wsbuf = make([]whiteSpace, 0, 16) // whitespace sequences are short
-	p.nodeSizes = nodeSizes
-	p.cachedPos = -1
-}
-
-func (p *printer) internalError(msg ...interface{}) {
-	if debug {
-		fmt.Print(p.pos.String() + ": ")
-		fmt.Println(msg...)
-		panic("go/printer")
-	}
-}
-
-// commentsHaveNewline reports whether a list of comments belonging to
-// an *ast.CommentGroup contains newlines. Because the position information
-// may only be partially correct, we also have to read the comment text.
-func (p *printer) commentsHaveNewline(list []*ast.Comment) bool {
-	// len(list) > 0
-	line := p.lineFor(list[0].Pos())
-	for i, c := range list {
-		if i > 0 && p.lineFor(list[i].Pos()) != line {
-			// not all comments on the same line
-			return true
-		}
-		if t := c.Text; len(t) >= 2 && (t[1] == '/' || strings.Contains(t, "\n")) {
-			return true
-		}
-	}
-	_ = line
-	return false
-}
-
-func (p *printer) nextComment() {
-	for p.cindex < len(p.comments) {
-		c := p.comments[p.cindex]
-		p.cindex++
-		if list := c.List; len(list) > 0 {
-			p.comment = c
-			p.commentOffset = p.posFor(list[0].Pos()).Offset
-			p.commentNewline = p.commentsHaveNewline(list)
-			return
-		}
-		// we should not reach here (correct ASTs don't have empty
-		// ast.CommentGroup nodes), but be conservative and try again
-	}
-	// no more comments
-	p.commentOffset = infinity
-}
-
-// commentBefore reports whether the current comment group occurs
-// before the next position in the source code and printing it does
-// not introduce implicit semicolons.
-//
-func (p *printer) commentBefore(next token.Position) bool {
-	return p.commentOffset < next.Offset && (!p.impliedSemi || !p.commentNewline)
-}
-
-// commentSizeBefore returns the estimated size of the
-// comments on the same line before the next position.
-//
-func (p *printer) commentSizeBefore(next token.Position) int {
-	// save/restore current p.commentInfo (p.nextComment() modifies it)
-	defer func(info commentInfo) {
-		p.commentInfo = info
-	}(p.commentInfo)
-
-	size := 0
-	for p.commentBefore(next) {
-		for _, c := range p.comment.List {
-			size += len(c.Text)
-		}
-		p.nextComment()
-	}
-	return size
-}
-
-// recordLine records the output line number for the next non-whitespace
-// token in *linePtr. It is used to compute an accurate line number for a
-// formatted construct, independent of pending (not yet emitted) whitespace
-// or comments.
-//
-func (p *printer) recordLine(linePtr *int) {
-	p.linePtr = linePtr
-}
-
-// linesFrom returns the number of output lines between the current
-// output line and the line argument, ignoring any pending (not yet
-// emitted) whitespace or comments. It is used to compute an accurate
-// size (in number of lines) for a formatted construct.
-//
-func (p *printer) linesFrom(line int) int {
-	return p.out.Line - line
-}
-
-func (p *printer) posFor(pos token.Pos) token.Position {
-	// not used frequently enough to cache entire token.Position
-	return p.fset.Position(pos)
-}
-
-func (p *printer) lineFor(pos token.Pos) int {
-	if pos != p.cachedPos {
-		p.cachedPos = pos
-		p.cachedLine = p.fset.Position(pos).Line
-	}
-	return p.cachedLine
-}
-
-// atLineBegin emits a //line comment if necessary and prints indentation.
-func (p *printer) atLineBegin(pos token.Position) {
-	// write a //line comment if necessary
-	if p.Config.Mode&SourcePos != 0 && pos.IsValid() && (p.out.Line != pos.Line || p.out.Filename != pos.Filename) {
-		p.output = append(p.output, tabwriter.Escape) // protect '\n' in //line from tabwriter interpretation
-		p.output = append(p.output, fmt.Sprintf("//line %s:%d\n", pos.Filename, pos.Line)...)
-		p.output = append(p.output, tabwriter.Escape)
-		// p.out must match the //line comment
-		p.out.Filename = pos.Filename
-		p.out.Line = pos.Line
-	}
-
-	// write indentation
-	// use "hard" htabs - indentation columns
-	// must not be discarded by the tabwriter
-	n := p.Config.Indent + p.indent // include base indentation
-	for i := 0; i < n; i++ {
-		p.output = append(p.output, '\t')
-	}
-
-	// update positions
-	p.pos.Offset += n
-	p.pos.Column += n
-	p.out.Column += n
-}
-
-// writeByte writes ch n times to p.output and updates p.pos.
-func (p *printer) writeByte(ch byte, n int) {
-	if p.out.Column == 1 {
-		p.atLineBegin(p.pos)
-	}
-
-	for i := 0; i < n; i++ {
-		p.output = append(p.output, ch)
-	}
-
-	// update positions
-	p.pos.Offset += n
-	if ch == '\n' || ch == '\f' {
-		p.pos.Line += n
-		p.out.Line += n
-		p.pos.Column = 1
-		p.out.Column = 1
-		return
-	}
-	p.pos.Column += n
-	p.out.Column += n
-}
-
-// writeString writes the string s to p.output and updates p.pos, p.out,
-// and p.last. If isLit is set, s is escaped w/ tabwriter.Escape characters
-// to protect s from being interpreted by the tabwriter.
-//
-// Note: writeString is only used to write Go tokens, literals, and
-// comments, all of which must be written literally. Thus, it is correct
-// to always set isLit = true. However, setting it explicitly only when
-// needed (i.e., when we don't know that s contains no tabs or line breaks)
-// avoids processing extra escape characters and reduces run time of the
-// printer benchmark by up to 10%.
-//
-func (p *printer) writeString(pos token.Position, s string, isLit bool) {
-	if p.out.Column == 1 {
-		p.atLineBegin(pos)
-	}
-
-	if pos.IsValid() {
-		// update p.pos (if pos is invalid, continue with existing p.pos)
-		// Note: Must do this after handling line beginnings because
-		// atLineBegin updates p.pos if there's indentation, but p.pos
-		// is the position of s.
-		p.pos = pos
-	}
-
-	if isLit {
-		// Protect s such that is passes through the tabwriter
-		// unchanged. Note that valid Go programs cannot contain
-		// tabwriter.Escape bytes since they do not appear in legal
-		// UTF-8 sequences.
-		p.output = append(p.output, tabwriter.Escape)
-	}
-
-	if debug {
-		p.output = append(p.output, fmt.Sprintf("/*%s*/", pos)...) // do not update p.pos!
-	}
-	p.output = append(p.output, s...)
-
-	// update positions
-	nlines := 0
-	var li int // index of last newline; valid if nlines > 0
-	for i := 0; i < len(s); i++ {
-		// Go tokens cannot contain '\f' - no need to look for it
-		if s[i] == '\n' {
-			nlines++
-			li = i
-		}
-	}
-	p.pos.Offset += len(s)
-	if nlines > 0 {
-		p.pos.Line += nlines
-		p.out.Line += nlines
-		c := len(s) - li
-		p.pos.Column = c
-		p.out.Column = c
-	} else {
-		p.pos.Column += len(s)
-		p.out.Column += len(s)
-	}
-
-	if isLit {
-		p.output = append(p.output, tabwriter.Escape)
-	}
-
-	p.last = p.pos
-}
-
-// writeCommentPrefix writes the whitespace before a comment.
-// If there is any pending whitespace, it consumes as much of
-// it as is likely to help position the comment nicely.
-// pos is the comment position, next the position of the item
-// after all pending comments, prev is the previous comment in
-// a group of comments (or nil), and tok is the next token.
-//
-func (p *printer) writeCommentPrefix(pos, next token.Position, prev, comment *ast.Comment, tok token.Token) {
-	if len(p.output) == 0 {
-		// the comment is the first item to be printed - don't write any whitespace
-		return
-	}
-
-	if pos.IsValid() && pos.Filename != p.last.Filename {
-		// comment in a different file - separate with newlines
-		p.writeByte('\f', maxNewlines)
-		return
-	}
-
-	if pos.Line == p.last.Line && (prev == nil || prev.Text[1] != '/') {
-		// comment on the same line as last item:
-		// separate with at least one separator
-		hasSep := false
-		if prev == nil {
-			// first comment of a comment group
-			j := 0
-			for i, ch := range p.wsbuf {
-				switch ch {
-				case blank:
-					// ignore any blanks before a comment
-					p.wsbuf[i] = ignore
-					continue
-				case vtab:
-					// respect existing tabs - important
-					// for proper formatting of commented structs
-					hasSep = true
-					continue
-				case indent:
-					// apply pending indentation
-					continue
-				}
-				j = i
-				break
-			}
-			p.writeWhitespace(j)
-		}
-		// make sure there is at least one separator
-		if !hasSep {
-			sep := byte('\t')
-			if pos.Line == next.Line {
-				// next item is on the same line as the comment
-				// (which must be a /*-style comment): separate
-				// with a blank instead of a tab
-				sep = ' '
-			}
-			p.writeByte(sep, 1)
-		}
-
-	} else {
-		// comment on a different line:
-		// separate with at least one line break
-		droppedLinebreak := false
-		j := 0
-		for i, ch := range p.wsbuf {
-			switch ch {
-			case blank, vtab:
-				// ignore any horizontal whitespace before line breaks
-				p.wsbuf[i] = ignore
-				continue
-			case indent:
-				// apply pending indentation
-				continue
-			case unindent:
-				// if this is not the last unindent, apply it
-				// as it is (likely) belonging to the last
-				// construct (e.g., a multi-line expression list)
-				// and is not part of closing a block
-				if i+1 < len(p.wsbuf) && p.wsbuf[i+1] == unindent {
-					continue
-				}
-				// if the next token is not a closing }, apply the unindent
-				// if it appears that the comment is aligned with the
-				// token; otherwise assume the unindent is part of a
-				// closing block and stop (this scenario appears with
-				// comments before a case label where the comments
-				// apply to the next case instead of the current one)
-				if tok != token.RBRACE && pos.Column == next.Column {
-					continue
-				}
-			case newline, formfeed:
-				p.wsbuf[i] = ignore
-				droppedLinebreak = prev == nil // record only if first comment of a group
-			}
-			j = i
-			break
-		}
-		p.writeWhitespace(j)
-
-		// determine number of linebreaks before the comment
-		n := 0
-		if pos.IsValid() && p.last.IsValid() {
-			n = pos.Line - p.last.Line
-			if n < 0 { // should never happen
-				n = 0
-			}
-		}
-
-		// at the package scope level only (p.indent == 0),
-		// add an extra newline if we dropped one before:
-		// this preserves a blank line before documentation
-		// comments at the package scope level (issue 2570)
-		if p.indent == 0 && droppedLinebreak {
-			n++
-		}
-
-		// make sure there is at least one line break
-		// if the previous comment was a line comment
-		if n == 0 && prev != nil && prev.Text[1] == '/' {
-			n = 1
-		}
-
-		if n > 0 {
-			// use formfeeds to break columns before a comment;
-			// this is analogous to using formfeeds to separate
-			// individual lines of /*-style comments
-			p.writeByte('\f', nlimit(n))
-		}
-	}
-}
-
-// Returns true if s contains only white space
-// (only tabs and blanks can appear in the printer's context).
-//
-func isBlank(s string) bool {
-	for i := 0; i < len(s); i++ {
-		if s[i] > ' ' {
-			return false
-		}
-	}
-	return true
-}
-
-// commonPrefix returns the common prefix of a and b.
-func commonPrefix(a, b string) string {
-	i := 0
-	for i < len(a) && i < len(b) && a[i] == b[i] && (a[i] <= ' ' || a[i] == '*') {
-		i++
-	}
-	return a[0:i]
-}
-
-// trimRight returns s with trailing whitespace removed.
-func trimRight(s string) string {
-	return strings.TrimRightFunc(s, unicode.IsSpace)
-}
-
-// stripCommonPrefix removes a common prefix from /*-style comment lines (unless no
-// comment line is indented, all but the first line have some form of space prefix).
-// The prefix is computed using heuristics such that is likely that the comment
-// contents are nicely laid out after re-printing each line using the printer's
-// current indentation.
-//
-func stripCommonPrefix(lines []string) {
-	if len(lines) <= 1 {
-		return // at most one line - nothing to do
-	}
-	// len(lines) > 1
-
-	// The heuristic in this function tries to handle a few
-	// common patterns of /*-style comments: Comments where
-	// the opening /* and closing */ are aligned and the
-	// rest of the comment text is aligned and indented with
-	// blanks or tabs, cases with a vertical "line of stars"
-	// on the left, and cases where the closing */ is on the
-	// same line as the last comment text.
-
-	// Compute maximum common white prefix of all but the first,
-	// last, and blank lines, and replace blank lines with empty
-	// lines (the first line starts with /* and has no prefix).
-	// In cases where only the first and last lines are not blank,
-	// such as two-line comments, or comments where all inner lines
-	// are blank, consider the last line for the prefix computation
-	// since otherwise the prefix would be empty.
-	//
-	// Note that the first and last line are never empty (they
-	// contain the opening /* and closing */ respectively) and
-	// thus they can be ignored by the blank line check.
-	prefix := ""
-	prefixSet := false
-	if len(lines) > 2 {
-		for i, line := range lines[1 : len(lines)-1] {
-			if isBlank(line) {
-				lines[1+i] = "" // range starts with lines[1]
-			} else {
-				if !prefixSet {
-					prefix = line
-					prefixSet = true
-				}
-				prefix = commonPrefix(prefix, line)
-			}
-
-		}
-	}
-	// If we don't have a prefix yet, consider the last line.
-	if !prefixSet {
-		line := lines[len(lines)-1]
-		prefix = commonPrefix(line, line)
-	}
-
-	/*
-	 * Check for vertical "line of stars" and correct prefix accordingly.
-	 */
-	lineOfStars := false
-	if i := strings.Index(prefix, "*"); i >= 0 {
-		// Line of stars present.
-		if i > 0 && prefix[i-1] == ' ' {
-			i-- // remove trailing blank from prefix so stars remain aligned
-		}
-		prefix = prefix[0:i]
-		lineOfStars = true
-	} else {
-		// No line of stars present.
-		// Determine the white space on the first line after the /*
-		// and before the beginning of the comment text, assume two
-		// blanks instead of the /* unless the first character after
-		// the /* is a tab. If the first comment line is empty but
-		// for the opening /*, assume up to 3 blanks or a tab. This
-		// whitespace may be found as suffix in the common prefix.
-		first := lines[0]
-		if isBlank(first[2:]) {
-			// no comment text on the first line:
-			// reduce prefix by up to 3 blanks or a tab
-			// if present - this keeps comment text indented
-			// relative to the /* and */'s if it was indented
-			// in the first place
-			i := len(prefix)
-			for n := 0; n < 3 && i > 0 && prefix[i-1] == ' '; n++ {
-				i--
-			}
-			if i == len(prefix) && i > 0 && prefix[i-1] == '\t' {
-				i--
-			}
-			prefix = prefix[0:i]
-		} else {
-			// comment text on the first line
-			suffix := make([]byte, len(first))
-			n := 2 // start after opening /*
-			for n < len(first) && first[n] <= ' ' {
-				suffix[n] = first[n]
-				n++
-			}
-			if n > 2 && suffix[2] == '\t' {
-				// assume the '\t' compensates for the /*
-				suffix = suffix[2:n]
-			} else {
-				// otherwise assume two blanks
-				suffix[0], suffix[1] = ' ', ' '
-				suffix = suffix[0:n]
-			}
-			// Shorten the computed common prefix by the length of
-			// suffix, if it is found as suffix of the prefix.
-			prefix = strings.TrimSuffix(prefix, string(suffix))
-		}
-	}
-
-	// Handle last line: If it only contains a closing */, align it
-	// with the opening /*, otherwise align the text with the other
-	// lines.
-	last := lines[len(lines)-1]
-	closing := "*/"
-	i := strings.Index(last, closing) // i >= 0 (closing is always present)
-	if isBlank(last[0:i]) {
-		// last line only contains closing */
-		if lineOfStars {
-			closing = " */" // add blank to align final star
-		}
-		lines[len(lines)-1] = prefix + closing
-	} else {
-		// last line contains more comment text - assume
-		// it is aligned like the other lines and include
-		// in prefix computation
-		prefix = commonPrefix(prefix, last)
-	}
-
-	// Remove the common prefix from all but the first and empty lines.
-	for i, line := range lines {
-		if i > 0 && line != "" {
-			lines[i] = line[len(prefix):]
-		}
-	}
-}
-
-func (p *printer) writeComment(comment *ast.Comment) {
-	text := comment.Text
-	pos := p.posFor(comment.Pos())
-
-	const linePrefix = "//line "
-	if strings.HasPrefix(text, linePrefix) && (!pos.IsValid() || pos.Column == 1) {
-		// possibly a line directive
-		ldir := strings.TrimSpace(text[len(linePrefix):])
-		if i := strings.LastIndex(ldir, ":"); i >= 0 {
-			if line, err := strconv.Atoi(ldir[i+1:]); err == nil && line > 0 {
-				// The line directive we are about to print changed
-				// the Filename and Line number used for subsequent
-				// tokens. We have to update our AST-space position
-				// accordingly and suspend indentation temporarily.
-				indent := p.indent
-				p.indent = 0
-				defer func() {
-					p.pos.Filename = ldir[:i]
-					p.pos.Line = line
-					p.pos.Column = 1
-					p.indent = indent
-				}()
-			}
-		}
-	}
-
-	// shortcut common case of //-style comments
-	if text[1] == '/' {
-		p.writeString(pos, trimRight(text), true)
-		return
-	}
-
-	// for /*-style comments, print line by line and let the
-	// write function take care of the proper indentation
-	lines := strings.Split(text, "\n")
-
-	// The comment started in the first column but is going
-	// to be indented. For an idempotent result, add indentation
-	// to all lines such that they look like they were indented
-	// before - this will make sure the common prefix computation
-	// is the same independent of how many times formatting is
-	// applied (was issue 1835).
-	if pos.IsValid() && pos.Column == 1 && p.indent > 0 {
-		for i, line := range lines[1:] {
-			lines[1+i] = "   " + line
-		}
-	}
-
-	stripCommonPrefix(lines)
-
-	// write comment lines, separated by formfeed,
-	// without a line break after the last line
-	for i, line := range lines {
-		if i > 0 {
-			p.writeByte('\f', 1)
-			pos = p.pos
-		}
-		if len(line) > 0 {
-			p.writeString(pos, trimRight(line), true)
-		}
-	}
-}
-
-// writeCommentSuffix writes a line break after a comment if indicated
-// and processes any leftover indentation information. If a line break
-// is needed, the kind of break (newline vs formfeed) depends on the
-// pending whitespace. The writeCommentSuffix result indicates if a
-// newline was written or if a formfeed was dropped from the whitespace
-// buffer.
-//
-func (p *printer) writeCommentSuffix(needsLinebreak bool) (wroteNewline, droppedFF bool) {
-	for i, ch := range p.wsbuf {
-		switch ch {
-		case blank, vtab:
-			// ignore trailing whitespace
-			p.wsbuf[i] = ignore
-		case indent, unindent:
-			// don't lose indentation information
-		case newline, formfeed:
-			// if we need a line break, keep exactly one
-			// but remember if we dropped any formfeeds
-			if needsLinebreak {
-				needsLinebreak = false
-				wroteNewline = true
-			} else {
-				if ch == formfeed {
-					droppedFF = true
-				}
-				p.wsbuf[i] = ignore
-			}
-		}
-	}
-	p.writeWhitespace(len(p.wsbuf))
-
-	// make sure we have a line break
-	if needsLinebreak {
-		p.writeByte('\n', 1)
-		wroteNewline = true
-	}
-
-	return
-}
-
-// intersperseComments consumes all comments that appear before the next token
-// tok and prints it together with the buffered whitespace (i.e., the whitespace
-// that needs to be written before the next token). A heuristic is used to mix
-// the comments and whitespace. The intersperseComments result indicates if a
-// newline was written or if a formfeed was dropped from the whitespace buffer.
-//
-func (p *printer) intersperseComments(next token.Position, tok token.Token) (wroteNewline, droppedFF bool) {
-	var last *ast.Comment
-	for p.commentBefore(next) {
-		for _, c := range p.comment.List {
-			p.writeCommentPrefix(p.posFor(c.Pos()), next, last, c, tok)
-			p.writeComment(c)
-			last = c
-		}
-		p.nextComment()
-	}
-
-	if last != nil {
-		// if the last comment is a /*-style comment and the next item
-		// follows on the same line but is not a comma, and not a "closing"
-		// token immediately following its corresponding "opening" token,
-		// add an extra blank for separation unless explicitly disabled
-		if p.mode&noExtraBlank == 0 &&
-			last.Text[1] == '*' && p.lineFor(last.Pos()) == next.Line &&
-			tok != token.COMMA &&
-			(tok != token.RPAREN || p.prevOpen == token.LPAREN) &&
-			(tok != token.RBRACK || p.prevOpen == token.LBRACK) {
-			p.writeByte(' ', 1)
-		}
-		// ensure that there is a line break after a //-style comment,
-		// before a closing '}' unless explicitly disabled, or at eof
-		needsLinebreak :=
-			last.Text[1] == '/' ||
-				tok == token.RBRACE && p.mode&noExtraLinebreak == 0 ||
-				tok == token.EOF
-		return p.writeCommentSuffix(needsLinebreak)
-	}
-
-	// no comment was written - we should never reach here since
-	// intersperseComments should not be called in that case
-	p.internalError("intersperseComments called without pending comments")
-	return
-}
-
-// whiteWhitespace writes the first n whitespace entries.
-func (p *printer) writeWhitespace(n int) {
-	// write entries
-	for i := 0; i < n; i++ {
-		switch ch := p.wsbuf[i]; ch {
-		case ignore:
-			// ignore!
-		case indent:
-			p.indent++
-		case unindent:
-			p.indent--
-			if p.indent < 0 {
-				p.internalError("negative indentation:", p.indent)
-				p.indent = 0
-			}
-		case newline, formfeed:
-			// A line break immediately followed by a "correcting"
-			// unindent is swapped with the unindent - this permits
-			// proper label positioning. If a comment is between
-			// the line break and the label, the unindent is not
-			// part of the comment whitespace prefix and the comment
-			// will be positioned correctly indented.
-			if i+1 < n && p.wsbuf[i+1] == unindent {
-				// Use a formfeed to terminate the current section.
-				// Otherwise, a long label name on the next line leading
-				// to a wide column may increase the indentation column
-				// of lines before the label; effectively leading to wrong
-				// indentation.
-				p.wsbuf[i], p.wsbuf[i+1] = unindent, formfeed
-				i-- // do it again
-				continue
-			}
-			fallthrough
-		default:
-			p.writeByte(byte(ch), 1)
-		}
-	}
-
-	// shift remaining entries down
-	l := copy(p.wsbuf, p.wsbuf[n:])
-	p.wsbuf = p.wsbuf[:l]
-}
-
-// ----------------------------------------------------------------------------
-// Printing interface
-
-// nlines limits n to maxNewlines.
-func nlimit(n int) int {
-	if n > maxNewlines {
-		n = maxNewlines
-	}
-	return n
-}
-
-func mayCombine(prev token.Token, next byte) (b bool) {
-	switch prev {
-	case token.INT:
-		b = next == '.' // 1.
-	case token.ADD:
-		b = next == '+' // ++
-	case token.SUB:
-		b = next == '-' // --
-	case token.QUO:
-		b = next == '*' // /*
-	case token.LSS:
-		b = next == '-' || next == '<' // <- or <<
-	case token.AND:
-		b = next == '&' || next == '^' // && or &^
-	}
-	return
-}
-
-// print prints a list of "items" (roughly corresponding to syntactic
-// tokens, but also including whitespace and formatting information).
-// It is the only print function that should be called directly from
-// any of the AST printing functions in nodes.go.
-//
-// Whitespace is accumulated until a non-whitespace token appears. Any
-// comments that need to appear before that token are printed first,
-// taking into account the amount and structure of any pending white-
-// space for best comment placement. Then, any leftover whitespace is
-// printed, followed by the actual token.
-//
-func (p *printer) print(args ...interface{}) {
-	for _, arg := range args {
-		// information about the current arg
-		var data string
-		var isLit bool
-		var impliedSemi bool // value for p.impliedSemi after this arg
-
-		// record previous opening token, if any
-		switch p.lastTok {
-		case token.ILLEGAL:
-			// ignore (white space)
-		case token.LPAREN, token.LBRACK:
-			p.prevOpen = p.lastTok
-		default:
-			// other tokens followed any opening token
-			p.prevOpen = token.ILLEGAL
-		}
-
-		switch x := arg.(type) {
-		case pmode:
-			// toggle printer mode
-			p.mode ^= x
-			continue
-
-		case whiteSpace:
-			if x == ignore {
-				// don't add ignore's to the buffer; they
-				// may screw up "correcting" unindents (see
-				// LabeledStmt)
-				continue
-			}
-			i := len(p.wsbuf)
-			if i == cap(p.wsbuf) {
-				// Whitespace sequences are very short so this should
-				// never happen. Handle gracefully (but possibly with
-				// bad comment placement) if it does happen.
-				p.writeWhitespace(i)
-				i = 0
-			}
-			p.wsbuf = p.wsbuf[0 : i+1]
-			p.wsbuf[i] = x
-			if x == newline || x == formfeed {
-				// newlines affect the current state (p.impliedSemi)
-				// and not the state after printing arg (impliedSemi)
-				// because comments can be interspersed before the arg
-				// in this case
-				p.impliedSemi = false
-			}
-			p.lastTok = token.ILLEGAL
-			continue
-
-		case *ast.Ident:
-			data = x.Name
-			impliedSemi = true
-			p.lastTok = token.IDENT
-
-		case *ast.BasicLit:
-			data = x.Value
-			isLit = true
-			impliedSemi = true
-			p.lastTok = x.Kind
-
-		case token.Token:
-			s := x.String()
-			if mayCombine(p.lastTok, s[0]) {
-				// the previous and the current token must be
-				// separated by a blank otherwise they combine
-				// into a different incorrect token sequence
-				// (except for token.INT followed by a '.' this
-				// should never happen because it is taken care
-				// of via binary expression formatting)
-				if len(p.wsbuf) != 0 {
-					p.internalError("whitespace buffer not empty")
-				}
-				p.wsbuf = p.wsbuf[0:1]
-				p.wsbuf[0] = ' '
-			}
-			data = s
-			// some keywords followed by a newline imply a semicolon
-			switch x {
-			case token.BREAK, token.CONTINUE, token.FALLTHROUGH, token.RETURN,
-				token.INC, token.DEC, token.RPAREN, token.RBRACK, token.RBRACE:
-				impliedSemi = true
-			}
-			p.lastTok = x
-
-		case token.Pos:
-			if x.IsValid() {
-				p.pos = p.posFor(x) // accurate position of next item
-			}
-			continue
-
-		case string:
-			// incorrect AST - print error message
-			data = x
-			isLit = true
-			impliedSemi = true
-			p.lastTok = token.STRING
-
-		default:
-			fmt.Fprintf(os.Stderr, "print: unsupported argument %v (%T)\n", arg, arg)
-			panic("go/printer type")
-		}
-		// data != ""
-
-		next := p.pos // estimated/accurate position of next item
-		wroteNewline, droppedFF := p.flush(next, p.lastTok)
-
-		// intersperse extra newlines if present in the source and
-		// if they don't cause extra semicolons (don't do this in
-		// flush as it will cause extra newlines at the end of a file)
-		if !p.impliedSemi {
-			n := nlimit(next.Line - p.pos.Line)
-			// don't exceed maxNewlines if we already wrote one
-			if wroteNewline && n == maxNewlines {
-				n = maxNewlines - 1
-			}
-			if n > 0 {
-				ch := byte('\n')
-				if droppedFF {
-					ch = '\f' // use formfeed since we dropped one before
-				}
-				p.writeByte(ch, n)
-				impliedSemi = false
-			}
-		}
-
-		// the next token starts now - record its line number if requested
-		if p.linePtr != nil {
-			*p.linePtr = p.out.Line
-			p.linePtr = nil
-		}
-
-		p.writeString(next, data, isLit)
-		p.impliedSemi = impliedSemi
-	}
-}
-
-// flush prints any pending comments and whitespace occurring textually
-// before the position of the next token tok. The flush result indicates
-// if a newline was written or if a formfeed was dropped from the whitespace
-// buffer.
-//
-func (p *printer) flush(next token.Position, tok token.Token) (wroteNewline, droppedFF bool) {
-	if p.commentBefore(next) {
-		// if there are comments before the next item, intersperse them
-		wroteNewline, droppedFF = p.intersperseComments(next, tok)
-	} else {
-		// otherwise, write any leftover whitespace
-		p.writeWhitespace(len(p.wsbuf))
-	}
-	return
-}
-
-// getNode returns the ast.CommentGroup associated with n, if any.
-func getDoc(n ast.Node) *ast.CommentGroup {
-	switch n := n.(type) {
-	case *ast.Field:
-		return n.Doc
-	case *ast.ImportSpec:
-		return n.Doc
-	case *ast.ValueSpec:
-		return n.Doc
-	case *ast.TypeSpec:
-		return n.Doc
-	case *ast.GenDecl:
-		return n.Doc
-	case *ast.FuncDecl:
-		return n.Doc
-	case *ast.File:
-		return n.Doc
-	}
-	return nil
-}
-
-func (p *printer) printNode(node interface{}) error {
-	// unpack *CommentedNode, if any
-	var comments []*ast.CommentGroup
-	if cnode, ok := node.(*CommentedNode); ok {
-		node = cnode.Node
-		comments = cnode.Comments
-	}
-
-	if comments != nil {
-		// commented node - restrict comment list to relevant range
-		n, ok := node.(ast.Node)
-		if !ok {
-			goto unsupported
-		}
-		beg := n.Pos()
-		end := n.End()
-		// if the node has associated documentation,
-		// include that commentgroup in the range
-		// (the comment list is sorted in the order
-		// of the comment appearance in the source code)
-		if doc := getDoc(n); doc != nil {
-			beg = doc.Pos()
-		}
-		// token.Pos values are global offsets, we can
-		// compare them directly
-		i := 0
-		for i < len(comments) && comments[i].End() < beg {
-			i++
-		}
-		j := i
-		for j < len(comments) && comments[j].Pos() < end {
-			j++
-		}
-		if i < j {
-			p.comments = comments[i:j]
-		}
-	} else if n, ok := node.(*ast.File); ok {
-		// use ast.File comments, if any
-		p.comments = n.Comments
-	}
-
-	// if there are no comments, use node comments
-	p.useNodeComments = p.comments == nil
-
-	// get comments ready for use
-	p.nextComment()
-
-	// format node
-	switch n := node.(type) {
-	case ast.Expr:
-		p.expr(n)
-	case ast.Stmt:
-		// A labeled statement will un-indent to position the label.
-		// Set p.indent to 1 so we don't get indent "underflow".
-		if _, ok := n.(*ast.LabeledStmt); ok {
-			p.indent = 1
-		}
-		p.stmt(n, false)
-	case ast.Decl:
-		p.decl(n)
-	case ast.Spec:
-		p.spec(n, 1, false)
-	case []ast.Stmt:
-		// A labeled statement will un-indent to position the label.
-		// Set p.indent to 1 so we don't get indent "underflow".
-		for _, s := range n {
-			if _, ok := s.(*ast.LabeledStmt); ok {
-				p.indent = 1
-			}
-		}
-		p.stmtList(n, 0, false)
-	case []ast.Decl:
-		p.declList(n)
-	case *ast.File:
-		p.file(n)
-	default:
-		goto unsupported
-	}
-
-	return nil
-
-unsupported:
-	return fmt.Errorf("go/printer: unsupported node type %T", node)
-}
-
-// ----------------------------------------------------------------------------
-// Trimmer
-
-// A trimmer is an io.Writer filter for stripping tabwriter.Escape
-// characters, trailing blanks and tabs, and for converting formfeed
-// and vtab characters into newlines and htabs (in case no tabwriter
-// is used). Text bracketed by tabwriter.Escape characters is passed
-// through unchanged.
-//
-type trimmer struct {
-	output io.Writer
-	state  int
-	space  []byte
-}
-
-// trimmer is implemented as a state machine.
-// It can be in one of the following states:
-const (
-	inSpace  = iota // inside space
-	inEscape        // inside text bracketed by tabwriter.Escapes
-	inText          // inside text
-)
-
-func (p *trimmer) resetSpace() {
-	p.state = inSpace
-	p.space = p.space[0:0]
-}
-
-// Design note: It is tempting to eliminate extra blanks occurring in
-//              whitespace in this function as it could simplify some
-//              of the blanks logic in the node printing functions.
-//              However, this would mess up any formatting done by
-//              the tabwriter.
-
-var aNewline = []byte("\n")
-
-func (p *trimmer) Write(data []byte) (n int, err error) {
-	// invariants:
-	// p.state == inSpace:
-	//	p.space is unwritten
-	// p.state == inEscape, inText:
-	//	data[m:n] is unwritten
-	m := 0
-	var b byte
-	for n, b = range data {
-		if b == '\v' {
-			b = '\t' // convert to htab
-		}
-		switch p.state {
-		case inSpace:
-			switch b {
-			case '\t', ' ':
-				p.space = append(p.space, b)
-			case '\n', '\f':
-				p.resetSpace() // discard trailing space
-				_, err = p.output.Write(aNewline)
-			case tabwriter.Escape:
-				_, err = p.output.Write(p.space)
-				p.state = inEscape
-				m = n + 1 // +1: skip tabwriter.Escape
-			default:
-				_, err = p.output.Write(p.space)
-				p.state = inText
-				m = n
-			}
-		case inEscape:
-			if b == tabwriter.Escape {
-				_, err = p.output.Write(data[m:n])
-				p.resetSpace()
-			}
-		case inText:
-			switch b {
-			case '\t', ' ':
-				_, err = p.output.Write(data[m:n])
-				p.resetSpace()
-				p.space = append(p.space, b)
-			case '\n', '\f':
-				_, err = p.output.Write(data[m:n])
-				p.resetSpace()
-				_, err = p.output.Write(aNewline)
-			case tabwriter.Escape:
-				_, err = p.output.Write(data[m:n])
-				p.state = inEscape
-				m = n + 1 // +1: skip tabwriter.Escape
-			}
-		default:
-			panic("unreachable")
-		}
-		if err != nil {
-			return
-		}
-	}
-	n = len(data)
-
-	switch p.state {
-	case inEscape, inText:
-		_, err = p.output.Write(data[m:n])
-		p.resetSpace()
-	}
-
-	return
-}
-
-// ----------------------------------------------------------------------------
-// Public interface
-
-// A Mode value is a set of flags (or 0). They control printing.
-type Mode uint
-
-const (
-	RawFormat Mode = 1 << iota // do not use a tabwriter; if set, UseSpaces is ignored
-	TabIndent                  // use tabs for indentation independent of UseSpaces
-	UseSpaces                  // use spaces instead of tabs for alignment
-	SourcePos                  // emit //line comments to preserve original source positions
-)
-
-// A Config node controls the output of Fprint.
-type Config struct {
-	Mode     Mode // default: 0
-	Tabwidth int  // default: 8
-	Indent   int  // default: 0 (all code is indented at least by this much)
-}
-
-// fprint implements Fprint and takes a nodesSizes map for setting up the printer state.
-func (cfg *Config) fprint(output io.Writer, fset *token.FileSet, node interface{}, nodeSizes map[ast.Node]int) (err error) {
-	// print node
-	var p printer
-	p.init(cfg, fset, nodeSizes)
-	if err = p.printNode(node); err != nil {
-		return
-	}
-	// print outstanding comments
-	p.impliedSemi = false // EOF acts like a newline
-	p.flush(token.Position{Offset: infinity, Line: infinity}, token.EOF)
-
-	// redirect output through a trimmer to eliminate trailing whitespace
-	// (Input to a tabwriter must be untrimmed since trailing tabs provide
-	// formatting information. The tabwriter could provide trimming
-	// functionality but no tabwriter is used when RawFormat is set.)
-	output = &trimmer{output: output}
-
-	// redirect output through a tabwriter if necessary
-	if cfg.Mode&RawFormat == 0 {
-		minwidth := cfg.Tabwidth
-
-		padchar := byte('\t')
-		if cfg.Mode&UseSpaces != 0 {
-			padchar = ' '
-		}
-
-		twmode := tabwriter.DiscardEmptyColumns
-		if cfg.Mode&TabIndent != 0 {
-			minwidth = 0
-			twmode |= tabwriter.TabIndent
-		}
-
-		output = tabwriter.NewWriter(output, minwidth, cfg.Tabwidth, 1, padchar, twmode)
-	}
-
-	// write printer result via tabwriter/trimmer to output
-	if _, err = output.Write(p.output); err != nil {
-		return
-	}
-
-	// flush tabwriter, if any
-	if tw, _ := output.(*tabwriter.Writer); tw != nil {
-		err = tw.Flush()
-	}
-
-	return
-}
-
-// A CommentedNode bundles an AST node and corresponding comments.
-// It may be provided as argument to any of the Fprint functions.
-//
-type CommentedNode struct {
-	Node     interface{} // *ast.File, or ast.Expr, ast.Decl, ast.Spec, or ast.Stmt
-	Comments []*ast.CommentGroup
-}
-
-// Fprint "pretty-prints" an AST node to output for a given configuration cfg.
-// Position information is interpreted relative to the file set fset.
-// The node type must be *ast.File, *CommentedNode, []ast.Decl, []ast.Stmt,
-// or assignment-compatible to ast.Expr, ast.Decl, ast.Spec, or ast.Stmt.
-//
-func (cfg *Config) Fprint(output io.Writer, fset *token.FileSet, node interface{}) error {
-	return cfg.fprint(output, fset, node, make(map[ast.Node]int))
-}
-
-// Fprint "pretty-prints" an AST node to output.
-// It calls Config.Fprint with default settings.
-//
-func Fprint(output io.Writer, fset *token.FileSet, node interface{}) error {
-	return (&Config{Tabwidth: 8}).Fprint(output, fset, node)
-}
diff --git a/third_party/golang/go/printer/printer_test.go b/third_party/golang/go/printer/printer_test.go
deleted file mode 100644
index 5e3e412f91c5c..0000000000000
--- a/third_party/golang/go/printer/printer_test.go
+++ /dev/null
@@ -1,562 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package printer
-
-import (
-	"bytes"
-	"errors"
-	"flag"
-	"fmt"
-	"io/ioutil"
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"k8s.io/kubernetes/third_party/golang/go/parser"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-	"path/filepath"
-	"testing"
-	"time"
-)
-
-const (
-	dataDir  = "testdata"
-	tabwidth = 8
-)
-
-var update = flag.Bool("update", false, "update golden files")
-
-var fset = token.NewFileSet()
-
-type checkMode uint
-
-const (
-	export checkMode = 1 << iota
-	rawFormat
-	idempotent
-)
-
-// format parses src, prints the corresponding AST, verifies the resulting
-// src is syntactically correct, and returns the resulting src or an error
-// if any.
-func format(src []byte, mode checkMode) ([]byte, error) {
-	// parse src
-	f, err := parser.ParseFile(fset, "", src, parser.ParseComments)
-	if err != nil {
-		return nil, fmt.Errorf("parse: %s\n%s", err, src)
-	}
-
-	// filter exports if necessary
-	if mode&export != 0 {
-		ast.FileExports(f) // ignore result
-		f.Comments = nil   // don't print comments that are not in AST
-	}
-
-	// determine printer configuration
-	cfg := Config{Tabwidth: tabwidth}
-	if mode&rawFormat != 0 {
-		cfg.Mode |= RawFormat
-	}
-
-	// print AST
-	var buf bytes.Buffer
-	if err := cfg.Fprint(&buf, fset, f); err != nil {
-		return nil, fmt.Errorf("print: %s", err)
-	}
-
-	// make sure formatted output is syntactically correct
-	res := buf.Bytes()
-	if _, err := parser.ParseFile(fset, "", res, 0); err != nil {
-		return nil, fmt.Errorf("re-parse: %s\n%s", err, buf.Bytes())
-	}
-
-	return res, nil
-}
-
-// lineAt returns the line in text starting at offset offs.
-func lineAt(text []byte, offs int) []byte {
-	i := offs
-	for i < len(text) && text[i] != '\n' {
-		i++
-	}
-	return text[offs:i]
-}
-
-// diff compares a and b.
-func diff(aname, bname string, a, b []byte) error {
-	var buf bytes.Buffer // holding long error message
-
-	// compare lengths
-	if len(a) != len(b) {
-		fmt.Fprintf(&buf, "\nlength changed: len(%s) = %d, len(%s) = %d", aname, len(a), bname, len(b))
-	}
-
-	// compare contents
-	line := 1
-	offs := 1
-	for i := 0; i < len(a) && i < len(b); i++ {
-		ch := a[i]
-		if ch != b[i] {
-			fmt.Fprintf(&buf, "\n%s:%d:%d: %s", aname, line, i-offs+1, lineAt(a, offs))
-			fmt.Fprintf(&buf, "\n%s:%d:%d: %s", bname, line, i-offs+1, lineAt(b, offs))
-			fmt.Fprintf(&buf, "\n\n")
-			break
-		}
-		if ch == '\n' {
-			line++
-			offs = i + 1
-		}
-	}
-
-	if buf.Len() > 0 {
-		return errors.New(buf.String())
-	}
-	return nil
-}
-
-func runcheck(t *testing.T, source, golden string, mode checkMode) {
-	src, err := ioutil.ReadFile(source)
-	if err != nil {
-		t.Error(err)
-		return
-	}
-
-	res, err := format(src, mode)
-	if err != nil {
-		t.Error(err)
-		return
-	}
-
-	// update golden files if necessary
-	if *update {
-		if err := ioutil.WriteFile(golden, res, 0644); err != nil {
-			t.Error(err)
-		}
-		return
-	}
-
-	// get golden
-	gld, err := ioutil.ReadFile(golden)
-	if err != nil {
-		t.Error(err)
-		return
-	}
-
-	// formatted source and golden must be the same
-	if err := diff(source, golden, res, gld); err != nil {
-		t.Error(err)
-		return
-	}
-
-	if mode&idempotent != 0 {
-		// formatting golden must be idempotent
-		// (This is very difficult to achieve in general and for now
-		// it is only checked for files explicitly marked as such.)
-		res, err = format(gld, mode)
-		if err := diff(golden, fmt.Sprintf("format(%s)", golden), gld, res); err != nil {
-			t.Errorf("golden is not idempotent: %s", err)
-		}
-	}
-}
-
-func check(t *testing.T, source, golden string, mode checkMode) {
-	// run the test
-	cc := make(chan int)
-	go func() {
-		runcheck(t, source, golden, mode)
-		cc <- 0
-	}()
-
-	// wait with timeout
-	select {
-	case <-time.After(10 * time.Second): // plenty of a safety margin, even for very slow machines
-		// test running past time out
-		t.Errorf("%s: running too slowly", source)
-	case <-cc:
-		// test finished within allotted time margin
-	}
-}
-
-type entry struct {
-	source, golden string
-	mode           checkMode
-}
-
-// Use go test -update to create/update the respective golden files.
-var data = []entry{
-	{"empty.input", "empty.golden", idempotent},
-	{"comments.input", "comments.golden", 0},
-	{"comments.input", "comments.x", export},
-	{"comments2.input", "comments2.golden", idempotent},
-	{"linebreaks.input", "linebreaks.golden", idempotent},
-	{"expressions.input", "expressions.golden", idempotent},
-	{"expressions.input", "expressions.raw", rawFormat | idempotent},
-	{"declarations.input", "declarations.golden", 0},
-	{"statements.input", "statements.golden", 0},
-	{"slow.input", "slow.golden", idempotent},
-}
-
-func TestFiles(t *testing.T) {
-	for _, e := range data {
-		source := filepath.Join(dataDir, e.source)
-		golden := filepath.Join(dataDir, e.golden)
-		check(t, source, golden, e.mode)
-		// TODO(gri) check that golden is idempotent
-		//check(t, golden, golden, e.mode)
-	}
-}
-
-// TestLineComments, using a simple test case, checks that consecutive line
-// comments are properly terminated with a newline even if the AST position
-// information is incorrect.
-//
-func TestLineComments(t *testing.T) {
-	const src = `// comment 1
-	// comment 2
-	// comment 3
-	package main
-	`
-
-	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, "", src, parser.ParseComments)
-	if err != nil {
-		panic(err) // error in test
-	}
-
-	var buf bytes.Buffer
-	fset = token.NewFileSet() // use the wrong file set
-	Fprint(&buf, fset, f)
-
-	nlines := 0
-	for _, ch := range buf.Bytes() {
-		if ch == '\n' {
-			nlines++
-		}
-	}
-
-	const expected = 3
-	if nlines < expected {
-		t.Errorf("got %d, expected %d\n", nlines, expected)
-		t.Errorf("result:\n%s", buf.Bytes())
-	}
-}
-
-// Verify that the printer can be invoked during initialization.
-func init() {
-	const name = "foobar"
-	var buf bytes.Buffer
-	if err := Fprint(&buf, fset, &ast.Ident{Name: name}); err != nil {
-		panic(err) // error in test
-	}
-	// in debug mode, the result contains additional information;
-	// ignore it
-	if s := buf.String(); !debug && s != name {
-		panic("got " + s + ", want " + name)
-	}
-}
-
-// Verify that the printer doesn't crash if the AST contains BadXXX nodes.
-func TestBadNodes(t *testing.T) {
-	const src = "package p\n("
-	const res = "package p\nBadDecl\n"
-	f, err := parser.ParseFile(fset, "", src, parser.ParseComments)
-	if err == nil {
-		t.Error("expected illegal program") // error in test
-	}
-	var buf bytes.Buffer
-	Fprint(&buf, fset, f)
-	if buf.String() != res {
-		t.Errorf("got %q, expected %q", buf.String(), res)
-	}
-}
-
-// testComment verifies that f can be parsed again after printing it
-// with its first comment set to comment at any possible source offset.
-func testComment(t *testing.T, f *ast.File, srclen int, comment *ast.Comment) {
-	f.Comments[0].List[0] = comment
-	var buf bytes.Buffer
-	for offs := 0; offs <= srclen; offs++ {
-		buf.Reset()
-		// Printing f should result in a correct program no
-		// matter what the (incorrect) comment position is.
-		if err := Fprint(&buf, fset, f); err != nil {
-			t.Error(err)
-		}
-		if _, err := parser.ParseFile(fset, "", buf.Bytes(), 0); err != nil {
-			t.Fatalf("incorrect program for pos = %d:\n%s", comment.Slash, buf.String())
-		}
-		// Position information is just an offset.
-		// Move comment one byte down in the source.
-		comment.Slash++
-	}
-}
-
-// Verify that the printer produces a correct program
-// even if the position information of comments introducing newlines
-// is incorrect.
-func TestBadComments(t *testing.T) {
-	const src = `
-// first comment - text and position changed by test
-package p
-import "fmt"
-const pi = 3.14 // rough circle
-var (
-	x, y, z int = 1, 2, 3
-	u, v float64
-)
-func fibo(n int) {
-	if n < 2 {
-		return n /* seed values */
-	}
-	return fibo(n-1) + fibo(n-2)
-}
-`
-
-	f, err := parser.ParseFile(fset, "", src, parser.ParseComments)
-	if err != nil {
-		t.Error(err) // error in test
-	}
-
-	comment := f.Comments[0].List[0]
-	pos := comment.Pos()
-	if fset.Position(pos).Offset != 1 {
-		t.Error("expected offset 1") // error in test
-	}
-
-	testComment(t, f, len(src), &ast.Comment{Slash: pos, Text: "//-style comment"})
-	testComment(t, f, len(src), &ast.Comment{Slash: pos, Text: "/*-style comment */"})
-	testComment(t, f, len(src), &ast.Comment{Slash: pos, Text: "/*-style \n comment */"})
-	testComment(t, f, len(src), &ast.Comment{Slash: pos, Text: "/*-style comment \n\n\n */"})
-}
-
-type visitor chan *ast.Ident
-
-func (v visitor) Visit(n ast.Node) (w ast.Visitor) {
-	if ident, ok := n.(*ast.Ident); ok {
-		v <- ident
-	}
-	return v
-}
-
-// idents is an iterator that returns all idents in f via the result channel.
-func idents(f *ast.File) <-chan *ast.Ident {
-	v := make(visitor)
-	go func() {
-		ast.Walk(v, f)
-		close(v)
-	}()
-	return v
-}
-
-// identCount returns the number of identifiers found in f.
-func identCount(f *ast.File) int {
-	n := 0
-	for _ = range idents(f) {
-		n++
-	}
-	return n
-}
-
-// Verify that the SourcePos mode emits correct //line comments
-// by testing that position information for matching identifiers
-// is maintained.
-func TestSourcePos(t *testing.T) {
-	const src = `
-package p
-import ( "go/printer"; "math" )
-const pi = 3.14; var x = 0
-type t struct{ x, y, z int; u, v, w float32 }
-func (t *t) foo(a, b, c int) int {
-	return a*t.x + b*t.y +
-		// two extra lines here
-		// ...
-		c*t.z
-}
-`
-
-	// parse original
-	f1, err := parser.ParseFile(fset, "src", src, parser.ParseComments)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// pretty-print original
-	var buf bytes.Buffer
-	err = (&Config{Mode: UseSpaces | SourcePos, Tabwidth: 8}).Fprint(&buf, fset, f1)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	// parse pretty printed original
-	// (//line comments must be interpreted even w/o parser.ParseComments set)
-	f2, err := parser.ParseFile(fset, "", buf.Bytes(), 0)
-	if err != nil {
-		t.Fatalf("%s\n%s", err, buf.Bytes())
-	}
-
-	// At this point the position information of identifiers in f2 should
-	// match the position information of corresponding identifiers in f1.
-
-	// number of identifiers must be > 0 (test should run) and must match
-	n1 := identCount(f1)
-	n2 := identCount(f2)
-	if n1 == 0 {
-		t.Fatal("got no idents")
-	}
-	if n2 != n1 {
-		t.Errorf("got %d idents; want %d", n2, n1)
-	}
-
-	// verify that all identifiers have correct line information
-	i2range := idents(f2)
-	for i1 := range idents(f1) {
-		i2 := <-i2range
-
-		if i2.Name != i1.Name {
-			t.Errorf("got ident %s; want %s", i2.Name, i1.Name)
-		}
-
-		l1 := fset.Position(i1.Pos()).Line
-		l2 := fset.Position(i2.Pos()).Line
-		if l2 != l1 {
-			t.Errorf("got line %d; want %d for %s", l2, l1, i1.Name)
-		}
-	}
-
-	if t.Failed() {
-		t.Logf("\n%s", buf.Bytes())
-	}
-}
-
-var decls = []string{
-	`import "fmt"`,
-	"const pi = 3.1415\nconst e = 2.71828\n\nvar x = pi",
-	"func sum(x, y int) int\t{ return x + y }",
-}
-
-func TestDeclLists(t *testing.T) {
-	for _, src := range decls {
-		file, err := parser.ParseFile(fset, "", "package p;"+src, parser.ParseComments)
-		if err != nil {
-			panic(err) // error in test
-		}
-
-		var buf bytes.Buffer
-		err = Fprint(&buf, fset, file.Decls) // only print declarations
-		if err != nil {
-			panic(err) // error in test
-		}
-
-		out := buf.String()
-		if out != src {
-			t.Errorf("\ngot : %q\nwant: %q\n", out, src)
-		}
-	}
-}
-
-var stmts = []string{
-	"i := 0",
-	"select {}\nvar a, b = 1, 2\nreturn a + b",
-	"go f()\ndefer func() {}()",
-}
-
-func TestStmtLists(t *testing.T) {
-	for _, src := range stmts {
-		file, err := parser.ParseFile(fset, "", "package p; func _() {"+src+"}", parser.ParseComments)
-		if err != nil {
-			panic(err) // error in test
-		}
-
-		var buf bytes.Buffer
-		err = Fprint(&buf, fset, file.Decls[0].(*ast.FuncDecl).Body.List) // only print statements
-		if err != nil {
-			panic(err) // error in test
-		}
-
-		out := buf.String()
-		if out != src {
-			t.Errorf("\ngot : %q\nwant: %q\n", out, src)
-		}
-	}
-}
-
-func TestBaseIndent(t *testing.T) {
-	// The testfile must not contain multi-line raw strings since those
-	// are not indented (because their values must not change) and make
-	// this test fail.
-	const filename = "printer.go"
-	src, err := ioutil.ReadFile(filename)
-	if err != nil {
-		panic(err) // error in test
-	}
-
-	file, err := parser.ParseFile(fset, filename, src, 0)
-	if err != nil {
-		panic(err) // error in test
-	}
-
-	var buf bytes.Buffer
-	for indent := 0; indent < 4; indent++ {
-		buf.Reset()
-		(&Config{Tabwidth: tabwidth, Indent: indent}).Fprint(&buf, fset, file)
-		// all code must be indented by at least 'indent' tabs
-		lines := bytes.Split(buf.Bytes(), []byte{'\n'})
-		for i, line := range lines {
-			if len(line) == 0 {
-				continue // empty lines don't have indentation
-			}
-			n := 0
-			for j, b := range line {
-				if b != '\t' {
-					// end of indentation
-					n = j
-					break
-				}
-			}
-			if n < indent {
-				t.Errorf("line %d: got only %d tabs; want at least %d: %q", i, n, indent, line)
-			}
-		}
-	}
-}
-
-// TestFuncType tests that an ast.FuncType with a nil Params field
-// can be printed (per go/ast specification). Test case for issue 3870.
-func TestFuncType(t *testing.T) {
-	src := &ast.File{
-		Name: &ast.Ident{Name: "p"},
-		Decls: []ast.Decl{
-			&ast.FuncDecl{
-				Name: &ast.Ident{Name: "f"},
-				Type: &ast.FuncType{},
-			},
-		},
-	}
-
-	var buf bytes.Buffer
-	if err := Fprint(&buf, fset, src); err != nil {
-		t.Fatal(err)
-	}
-	got := buf.String()
-
-	const want = `package p
-
-func f()
-`
-
-	if got != want {
-		t.Fatalf("got:\n%s\nwant:\n%s\n", got, want)
-	}
-}
-
-// TextX is a skeleton test that can be filled in for debugging one-off cases.
-// Do not remove.
-func TestX(t *testing.T) {
-	const src = `
-package p
-func _() {}
-`
-	_, err := format([]byte(src), 0)
-	if err != nil {
-		t.Error(err)
-	}
-}
diff --git a/third_party/golang/go/printer/testdata/comments.golden b/third_party/golang/go/printer/testdata/comments.golden
deleted file mode 100644
index 849fa624489a6..0000000000000
--- a/third_party/golang/go/printer/testdata/comments.golden
+++ /dev/null
@@ -1,705 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This is a package for testing comment placement by go/printer.
-//
-package main
-
-import "fmt"	// fmt
-
-const c0 = 0	// zero
-const (
-	c1	= iota	// c1
-	c2		// c2
-)
-
-// Alignment of comments in declarations>
-const (
-	_	T	= iota	// comment
-	_			// comment
-	_			// comment
-	_	= iota + 10
-	_	// comments
-
-	_		= 10	// comment
-	_	T	= 20	// comment
-)
-
-const (
-	_____	= iota	// foo
-	_		// bar
-	_	= 0	// bal
-	_		// bat
-)
-
-const (
-	_	T	= iota	// comment
-	_			// comment
-	_			// comment
-	_	= iota + 10
-	_		// comment
-	_		= 10
-	_		= 20	// comment
-	_	T	= 0	// comment
-)
-
-// The SZ struct; it is empty.
-type SZ struct{}
-
-// The S0 struct; no field is exported.
-type S0 struct {
-	int
-	x, y, z	int	// 3 unexported fields
-}
-
-// The S1 struct; some fields are not exported.
-type S1 struct {
-	S0
-	A, B, C	float	// 3 exported fields
-	D, b, c	int	// 2 unexported fields
-}
-
-// The S2 struct; all fields are exported.
-type S2 struct {
-	S1
-	A, B, C	float	// 3 exported fields
-}
-
-// The IZ interface; it is empty.
-type SZ interface{}
-
-// The I0 interface; no method is exported.
-type I0 interface {
-	f(x int) int	// unexported method
-}
-
-// The I1 interface; some methods are not exported.
-type I1 interface {
-	I0
-	F(x float) float	// exported methods
-	g(x int) int		// unexported method
-}
-
-// The I2 interface; all methods are exported.
-type I2 interface {
-	I0
-	F(x float) float	// exported method
-	G(x float) float	// exported method
-}
-
-// The S3 struct; all comments except for the last one must appear in the export.
-type S3 struct {
-	// lead comment for F1
-	F1	int	// line comment for F1
-	// lead comment for F2
-	F2	int	// line comment for F2
-	f3	int	// f3 is not exported
-}
-
-// This comment group should be separated
-// with a newline from the next comment
-// group.
-
-// This comment should NOT be associated with the next declaration.
-
-var x int	// x
-var ()
-
-// This comment SHOULD be associated with f0.
-func f0() {
-	const pi = 3.14	// pi
-	var s1 struct{}	/* an empty struct */	/* foo */
-	// a struct constructor
-	// --------------------
-	var s2 struct{} = struct{}{}
-	x := pi
-}
-
-//
-// This comment should be associated with f1, with one blank line before the comment.
-//
-func f1() {
-	f0()
-	/* 1 */
-	// 2
-	/* 3 */
-	/* 4 */
-	f0()
-}
-
-func _() {
-	// this comment should be properly indented
-}
-
-func _(x int) int {
-	if x < 0 {	// the tab printed before this comment's // must not affect the remaining lines
-		return -x	// this statement should be properly indented
-	}
-	if x < 0 {	/* the tab printed before this comment's /* must not affect the remaining lines */
-		return -x	// this statement should be properly indented
-	}
-	return x
-}
-
-func typeswitch(x interface{}) {
-	switch v := x.(type) {
-	case bool, int, float:
-	case string:
-	default:
-	}
-
-	switch x.(type) {
-	}
-
-	switch v0, ok := x.(int); v := x.(type) {
-	}
-
-	switch v0, ok := x.(int); x.(type) {
-	case byte:	// this comment should be on the same line as the keyword
-		// this comment should be normally indented
-		_ = 0
-	case bool, int, float:
-		// this comment should be indented
-	case string:
-	default:
-		// this comment should be indented
-	}
-	// this comment should not be indented
-}
-
-//
-// Indentation of comments after possibly indented multi-line constructs
-// (test cases for issue 3147).
-//
-
-func _() {
-	s := 1 +
-		2
-	// should be indented like s
-}
-
-func _() {
-	s := 1 +
-		2	// comment
-	// should be indented like s
-}
-
-func _() {
-	s := 1 +
-		2	// comment
-	// should be indented like s
-	_ = 0
-}
-
-func _() {
-	s := 1 +
-		2
-	// should be indented like s
-	_ = 0
-}
-
-func _() {
-	s := 1 +
-		2
-
-	// should be indented like s
-}
-
-func _() {
-	s := 1 +
-		2	// comment
-
-	// should be indented like s
-}
-
-func _() {
-	s := 1 +
-		2	// comment
-
-	// should be indented like s
-	_ = 0
-}
-
-func _() {
-	s := 1 +
-		2
-
-	// should be indented like s
-	_ = 0
-}
-
-// Test case from issue 3147.
-func f() {
-	templateText := "a" +	// A
-		"b" +	// B
-		"c"	// C
-
-	// should be aligned with f()
-	f()
-}
-
-// Modified test case from issue 3147.
-func f() {
-	templateText := "a" +	// A
-		"b" +	// B
-		"c"	// C
-
-		// may not be aligned with f() (source is not aligned)
-	f()
-}
-
-//
-// Test cases for alignment of lines in general comments.
-//
-
-func _() {
-	/* freestanding comment
-	   aligned		line
-	   aligned line
-	*/
-}
-
-func _() {
-	/* freestanding comment
-	   aligned		line
-	   aligned line
-	*/
-}
-
-func _() {
-	/* freestanding comment
-	   aligned		line
-	   aligned line */
-}
-
-func _() {
-	/*	freestanding comment
-		aligned		line
-		aligned line
-	*/
-}
-
-func _() {
-	/*	freestanding comment
-		aligned		line
-		aligned line
-	*/
-}
-
-func _() {
-	/*	freestanding comment
-		aligned		line
-		aligned line */
-}
-
-func _() {
-	/*
-	   freestanding comment
-	   aligned		line
-	   aligned line
-	*/
-}
-
-func _() {
-	/*
-	   freestanding comment
-	   aligned		line
-	   aligned line
-	*/
-}
-
-func _() {
-	/*
-	   freestanding comment
-	   aligned		line
-	   aligned line */
-}
-
-func _() {
-	/*
-		freestanding comment
-		aligned		line
-		aligned line
-	*/
-}
-
-func _() {
-	/*
-		freestanding comment
-		aligned		line
-		aligned line
-	*/
-}
-
-func _() {
-	/*
-		freestanding comment
-		aligned		line
-		aligned line */
-}
-
-func _() {
-	/* freestanding comment
-	   aligned line
-	*/
-}
-
-func _() {
-	/* freestanding comment
-	   aligned line
-	*/
-}
-
-func _() {
-	/* freestanding comment
-	   aligned line */
-}
-
-func _() {
-	/*	freestanding comment
-		aligned line
-	*/
-}
-
-func _() {
-	/*	freestanding comment
-		aligned line
-	*/
-}
-
-func _() {
-	/*	freestanding comment
-		aligned line */
-}
-
-func _() {
-	/*
-	   freestanding comment
-	   aligned line
-	*/
-}
-
-func _() {
-	/*
-	   freestanding comment
-	   aligned line
-	*/
-}
-
-func _() {
-	/*
-	   freestanding comment
-	   aligned line */
-}
-
-func _() {
-	/*
-		freestanding comment
-		aligned line
-	*/
-}
-
-func _() {
-	/*
-		freestanding comment
-		aligned line
-	*/
-}
-
-func _() {
-	/*
-		freestanding comment
-		aligned line */
-}
-
-// Issue 9751.
-func _() {
-	/*a string
-
-	b string*/
-
-	/*A string
-
-
-
-	Z string*/
-
-	/*a string
-
-	b string
-
-	c string*/
-
-	{
-		/*a string
-		b string*/
-
-		/*a string
-
-		b string*/
-
-		/*a string
-
-		b string
-
-		c string*/
-	}
-
-	{
-		/*a string
-		b string*/
-
-		/*a string
-
-		b string*/
-
-		/*a string
-
-		b string
-
-		c string*/
-	}
-
-	/*
-	 */
-
-	/*
-
-	 */
-
-	/*
-
-	 * line
-
-	 */
-}
-
-/*
- * line
- * of
- * stars
- */
-
-/* another line
- * of
- * stars */
-
-/*	and another line
- *	of
- *	stars */
-
-/* a line of
- * stars */
-
-/*	and another line of
- *	stars */
-
-/* a line of stars
- */
-
-/*	and another line of
- */
-
-/* a line of stars
- */
-
-/*	and another line of
- */
-
-/*
-aligned in middle
-here
-        not here
-*/
-
-/*
-blank line in middle:
-
-with no leading spaces on blank line.
-*/
-
-/*
-   aligned in middle
-   here
-           not here
-*/
-
-/*
-	blank line in middle:
-
-	with no leading spaces on blank line.
-*/
-
-func _() {
-	/*
-	 * line
-	 * of
-	 * stars
-	 */
-
-	/*
-		aligned in middle
-		here
-			not here
-	*/
-
-	/*
-		blank line in middle:
-
-		with no leading spaces on blank line.
-	*/
-}
-
-// Some interesting interspersed comments.
-// See below for more common cases.
-func _( /* this */ x /* is */ /* an */ int) {
-}
-
-func _( /* no params - extra blank before and after comment */ )	{}
-func _(a, b int /* params - no extra blank after comment */)		{}
-
-func _()	{ f( /* no args - extra blank before and after comment */ ) }
-func _()	{ f(a, b /* args - no extra blank after comment */) }
-
-func _() {
-	f( /* no args - extra blank before and after comment */ )
-	f(a, b /* args - no extra blank after comment */)
-}
-
-func ( /* comment1 */ T /* comment2 */) _()	{}
-
-func _()	{ /* "short-ish one-line functions with comments are formatted as multi-line functions */ }
-func _()	{ x := 0; /* comment */ y = x /* comment */ }
-
-func _() {
-	_ = 0
-	/* closing curly brace should be on new line */
-}
-
-func _() {
-	_ = []int{0, 1 /* don't introduce a newline after this comment - was issue 1365 */}
-}
-
-// Test cases from issue 1542:
-// Comments must not be placed before commas and cause invalid programs.
-func _() {
-	var a = []int{1, 2	/*jasldf*/}
-	_ = a
-}
-
-func _() {
-	var a = []int{1, 2}/*jasldf
-	 */
-
-	_ = a
-}
-
-func _() {
-	var a = []int{1, 2}// jasldf
-
-	_ = a
-}
-
-// Comments immediately adjacent to punctuation followed by a newline
-// remain after the punctuation (looks better and permits alignment of
-// comments).
-func _() {
-	_ = T{
-		1,	// comment after comma
-		2,	/* comment after comma */
-		3,	// comment after comma
-	}
-	_ = T{
-		1,	// comment after comma
-		2,	/* comment after comma */
-		3,	// comment after comma
-	}
-	_ = T{
-		/* comment before literal */ 1,
-		2,	/* comment before comma - ok to move after comma */
-		3,	/* comment before comma - ok to move after comma */
-	}
-
-	for i = 0;	// comment after semicolon
-	i < 9;		/* comment after semicolon */
-	i++ {		// comment after opening curly brace
-	}
-
-	// TODO(gri) the last comment in this example should be aligned */
-	for i = 0;	// comment after semicolon
-	i < 9;		/* comment before semicolon - ok to move after semicolon */
-	i++ /* comment before opening curly brace */ {
-	}
-}
-
-// If there is no newline following punctuation, commas move before the punctuation.
-// This way, commas interspersed in lists stay with the respective expression.
-func f(x /* comment */, y int, z int /* comment */, u, v, w int /* comment */) {
-	f(x /* comment */, y)
-	f(x,	/* comment */
-		y)
-	f(
-		x,	/* comment */
-	)
-}
-
-func g(
-	x int,	/* comment */
-) {
-}
-
-type _ struct {
-	a, b /* comment */, c int
-}
-
-type _ struct {
-	a, b /* comment */, c int
-}
-
-func _() {
-	for a /* comment */, b := range x {
-	}
-}
-
-// Print line directives correctly.
-
-// The following is a legal line directive.
-//line foo:1
-func _() {
-	_ = 0
-	// The following is a legal line directive. It must not be indented:
-//line foo:2
-	_ = 1
-
-	// The following is not a legal line directive (it doesn't start in column 1):
-	//line foo:2
-	_ = 2
-
-	// The following is not a legal line directive (negative line number):
-	//line foo:-3
-	_ = 3
-}
-
-// Line comments with tabs
-func _() {
-	var finput *bufio.Reader	// input file
-	var stderr *bufio.Writer
-	var ftable *bufio.Writer	// y.go file
-	var foutput *bufio.Writer	// y.output file
-
-	var oflag string	// -o [y.go]		- y.go file
-	var vflag string	// -v [y.output]	- y.output file
-	var lflag bool		// -l			- disable line directives
-}
-
-// Trailing white space in comments should be trimmed
-func _() {
-	// This comment has 4 blanks following that should be trimmed:
-	/* Each line of this comment has blanks or tabs following that should be trimmed:
-	   line 2:
-	   line 3:
-	*/
-}
-
-/* This comment is the last entry in this file. It must be printed and should be followed by a newline */
diff --git a/third_party/golang/go/printer/testdata/comments.input b/third_party/golang/go/printer/testdata/comments.input
deleted file mode 100644
index 30cd23c6dd4cd..0000000000000
--- a/third_party/golang/go/printer/testdata/comments.input
+++ /dev/null
@@ -1,710 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This is a package for testing comment placement by go/printer.
-//
-package main
-
-import "fmt"  // fmt
-
-const c0 = 0  // zero
-const (
-	c1 = iota  // c1
-	c2  // c2
-)
-
-// Alignment of comments in declarations>
-const (
-	_ T = iota  // comment
-	_  // comment
-	_  // comment
-	_ = iota+10
-	_  // comments
-
-	_ = 10  // comment
-	_ T = 20  // comment
-)
-
-const (
-	_____ = iota // foo
-	_ // bar
-	_  = 0    // bal
-	_ // bat
-)
-
-const (
-	_ T = iota // comment
-	_ // comment
-	_ // comment
-	_ = iota + 10
-	_ // comment
-	_ = 10
-	_ = 20 // comment
-	_ T = 0 // comment
-)
-
-// The SZ struct; it is empty.
-type SZ struct {}
-
-// The S0 struct; no field is exported.
-type S0 struct {
-	int
-	x, y, z int  // 3 unexported fields
-}
-
-// The S1 struct; some fields are not exported.
-type S1 struct {
-	S0
-	A, B, C float  // 3 exported fields
-	D, b, c int  // 2 unexported fields
-}
-
-// The S2 struct; all fields are exported.
-type S2 struct {
-	S1
-	A, B, C float  // 3 exported fields
-}
-
-// The IZ interface; it is empty.
-type SZ interface {}
-
-// The I0 interface; no method is exported.
-type I0 interface {
-	f(x int) int  // unexported method
-}
-
-// The I1 interface; some methods are not exported.
-type I1 interface {
-	I0
-	F(x float) float  // exported methods
-	g(x int) int  // unexported method
-}
-
-// The I2 interface; all methods are exported.
-type I2 interface {
-	I0
-	F(x float) float  // exported method
-	G(x float) float  // exported method
-}
-
-// The S3 struct; all comments except for the last one must appear in the export.
-type S3 struct {
-	// lead comment for F1
-	F1 int // line comment for F1
-	// lead comment for F2
-	F2 int // line comment for F2
-	f3 int // f3 is not exported
-}
-
-// This comment group should be separated
-// with a newline from the next comment
-// group.
-
-// This comment should NOT be associated with the next declaration.
-
-var x int  // x
-var ()
-
-
-// This comment SHOULD be associated with f0.
-func f0() {
-	const pi = 3.14  // pi
-	var s1 struct {}  /* an empty struct */ /* foo */
-	// a struct constructor
-	// --------------------
-	var s2 struct {} = struct {}{}
-	x := pi
-}
-//
-// This comment should be associated with f1, with one blank line before the comment.
-//
-func f1() {
-	f0()
-	/* 1 */
-	// 2
-	/* 3 */
-	/* 4 */
-	f0()
-}
-
-
-func _() {
-// this comment should be properly indented
-}
-
-
-func _(x int) int {
-	if x < 0 {  // the tab printed before this comment's // must not affect the remaining lines
-		return -x  // this statement should be properly indented
-	}
-	if x < 0 {  /* the tab printed before this comment's /* must not affect the remaining lines */
-		return -x  // this statement should be properly indented
-	}
-	return x
-}
-
-
-func typeswitch(x interface{}) {
-	switch v := x.(type) {
-	case bool, int, float:
-	case string:
-	default:
-	}
-
-	switch x.(type) {
-	}
-
-	switch v0, ok := x.(int); v := x.(type) {
-	}
-
-	switch v0, ok := x.(int); x.(type) {
-	case byte:  // this comment should be on the same line as the keyword
-		// this comment should be normally indented
-		_ = 0
-	case bool, int, float:
-		// this comment should be indented
-	case string:
-	default:
-		// this comment should be indented
-	}
-	// this comment should not be indented
-}
-
-//
-// Indentation of comments after possibly indented multi-line constructs
-// (test cases for issue 3147).
-//
-
-func _() {
-	s := 1 +
-		2
-// should be indented like s
-}
-
-func _() {
-	s := 1 +
-		2 // comment
-		// should be indented like s
-}
-
-func _() {
-	s := 1 +
-		2 // comment
-	// should be indented like s
-	_ = 0
-}
-
-func _() {
-	s := 1 +
-		2
-	// should be indented like s
-	_ = 0
-}
-
-func _() {
-	s := 1 +
-		2
-
-// should be indented like s
-}
-
-func _() {
-	s := 1 +
-		2 // comment
-
-		// should be indented like s
-}
-
-func _() {
-	s := 1 +
-		2 // comment
-
-	// should be indented like s
-	_ = 0
-}
-
-func _() {
-	s := 1 +
-		2
-
-	// should be indented like s
-	_ = 0
-}
-
-// Test case from issue 3147.
-func f() {
-	templateText := "a" + // A
-		"b" + // B
-		"c" // C
-
-	// should be aligned with f()
-	f()
-}
-
-// Modified test case from issue 3147.
-func f() {
-	templateText := "a" + // A
-		"b" + // B
-		"c" // C
-
-		// may not be aligned with f() (source is not aligned)
-	f()
-}
-
-//
-// Test cases for alignment of lines in general comments.
-//
-
-func _() {
-	/* freestanding comment
-	   aligned		line
-	   aligned line
-	*/
-}
-
-func _() {
-	/* freestanding comment
-	   aligned		line
-	   aligned line
-	   */
-}
-
-func _() {
-	/* freestanding comment
-	   aligned		line
-	   aligned line */
-}
-
-func _() {
-	/*	freestanding comment
-		aligned		line
-		aligned line
-	*/
-}
-
-func _() {
-	/*	freestanding comment
-		aligned		line
-		aligned line
-		*/
-}
-
-func _() {
-	/*	freestanding comment
-		aligned		line
-		aligned line */
-}
-
-
-func _() {
-	/*
-	   freestanding comment
-	   aligned		line
-	   aligned line
-	*/
-}
-
-func _() {
-	/*
-	   freestanding comment
-	   aligned		line
-	   aligned line
-	   */
-}
-
-func _() {
-	/*
-	   freestanding comment
-	   aligned		line
-	   aligned line */
-}
-
-func _() {
-	/*
-		freestanding comment
-		aligned		line
-		aligned line
-	*/
-}
-
-func _() {
-	/*
-		freestanding comment
-		aligned		line
-		aligned line
-		*/
-}
-
-func _() {
-	/*
-		freestanding comment
-		aligned		line
-		aligned line */
-}
-
-func _() {
-	/* freestanding comment
-	   aligned line
-	*/
-}
-
-func _() {
-	/* freestanding comment
-	   aligned line
-	   */
-}
-
-func _() {
-	/* freestanding comment
-	   aligned line */
-}
-
-func _() {
-	/*	freestanding comment
-		aligned line
-	*/
-}
-
-func _() {
-	/*	freestanding comment
-		aligned line
-		*/
-}
-
-func _() {
-	/*	freestanding comment
-		aligned line */
-}
-
-
-func _() {
-	/*
-	   freestanding comment
-	   aligned line
-	*/
-}
-
-func _() {
-	/*
-	   freestanding comment
-	   aligned line
-	   */
-}
-
-func _() {
-	/*
-	   freestanding comment
-	   aligned line */
-}
-
-func _() {
-	/*
-		freestanding comment
-		aligned line
-	*/
-}
-
-func _() {
-	/*
-		freestanding comment
-		aligned line
-		*/
-}
-
-func _() {
-	/*
-		freestanding comment
-		aligned line */
-}
-
-// Issue 9751.
-func _() {
-	/*a string
-
-	b string*/
-
-	/*A string
-
-
-
-	Z string*/
-
-	/*a string
-
-	b string
-
-	c string*/
-
-	{
-		/*a string
-b string*/
-
-		/*a string
-
-b string*/
-
-		/*a string
-
-b string
-
-c string*/
-	}
-
-	{
-		/*a string
-				b string*/
-
-		/*a string
-
-				b string*/
-
-		/*a string
-
-				b string
-
-				c string*/
-	}
-
-	/*
-	*/
-
-	/*
-
-	*/
-
-	/*
-
-	 * line
-
-	*/
-}
-
-/*
- * line
- * of
- * stars
- */
-
-/* another line
- * of
- * stars */
-
-/*	and another line
- *	of
- *	stars */
-
-/* a line of
- * stars */
-
-/*	and another line of
- *	stars */
-
-/* a line of stars
-*/
-
-/*	and another line of
-*/
-
-/* a line of stars
- */
-
-/*	and another line of
- */
-
-/*
-aligned in middle
-here
-        not here
-*/
-
-/*
-blank line in middle:
-
-with no leading spaces on blank line.
-*/
-
-/*
-   aligned in middle
-   here
-           not here
-*/
-
-/*
-	blank line in middle:
-
-	with no leading spaces on blank line.
-*/
-
-func _() {
-	/*
-	 * line
-	 * of
-	 * stars
-	 */
-
-	/*
-	aligned in middle
-	here
-		not here
-	*/
-
-	/*
-	blank line in middle:
-
-	with no leading spaces on blank line.
-*/
-}
-
-
-// Some interesting interspersed comments.
-// See below for more common cases.
-func _(/* this */x/* is *//* an */ int) {
-}
-
-func _(/* no params - extra blank before and after comment */) {}
-func _(a, b int /* params - no extra blank after comment */) {}
-
-func _() { f(/* no args - extra blank before and after comment */) }
-func _() { f(a, b /* args - no extra blank after comment */) }
-
-func _() {
-	f(/* no args - extra blank before and after comment */)
-	f(a, b /* args - no extra blank after comment */)
-}
-
-func (/* comment1 */ T /* comment2 */) _() {}
-
-func _() { /* "short-ish one-line functions with comments are formatted as multi-line functions */ }
-func _() { x := 0; /* comment */ y = x /* comment */ }
-
-func _() {
-	_ = 0
-	/* closing curly brace should be on new line */ }
-
-func _() {
-	_ = []int{0, 1 /* don't introduce a newline after this comment - was issue 1365 */}
-}
-
-// Test cases from issue 1542:
-// Comments must not be placed before commas and cause invalid programs.
-func _() {
-	var a = []int{1, 2, /*jasldf*/
-	}
-	_ = a
-}
-
-func _() {
-	var a = []int{1, 2, /*jasldf
-						*/
-	}
-	_ = a
-}
-
-func _() {
-	var a = []int{1, 2, // jasldf
-	}
-	_ = a
-}
-
-// Comments immediately adjacent to punctuation followed by a newline
-// remain after the punctuation (looks better and permits alignment of
-// comments).
-func _() {
-	_ = T{
-		1,    // comment after comma
-		2,    /* comment after comma */
-		3  ,  // comment after comma
-	}
-	_ = T{
-		1  ,// comment after comma
-		2  ,/* comment after comma */
-		3,// comment after comma
-	}
-	_ = T{
-		/* comment before literal */1,
-		2/* comment before comma - ok to move after comma */,
-		3  /* comment before comma - ok to move after comma */  ,
-	}
-
-	for
-		i=0;// comment after semicolon
-		i<9;/* comment after semicolon */
-		i++{// comment after opening curly brace
-	}
-
-	// TODO(gri) the last comment in this example should be aligned */
-	for
-		i=0;// comment after semicolon
-		i<9/* comment before semicolon - ok to move after semicolon */;
-		i++ /* comment before opening curly brace */ {
-	}
-}
-
-// If there is no newline following punctuation, commas move before the punctuation.
-// This way, commas interspersed in lists stay with the respective expression.
-func f(x/* comment */, y int, z int /* comment */, u, v, w int /* comment */) {
-	f(x /* comment */, y)
-	f(x /* comment */, 
-	y)
-	f(
-		x /* comment */,
-	)
-}
-
-func g(
-	x int /* comment */,
-) {}
-
-type _ struct {
-	a, b /* comment */, c int
-}
-
-type _ struct { a, b /* comment */, c int }
-
-func _() {
-	for a /* comment */, b := range x {
-	}
-}
-
-// Print line directives correctly.
-
-// The following is a legal line directive.
-//line foo:1
-func _() {
-	_ = 0
-// The following is a legal line directive. It must not be indented:
-//line foo:2
-	_ = 1
-
-// The following is not a legal line directive (it doesn't start in column 1):
-	//line foo:2
-	_ = 2
-
-// The following is not a legal line directive (negative line number):
-//line foo:-3
-	_ = 3
-}
-
-// Line comments with tabs
-func _() {
-var	finput		*bufio.Reader			// input file
-var	stderr		*bufio.Writer
-var	ftable		*bufio.Writer			// y.go file
-var	foutput		*bufio.Writer			// y.output file
-
-var	oflag		string				// -o [y.go]		- y.go file
-var	vflag		string				// -v [y.output]	- y.output file
-var	lflag		bool				// -l			- disable line directives
-}
-
-// Trailing white space in comments should be trimmed
-func _() {
-// This comment has 4 blanks following that should be trimmed:    
-/* Each line of this comment has blanks or tabs following that should be trimmed:	
-   line 2:    
-   line 3:    			
-*/
-}
-
-/* This comment is the last entry in this file. It must be printed and should be followed by a newline */
diff --git a/third_party/golang/go/printer/testdata/comments.x b/third_party/golang/go/printer/testdata/comments.x
deleted file mode 100644
index ae7729286e5a6..0000000000000
--- a/third_party/golang/go/printer/testdata/comments.x
+++ /dev/null
@@ -1,56 +0,0 @@
-// This is a package for testing comment placement by go/printer.
-//
-package main
-
-// The SZ struct; it is empty.
-type SZ struct{}
-
-// The S0 struct; no field is exported.
-type S0 struct {
-	// contains filtered or unexported fields
-}
-
-// The S1 struct; some fields are not exported.
-type S1 struct {
-	S0
-	A, B, C	float	// 3 exported fields
-	D	int	// 2 unexported fields
-	// contains filtered or unexported fields
-}
-
-// The S2 struct; all fields are exported.
-type S2 struct {
-	S1
-	A, B, C	float	// 3 exported fields
-}
-
-// The IZ interface; it is empty.
-type SZ interface{}
-
-// The I0 interface; no method is exported.
-type I0 interface {
-	// contains filtered or unexported methods
-}
-
-// The I1 interface; some methods are not exported.
-type I1 interface {
-	I0
-	F(x float) float	// exported methods
-	// contains filtered or unexported methods
-}
-
-// The I2 interface; all methods are exported.
-type I2 interface {
-	I0
-	F(x float) float	// exported method
-	G(x float) float	// exported method
-}
-
-// The S3 struct; all comments except for the last one must appear in the export.
-type S3 struct {
-	// lead comment for F1
-	F1	int	// line comment for F1
-	// lead comment for F2
-	F2	int	// line comment for F2
-	// contains filtered or unexported fields
-}
diff --git a/third_party/golang/go/printer/testdata/comments2.golden b/third_party/golang/go/printer/testdata/comments2.golden
deleted file mode 100644
index 7676a26c1259e..0000000000000
--- a/third_party/golang/go/printer/testdata/comments2.golden
+++ /dev/null
@@ -1,105 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This is a package for testing comment placement by go/printer.
-//
-package main
-
-// Test cases for idempotent comment formatting (was issue 1835).
-/*
-c1a
-*/
-/*
-   c1b
-*/
-/* foo
-c1c
-*/
-/* foo
-   c1d
-*/
-/*
-c1e
-foo */
-/*
-   c1f
-   foo */
-
-func f() {
-	/*
-	   c2a
-	*/
-	/*
-	   c2b
-	*/
-	/* foo
-	   c2c
-	*/
-	/* foo
-	   c2d
-	*/
-	/*
-	   c2e
-	   foo */
-	/*
-	   c2f
-	   foo */
-}
-
-func g() {
-	/*
-	   c3a
-	*/
-	/*
-	   c3b
-	*/
-	/* foo
-	   c3c
-	*/
-	/* foo
-	   c3d
-	*/
-	/*
-	   c3e
-	   foo */
-	/*
-	   c3f
-	   foo */
-}
-
-// Test case taken literally from issue 1835.
-func main() {
-	/*
-	   prints test 5 times
-	*/
-	for i := 0; i < 5; i++ {
-		println("test")
-	}
-}
-
-func issue5623() {
-L:
-	_ = yyyyyyyyyyyyyyyy			// comment - should be aligned
-	_ = xxxxxxxxxxxxxxxxxxxxxxxxxxxx	/* comment */
-
-	_ = yyyyyyyyyyyyyyyy			/* comment - should be aligned */
-	_ = xxxxxxxxxxxxxxxxxxxxxxxxxxxx	// comment
-
-LLLLLLL:
-	_ = yyyyyyyyyyyyyyyy			// comment - should be aligned
-	_ = xxxxxxxxxxxxxxxxxxxxxxxxxxxx	// comment
-
-LL:
-LLLLL:
-	_ = xxxxxxxxxxxxxxxxxxxxxxxxxxxx	/* comment */
-	_ = yyyyyyyyyyyyyyyy			/* comment - should be aligned */
-
-	_ = xxxxxxxxxxxxxxxxxxxxxxxxxxxx	// comment
-	_ = yyyyyyyyyyyyyyyy			// comment - should be aligned
-
-	// test case from issue
-label:
-	mask := uint64(1)<>4
-	_ = "foo" + s
-	_ = s + "foo"
-	_ = 'a' + 'b'
-	_ = len(s) / 2
-	_ = len(t0.x) / a
-
-	// spaces around expressions of different precedence or expressions containing spaces
-	_ = a + -b
-	_ = a - ^b
-	_ = a / *p
-	_ = a + b*c
-	_ = 1 + b*c
-	_ = a + 2*c
-	_ = a + c*2
-	_ = 1 + 2*3
-	_ = s[1 : 2*3]
-	_ = s[a : b-c]
-	_ = s[0:]
-	_ = s[a+b]
-	_ = s[:b-c]
-	_ = s[a+b:]
-	_ = a[a< b
-	_ = a >= b
-	_ = a < b
-	_ = a <= b
-	_ = a < b && c > d
-	_ = a < b || c > d
-
-	// spaces around "long" operands
-	_ = a + longIdentifier1
-	_ = longIdentifier1 + a
-	_ = longIdentifier1 + longIdentifier2*longIdentifier3
-	_ = s + "a longer string"
-
-	// some selected cases
-	_ = a + t0.x
-	_ = a + t0.x + t1.x*t2.x
-	_ = a + b + c + d + e + 2*3
-	_ = a + b + c + 2*3 + d + e
-	_ = (a + b + c) * 2
-	_ = a - b + c - d + (a + b + c) + d&e
-	_ = under_bar - 1
-	_ = Open(dpath+"/file", O_WRONLY|O_CREAT, 0666)
-	_ = int(c0&_Mask4)<<18 | int(c1&_Maskx)<<12 | int(c2&_Maskx)<<6 | int(c3&_Maskx)
-
-	// test case for issue 8021
-	// want:
-	//  ([]bool{})[([]int{})[((1)+(((1)+((((1)*(((1)+(1))+(1)))+(1))*(1)))+(1)))]]
-	_ = ([]bool{})[([]int{})[((1)+(((1)+((((1)*(((1)+(1))+(1)))+(1))*(1)))+(1)))]]
-
-	// the parser does not restrict expressions that may appear as statements
-	true
-	42
-	"foo"
-	x
-	(x)
-	a + b
-	a + b + c
-	a + (b * c)
-	a + (b / c)
-	1 + a
-	a + 1
-	s[a]
-	x << 1
-	(s[0] << 1) & 0xf
-	"foo" + s
-	x == y
-	x < y || z > 42
-}
-
-// slice expressions with cap
-func _() {
-	_ = x[a:b:c]
-	_ = x[a:b : c+d]
-	_ = x[a : b+d : c]
-	_ = x[a : b+d : c+d]
-	_ = x[a+d : b:c]
-	_ = x[a+d : b : c+d]
-	_ = x[a+d : b+d : c]
-	_ = x[a+d : b+d : c+d]
-
-	_ = x[:b:c]
-	_ = x[:b : c+d]
-	_ = x[:b+d : c]
-	_ = x[:b+d : c+d]
-}
-
-func _() {
-	_ = a + b
-	_ = a + b + c
-	_ = a + b*c
-	_ = a + (b * c)
-	_ = (a + b) * c
-	_ = a + (b * c * d)
-	_ = a + (b*c + d)
-
-	_ = 1 << x
-	_ = -1 << x
-	_ = 1<>4
-
-	b.buf = b.buf[0 : b.off+m+n]
-	b.buf = b.buf[0 : b.off+m*n]
-	f(b.buf[0 : b.off+m+n])
-
-	signed += ' ' * 8
-	tw.octal(header[148:155], chksum)
-
-	_ = x > 0 && i >= 0
-
-	x1, x0 := x>>w2, x&m2
-	z0 = t1<>w2) >> w2
-	q1, r1 := x1/d1, x1%d1
-	r1 = r1*b2 | x0>>w2
-	x1 = (x1 << z) | (x0 >> (uint(w) - z))
-	x1 = x1<>(uint(w)-z)
-
-	_ = buf[0 : len(buf)+1]
-	_ = buf[0 : n+1]
-
-	a, b = b, a
-	a = b + c
-	a = b*c + d
-	_ = a*b + c
-	_ = a - b - c
-	_ = a - (b - c)
-	_ = a - b*c
-	_ = a - (b * c)
-	_ = a * b / c
-	_ = a / *b
-	_ = x[a|^b]
-	_ = x[a / *b]
-	_ = a & ^b
-	_ = a + +b
-	_ = a - -b
-	_ = x[a*-b]
-	_ = x[a + +b]
-	_ = x ^ y ^ z
-	_ = b[a>>24] ^ b[(a>>16)&0xFF] ^ b[(a>>8)&0xFF] ^ b[a&0xFF]
-	_ = len(longVariableName) * 2
-
-	_ = token(matchType + xlength<> 4
-	_ = "foo"+s
-	_ = s+"foo"
-	_ = 'a'+'b'
-	_ = len(s)/2
-	_ = len(t0.x)/a
-
-	// spaces around expressions of different precedence or expressions containing spaces
-	_ = a + -b
-	_ = a - ^b
-	_ = a / *p
-	_ = a + b*c
-	_ = 1 + b*c
-	_ = a + 2*c
-	_ = a + c*2
-	_ = 1 + 2*3
-	_ = s[1 : 2*3]
-	_ = s[a : b-c]
-	_ = s[0:]
-	_ = s[a+b]
-	_ = s[: b-c]
-	_ = s[a+b :]
-	_ = a[a< b
-	_ = a >= b
-	_ = a < b
-	_ = a <= b
-	_ = a < b && c > d
-	_ = a < b || c > d
-
-	// spaces around "long" operands
-	_ = a + longIdentifier1
-	_ = longIdentifier1 + a
-	_ = longIdentifier1 + longIdentifier2 * longIdentifier3
-	_ = s + "a longer string"
-
-	// some selected cases
-	_ = a + t0.x
-	_ = a + t0.x + t1.x * t2.x
-	_ = a + b + c + d + e + 2*3
-	_ = a + b + c + 2*3 + d + e
-	_ = (a+b+c)*2
-	_ = a - b + c - d + (a+b+c) + d&e
-	_ = under_bar-1
-	_ = Open(dpath + "/file", O_WRONLY | O_CREAT, 0666)
-	_ = int(c0&_Mask4)<<18 | int(c1&_Maskx)<<12 | int(c2&_Maskx)<<6 | int(c3&_Maskx)
-
-	// test case for issue 8021
-	// want:
-	//  ([]bool{})[([]int{})[((1)+(((1)+((((1)*(((1)+(1))+(1)))+(1))*(1)))+(1)))]]
-	_ = ([]bool{})[([]int{})[((1) + (((((1) + (((((((1) * (((((1) + (1))) + (1))))) + (1))) * (1))))) + (1))))]]
-
-	// the parser does not restrict expressions that may appear as statements
-	true
-	42
-	"foo"
-	x
-	(x)
-	a+b
-	a+b+c
-	a+(b*c)
-	a+(b/c)
-	1+a
-	a+1
-	s[a]
-	x<<1
-	(s[0]<<1)&0xf
-	"foo"+s
-	x == y
-	x < y || z > 42
-}
-
-
-// slice expressions with cap
-func _() {
-	_ = x[a:b:c]
-	_ = x[a:b:c+d]
-	_ = x[a:b+d:c]
-	_ = x[a:b+d:c+d]
-	_ = x[a+d:b:c]
-	_ = x[a+d:b:c+d]
-	_ = x[a+d:b+d:c]
-	_ = x[a+d:b+d:c+d]
-
-	_ = x[:b:c]
-	_ = x[:b:c+d]
-	_ = x[:b+d:c]
-	_ = x[:b+d:c+d]
-}
-
-func _() {
-	_ = a+b
-	_ = a+b+c
-	_ = a+b*c
-	_ = a+(b*c)
-	_ = (a+b)*c
-	_ = a+(b*c*d)
-	_ = a+(b*c+d)
-
-	_ = 1<>4
-
-	b.buf = b.buf[0:b.off+m+n]
-	b.buf = b.buf[0:b.off+m*n]
-	f(b.buf[0:b.off+m+n])
-
-	signed += ' '*8
-	tw.octal(header[148:155], chksum)
-
-	_ = x > 0 && i >= 0
-
-	x1, x0 := x>>w2, x&m2
-	z0 = t1<>w2)>>w2
-	q1, r1 := x1/d1, x1%d1
-	r1 = r1*b2 | x0>>w2
-	x1 = (x1<>(uint(w)-z))
-	x1 = x1<>(uint(w)-z)
-
-	_ = buf[0:len(buf)+1]
-	_ = buf[0:n+1]
-
-	a,b = b,a
-	a = b+c
-	a = b*c+d
-	_ = a*b+c
-	_ = a-b-c
-	_ = a-(b-c)
-	_ = a-b*c
-	_ = a-(b*c)
-	_ = a*b/c
-	_ = a/ *b
-	_ = x[a|^b]
-	_ = x[a/ *b]
-	_ = a& ^b
-	_ = a+ +b
-	_ = a- -b
-	_ = x[a*-b]
-	_ = x[a+ +b]
-	_ = x^y^z
-	_ = b[a>>24] ^ b[(a>>16)&0xFF] ^ b[(a>>8)&0xFF] ^ b[a&0xFF]
-	_ = len(longVariableName)*2
-
-	_ = token(matchType + xlength<>4
-	_ = "foo" + s
-	_ = s + "foo"
-	_ = 'a' + 'b'
-	_ = len(s) / 2
-	_ = len(t0.x) / a
-
-	// spaces around expressions of different precedence or expressions containing spaces
-	_ = a + -b
-	_ = a - ^b
-	_ = a / *p
-	_ = a + b*c
-	_ = 1 + b*c
-	_ = a + 2*c
-	_ = a + c*2
-	_ = 1 + 2*3
-	_ = s[1 : 2*3]
-	_ = s[a : b-c]
-	_ = s[0:]
-	_ = s[a+b]
-	_ = s[:b-c]
-	_ = s[a+b:]
-	_ = a[a< b
-	_ = a >= b
-	_ = a < b
-	_ = a <= b
-	_ = a < b && c > d
-	_ = a < b || c > d
-
-	// spaces around "long" operands
-	_ = a + longIdentifier1
-	_ = longIdentifier1 + a
-	_ = longIdentifier1 + longIdentifier2*longIdentifier3
-	_ = s + "a longer string"
-
-	// some selected cases
-	_ = a + t0.x
-	_ = a + t0.x + t1.x*t2.x
-	_ = a + b + c + d + e + 2*3
-	_ = a + b + c + 2*3 + d + e
-	_ = (a + b + c) * 2
-	_ = a - b + c - d + (a + b + c) + d&e
-	_ = under_bar - 1
-	_ = Open(dpath+"/file", O_WRONLY|O_CREAT, 0666)
-	_ = int(c0&_Mask4)<<18 | int(c1&_Maskx)<<12 | int(c2&_Maskx)<<6 | int(c3&_Maskx)
-
-	// test case for issue 8021
-	// want:
-	//  ([]bool{})[([]int{})[((1)+(((1)+((((1)*(((1)+(1))+(1)))+(1))*(1)))+(1)))]]
-	_ = ([]bool{})[([]int{})[((1)+(((1)+((((1)*(((1)+(1))+(1)))+(1))*(1)))+(1)))]]
-
-	// the parser does not restrict expressions that may appear as statements
-	true
-	42
-	"foo"
-	x
-	(x)
-	a + b
-	a + b + c
-	a + (b * c)
-	a + (b / c)
-	1 + a
-	a + 1
-	s[a]
-	x << 1
-	(s[0] << 1) & 0xf
-	"foo" + s
-	x == y
-	x < y || z > 42
-}
-
-// slice expressions with cap
-func _() {
-	_ = x[a:b:c]
-	_ = x[a:b : c+d]
-	_ = x[a : b+d : c]
-	_ = x[a : b+d : c+d]
-	_ = x[a+d : b:c]
-	_ = x[a+d : b : c+d]
-	_ = x[a+d : b+d : c]
-	_ = x[a+d : b+d : c+d]
-
-	_ = x[:b:c]
-	_ = x[:b : c+d]
-	_ = x[:b+d : c]
-	_ = x[:b+d : c+d]
-}
-
-func _() {
-	_ = a + b
-	_ = a + b + c
-	_ = a + b*c
-	_ = a + (b * c)
-	_ = (a + b) * c
-	_ = a + (b * c * d)
-	_ = a + (b*c + d)
-
-	_ = 1 << x
-	_ = -1 << x
-	_ = 1<>4
-
-	b.buf = b.buf[0 : b.off+m+n]
-	b.buf = b.buf[0 : b.off+m*n]
-	f(b.buf[0 : b.off+m+n])
-
-	signed += ' ' * 8
-	tw.octal(header[148:155], chksum)
-
-	_ = x > 0 && i >= 0
-
-	x1, x0 := x>>w2, x&m2
-	z0 = t1<>w2) >> w2
-	q1, r1 := x1/d1, x1%d1
-	r1 = r1*b2 | x0>>w2
-	x1 = (x1 << z) | (x0 >> (uint(w) - z))
-	x1 = x1<>(uint(w)-z)
-
-	_ = buf[0 : len(buf)+1]
-	_ = buf[0 : n+1]
-
-	a, b = b, a
-	a = b + c
-	a = b*c + d
-	_ = a*b + c
-	_ = a - b - c
-	_ = a - (b - c)
-	_ = a - b*c
-	_ = a - (b * c)
-	_ = a * b / c
-	_ = a / *b
-	_ = x[a|^b]
-	_ = x[a / *b]
-	_ = a & ^b
-	_ = a + +b
-	_ = a - -b
-	_ = x[a*-b]
-	_ = x[a + +b]
-	_ = x ^ y ^ z
-	_ = b[a>>24] ^ b[(a>>16)&0xFF] ^ b[(a>>8)&0xFF] ^ b[a&0xFF]
-	_ = len(longVariableName) * 2
-
-	_ = token(matchType + xlength< /tmp/16gig.txt
-	//   tar -b 1 -c -f- /tmp/16gig.txt | dd bs=512 count=8 > writer-big.tar
-	&writerTest{
-		file:	"testdata/writer-big.tar",
-		entries: []*writerTestEntry{
-			&writerTestEntry{
-				header: &Header{
-					Name:		"tmp/16gig.txt",
-					Mode:		0640,
-					Uid:		73025,
-					Gid:		5000,
-					Size:		16 << 30,
-					Mtime:		1254699560,
-					Typeflag:	'0',
-					Uname:		"dsymonds",
-					Gname:		"eng",
-				},
-				// no contents
-			},
-		},
-	},
-}
-
-type untarTest struct {
-	file	string
-	headers	[]*Header
-}
-
-var untarTests = []*untarTest{
-	&untarTest{
-		file:	"testdata/gnu.tar",
-		headers: []*Header{
-			&Header{
-				Name:		"small.txt",
-				Mode:		0640,
-				Uid:		73025,
-				Gid:		5000,
-				Size:		5,
-				Mtime:		1244428340,
-				Typeflag:	'0',
-				Uname:		"dsymonds",
-				Gname:		"eng",
-			},
-			&Header{
-				Name:		"small2.txt",
-				Mode:		0640,
-				Uid:		73025,
-				Gid:		5000,
-				Size:		11,
-				Mtime:		1244436044,
-				Typeflag:	'0',
-				Uname:		"dsymonds",
-				Gname:		"eng",
-			},
-		},
-	},
-	&untarTest{
-		file:	"testdata/star.tar",
-		headers: []*Header{
-			&Header{
-				Name:		"small.txt",
-				Mode:		0640,
-				Uid:		73025,
-				Gid:		5000,
-				Size:		5,
-				Mtime:		1244592783,
-				Typeflag:	'0',
-				Uname:		"dsymonds",
-				Gname:		"eng",
-				Atime:		1244592783,
-				Ctime:		1244592783,
-			},
-			&Header{
-				Name:		"small2.txt",
-				Mode:		0640,
-				Uid:		73025,
-				Gid:		5000,
-				Size:		11,
-				Mtime:		1244592783,
-				Typeflag:	'0',
-				Uname:		"dsymonds",
-				Gname:		"eng",
-				Atime:		1244592783,
-				Ctime:		1244592783,
-			},
-		},
-	},
-	&untarTest{
-		file:	"testdata/v7.tar",
-		headers: []*Header{
-			&Header{
-				Name:		"small.txt",
-				Mode:		0444,
-				Uid:		73025,
-				Gid:		5000,
-				Size:		5,
-				Mtime:		1244593104,
-				Typeflag:	'\x00',
-			},
-			&Header{
-				Name:		"small2.txt",
-				Mode:		0444,
-				Uid:		73025,
-				Gid:		5000,
-				Size:		11,
-				Mtime:		1244593104,
-				Typeflag:	'\x00',
-			},
-		},
-	},
-}
-
-var facts = map[int]string{
-	0:	"1",
-	1:	"1",
-	2:	"2",
-	10:	"3628800",
-	20:	"2432902008176640000",
-	100: "933262154439441526816992388562667004907159682643816214685929" +
-		"638952175999932299156089414639761565182862536979208272237582" +
-		"51185210916864000000000000000000000000",
-}
-
-func usage() {
-	fmt.Fprintf(os.Stderr,
-		// TODO(gri): the 2nd string of this string list should not be indented
-		"usage: godoc package [name ...]\n"+
-			"	godoc -http=:6060\n")
-	flag.PrintDefaults()
-	os.Exit(2)
-}
-
-func TestReader(t *testing.T) {
-testLoop:
-	for i, test := range untarTests {
-		f, err := os.Open(test.file, os.O_RDONLY, 0444)
-		if err != nil {
-			t.Errorf("test %d: Unexpected error: %v", i, err)
-			continue
-		}
-		tr := NewReader(f)
-		for j, header := range test.headers {
-			hdr, err := tr.Next()
-			if err != nil || hdr == nil {
-				t.Errorf("test %d, entry %d: Didn't get entry: %v", i, j, err)
-				f.Close()
-				continue testLoop
-			}
-			if !reflect.DeepEqual(hdr, header) {
-				t.Errorf("test %d, entry %d: Incorrect header:\nhave %+v\nwant %+v",
-					i, j, *hdr, *header)
-			}
-		}
-		hdr, err := tr.Next()
-		if hdr != nil || err != nil {
-			t.Errorf("test %d: Unexpected entry or error: hdr=%v err=%v", i, err)
-		}
-		f.Close()
-	}
-}
-
-// Respect line breaks in function calls.
-func _() {
-	f(x)
-	f(x,
-		x)
-	f(x,
-		x,
-	)
-	f(
-		x,
-		x)
-	f(
-		x,
-		x,
-	)
-}
-
-// Respect line breaks in function declarations.
-func _(x T)	{}
-func _(x T,
-	y T) {
-}
-func _(x T,
-	y T,
-) {
-}
-func _(
-	x T,
-	y T) {
-}
-func _(
-	x T,
-	y T,
-) {
-}
-
-// Example from issue 2597.
-func ManageStatus0(
-	in <-chan *Status,
-	req <-chan Request,
-	stat chan<- *TargetInfo,
-	TargetHistorySize int) {
-}
-
-func ManageStatus1(
-	in <-chan *Status,
-	req <-chan Request,
-	stat chan<- *TargetInfo,
-	TargetHistorySize int,
-) {
-}
-
-// There should be exactly one linebreak after this comment.
diff --git a/third_party/golang/go/printer/testdata/linebreaks.input b/third_party/golang/go/printer/testdata/linebreaks.input
deleted file mode 100644
index e782bb0444370..0000000000000
--- a/third_party/golang/go/printer/testdata/linebreaks.input
+++ /dev/null
@@ -1,271 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package linebreaks
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"os"
-	"reflect"
-	"strings"
-	"testing"
-)
-
-type writerTestEntry struct {
-	header *Header
-	contents string
-}
-
-type writerTest struct {
-	file string  // filename of expected output
-	entries []*writerTestEntry
-}
-
-var writerTests = []*writerTest{
-	&writerTest{
-		file: "testdata/writer.tar",
-		entries: []*writerTestEntry{
-			&writerTestEntry{
-				header: &Header{
-					Name: "small.txt",
-					Mode: 0640,
-					Uid: 73025,
-					Gid: 5000,
-					Size: 5,
-					Mtime: 1246508266,
-					Typeflag: '0',
-					Uname: "dsymonds",
-					Gname: "eng",
-				},
-				contents: "Kilts",
-			},
-			&writerTestEntry{
-				header: &Header{
-					Name: "small2.txt",
-					Mode: 0640,
-					Uid: 73025,
-					Gid: 5000,
-					Size: 11,
-					Mtime: 1245217492,
-					Typeflag: '0',
-					Uname: "dsymonds",
-					Gname: "eng",
-				},
-				contents: "Google.com\n",
-			},
-		},
-	},
-	// The truncated test file was produced using these commands:
-	//   dd if=/dev/zero bs=1048576 count=16384 > /tmp/16gig.txt
-	//   tar -b 1 -c -f- /tmp/16gig.txt | dd bs=512 count=8 > writer-big.tar
-	&writerTest{
-		file: "testdata/writer-big.tar",
-		entries: []*writerTestEntry{
-			&writerTestEntry{
-				header: &Header{
-					Name: "tmp/16gig.txt",
-					Mode: 0640,
-					Uid: 73025,
-					Gid: 5000,
-					Size: 16 << 30,
-					Mtime: 1254699560,
-					Typeflag: '0',
-					Uname: "dsymonds",
-					Gname: "eng",
-				},
-				// no contents
-			},
-		},
-	},
-}
-
-type untarTest struct {
-	file string
-	headers []*Header
-}
-
-var untarTests = []*untarTest{
-	&untarTest{
-		file: "testdata/gnu.tar",
-		headers: []*Header{
-			&Header{
-				Name: "small.txt",
-				Mode: 0640,
-				Uid: 73025,
-				Gid: 5000,
-				Size: 5,
-				Mtime: 1244428340,
-				Typeflag: '0',
-				Uname: "dsymonds",
-				Gname: "eng",
-			},
-			&Header{
-				Name: "small2.txt",
-				Mode: 0640,
-				Uid: 73025,
-				Gid: 5000,
-				Size: 11,
-				Mtime: 1244436044,
-				Typeflag: '0',
-				Uname: "dsymonds",
-				Gname: "eng",
-			},
-		},
-	},
-	&untarTest{
-		file: "testdata/star.tar",
-		headers: []*Header{
-			&Header{
-				Name: "small.txt",
-				Mode: 0640,
-				Uid: 73025,
-				Gid: 5000,
-				Size: 5,
-				Mtime: 1244592783,
-				Typeflag: '0',
-				Uname: "dsymonds",
-				Gname: "eng",
-				Atime: 1244592783,
-				Ctime: 1244592783,
-			},
-			&Header{
-				Name: "small2.txt",
-				Mode: 0640,
-				Uid: 73025,
-				Gid: 5000,
-				Size: 11,
-				Mtime: 1244592783,
-				Typeflag: '0',
-				Uname: "dsymonds",
-				Gname: "eng",
-				Atime: 1244592783,
-				Ctime: 1244592783,
-			},
-		},
-	},
-	&untarTest{
-		file: "testdata/v7.tar",
-		headers: []*Header{
-			&Header{
-				Name: "small.txt",
-				Mode: 0444,
-				Uid: 73025,
-				Gid: 5000,
-				Size: 5,
-				Mtime: 1244593104,
-				Typeflag: '\x00',
-			},
-			&Header{
-				Name: "small2.txt",
-				Mode: 0444,
-				Uid: 73025,
-				Gid: 5000,
-				Size: 11,
-				Mtime: 1244593104,
-				Typeflag: '\x00',
-			},
-		},
-	},
-}
-
-var facts = map[int] string {
-	0: "1",
-	1: "1",
-	2: "2",
-	10: "3628800",
-	20: "2432902008176640000",
-	100: "933262154439441526816992388562667004907159682643816214685929" +
-		"638952175999932299156089414639761565182862536979208272237582" +
-		"51185210916864000000000000000000000000",
-}
-
-func usage() {
-	fmt.Fprintf(os.Stderr,
-		// TODO(gri): the 2nd string of this string list should not be indented
-		"usage: godoc package [name ...]\n" +
-		"	godoc -http=:6060\n")
-	flag.PrintDefaults()
-	os.Exit(2)
-}
-
-func TestReader(t *testing.T) {
-testLoop:
-	for i, test := range untarTests {
-		f, err := os.Open(test.file, os.O_RDONLY, 0444)
-		if err != nil {
-			t.Errorf("test %d: Unexpected error: %v", i, err)
-			continue
-		}
-		tr := NewReader(f)
-		for j, header := range test.headers {
-			hdr, err := tr.Next()
-			if err != nil || hdr == nil {
-				t.Errorf("test %d, entry %d: Didn't get entry: %v", i, j, err)
-				f.Close()
-				continue testLoop
-			}
-			if !reflect.DeepEqual(hdr, header) {
-				t.Errorf("test %d, entry %d: Incorrect header:\nhave %+v\nwant %+v",
-					 i, j, *hdr, *header)
-			}
-		}
-		hdr, err := tr.Next()
-		if hdr != nil || err != nil {
-			t.Errorf("test %d: Unexpected entry or error: hdr=%v err=%v", i, err)
-		}
-		f.Close()
-	}
-}
-
-// Respect line breaks in function calls.
-func _() {
-	f(x)
-	f(x,
-	  x)
-	f(x,
-	  x,
-	)
-	f(
-	  x,
-	  x)
-	f(
-	  x,
-	  x,
-	)
-}
-
-// Respect line breaks in function declarations.
-func _(x T) {}
-func _(x T,
-       y T) {}
-func _(x T,
-       y T,
-) {}
-func _(
-       x T,
-       y T) {}
-func _(
-       x T,
-       y T,
-) {}
-
-// Example from issue 2597.
-func ManageStatus0(
-	in <-chan *Status,
-	req <-chan Request,
-	stat chan<- *TargetInfo,
-	TargetHistorySize int) {
-}
-    
-func ManageStatus1(
-	in <-chan *Status,
-	req <-chan Request,
-	stat chan<- *TargetInfo,
-	TargetHistorySize int,
-) {
-}
-    
-// There should be exactly one linebreak after this comment.
diff --git a/third_party/golang/go/printer/testdata/parser.go b/third_party/golang/go/printer/testdata/parser.go
deleted file mode 100644
index f84628f535a2f..0000000000000
--- a/third_party/golang/go/printer/testdata/parser.go
+++ /dev/null
@@ -1,2153 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package parser implements a parser for Go source files. Input may be
-// provided in a variety of forms (see the various Parse* functions); the
-// output is an abstract syntax tree (AST) representing the Go source. The
-// parser is invoked through one of the Parse* functions.
-
-package parser
-
-import (
-	"fmt"
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"k8s.io/kubernetes/third_party/golang/go/scanner"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-)
-
-// The mode parameter to the Parse* functions is a set of flags (or 0).
-// They control the amount of source code parsed and other optional
-// parser functionality.
-//
-const (
-	PackageClauseOnly uint = 1 << iota // parsing stops after package clause
-	ImportsOnly                        // parsing stops after import declarations
-	ParseComments                      // parse comments and add them to AST
-	Trace                              // print a trace of parsed productions
-	DeclarationErrors                  // report declaration errors
-)
-
-// The parser structure holds the parser's internal state.
-type parser struct {
-	file *token.File
-	scanner.ErrorVector
-	scanner scanner.Scanner
-
-	// Tracing/debugging
-	mode   uint // parsing mode
-	trace  bool // == (mode & Trace != 0)
-	indent uint // indentation used for tracing output
-
-	// Comments
-	comments    []*ast.CommentGroup
-	leadComment *ast.CommentGroup // last lead comment
-	lineComment *ast.CommentGroup // last line comment
-
-	// Next token
-	pos token.Pos   // token position
-	tok token.Token // one token look-ahead
-	lit string      // token literal
-
-	// Non-syntactic parser control
-	exprLev int // < 0: in control clause, >= 0: in expression
-
-	// Ordinary identifier scopes
-	pkgScope   *ast.Scope        // pkgScope.Outer == nil
-	topScope   *ast.Scope        // top-most scope; may be pkgScope
-	unresolved []*ast.Ident      // unresolved identifiers
-	imports    []*ast.ImportSpec // list of imports
-
-	// Label scope
-	// (maintained by open/close LabelScope)
-	labelScope  *ast.Scope     // label scope for current function
-	targetStack [][]*ast.Ident // stack of unresolved labels
-}
-
-// scannerMode returns the scanner mode bits given the parser's mode bits.
-func scannerMode(mode uint) uint {
-	var m uint = scanner.InsertSemis
-	if mode&ParseComments != 0 {
-		m |= scanner.ScanComments
-	}
-	return m
-}
-
-func (p *parser) init(fset *token.FileSet, filename string, src []byte, mode uint) {
-	p.file = fset.AddFile(filename, fset.Base(), len(src))
-	p.scanner.Init(p.file, src, p, scannerMode(mode))
-
-	p.mode = mode
-	p.trace = mode&Trace != 0 // for convenience (p.trace is used frequently)
-
-	p.next()
-
-	// set up the pkgScope here (as opposed to in parseFile) because
-	// there are other parser entry points (ParseExpr, etc.)
-	p.openScope()
-	p.pkgScope = p.topScope
-
-	// for the same reason, set up a label scope
-	p.openLabelScope()
-}
-
-// ----------------------------------------------------------------------------
-// Scoping support
-
-func (p *parser) openScope() {
-	p.topScope = ast.NewScope(p.topScope)
-}
-
-func (p *parser) closeScope() {
-	p.topScope = p.topScope.Outer
-}
-
-func (p *parser) openLabelScope() {
-	p.labelScope = ast.NewScope(p.labelScope)
-	p.targetStack = append(p.targetStack, nil)
-}
-
-func (p *parser) closeLabelScope() {
-	// resolve labels
-	n := len(p.targetStack) - 1
-	scope := p.labelScope
-	for _, ident := range p.targetStack[n] {
-		ident.Obj = scope.Lookup(ident.Name)
-		if ident.Obj == nil && p.mode&DeclarationErrors != 0 {
-			p.error(ident.Pos(), fmt.Sprintf("label %s undefined", ident.Name))
-		}
-	}
-	// pop label scope
-	p.targetStack = p.targetStack[0:n]
-	p.labelScope = p.labelScope.Outer
-}
-
-func (p *parser) declare(decl interface{}, scope *ast.Scope, kind ast.ObjKind, idents ...*ast.Ident) {
-	for _, ident := range idents {
-		assert(ident.Obj == nil, "identifier already declared or resolved")
-		if ident.Name != "_" {
-			obj := ast.NewObj(kind, ident.Name)
-			// remember the corresponding declaration for redeclaration
-			// errors and global variable resolution/typechecking phase
-			obj.Decl = decl
-			if alt := scope.Insert(obj); alt != nil && p.mode&DeclarationErrors != 0 {
-				prevDecl := ""
-				if pos := alt.Pos(); pos.IsValid() {
-					prevDecl = fmt.Sprintf("\n\tprevious declaration at %s", p.file.Position(pos))
-				}
-				p.error(ident.Pos(), fmt.Sprintf("%s redeclared in this block%s", ident.Name, prevDecl))
-			}
-			ident.Obj = obj
-		}
-	}
-}
-
-func (p *parser) shortVarDecl(idents []*ast.Ident) {
-	// Go spec: A short variable declaration may redeclare variables
-	// provided they were originally declared in the same block with
-	// the same type, and at least one of the non-blank variables is new.
-	n := 0 // number of new variables
-	for _, ident := range idents {
-		assert(ident.Obj == nil, "identifier already declared or resolved")
-		if ident.Name != "_" {
-			obj := ast.NewObj(ast.Var, ident.Name)
-			// short var declarations cannot have redeclaration errors
-			// and are not global => no need to remember the respective
-			// declaration
-			alt := p.topScope.Insert(obj)
-			if alt == nil {
-				n++ // new declaration
-				alt = obj
-			}
-			ident.Obj = alt
-		}
-	}
-	if n == 0 && p.mode&DeclarationErrors != 0 {
-		p.error(idents[0].Pos(), "no new variables on left side of :=")
-	}
-}
-
-// The unresolved object is a sentinel to mark identifiers that have been added
-// to the list of unresolved identifiers. The sentinel is only used for verifying
-// internal consistency.
-var unresolved = new(ast.Object)
-
-func (p *parser) resolve(x ast.Expr) {
-	// nothing to do if x is not an identifier or the blank identifier
-	ident, _ := x.(*ast.Ident)
-	if ident == nil {
-		return
-	}
-	assert(ident.Obj == nil, "identifier already declared or resolved")
-	if ident.Name == "_" {
-		return
-	}
-	// try to resolve the identifier
-	for s := p.topScope; s != nil; s = s.Outer {
-		if obj := s.Lookup(ident.Name); obj != nil {
-			ident.Obj = obj
-			return
-		}
-	}
-	// all local scopes are known, so any unresolved identifier
-	// must be found either in the file scope, package scope
-	// (perhaps in another file), or universe scope --- collect
-	// them so that they can be resolved later
-	ident.Obj = unresolved
-	p.unresolved = append(p.unresolved, ident)
-}
-
-// ----------------------------------------------------------------------------
-// Parsing support
-
-func (p *parser) printTrace(a ...interface{}) {
-	const dots = ". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . " +
-		". . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . "
-	const n = uint(len(dots))
-	pos := p.file.Position(p.pos)
-	fmt.Printf("%5d:%3d: ", pos.Line, pos.Column)
-	i := 2 * p.indent
-	for ; i > n; i -= n {
-		fmt.Print(dots)
-	}
-	fmt.Print(dots[0:i])
-	fmt.Println(a...)
-}
-
-func trace(p *parser, msg string) *parser {
-	p.printTrace(msg, "(")
-	p.indent++
-	return p
-}
-
-// Usage pattern: defer un(trace(p, "..."));
-func un(p *parser) {
-	p.indent--
-	p.printTrace(")")
-}
-
-// Advance to the next token.
-func (p *parser) next0() {
-	// Because of one-token look-ahead, print the previous token
-	// when tracing as it provides a more readable output. The
-	// very first token (!p.pos.IsValid()) is not initialized
-	// (it is token.ILLEGAL), so don't print it .
-	if p.trace && p.pos.IsValid() {
-		s := p.tok.String()
-		switch {
-		case p.tok.IsLiteral():
-			p.printTrace(s, p.lit)
-		case p.tok.IsOperator(), p.tok.IsKeyword():
-			p.printTrace("\"" + s + "\"")
-		default:
-			p.printTrace(s)
-		}
-	}
-
-	p.pos, p.tok, p.lit = p.scanner.Scan()
-}
-
-// Consume a comment and return it and the line on which it ends.
-func (p *parser) consumeComment() (comment *ast.Comment, endline int) {
-	// /*-style comments may end on a different line than where they start.
-	// Scan the comment for '\n' chars and adjust endline accordingly.
-	endline = p.file.Line(p.pos)
-	if p.lit[1] == '*' {
-		// don't use range here - no need to decode Unicode code points
-		for i := 0; i < len(p.lit); i++ {
-			if p.lit[i] == '\n' {
-				endline++
-			}
-		}
-	}
-
-	comment = &ast.Comment{p.pos, p.lit}
-	p.next0()
-
-	return
-}
-
-// Consume a group of adjacent comments, add it to the parser's
-// comments list, and return it together with the line at which
-// the last comment in the group ends. An empty line or non-comment
-// token terminates a comment group.
-//
-func (p *parser) consumeCommentGroup() (comments *ast.CommentGroup, endline int) {
-	var list []*ast.Comment
-	endline = p.file.Line(p.pos)
-	for p.tok == token.COMMENT && endline+1 >= p.file.Line(p.pos) {
-		var comment *ast.Comment
-		comment, endline = p.consumeComment()
-		list = append(list, comment)
-	}
-
-	// add comment group to the comments list
-	comments = &ast.CommentGroup{list}
-	p.comments = append(p.comments, comments)
-
-	return
-}
-
-// Advance to the next non-comment token. In the process, collect
-// any comment groups encountered, and remember the last lead and
-// and line comments.
-//
-// A lead comment is a comment group that starts and ends in a
-// line without any other tokens and that is followed by a non-comment
-// token on the line immediately after the comment group.
-//
-// A line comment is a comment group that follows a non-comment
-// token on the same line, and that has no tokens after it on the line
-// where it ends.
-//
-// Lead and line comments may be considered documentation that is
-// stored in the AST.
-//
-func (p *parser) next() {
-	p.leadComment = nil
-	p.lineComment = nil
-	line := p.file.Line(p.pos) // current line
-	p.next0()
-
-	if p.tok == token.COMMENT {
-		var comment *ast.CommentGroup
-		var endline int
-
-		if p.file.Line(p.pos) == line {
-			// The comment is on same line as the previous token; it
-			// cannot be a lead comment but may be a line comment.
-			comment, endline = p.consumeCommentGroup()
-			if p.file.Line(p.pos) != endline {
-				// The next token is on a different line, thus
-				// the last comment group is a line comment.
-				p.lineComment = comment
-			}
-		}
-
-		// consume successor comments, if any
-		endline = -1
-		for p.tok == token.COMMENT {
-			comment, endline = p.consumeCommentGroup()
-		}
-
-		if endline+1 == p.file.Line(p.pos) {
-			// The next token is following on the line immediately after the
-			// comment group, thus the last comment group is a lead comment.
-			p.leadComment = comment
-		}
-	}
-}
-
-func (p *parser) error(pos token.Pos, msg string) {
-	p.Error(p.file.Position(pos), msg)
-}
-
-func (p *parser) errorExpected(pos token.Pos, msg string) {
-	msg = "expected " + msg
-	if pos == p.pos {
-		// the error happened at the current position;
-		// make the error message more specific
-		if p.tok == token.SEMICOLON && p.lit[0] == '\n' {
-			msg += ", found newline"
-		} else {
-			msg += ", found '" + p.tok.String() + "'"
-			if p.tok.IsLiteral() {
-				msg += " " + p.lit
-			}
-		}
-	}
-	p.error(pos, msg)
-}
-
-func (p *parser) expect(tok token.Token) token.Pos {
-	pos := p.pos
-	if p.tok != tok {
-		p.errorExpected(pos, "'"+tok.String()+"'")
-	}
-	p.next() // make progress
-	return pos
-}
-
-func (p *parser) expectSemi() {
-	if p.tok != token.RPAREN && p.tok != token.RBRACE {
-		p.expect(token.SEMICOLON)
-	}
-}
-
-func assert(cond bool, msg string) {
-	if !cond {
-		panic("go/parser internal error: " + msg)
-	}
-}
-
-// ----------------------------------------------------------------------------
-// Identifiers
-
-func (p *parser) parseIdent() *ast.Ident {
-	pos := p.pos
-	name := "_"
-	if p.tok == token.IDENT {
-		name = p.lit
-		p.next()
-	} else {
-		p.expect(token.IDENT) // use expect() error handling
-	}
-	return &ast.Ident{pos, name, nil}
-}
-
-func (p *parser) parseIdentList() (list []*ast.Ident) {
-	if p.trace {
-		defer un(trace(p, "IdentList"))
-	}
-
-	list = append(list, p.parseIdent())
-	for p.tok == token.COMMA {
-		p.next()
-		list = append(list, p.parseIdent())
-	}
-
-	return
-}
-
-// ----------------------------------------------------------------------------
-// Common productions
-
-// If lhs is set, result list elements which are identifiers are not resolved.
-func (p *parser) parseExprList(lhs bool) (list []ast.Expr) {
-	if p.trace {
-		defer un(trace(p, "ExpressionList"))
-	}
-
-	list = append(list, p.parseExpr(lhs))
-	for p.tok == token.COMMA {
-		p.next()
-		list = append(list, p.parseExpr(lhs))
-	}
-
-	return
-}
-
-func (p *parser) parseLhsList() []ast.Expr {
-	list := p.parseExprList(true)
-	switch p.tok {
-	case token.DEFINE:
-		// lhs of a short variable declaration
-		p.shortVarDecl(p.makeIdentList(list))
-	case token.COLON:
-		// lhs of a label declaration or a communication clause of a select
-		// statement (parseLhsList is not called when parsing the case clause
-		// of a switch statement):
-		// - labels are declared by the caller of parseLhsList
-		// - for communication clauses, if there is a stand-alone identifier
-		//   followed by a colon, we have a syntax error; there is no need
-		//   to resolve the identifier in that case
-	default:
-		// identifiers must be declared elsewhere
-		for _, x := range list {
-			p.resolve(x)
-		}
-	}
-	return list
-}
-
-func (p *parser) parseRhsList() []ast.Expr {
-	return p.parseExprList(false)
-}
-
-// ----------------------------------------------------------------------------
-// Types
-
-func (p *parser) parseType() ast.Expr {
-	if p.trace {
-		defer un(trace(p, "Type"))
-	}
-
-	typ := p.tryType()
-
-	if typ == nil {
-		pos := p.pos
-		p.errorExpected(pos, "type")
-		p.next() // make progress
-		return &ast.BadExpr{pos, p.pos}
-	}
-
-	return typ
-}
-
-// If the result is an identifier, it is not resolved.
-func (p *parser) parseTypeName() ast.Expr {
-	if p.trace {
-		defer un(trace(p, "TypeName"))
-	}
-
-	ident := p.parseIdent()
-	// don't resolve ident yet - it may be a parameter or field name
-
-	if p.tok == token.PERIOD {
-		// ident is a package name
-		p.next()
-		p.resolve(ident)
-		sel := p.parseIdent()
-		return &ast.SelectorExpr{ident, sel}
-	}
-
-	return ident
-}
-
-func (p *parser) parseArrayType(ellipsisOk bool) ast.Expr {
-	if p.trace {
-		defer un(trace(p, "ArrayType"))
-	}
-
-	lbrack := p.expect(token.LBRACK)
-	var len ast.Expr
-	if ellipsisOk && p.tok == token.ELLIPSIS {
-		len = &ast.Ellipsis{p.pos, nil}
-		p.next()
-	} else if p.tok != token.RBRACK {
-		len = p.parseRhs()
-	}
-	p.expect(token.RBRACK)
-	elt := p.parseType()
-
-	return &ast.ArrayType{lbrack, len, elt}
-}
-
-func (p *parser) makeIdentList(list []ast.Expr) []*ast.Ident {
-	idents := make([]*ast.Ident, len(list))
-	for i, x := range list {
-		ident, isIdent := x.(*ast.Ident)
-		if !isIdent {
-			pos := x.(ast.Expr).Pos()
-			p.errorExpected(pos, "identifier")
-			ident = &ast.Ident{pos, "_", nil}
-		}
-		idents[i] = ident
-	}
-	return idents
-}
-
-func (p *parser) parseFieldDecl(scope *ast.Scope) *ast.Field {
-	if p.trace {
-		defer un(trace(p, "FieldDecl"))
-	}
-
-	doc := p.leadComment
-
-	// fields
-	list, typ := p.parseVarList(false)
-
-	// optional tag
-	var tag *ast.BasicLit
-	if p.tok == token.STRING {
-		tag = &ast.BasicLit{p.pos, p.tok, p.lit}
-		p.next()
-	}
-
-	// analyze case
-	var idents []*ast.Ident
-	if typ != nil {
-		// IdentifierList Type
-		idents = p.makeIdentList(list)
-	} else {
-		// ["*"] TypeName (AnonymousField)
-		typ = list[0] // we always have at least one element
-		p.resolve(typ)
-		if n := len(list); n > 1 || !isTypeName(deref(typ)) {
-			pos := typ.Pos()
-			p.errorExpected(pos, "anonymous field")
-			typ = &ast.BadExpr{pos, list[n-1].End()}
-		}
-	}
-
-	p.expectSemi() // call before accessing p.linecomment
-
-	field := &ast.Field{doc, idents, typ, tag, p.lineComment}
-	p.declare(field, scope, ast.Var, idents...)
-
-	return field
-}
-
-func (p *parser) parseStructType() *ast.StructType {
-	if p.trace {
-		defer un(trace(p, "StructType"))
-	}
-
-	pos := p.expect(token.STRUCT)
-	lbrace := p.expect(token.LBRACE)
-	scope := ast.NewScope(nil) // struct scope
-	var list []*ast.Field
-	for p.tok == token.IDENT || p.tok == token.MUL || p.tok == token.LPAREN {
-		// a field declaration cannot start with a '(' but we accept
-		// it here for more robust parsing and better error messages
-		// (parseFieldDecl will check and complain if necessary)
-		list = append(list, p.parseFieldDecl(scope))
-	}
-	rbrace := p.expect(token.RBRACE)
-
-	// TODO(gri): store struct scope in AST
-	return &ast.StructType{pos, &ast.FieldList{lbrace, list, rbrace}, false}
-}
-
-func (p *parser) parsePointerType() *ast.StarExpr {
-	if p.trace {
-		defer un(trace(p, "PointerType"))
-	}
-
-	star := p.expect(token.MUL)
-	base := p.parseType()
-
-	return &ast.StarExpr{star, base}
-}
-
-func (p *parser) tryVarType(isParam bool) ast.Expr {
-	if isParam && p.tok == token.ELLIPSIS {
-		pos := p.pos
-		p.next()
-		typ := p.tryIdentOrType(isParam) // don't use parseType so we can provide better error message
-		if typ == nil {
-			p.error(pos, "'...' parameter is missing type")
-			typ = &ast.BadExpr{pos, p.pos}
-		}
-		if p.tok != token.RPAREN {
-			p.error(pos, "can use '...' with last parameter type only")
-		}
-		return &ast.Ellipsis{pos, typ}
-	}
-	return p.tryIdentOrType(false)
-}
-
-func (p *parser) parseVarType(isParam bool) ast.Expr {
-	typ := p.tryVarType(isParam)
-	if typ == nil {
-		pos := p.pos
-		p.errorExpected(pos, "type")
-		p.next() // make progress
-		typ = &ast.BadExpr{pos, p.pos}
-	}
-	return typ
-}
-
-func (p *parser) parseVarList(isParam bool) (list []ast.Expr, typ ast.Expr) {
-	if p.trace {
-		defer un(trace(p, "VarList"))
-	}
-
-	// a list of identifiers looks like a list of type names
-	for {
-		// parseVarType accepts any type (including parenthesized ones)
-		// even though the syntax does not permit them here: we
-		// accept them all for more robust parsing and complain
-		// afterwards
-		list = append(list, p.parseVarType(isParam))
-		if p.tok != token.COMMA {
-			break
-		}
-		p.next()
-	}
-
-	// if we had a list of identifiers, it must be followed by a type
-	typ = p.tryVarType(isParam)
-	if typ != nil {
-		p.resolve(typ)
-	}
-
-	return
-}
-
-func (p *parser) parseParameterList(scope *ast.Scope, ellipsisOk bool) (params []*ast.Field) {
-	if p.trace {
-		defer un(trace(p, "ParameterList"))
-	}
-
-	list, typ := p.parseVarList(ellipsisOk)
-	if typ != nil {
-		// IdentifierList Type
-		idents := p.makeIdentList(list)
-		field := &ast.Field{nil, idents, typ, nil, nil}
-		params = append(params, field)
-		// Go spec: The scope of an identifier denoting a function
-		// parameter or result variable is the function body.
-		p.declare(field, scope, ast.Var, idents...)
-		if p.tok == token.COMMA {
-			p.next()
-		}
-
-		for p.tok != token.RPAREN && p.tok != token.EOF {
-			idents := p.parseIdentList()
-			typ := p.parseVarType(ellipsisOk)
-			field := &ast.Field{nil, idents, typ, nil, nil}
-			params = append(params, field)
-			// Go spec: The scope of an identifier denoting a function
-			// parameter or result variable is the function body.
-			p.declare(field, scope, ast.Var, idents...)
-			if p.tok != token.COMMA {
-				break
-			}
-			p.next()
-		}
-
-	} else {
-		// Type { "," Type } (anonymous parameters)
-		params = make([]*ast.Field, len(list))
-		for i, x := range list {
-			p.resolve(x)
-			params[i] = &ast.Field{Type: x}
-		}
-	}
-
-	return
-}
-
-func (p *parser) parseParameters(scope *ast.Scope, ellipsisOk bool) *ast.FieldList {
-	if p.trace {
-		defer un(trace(p, "Parameters"))
-	}
-
-	var params []*ast.Field
-	lparen := p.expect(token.LPAREN)
-	if p.tok != token.RPAREN {
-		params = p.parseParameterList(scope, ellipsisOk)
-	}
-	rparen := p.expect(token.RPAREN)
-
-	return &ast.FieldList{lparen, params, rparen}
-}
-
-func (p *parser) parseResult(scope *ast.Scope) *ast.FieldList {
-	if p.trace {
-		defer un(trace(p, "Result"))
-	}
-
-	if p.tok == token.LPAREN {
-		return p.parseParameters(scope, false)
-	}
-
-	typ := p.tryType()
-	if typ != nil {
-		list := make([]*ast.Field, 1)
-		list[0] = &ast.Field{Type: typ}
-		return &ast.FieldList{List: list}
-	}
-
-	return nil
-}
-
-func (p *parser) parseSignature(scope *ast.Scope) (params, results *ast.FieldList) {
-	if p.trace {
-		defer un(trace(p, "Signature"))
-	}
-
-	params = p.parseParameters(scope, true)
-	results = p.parseResult(scope)
-
-	return
-}
-
-func (p *parser) parseFuncType() (*ast.FuncType, *ast.Scope) {
-	if p.trace {
-		defer un(trace(p, "FuncType"))
-	}
-
-	pos := p.expect(token.FUNC)
-	scope := ast.NewScope(p.topScope) // function scope
-	params, results := p.parseSignature(scope)
-
-	return &ast.FuncType{pos, params, results}, scope
-}
-
-func (p *parser) parseMethodSpec(scope *ast.Scope) *ast.Field {
-	if p.trace {
-		defer un(trace(p, "MethodSpec"))
-	}
-
-	doc := p.leadComment
-	var idents []*ast.Ident
-	var typ ast.Expr
-	x := p.parseTypeName()
-	if ident, isIdent := x.(*ast.Ident); isIdent && p.tok == token.LPAREN {
-		// method
-		idents = []*ast.Ident{ident}
-		scope := ast.NewScope(nil) // method scope
-		params, results := p.parseSignature(scope)
-		typ = &ast.FuncType{token.NoPos, params, results}
-	} else {
-		// embedded interface
-		typ = x
-	}
-	p.expectSemi() // call before accessing p.linecomment
-
-	spec := &ast.Field{doc, idents, typ, nil, p.lineComment}
-	p.declare(spec, scope, ast.Fun, idents...)
-
-	return spec
-}
-
-func (p *parser) parseInterfaceType() *ast.InterfaceType {
-	if p.trace {
-		defer un(trace(p, "InterfaceType"))
-	}
-
-	pos := p.expect(token.INTERFACE)
-	lbrace := p.expect(token.LBRACE)
-	scope := ast.NewScope(nil) // interface scope
-	var list []*ast.Field
-	for p.tok == token.IDENT {
-		list = append(list, p.parseMethodSpec(scope))
-	}
-	rbrace := p.expect(token.RBRACE)
-
-	// TODO(gri): store interface scope in AST
-	return &ast.InterfaceType{pos, &ast.FieldList{lbrace, list, rbrace}, false}
-}
-
-func (p *parser) parseMapType() *ast.MapType {
-	if p.trace {
-		defer un(trace(p, "MapType"))
-	}
-
-	pos := p.expect(token.MAP)
-	p.expect(token.LBRACK)
-	key := p.parseType()
-	p.expect(token.RBRACK)
-	value := p.parseType()
-
-	return &ast.MapType{pos, key, value}
-}
-
-func (p *parser) parseChanType() *ast.ChanType {
-	if p.trace {
-		defer un(trace(p, "ChanType"))
-	}
-
-	pos := p.pos
-	dir := ast.SEND | ast.RECV
-	if p.tok == token.CHAN {
-		p.next()
-		if p.tok == token.ARROW {
-			p.next()
-			dir = ast.SEND
-		}
-	} else {
-		p.expect(token.ARROW)
-		p.expect(token.CHAN)
-		dir = ast.RECV
-	}
-	value := p.parseType()
-
-	return &ast.ChanType{pos, dir, value}
-}
-
-// If the result is an identifier, it is not resolved.
-func (p *parser) tryIdentOrType(ellipsisOk bool) ast.Expr {
-	switch p.tok {
-	case token.IDENT:
-		return p.parseTypeName()
-	case token.LBRACK:
-		return p.parseArrayType(ellipsisOk)
-	case token.STRUCT:
-		return p.parseStructType()
-	case token.MUL:
-		return p.parsePointerType()
-	case token.FUNC:
-		typ, _ := p.parseFuncType()
-		return typ
-	case token.INTERFACE:
-		return p.parseInterfaceType()
-	case token.MAP:
-		return p.parseMapType()
-	case token.CHAN, token.ARROW:
-		return p.parseChanType()
-	case token.LPAREN:
-		lparen := p.pos
-		p.next()
-		typ := p.parseType()
-		rparen := p.expect(token.RPAREN)
-		return &ast.ParenExpr{lparen, typ, rparen}
-	}
-
-	// no type found
-	return nil
-}
-
-func (p *parser) tryType() ast.Expr {
-	typ := p.tryIdentOrType(false)
-	if typ != nil {
-		p.resolve(typ)
-	}
-	return typ
-}
-
-// ----------------------------------------------------------------------------
-// Blocks
-
-func (p *parser) parseStmtList() (list []ast.Stmt) {
-	if p.trace {
-		defer un(trace(p, "StatementList"))
-	}
-
-	for p.tok != token.CASE && p.tok != token.DEFAULT && p.tok != token.RBRACE && p.tok != token.EOF {
-		list = append(list, p.parseStmt())
-	}
-
-	return
-}
-
-func (p *parser) parseBody(scope *ast.Scope) *ast.BlockStmt {
-	if p.trace {
-		defer un(trace(p, "Body"))
-	}
-
-	lbrace := p.expect(token.LBRACE)
-	p.topScope = scope // open function scope
-	p.openLabelScope()
-	list := p.parseStmtList()
-	p.closeLabelScope()
-	p.closeScope()
-	rbrace := p.expect(token.RBRACE)
-
-	return &ast.BlockStmt{lbrace, list, rbrace}
-}
-
-func (p *parser) parseBlockStmt() *ast.BlockStmt {
-	if p.trace {
-		defer un(trace(p, "BlockStmt"))
-	}
-
-	lbrace := p.expect(token.LBRACE)
-	p.openScope()
-	list := p.parseStmtList()
-	p.closeScope()
-	rbrace := p.expect(token.RBRACE)
-
-	return &ast.BlockStmt{lbrace, list, rbrace}
-}
-
-// ----------------------------------------------------------------------------
-// Expressions
-
-func (p *parser) parseFuncTypeOrLit() ast.Expr {
-	if p.trace {
-		defer un(trace(p, "FuncTypeOrLit"))
-	}
-
-	typ, scope := p.parseFuncType()
-	if p.tok != token.LBRACE {
-		// function type only
-		return typ
-	}
-
-	p.exprLev++
-	body := p.parseBody(scope)
-	p.exprLev--
-
-	return &ast.FuncLit{typ, body}
-}
-
-// parseOperand may return an expression or a raw type (incl. array
-// types of the form [...]T. Callers must verify the result.
-// If lhs is set and the result is an identifier, it is not resolved.
-//
-func (p *parser) parseOperand(lhs bool) ast.Expr {
-	if p.trace {
-		defer un(trace(p, "Operand"))
-	}
-
-	switch p.tok {
-	case token.IDENT:
-		x := p.parseIdent()
-		if !lhs {
-			p.resolve(x)
-		}
-		return x
-
-	case token.INT, token.FLOAT, token.IMAG, token.CHAR, token.STRING:
-		x := &ast.BasicLit{p.pos, p.tok, p.lit}
-		p.next()
-		return x
-
-	case token.LPAREN:
-		lparen := p.pos
-		p.next()
-		p.exprLev++
-		x := p.parseRhs()
-		p.exprLev--
-		rparen := p.expect(token.RPAREN)
-		return &ast.ParenExpr{lparen, x, rparen}
-
-	case token.FUNC:
-		return p.parseFuncTypeOrLit()
-
-	default:
-		if typ := p.tryIdentOrType(true); typ != nil {
-			// could be type for composite literal or conversion
-			_, isIdent := typ.(*ast.Ident)
-			assert(!isIdent, "type cannot be identifier")
-			return typ
-		}
-	}
-
-	pos := p.pos
-	p.errorExpected(pos, "operand")
-	p.next() // make progress
-	return &ast.BadExpr{pos, p.pos}
-}
-
-func (p *parser) parseSelector(x ast.Expr) ast.Expr {
-	if p.trace {
-		defer un(trace(p, "Selector"))
-	}
-
-	sel := p.parseIdent()
-
-	return &ast.SelectorExpr{x, sel}
-}
-
-func (p *parser) parseTypeAssertion(x ast.Expr) ast.Expr {
-	if p.trace {
-		defer un(trace(p, "TypeAssertion"))
-	}
-
-	p.expect(token.LPAREN)
-	var typ ast.Expr
-	if p.tok == token.TYPE {
-		// type switch: typ == nil
-		p.next()
-	} else {
-		typ = p.parseType()
-	}
-	p.expect(token.RPAREN)
-
-	return &ast.TypeAssertExpr{x, typ}
-}
-
-func (p *parser) parseIndexOrSlice(x ast.Expr) ast.Expr {
-	if p.trace {
-		defer un(trace(p, "IndexOrSlice"))
-	}
-
-	lbrack := p.expect(token.LBRACK)
-	p.exprLev++
-	var low, high ast.Expr
-	isSlice := false
-	if p.tok != token.COLON {
-		low = p.parseRhs()
-	}
-	if p.tok == token.COLON {
-		isSlice = true
-		p.next()
-		if p.tok != token.RBRACK {
-			high = p.parseRhs()
-		}
-	}
-	p.exprLev--
-	rbrack := p.expect(token.RBRACK)
-
-	if isSlice {
-		return &ast.SliceExpr{x, lbrack, low, high, rbrack}
-	}
-	return &ast.IndexExpr{x, lbrack, low, rbrack}
-}
-
-func (p *parser) parseCallOrConversion(fun ast.Expr) *ast.CallExpr {
-	if p.trace {
-		defer un(trace(p, "CallOrConversion"))
-	}
-
-	lparen := p.expect(token.LPAREN)
-	p.exprLev++
-	var list []ast.Expr
-	var ellipsis token.Pos
-	for p.tok != token.RPAREN && p.tok != token.EOF && !ellipsis.IsValid() {
-		list = append(list, p.parseRhs())
-		if p.tok == token.ELLIPSIS {
-			ellipsis = p.pos
-			p.next()
-		}
-		if p.tok != token.COMMA {
-			break
-		}
-		p.next()
-	}
-	p.exprLev--
-	rparen := p.expect(token.RPAREN)
-
-	return &ast.CallExpr{fun, lparen, list, ellipsis, rparen}
-}
-
-func (p *parser) parseElement(keyOk bool) ast.Expr {
-	if p.trace {
-		defer un(trace(p, "Element"))
-	}
-
-	if p.tok == token.LBRACE {
-		return p.parseLiteralValue(nil)
-	}
-
-	x := p.parseExpr(keyOk) // don't resolve if map key
-	if keyOk {
-		if p.tok == token.COLON {
-			colon := p.pos
-			p.next()
-			return &ast.KeyValueExpr{x, colon, p.parseElement(false)}
-		}
-		p.resolve(x) // not a map key
-	}
-
-	return x
-}
-
-func (p *parser) parseElementList() (list []ast.Expr) {
-	if p.trace {
-		defer un(trace(p, "ElementList"))
-	}
-
-	for p.tok != token.RBRACE && p.tok != token.EOF {
-		list = append(list, p.parseElement(true))
-		if p.tok != token.COMMA {
-			break
-		}
-		p.next()
-	}
-
-	return
-}
-
-func (p *parser) parseLiteralValue(typ ast.Expr) ast.Expr {
-	if p.trace {
-		defer un(trace(p, "LiteralValue"))
-	}
-
-	lbrace := p.expect(token.LBRACE)
-	var elts []ast.Expr
-	p.exprLev++
-	if p.tok != token.RBRACE {
-		elts = p.parseElementList()
-	}
-	p.exprLev--
-	rbrace := p.expect(token.RBRACE)
-	return &ast.CompositeLit{typ, lbrace, elts, rbrace}
-}
-
-// checkExpr checks that x is an expression (and not a type).
-func (p *parser) checkExpr(x ast.Expr) ast.Expr {
-	switch t := unparen(x).(type) {
-	case *ast.BadExpr:
-	case *ast.Ident:
-	case *ast.BasicLit:
-	case *ast.FuncLit:
-	case *ast.CompositeLit:
-	case *ast.ParenExpr:
-		panic("unreachable")
-	case *ast.SelectorExpr:
-	case *ast.IndexExpr:
-	case *ast.SliceExpr:
-	case *ast.TypeAssertExpr:
-		if t.Type == nil {
-			// the form X.(type) is only allowed in type switch expressions
-			p.errorExpected(x.Pos(), "expression")
-			x = &ast.BadExpr{x.Pos(), x.End()}
-		}
-	case *ast.CallExpr:
-	case *ast.StarExpr:
-	case *ast.UnaryExpr:
-		if t.Op == token.RANGE {
-			// the range operator is only allowed at the top of a for statement
-			p.errorExpected(x.Pos(), "expression")
-			x = &ast.BadExpr{x.Pos(), x.End()}
-		}
-	case *ast.BinaryExpr:
-	default:
-		// all other nodes are not proper expressions
-		p.errorExpected(x.Pos(), "expression")
-		x = &ast.BadExpr{x.Pos(), x.End()}
-	}
-	return x
-}
-
-// isTypeName reports whether x is a (qualified) TypeName.
-func isTypeName(x ast.Expr) bool {
-	switch t := x.(type) {
-	case *ast.BadExpr:
-	case *ast.Ident:
-	case *ast.SelectorExpr:
-		_, isIdent := t.X.(*ast.Ident)
-		return isIdent
-	default:
-		return false // all other nodes are not type names
-	}
-	return true
-}
-
-// isLiteralType reports whether x is a legal composite literal type.
-func isLiteralType(x ast.Expr) bool {
-	switch t := x.(type) {
-	case *ast.BadExpr:
-	case *ast.Ident:
-	case *ast.SelectorExpr:
-		_, isIdent := t.X.(*ast.Ident)
-		return isIdent
-	case *ast.ArrayType:
-	case *ast.StructType:
-	case *ast.MapType:
-	default:
-		return false // all other nodes are not legal composite literal types
-	}
-	return true
-}
-
-// If x is of the form *T, deref returns T, otherwise it returns x.
-func deref(x ast.Expr) ast.Expr {
-	if p, isPtr := x.(*ast.StarExpr); isPtr {
-		x = p.X
-	}
-	return x
-}
-
-// If x is of the form (T), unparen returns unparen(T), otherwise it returns x.
-func unparen(x ast.Expr) ast.Expr {
-	if p, isParen := x.(*ast.ParenExpr); isParen {
-		x = unparen(p.X)
-	}
-	return x
-}
-
-// checkExprOrType checks that x is an expression or a type
-// (and not a raw type such as [...]T).
-//
-func (p *parser) checkExprOrType(x ast.Expr) ast.Expr {
-	switch t := unparen(x).(type) {
-	case *ast.ParenExpr:
-		panic("unreachable")
-	case *ast.UnaryExpr:
-		if t.Op == token.RANGE {
-			// the range operator is only allowed at the top of a for statement
-			p.errorExpected(x.Pos(), "expression")
-			x = &ast.BadExpr{x.Pos(), x.End()}
-		}
-	case *ast.ArrayType:
-		if len, isEllipsis := t.Len.(*ast.Ellipsis); isEllipsis {
-			p.error(len.Pos(), "expected array length, found '...'")
-			x = &ast.BadExpr{x.Pos(), x.End()}
-		}
-	}
-
-	// all other nodes are expressions or types
-	return x
-}
-
-// If lhs is set and the result is an identifier, it is not resolved.
-func (p *parser) parsePrimaryExpr(lhs bool) ast.Expr {
-	if p.trace {
-		defer un(trace(p, "PrimaryExpr"))
-	}
-
-	x := p.parseOperand(lhs)
-L:
-	for {
-		switch p.tok {
-		case token.PERIOD:
-			p.next()
-			if lhs {
-				p.resolve(x)
-			}
-			switch p.tok {
-			case token.IDENT:
-				x = p.parseSelector(p.checkExpr(x))
-			case token.LPAREN:
-				x = p.parseTypeAssertion(p.checkExpr(x))
-			default:
-				pos := p.pos
-				p.next() // make progress
-				p.errorExpected(pos, "selector or type assertion")
-				x = &ast.BadExpr{pos, p.pos}
-			}
-		case token.LBRACK:
-			if lhs {
-				p.resolve(x)
-			}
-			x = p.parseIndexOrSlice(p.checkExpr(x))
-		case token.LPAREN:
-			if lhs {
-				p.resolve(x)
-			}
-			x = p.parseCallOrConversion(p.checkExprOrType(x))
-		case token.LBRACE:
-			if isLiteralType(x) && (p.exprLev >= 0 || !isTypeName(x)) {
-				if lhs {
-					p.resolve(x)
-				}
-				x = p.parseLiteralValue(x)
-			} else {
-				break L
-			}
-		default:
-			break L
-		}
-		lhs = false // no need to try to resolve again
-	}
-
-	return x
-}
-
-// If lhs is set and the result is an identifier, it is not resolved.
-func (p *parser) parseUnaryExpr(lhs bool) ast.Expr {
-	if p.trace {
-		defer un(trace(p, "UnaryExpr"))
-	}
-
-	switch p.tok {
-	case token.ADD, token.SUB, token.NOT, token.XOR, token.AND, token.RANGE:
-		pos, op := p.pos, p.tok
-		p.next()
-		x := p.parseUnaryExpr(false)
-		return &ast.UnaryExpr{pos, op, p.checkExpr(x)}
-
-	case token.ARROW:
-		// channel type or receive expression
-		pos := p.pos
-		p.next()
-		if p.tok == token.CHAN {
-			p.next()
-			value := p.parseType()
-			return &ast.ChanType{pos, ast.RECV, value}
-		}
-
-		x := p.parseUnaryExpr(false)
-		return &ast.UnaryExpr{pos, token.ARROW, p.checkExpr(x)}
-
-	case token.MUL:
-		// pointer type or unary "*" expression
-		pos := p.pos
-		p.next()
-		x := p.parseUnaryExpr(false)
-		return &ast.StarExpr{pos, p.checkExprOrType(x)}
-	}
-
-	return p.parsePrimaryExpr(lhs)
-}
-
-// If lhs is set and the result is an identifier, it is not resolved.
-func (p *parser) parseBinaryExpr(lhs bool, prec1 int) ast.Expr {
-	if p.trace {
-		defer un(trace(p, "BinaryExpr"))
-	}
-
-	x := p.parseUnaryExpr(lhs)
-	for prec := p.tok.Precedence(); prec >= prec1; prec-- {
-		for p.tok.Precedence() == prec {
-			pos, op := p.pos, p.tok
-			p.next()
-			if lhs {
-				p.resolve(x)
-				lhs = false
-			}
-			y := p.parseBinaryExpr(false, prec+1)
-			x = &ast.BinaryExpr{p.checkExpr(x), pos, op, p.checkExpr(y)}
-		}
-	}
-
-	return x
-}
-
-// If lhs is set and the result is an identifier, it is not resolved.
-// TODO(gri): parseExpr may return a type or even a raw type ([..]int) -
-//            should reject when a type/raw type is obviously not allowed
-func (p *parser) parseExpr(lhs bool) ast.Expr {
-	if p.trace {
-		defer un(trace(p, "Expression"))
-	}
-
-	return p.parseBinaryExpr(lhs, token.LowestPrec+1)
-}
-
-func (p *parser) parseRhs() ast.Expr {
-	return p.parseExpr(false)
-}
-
-// ----------------------------------------------------------------------------
-// Statements
-
-func (p *parser) parseSimpleStmt(labelOk bool) ast.Stmt {
-	if p.trace {
-		defer un(trace(p, "SimpleStmt"))
-	}
-
-	x := p.parseLhsList()
-
-	switch p.tok {
-	case
-		token.DEFINE, token.ASSIGN, token.ADD_ASSIGN,
-		token.SUB_ASSIGN, token.MUL_ASSIGN, token.QUO_ASSIGN,
-		token.REM_ASSIGN, token.AND_ASSIGN, token.OR_ASSIGN,
-		token.XOR_ASSIGN, token.SHL_ASSIGN, token.SHR_ASSIGN, token.AND_NOT_ASSIGN:
-		// assignment statement
-		pos, tok := p.pos, p.tok
-		p.next()
-		y := p.parseRhsList()
-		return &ast.AssignStmt{x, pos, tok, y}
-	}
-
-	if len(x) > 1 {
-		p.errorExpected(x[0].Pos(), "1 expression")
-		// continue with first expression
-	}
-
-	switch p.tok {
-	case token.COLON:
-		// labeled statement
-		colon := p.pos
-		p.next()
-		if label, isIdent := x[0].(*ast.Ident); labelOk && isIdent {
-			// Go spec: The scope of a label is the body of the function
-			// in which it is declared and excludes the body of any nested
-			// function.
-			stmt := &ast.LabeledStmt{label, colon, p.parseStmt()}
-			p.declare(stmt, p.labelScope, ast.Lbl, label)
-			return stmt
-		}
-		p.error(x[0].Pos(), "illegal label declaration")
-		return &ast.BadStmt{x[0].Pos(), colon + 1}
-
-	case token.ARROW:
-		// send statement
-		arrow := p.pos
-		p.next() // consume "<-"
-		y := p.parseRhs()
-		return &ast.SendStmt{x[0], arrow, y}
-
-	case token.INC, token.DEC:
-		// increment or decrement
-		s := &ast.IncDecStmt{x[0], p.pos, p.tok}
-		p.next() // consume "++" or "--"
-		return s
-	}
-
-	// expression
-	return &ast.ExprStmt{x[0]}
-}
-
-func (p *parser) parseCallExpr() *ast.CallExpr {
-	x := p.parseRhs()
-	if call, isCall := x.(*ast.CallExpr); isCall {
-		return call
-	}
-	p.errorExpected(x.Pos(), "function/method call")
-	return nil
-}
-
-func (p *parser) parseGoStmt() ast.Stmt {
-	if p.trace {
-		defer un(trace(p, "GoStmt"))
-	}
-
-	pos := p.expect(token.GO)
-	call := p.parseCallExpr()
-	p.expectSemi()
-	if call == nil {
-		return &ast.BadStmt{pos, pos + 2} // len("go")
-	}
-
-	return &ast.GoStmt{pos, call}
-}
-
-func (p *parser) parseDeferStmt() ast.Stmt {
-	if p.trace {
-		defer un(trace(p, "DeferStmt"))
-	}
-
-	pos := p.expect(token.DEFER)
-	call := p.parseCallExpr()
-	p.expectSemi()
-	if call == nil {
-		return &ast.BadStmt{pos, pos + 5} // len("defer")
-	}
-
-	return &ast.DeferStmt{pos, call}
-}
-
-func (p *parser) parseReturnStmt() *ast.ReturnStmt {
-	if p.trace {
-		defer un(trace(p, "ReturnStmt"))
-	}
-
-	pos := p.pos
-	p.expect(token.RETURN)
-	var x []ast.Expr
-	if p.tok != token.SEMICOLON && p.tok != token.RBRACE {
-		x = p.parseRhsList()
-	}
-	p.expectSemi()
-
-	return &ast.ReturnStmt{pos, x}
-}
-
-func (p *parser) parseBranchStmt(tok token.Token) *ast.BranchStmt {
-	if p.trace {
-		defer un(trace(p, "BranchStmt"))
-	}
-
-	pos := p.expect(tok)
-	var label *ast.Ident
-	if tok != token.FALLTHROUGH && p.tok == token.IDENT {
-		label = p.parseIdent()
-		// add to list of unresolved targets
-		n := len(p.targetStack) - 1
-		p.targetStack[n] = append(p.targetStack[n], label)
-	}
-	p.expectSemi()
-
-	return &ast.BranchStmt{pos, tok, label}
-}
-
-func (p *parser) makeExpr(s ast.Stmt) ast.Expr {
-	if s == nil {
-		return nil
-	}
-	if es, isExpr := s.(*ast.ExprStmt); isExpr {
-		return p.checkExpr(es.X)
-	}
-	p.error(s.Pos(), "expected condition, found simple statement")
-	return &ast.BadExpr{s.Pos(), s.End()}
-}
-
-func (p *parser) parseIfStmt() *ast.IfStmt {
-	if p.trace {
-		defer un(trace(p, "IfStmt"))
-	}
-
-	pos := p.expect(token.IF)
-	p.openScope()
-	defer p.closeScope()
-
-	var s ast.Stmt
-	var x ast.Expr
-	{
-		prevLev := p.exprLev
-		p.exprLev = -1
-		if p.tok == token.SEMICOLON {
-			p.next()
-			x = p.parseRhs()
-		} else {
-			s = p.parseSimpleStmt(false)
-			if p.tok == token.SEMICOLON {
-				p.next()
-				x = p.parseRhs()
-			} else {
-				x = p.makeExpr(s)
-				s = nil
-			}
-		}
-		p.exprLev = prevLev
-	}
-
-	body := p.parseBlockStmt()
-	var else_ ast.Stmt
-	if p.tok == token.ELSE {
-		p.next()
-		else_ = p.parseStmt()
-	} else {
-		p.expectSemi()
-	}
-
-	return &ast.IfStmt{pos, s, x, body, else_}
-}
-
-func (p *parser) parseTypeList() (list []ast.Expr) {
-	if p.trace {
-		defer un(trace(p, "TypeList"))
-	}
-
-	list = append(list, p.parseType())
-	for p.tok == token.COMMA {
-		p.next()
-		list = append(list, p.parseType())
-	}
-
-	return
-}
-
-func (p *parser) parseCaseClause(exprSwitch bool) *ast.CaseClause {
-	if p.trace {
-		defer un(trace(p, "CaseClause"))
-	}
-
-	pos := p.pos
-	var list []ast.Expr
-	if p.tok == token.CASE {
-		p.next()
-		if exprSwitch {
-			list = p.parseRhsList()
-		} else {
-			list = p.parseTypeList()
-		}
-	} else {
-		p.expect(token.DEFAULT)
-	}
-
-	colon := p.expect(token.COLON)
-	p.openScope()
-	body := p.parseStmtList()
-	p.closeScope()
-
-	return &ast.CaseClause{pos, list, colon, body}
-}
-
-func isExprSwitch(s ast.Stmt) bool {
-	if s == nil {
-		return true
-	}
-	if e, ok := s.(*ast.ExprStmt); ok {
-		if a, ok := e.X.(*ast.TypeAssertExpr); ok {
-			return a.Type != nil // regular type assertion
-		}
-		return true
-	}
-	return false
-}
-
-func (p *parser) parseSwitchStmt() ast.Stmt {
-	if p.trace {
-		defer un(trace(p, "SwitchStmt"))
-	}
-
-	pos := p.expect(token.SWITCH)
-	p.openScope()
-	defer p.closeScope()
-
-	var s1, s2 ast.Stmt
-	if p.tok != token.LBRACE {
-		prevLev := p.exprLev
-		p.exprLev = -1
-		if p.tok != token.SEMICOLON {
-			s2 = p.parseSimpleStmt(false)
-		}
-		if p.tok == token.SEMICOLON {
-			p.next()
-			s1 = s2
-			s2 = nil
-			if p.tok != token.LBRACE {
-				s2 = p.parseSimpleStmt(false)
-			}
-		}
-		p.exprLev = prevLev
-	}
-
-	exprSwitch := isExprSwitch(s2)
-	lbrace := p.expect(token.LBRACE)
-	var list []ast.Stmt
-	for p.tok == token.CASE || p.tok == token.DEFAULT {
-		list = append(list, p.parseCaseClause(exprSwitch))
-	}
-	rbrace := p.expect(token.RBRACE)
-	p.expectSemi()
-	body := &ast.BlockStmt{lbrace, list, rbrace}
-
-	if exprSwitch {
-		return &ast.SwitchStmt{pos, s1, p.makeExpr(s2), body}
-	}
-	// type switch
-	// TODO(gri): do all the checks!
-	return &ast.TypeSwitchStmt{pos, s1, s2, body}
-}
-
-func (p *parser) parseCommClause() *ast.CommClause {
-	if p.trace {
-		defer un(trace(p, "CommClause"))
-	}
-
-	p.openScope()
-	pos := p.pos
-	var comm ast.Stmt
-	if p.tok == token.CASE {
-		p.next()
-		lhs := p.parseLhsList()
-		if p.tok == token.ARROW {
-			// SendStmt
-			if len(lhs) > 1 {
-				p.errorExpected(lhs[0].Pos(), "1 expression")
-				// continue with first expression
-			}
-			arrow := p.pos
-			p.next()
-			rhs := p.parseRhs()
-			comm = &ast.SendStmt{lhs[0], arrow, rhs}
-		} else {
-			// RecvStmt
-			pos := p.pos
-			tok := p.tok
-			var rhs ast.Expr
-			if tok == token.ASSIGN || tok == token.DEFINE {
-				// RecvStmt with assignment
-				if len(lhs) > 2 {
-					p.errorExpected(lhs[0].Pos(), "1 or 2 expressions")
-					// continue with first two expressions
-					lhs = lhs[0:2]
-				}
-				p.next()
-				rhs = p.parseRhs()
-			} else {
-				// rhs must be single receive operation
-				if len(lhs) > 1 {
-					p.errorExpected(lhs[0].Pos(), "1 expression")
-					// continue with first expression
-				}
-				rhs = lhs[0]
-				lhs = nil // there is no lhs
-			}
-			if x, isUnary := rhs.(*ast.UnaryExpr); !isUnary || x.Op != token.ARROW {
-				p.errorExpected(rhs.Pos(), "send or receive operation")
-				rhs = &ast.BadExpr{rhs.Pos(), rhs.End()}
-			}
-			if lhs != nil {
-				comm = &ast.AssignStmt{lhs, pos, tok, []ast.Expr{rhs}}
-			} else {
-				comm = &ast.ExprStmt{rhs}
-			}
-		}
-	} else {
-		p.expect(token.DEFAULT)
-	}
-
-	colon := p.expect(token.COLON)
-	body := p.parseStmtList()
-	p.closeScope()
-
-	return &ast.CommClause{pos, comm, colon, body}
-}
-
-func (p *parser) parseSelectStmt() *ast.SelectStmt {
-	if p.trace {
-		defer un(trace(p, "SelectStmt"))
-	}
-
-	pos := p.expect(token.SELECT)
-	lbrace := p.expect(token.LBRACE)
-	var list []ast.Stmt
-	for p.tok == token.CASE || p.tok == token.DEFAULT {
-		list = append(list, p.parseCommClause())
-	}
-	rbrace := p.expect(token.RBRACE)
-	p.expectSemi()
-	body := &ast.BlockStmt{lbrace, list, rbrace}
-
-	return &ast.SelectStmt{pos, body}
-}
-
-func (p *parser) parseForStmt() ast.Stmt {
-	if p.trace {
-		defer un(trace(p, "ForStmt"))
-	}
-
-	pos := p.expect(token.FOR)
-	p.openScope()
-	defer p.closeScope()
-
-	var s1, s2, s3 ast.Stmt
-	if p.tok != token.LBRACE {
-		prevLev := p.exprLev
-		p.exprLev = -1
-		if p.tok != token.SEMICOLON {
-			s2 = p.parseSimpleStmt(false)
-		}
-		if p.tok == token.SEMICOLON {
-			p.next()
-			s1 = s2
-			s2 = nil
-			if p.tok != token.SEMICOLON {
-				s2 = p.parseSimpleStmt(false)
-			}
-			p.expectSemi()
-			if p.tok != token.LBRACE {
-				s3 = p.parseSimpleStmt(false)
-			}
-		}
-		p.exprLev = prevLev
-	}
-
-	body := p.parseBlockStmt()
-	p.expectSemi()
-
-	if as, isAssign := s2.(*ast.AssignStmt); isAssign {
-		// possibly a for statement with a range clause; check assignment operator
-		if as.Tok != token.ASSIGN && as.Tok != token.DEFINE {
-			p.errorExpected(as.TokPos, "'=' or ':='")
-			return &ast.BadStmt{pos, body.End()}
-		}
-		// check lhs
-		var key, value ast.Expr
-		switch len(as.Lhs) {
-		case 2:
-			key, value = as.Lhs[0], as.Lhs[1]
-		case 1:
-			key = as.Lhs[0]
-		default:
-			p.errorExpected(as.Lhs[0].Pos(), "1 or 2 expressions")
-			return &ast.BadStmt{pos, body.End()}
-		}
-		// check rhs
-		if len(as.Rhs) != 1 {
-			p.errorExpected(as.Rhs[0].Pos(), "1 expression")
-			return &ast.BadStmt{pos, body.End()}
-		}
-		if rhs, isUnary := as.Rhs[0].(*ast.UnaryExpr); isUnary && rhs.Op == token.RANGE {
-			// rhs is range expression
-			// (any short variable declaration was handled by parseSimpleStat above)
-			return &ast.RangeStmt{pos, key, value, as.TokPos, as.Tok, rhs.X, body}
-		}
-		p.errorExpected(s2.Pos(), "range clause")
-		return &ast.BadStmt{pos, body.End()}
-	}
-
-	// regular for statement
-	return &ast.ForStmt{pos, s1, p.makeExpr(s2), s3, body}
-}
-
-func (p *parser) parseStmt() (s ast.Stmt) {
-	if p.trace {
-		defer un(trace(p, "Statement"))
-	}
-
-	switch p.tok {
-	case token.CONST, token.TYPE, token.VAR:
-		s = &ast.DeclStmt{p.parseDecl()}
-	case
-		// tokens that may start a top-level expression
-		token.IDENT, token.INT, token.FLOAT, token.CHAR, token.STRING, token.FUNC, token.LPAREN, // operand
-		token.LBRACK, token.STRUCT, // composite type
-		token.MUL, token.AND, token.ARROW, token.ADD, token.SUB, token.XOR: // unary operators
-		s = p.parseSimpleStmt(true)
-		// because of the required look-ahead, labeled statements are
-		// parsed by parseSimpleStmt - don't expect a semicolon after
-		// them
-		if _, isLabeledStmt := s.(*ast.LabeledStmt); !isLabeledStmt {
-			p.expectSemi()
-		}
-	case token.GO:
-		s = p.parseGoStmt()
-	case token.DEFER:
-		s = p.parseDeferStmt()
-	case token.RETURN:
-		s = p.parseReturnStmt()
-	case token.BREAK, token.CONTINUE, token.GOTO, token.FALLTHROUGH:
-		s = p.parseBranchStmt(p.tok)
-	case token.LBRACE:
-		s = p.parseBlockStmt()
-		p.expectSemi()
-	case token.IF:
-		s = p.parseIfStmt()
-	case token.SWITCH:
-		s = p.parseSwitchStmt()
-	case token.SELECT:
-		s = p.parseSelectStmt()
-	case token.FOR:
-		s = p.parseForStmt()
-	case token.SEMICOLON:
-		s = &ast.EmptyStmt{p.pos}
-		p.next()
-	case token.RBRACE:
-		// a semicolon may be omitted before a closing "}"
-		s = &ast.EmptyStmt{p.pos}
-	default:
-		// no statement found
-		pos := p.pos
-		p.errorExpected(pos, "statement")
-		p.next() // make progress
-		s = &ast.BadStmt{pos, p.pos}
-	}
-
-	return
-}
-
-// ----------------------------------------------------------------------------
-// Declarations
-
-type parseSpecFunction func(p *parser, doc *ast.CommentGroup, iota int) ast.Spec
-
-func parseImportSpec(p *parser, doc *ast.CommentGroup, _ int) ast.Spec {
-	if p.trace {
-		defer un(trace(p, "ImportSpec"))
-	}
-
-	var ident *ast.Ident
-	switch p.tok {
-	case token.PERIOD:
-		ident = &ast.Ident{p.pos, ".", nil}
-		p.next()
-	case token.IDENT:
-		ident = p.parseIdent()
-	}
-
-	var path *ast.BasicLit
-	if p.tok == token.STRING {
-		path = &ast.BasicLit{p.pos, p.tok, p.lit}
-		p.next()
-	} else {
-		p.expect(token.STRING) // use expect() error handling
-	}
-	p.expectSemi() // call before accessing p.linecomment
-
-	// collect imports
-	spec := &ast.ImportSpec{doc, ident, path, p.lineComment}
-	p.imports = append(p.imports, spec)
-
-	return spec
-}
-
-func parseConstSpec(p *parser, doc *ast.CommentGroup, iota int) ast.Spec {
-	if p.trace {
-		defer un(trace(p, "ConstSpec"))
-	}
-
-	idents := p.parseIdentList()
-	typ := p.tryType()
-	var values []ast.Expr
-	if typ != nil || p.tok == token.ASSIGN || iota == 0 {
-		p.expect(token.ASSIGN)
-		values = p.parseRhsList()
-	}
-	p.expectSemi() // call before accessing p.linecomment
-
-	// Go spec: The scope of a constant or variable identifier declared inside
-	// a function begins at the end of the ConstSpec or VarSpec and ends at
-	// the end of the innermost containing block.
-	// (Global identifiers are resolved in a separate phase after parsing.)
-	spec := &ast.ValueSpec{doc, idents, typ, values, p.lineComment}
-	p.declare(spec, p.topScope, ast.Con, idents...)
-
-	return spec
-}
-
-func parseTypeSpec(p *parser, doc *ast.CommentGroup, _ int) ast.Spec {
-	if p.trace {
-		defer un(trace(p, "TypeSpec"))
-	}
-
-	ident := p.parseIdent()
-
-	// Go spec: The scope of a type identifier declared inside a function begins
-	// at the identifier in the TypeSpec and ends at the end of the innermost
-	// containing block.
-	// (Global identifiers are resolved in a separate phase after parsing.)
-	spec := &ast.TypeSpec{doc, ident, nil, nil}
-	p.declare(spec, p.topScope, ast.Typ, ident)
-
-	spec.Type = p.parseType()
-	p.expectSemi() // call before accessing p.linecomment
-	spec.Comment = p.lineComment
-
-	return spec
-}
-
-func parseVarSpec(p *parser, doc *ast.CommentGroup, _ int) ast.Spec {
-	if p.trace {
-		defer un(trace(p, "VarSpec"))
-	}
-
-	idents := p.parseIdentList()
-	typ := p.tryType()
-	var values []ast.Expr
-	if typ == nil || p.tok == token.ASSIGN {
-		p.expect(token.ASSIGN)
-		values = p.parseRhsList()
-	}
-	p.expectSemi() // call before accessing p.linecomment
-
-	// Go spec: The scope of a constant or variable identifier declared inside
-	// a function begins at the end of the ConstSpec or VarSpec and ends at
-	// the end of the innermost containing block.
-	// (Global identifiers are resolved in a separate phase after parsing.)
-	spec := &ast.ValueSpec{doc, idents, typ, values, p.lineComment}
-	p.declare(spec, p.topScope, ast.Var, idents...)
-
-	return spec
-}
-
-func (p *parser) parseGenDecl(keyword token.Token, f parseSpecFunction) *ast.GenDecl {
-	if p.trace {
-		defer un(trace(p, "GenDecl("+keyword.String()+")"))
-	}
-
-	doc := p.leadComment
-	pos := p.expect(keyword)
-	var lparen, rparen token.Pos
-	var list []ast.Spec
-	if p.tok == token.LPAREN {
-		lparen = p.pos
-		p.next()
-		for iota := 0; p.tok != token.RPAREN && p.tok != token.EOF; iota++ {
-			list = append(list, f(p, p.leadComment, iota))
-		}
-		rparen = p.expect(token.RPAREN)
-		p.expectSemi()
-	} else {
-		list = append(list, f(p, nil, 0))
-	}
-
-	return &ast.GenDecl{doc, pos, keyword, lparen, list, rparen}
-}
-
-func (p *parser) parseReceiver(scope *ast.Scope) *ast.FieldList {
-	if p.trace {
-		defer un(trace(p, "Receiver"))
-	}
-
-	pos := p.pos
-	par := p.parseParameters(scope, false)
-
-	// must have exactly one receiver
-	if par.NumFields() != 1 {
-		p.errorExpected(pos, "exactly one receiver")
-		// TODO determine a better range for BadExpr below
-		par.List = []*ast.Field{{Type: &ast.BadExpr{pos, pos}}}
-		return par
-	}
-
-	// recv type must be of the form ["*"] identifier
-	recv := par.List[0]
-	base := deref(recv.Type)
-	if _, isIdent := base.(*ast.Ident); !isIdent {
-		p.errorExpected(base.Pos(), "(unqualified) identifier")
-		par.List = []*ast.Field{{Type: &ast.BadExpr{recv.Pos(), recv.End()}}}
-	}
-
-	return par
-}
-
-func (p *parser) parseFuncDecl() *ast.FuncDecl {
-	if p.trace {
-		defer un(trace(p, "FunctionDecl"))
-	}
-
-	doc := p.leadComment
-	pos := p.expect(token.FUNC)
-	scope := ast.NewScope(p.topScope) // function scope
-
-	var recv *ast.FieldList
-	if p.tok == token.LPAREN {
-		recv = p.parseReceiver(scope)
-	}
-
-	ident := p.parseIdent()
-
-	params, results := p.parseSignature(scope)
-
-	var body *ast.BlockStmt
-	if p.tok == token.LBRACE {
-		body = p.parseBody(scope)
-	}
-	p.expectSemi()
-
-	decl := &ast.FuncDecl{doc, recv, ident, &ast.FuncType{pos, params, results}, body}
-	if recv == nil {
-		// Go spec: The scope of an identifier denoting a constant, type,
-		// variable, or function (but not method) declared at top level
-		// (outside any function) is the package block.
-		//
-		// init() functions cannot be referred to and there may
-		// be more than one - don't put them in the pkgScope
-		if ident.Name != "init" {
-			p.declare(decl, p.pkgScope, ast.Fun, ident)
-		}
-	}
-
-	return decl
-}
-
-func (p *parser) parseDecl() ast.Decl {
-	if p.trace {
-		defer un(trace(p, "Declaration"))
-	}
-
-	var f parseSpecFunction
-	switch p.tok {
-	case token.CONST:
-		f = parseConstSpec
-
-	case token.TYPE:
-		f = parseTypeSpec
-
-	case token.VAR:
-		f = parseVarSpec
-
-	case token.FUNC:
-		return p.parseFuncDecl()
-
-	default:
-		pos := p.pos
-		p.errorExpected(pos, "declaration")
-		p.next() // make progress
-		decl := &ast.BadDecl{pos, p.pos}
-		return decl
-	}
-
-	return p.parseGenDecl(p.tok, f)
-}
-
-func (p *parser) parseDeclList() (list []ast.Decl) {
-	if p.trace {
-		defer un(trace(p, "DeclList"))
-	}
-
-	for p.tok != token.EOF {
-		list = append(list, p.parseDecl())
-	}
-
-	return
-}
-
-// ----------------------------------------------------------------------------
-// Source files
-
-func (p *parser) parseFile() *ast.File {
-	if p.trace {
-		defer un(trace(p, "File"))
-	}
-
-	// package clause
-	doc := p.leadComment
-	pos := p.expect(token.PACKAGE)
-	// Go spec: The package clause is not a declaration;
-	// the package name does not appear in any scope.
-	ident := p.parseIdent()
-	if ident.Name == "_" {
-		p.error(p.pos, "invalid package name _")
-	}
-	p.expectSemi()
-
-	var decls []ast.Decl
-
-	// Don't bother parsing the rest if we had errors already.
-	// Likely not a Go source file at all.
-
-	if p.ErrorCount() == 0 && p.mode&PackageClauseOnly == 0 {
-		// import decls
-		for p.tok == token.IMPORT {
-			decls = append(decls, p.parseGenDecl(token.IMPORT, parseImportSpec))
-		}
-
-		if p.mode&ImportsOnly == 0 {
-			// rest of package body
-			for p.tok != token.EOF {
-				decls = append(decls, p.parseDecl())
-			}
-		}
-	}
-
-	assert(p.topScope == p.pkgScope, "imbalanced scopes")
-
-	// resolve global identifiers within the same file
-	i := 0
-	for _, ident := range p.unresolved {
-		// i <= index for current ident
-		assert(ident.Obj == unresolved, "object already resolved")
-		ident.Obj = p.pkgScope.Lookup(ident.Name) // also removes unresolved sentinel
-		if ident.Obj == nil {
-			p.unresolved[i] = ident
-			i++
-		}
-	}
-
-	// TODO(gri): store p.imports in AST
-	return &ast.File{doc, pos, ident, decls, p.pkgScope, p.imports, p.unresolved[0:i], p.comments}
-}
diff --git a/third_party/golang/go/printer/testdata/slow.golden b/third_party/golang/go/printer/testdata/slow.golden
deleted file mode 100644
index 43a15cb1d0815..0000000000000
--- a/third_party/golang/go/printer/testdata/slow.golden
+++ /dev/null
@@ -1,85 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package deepequal_test
-
-import (
-	"testing"
-	"google3/spam/archer/frontend/deepequal"
-)
-
-func TestTwoNilValues(t *testing.T) {
-	if err := deepequal.Check(nil, nil); err != nil {
-		t.Errorf("expected nil, saw %v", err)
-	}
-}
-
-type Foo struct {
-	bar	*Bar
-	bang	*Bar
-}
-
-type Bar struct {
-	baz	*Baz
-	foo	[]*Foo
-}
-
-type Baz struct {
-	entries		map[int]interface{}
-	whatever	string
-}
-
-func newFoo() *Foo {
-	return &Foo{bar: &Bar{baz: &Baz{
-		entries: map[int]interface{}{
-			42:	&Foo{},
-			21:	&Bar{},
-			11:	&Baz{whatever: "it's just a test"}}}},
-		bang: &Bar{foo: []*Foo{
-			&Foo{bar: &Bar{baz: &Baz{
-				entries: map[int]interface{}{
-					43:	&Foo{},
-					22:	&Bar{},
-					13:	&Baz{whatever: "this is nuts"}}}},
-				bang: &Bar{foo: []*Foo{
-					&Foo{bar: &Bar{baz: &Baz{
-						entries: map[int]interface{}{
-							61:	&Foo{},
-							71:	&Bar{},
-							11:	&Baz{whatever: "no, it's Go"}}}},
-						bang: &Bar{foo: []*Foo{
-							&Foo{bar: &Bar{baz: &Baz{
-								entries: map[int]interface{}{
-									0:	&Foo{},
-									-2:	&Bar{},
-									-11:	&Baz{whatever: "we need to go deeper"}}}},
-								bang: &Bar{foo: []*Foo{
-									&Foo{bar: &Bar{baz: &Baz{
-										entries: map[int]interface{}{
-											-2:	&Foo{},
-											-5:	&Bar{},
-											-7:	&Baz{whatever: "are you serious?"}}}},
-										bang:	&Bar{foo: []*Foo{}}},
-									&Foo{bar: &Bar{baz: &Baz{
-										entries: map[int]interface{}{
-											-100:	&Foo{},
-											50:	&Bar{},
-											20:	&Baz{whatever: "na, not really ..."}}}},
-										bang:	&Bar{foo: []*Foo{}}}}}}}}},
-					&Foo{bar: &Bar{baz: &Baz{
-						entries: map[int]interface{}{
-							2:	&Foo{},
-							1:	&Bar{},
-							-1:	&Baz{whatever: "... it's just a test."}}}},
-						bang:	&Bar{foo: []*Foo{}}}}}}}}}
-}
-
-func TestElaborate(t *testing.T) {
-	a := newFoo()
-	b := newFoo()
-
-	if err := deepequal.Check(a, b); err != nil {
-		t.Errorf("expected nil, saw %v", err)
-	}
-}
diff --git a/third_party/golang/go/printer/testdata/slow.input b/third_party/golang/go/printer/testdata/slow.input
deleted file mode 100644
index 0e5a23d88605b..0000000000000
--- a/third_party/golang/go/printer/testdata/slow.input
+++ /dev/null
@@ -1,85 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package deepequal_test
-
-import (
-        "testing"
-        "google3/spam/archer/frontend/deepequal"
-)
-
-func TestTwoNilValues(t *testing.T) {
-        if err := deepequal.Check(nil, nil); err != nil {
-                t.Errorf("expected nil, saw %v", err)
-        }
-}
-
-type Foo struct {
-        bar *Bar
-        bang *Bar
-}
-
-type Bar struct {
-        baz *Baz
-        foo []*Foo
-}
-
-type Baz struct {
-        entries  map[int]interface{}
-        whatever string
-}
-
-func newFoo() (*Foo) {
-return &Foo{bar: &Bar{ baz: &Baz{
-entries: map[int]interface{}{
-42: &Foo{},
-21: &Bar{},
-11: &Baz{ whatever: "it's just a test" }}}},
-        bang: &Bar{foo: []*Foo{
-&Foo{bar: &Bar{ baz: &Baz{
-entries: map[int]interface{}{
-43: &Foo{},
-22: &Bar{},
-13: &Baz{ whatever: "this is nuts" }}}},
-        bang: &Bar{foo: []*Foo{
-&Foo{bar: &Bar{ baz: &Baz{
-entries: map[int]interface{}{
-61: &Foo{},
-71: &Bar{},
-11: &Baz{ whatever: "no, it's Go" }}}},
-        bang: &Bar{foo: []*Foo{
-&Foo{bar: &Bar{ baz: &Baz{
-entries: map[int]interface{}{
-0: &Foo{},
--2: &Bar{},
--11: &Baz{ whatever: "we need to go deeper" }}}},
-        bang: &Bar{foo: []*Foo{
-&Foo{bar: &Bar{ baz: &Baz{
-entries: map[int]interface{}{
--2: &Foo{},
--5: &Bar{},
--7: &Baz{ whatever: "are you serious?" }}}},
-        bang: &Bar{foo: []*Foo{}}},
-&Foo{bar: &Bar{ baz: &Baz{
-entries: map[int]interface{}{
--100: &Foo{},
-50: &Bar{},
-20: &Baz{ whatever: "na, not really ..." }}}},
-        bang: &Bar{foo: []*Foo{}}}}}}}}},
-&Foo{bar: &Bar{ baz: &Baz{
-entries: map[int]interface{}{
-2: &Foo{},
-1: &Bar{},
--1: &Baz{ whatever: "... it's just a test." }}}},
-        bang: &Bar{foo: []*Foo{}}}}}}}}}
-}
-
-func TestElaborate(t *testing.T) {
-        a := newFoo()
-        b := newFoo()
-
-        if err := deepequal.Check(a, b); err != nil {
-                t.Errorf("expected nil, saw %v", err)
-        }
-}
diff --git a/third_party/golang/go/printer/testdata/statements.golden b/third_party/golang/go/printer/testdata/statements.golden
deleted file mode 100644
index 4b13460473553..0000000000000
--- a/third_party/golang/go/printer/testdata/statements.golden
+++ /dev/null
@@ -1,644 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package statements
-
-var expr bool
-
-func use(x interface{})	{}
-
-// Formatting of multi-line return statements.
-func _f() {
-	return
-	return x, y, z
-	return T{}
-	return T{1, 2, 3},
-		x, y, z
-	return T{1, 2, 3},
-		x, y,
-		z
-	return T{1,
-		2,
-		3}
-	return T{1,
-		2,
-		3,
-	}
-	return T{
-		1,
-		2,
-		3}
-	return T{
-		1,
-		2,
-		3,
-	}
-	return T{
-		1,
-		T{1, 2, 3},
-		3,
-	}
-	return T{
-		1,
-		T{1,
-			2, 3},
-		3,
-	}
-	return T{
-		1,
-		T{1,
-			2,
-			3},
-		3,
-	}
-	return T{
-		1,
-		2,
-	}, nil
-	return T{
-			1,
-			2,
-		},
-		T{
-			x:	3,
-			y:	4,
-		}, nil
-	return T{
-			1,
-			2,
-		},
-		nil
-	return T{
-			1,
-			2,
-		},
-		T{
-			x:	3,
-			y:	4,
-		},
-		nil
-	return x + y +
-		z
-	return func() {}
-	return func() {
-			_ = 0
-		}, T{
-			1, 2,
-		}
-	return func() {
-		_ = 0
-	}
-	return func() T {
-		return T{
-			1, 2,
-		}
-	}
-}
-
-// Formatting of multi-line returns: test cases from issue 1207.
-func F() (*T, os.Error) {
-	return &T{
-			X:	1,
-			Y:	2,
-		},
-		nil
-}
-
-func G() (*T, *T, os.Error) {
-	return &T{
-			X:	1,
-			Y:	2,
-		},
-		&T{
-			X:	3,
-			Y:	4,
-		},
-		nil
-}
-
-func _() interface{} {
-	return &fileStat{
-		name:		basename(file.name),
-		size:		mkSize(d.FileSizeHigh, d.FileSizeLow),
-		modTime:	mkModTime(d.LastWriteTime),
-		mode:		mkMode(d.FileAttributes),
-		sys:		mkSysFromFI(&d),
-	}, nil
-}
-
-// Formatting of if-statement headers.
-func _() {
-	if true {
-	}
-	if true {
-	}	// no semicolon printed
-	if expr {
-	}
-	if expr {
-	}	// no semicolon printed
-	if expr {
-	}	// no parens printed
-	if expr {
-	}	// no semicolon and parens printed
-	if x := expr; true {
-		use(x)
-	}
-	if x := expr; expr {
-		use(x)
-	}
-}
-
-// Formatting of switch-statement headers.
-func _() {
-	switch {
-	}
-	switch {
-	}	// no semicolon printed
-	switch expr {
-	}
-	switch expr {
-	}	// no semicolon printed
-	switch expr {
-	}	// no parens printed
-	switch expr {
-	}	// no semicolon and parens printed
-	switch x := expr; {
-	default:
-		use(
-			x)
-	}
-	switch x := expr; expr {
-	default:
-		use(x)
-	}
-}
-
-// Formatting of switch statement bodies.
-func _() {
-	switch {
-	}
-
-	switch x := 0; x {
-	case 1:
-		use(x)
-		use(x)	// followed by an empty line
-
-	case 2:	// followed by an empty line
-
-		use(x)	// followed by an empty line
-
-	case 3:	// no empty lines
-		use(x)
-		use(x)
-	}
-
-	switch x {
-	case 0:
-		use(x)
-	case 1:	// this comment should have no effect on the previous or next line
-		use(x)
-	}
-
-	switch x := 0; x {
-	case 1:
-		x = 0
-		// this comment should be indented
-	case 2:
-		x = 0
-	// this comment should not be indented, it is aligned with the next case
-	case 3:
-		x = 0
-		/* indented comment
-		   aligned
-		   aligned
-		*/
-		// bla
-		/* and more */
-	case 4:
-		x = 0
-	/* not indented comment
-	   aligned
-	   aligned
-	*/
-	// bla
-	/* and more */
-	case 5:
-	}
-}
-
-// Formatting of selected select statements.
-func _() {
-	select {}
-	select { /* this comment should not be tab-aligned because the closing } is on the same line */
-	}
-	select {	/* this comment should be tab-aligned */
-	}
-	select {	// this comment should be tab-aligned
-	}
-	select {
-	case <-c:
-	}
-}
-
-// Formatting of for-statement headers for single-line for-loops.
-func _() {
-	for {
-	}
-	for expr {
-	}
-	for expr {
-	}	// no parens printed
-	for {
-	}	// no semicolons printed
-	for x := expr; ; {
-		use(x)
-	}
-	for expr {
-	}	// no semicolons printed
-	for expr {
-	}	// no semicolons and parens printed
-	for ; ; expr = false {
-	}
-	for x := expr; expr; {
-		use(x)
-	}
-	for x := expr; ; expr = false {
-		use(x)
-	}
-	for ; expr; expr = false {
-	}
-	for x := expr; expr; expr = false {
-		use(x)
-	}
-	for x := range []int{} {
-		use(x)
-	}
-	for x := range []int{} {
-		use(x)
-	}	// no parens printed
-}
-
-// Formatting of for-statement headers for multi-line for-loops.
-func _() {
-	for {
-	}
-	for expr {
-	}
-	for expr {
-	}	// no parens printed
-	for {
-	}	// no semicolons printed
-	for x := expr; ; {
-		use(x)
-	}
-	for expr {
-	}	// no semicolons printed
-	for expr {
-	}	// no semicolons and parens printed
-	for ; ; expr = false {
-	}
-	for x := expr; expr; {
-		use(x)
-	}
-	for x := expr; ; expr = false {
-		use(x)
-	}
-	for ; expr; expr = false {
-	}
-	for x := expr; expr; expr = false {
-		use(x)
-	}
-	for range []int{} {
-		println("foo")
-	}
-	for x := range []int{} {
-		use(x)
-	}
-	for x := range []int{} {
-		use(x)
-	}	// no parens printed
-}
-
-// Formatting of selected short single- and multi-line statements.
-func _() {
-	if cond {
-	}
-	if cond {
-	}	// multiple lines
-	if cond {
-	} else {
-	}	// else clause always requires multiple lines
-
-	for {
-	}
-	for i := 0; i < len(a); 1++ {
-	}
-	for i := 0; i < len(a); 1++ {
-		a[i] = i
-	}
-	for i := 0; i < len(a); 1++ {
-		a[i] = i
-	}	// multiple lines
-
-	for range a {
-	}
-	for _ = range a {
-	}
-	for _, _ = range a {
-	}
-	for i := range a {
-	}
-	for i := range a {
-		a[i] = i
-	}
-	for i := range a {
-		a[i] = i
-	}	// multiple lines
-
-	go func() {
-		for {
-			a <- <-b
-		}
-	}()
-	defer func() {
-		if x := recover(); x != nil {
-			err = fmt.Sprintf("error: %s", x.msg)
-		}
-	}()
-}
-
-// Don't remove mandatory parentheses around composite literals in control clauses.
-func _() {
-	// strip parentheses - no composite literals or composite literals don't start with a type name
-	if x {
-	}
-	if x {
-	}
-	if []T{} {
-	}
-	if []T{} {
-	}
-	if []T{} {
-	}
-
-	for x {
-	}
-	for x {
-	}
-	for []T{} {
-	}
-	for []T{} {
-	}
-	for []T{} {
-	}
-
-	switch x {
-	}
-	switch x {
-	}
-	switch []T{} {
-	}
-	switch []T{} {
-	}
-
-	for _ = range []T{T{42}} {
-	}
-
-	// leave parentheses - composite literals start with a type name
-	if (T{}) {
-	}
-	if (T{}) {
-	}
-	if (T{}) {
-	}
-
-	for (T{}) {
-	}
-	for (T{}) {
-	}
-	for (T{}) {
-	}
-
-	switch (T{}) {
-	}
-	switch (T{}) {
-	}
-
-	for _ = range (T1{T{42}}) {
-	}
-
-	if x == (T{42}[0]) {
-	}
-	if (x == T{42}[0]) {
-	}
-	if x == (T{42}[0]) {
-	}
-	if x == (T{42}[0]) {
-	}
-	if x == (T{42}[0]) {
-	}
-	if x == a+b*(T{42}[0]) {
-	}
-	if (x == a+b*T{42}[0]) {
-	}
-	if x == a+b*(T{42}[0]) {
-	}
-	if x == a+(b*(T{42}[0])) {
-	}
-	if x == a+b*(T{42}[0]) {
-	}
-	if (a + b*(T{42}[0])) == x {
-	}
-	if (a + b*(T{42}[0])) == x {
-	}
-
-	if struct{ x bool }{false}.x {
-	}
-	if (struct{ x bool }{false}.x) == false {
-	}
-	if struct{ x bool }{false}.x == false {
-	}
-}
-
-// Extra empty lines inside functions. Do respect source code line
-// breaks between statement boundaries but print at most one empty
-// line at a time.
-func _() {
-
-	const _ = 0
-
-	const _ = 1
-	type _ int
-	type _ float
-
-	var _ = 0
-	var x = 1
-
-	// Each use(x) call below should have at most one empty line before and after.
-	// Known bug: The first use call may have more than one empty line before
-	//            (see go/printer/nodes.go, func linebreak).
-
-	use(x)
-
-	if x < x {
-
-		use(x)
-
-	} else {
-
-		use(x)
-
-	}
-}
-
-// Formatting around labels.
-func _() {
-L:
-}
-
-func _() {
-	// this comment should be indented
-L:	// no semicolon needed
-}
-
-func _() {
-	switch 0 {
-	case 0:
-	L0:
-		;	// semicolon required
-	case 1:
-	L1:
-		;	// semicolon required
-	default:
-	L2:	// no semicolon needed
-	}
-}
-
-func _() {
-	f()
-L1:
-	f()
-L2:
-	;
-L3:
-}
-
-func _() {
-	// this comment should be indented
-L:
-}
-
-func _() {
-L:
-	_ = 0
-}
-
-func _() {
-	// this comment should be indented
-L:
-	_ = 0
-}
-
-func _() {
-	for {
-	L1:
-		_ = 0
-	L2:
-		_ = 0
-	}
-}
-
-func _() {
-	// this comment should be indented
-	for {
-	L1:
-		_ = 0
-	L2:
-		_ = 0
-	}
-}
-
-func _() {
-	if true {
-		_ = 0
-	}
-	_ = 0	// the indentation here should not be affected by the long label name
-AnOverlongLabel:
-	_ = 0
-
-	if true {
-		_ = 0
-	}
-	_ = 0
-
-L:
-	_ = 0
-}
-
-func _() {
-	for {
-		goto L
-	}
-L:
-
-	MoreCode()
-}
-
-func _() {
-	for {
-		goto L
-	}
-L:	// A comment on the same line as the label, followed by a single empty line.
-	// Known bug: There may be more than one empty line before MoreCode()
-	//            (see go/printer/nodes.go, func linebreak).
-
-	MoreCode()
-}
-
-func _() {
-	for {
-		goto L
-	}
-L:
-
-	// There should be a single empty line before this comment.
-	MoreCode()
-}
-
-func _() {
-	for {
-		goto AVeryLongLabelThatShouldNotAffectFormatting
-	}
-AVeryLongLabelThatShouldNotAffectFormatting:
-	// There should be a single empty line after this comment.
-
-	// There should be a single empty line before this comment.
-	MoreCode()
-}
-
-// Formatting of empty statements.
-func _() {
-
-}
-
-func _() {
-}
-
-func _() {
-}
-
-func _() {
-	f()
-}
-
-func _() {
-L:
-	;
-}
-
-func _() {
-L:
-	;
-	f()
-}
diff --git a/third_party/golang/go/printer/testdata/statements.input b/third_party/golang/go/printer/testdata/statements.input
deleted file mode 100644
index cade1576bf784..0000000000000
--- a/third_party/golang/go/printer/testdata/statements.input
+++ /dev/null
@@ -1,555 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package statements
-
-var expr bool
-
-func use(x interface{}) {}
-
-// Formatting of multi-line return statements.
-func _f() {
-	return
-	return x, y, z
-	return T{}
-	return T{1, 2, 3},
-		x, y, z
-	return T{1, 2, 3},
-		x, y,
-		z
-	return T{1,
-		2,
-		3}
-	return T{1,
-		2,
-		3,
-	}
-	return T{
-		1,
-		2,
-		3}
-	return T{
-		1,
-		2,
-		3,
-	}
-	return T{
-		1,
-		T{1, 2, 3},
-		3,
-	}
-	return T{
-		1,
-		T{1,
-			2, 3},
-		3,
-	}
-	return T{
-		1,
-		T{1,
-			2,
-			3},
-		3,
-	}
-	return T{
-			1,
-			2,
-		}, nil
-	return T{
-			1,
-			2,
-		},
-		T{
-			x: 3,
-			y: 4,
-		}, nil
-	return T{
-			1,
-			2,
-		},
-		nil
-	return T{
-			1,
-			2,
-		},
-		T{
-			x: 3,
-			y: 4,
-		},
-		nil
-	return x + y +
-		z
-	return func() {}
-	return func() {
-		_ = 0
-	}, T{
-		1, 2,
-	}
-	return func() {
-		_ = 0
-	}
-	return func() T {
-		return T {
-			1, 2,
-		}
-	}
-}
-
-// Formatting of multi-line returns: test cases from issue 1207.
-func F() (*T, os.Error) {
-       return &T{
-               X: 1,
-               Y: 2,
-       },
-               nil
-}
-
-func G() (*T, *T, os.Error) {
-       return &T{
-               X: 1,
-               Y: 2,
-       },
-               &T{
-                       X: 3,
-                       Y: 4,
-               },
-               nil
-}
-
-func _() interface{} {
-	return &fileStat{
-			name:    basename(file.name),
-			size:    mkSize(d.FileSizeHigh, d.FileSizeLow),
-			modTime: mkModTime(d.LastWriteTime),
-			mode:    mkMode(d.FileAttributes),
-			sys:     mkSysFromFI(&d),
-		}, nil
-}
-
-// Formatting of if-statement headers.
-func _() {
-	if true {}
-	if; true {}  // no semicolon printed
-	if expr{}
-	if;expr{}  // no semicolon printed
-	if (expr){}  // no parens printed
-	if;((expr)){}  // no semicolon and parens printed
-	if x:=expr;true{
-	use(x)}
-	if x:=expr; expr {use(x)}
-}
-
-
-// Formatting of switch-statement headers.
-func _() {
-	switch {}
-	switch;{}  // no semicolon printed
-	switch expr {}
-	switch;expr{}  // no semicolon printed
-	switch (expr) {}  // no parens printed
-	switch;((expr)){}  // no semicolon and parens printed
-	switch x := expr; { default:use(
-x)
-	}
-	switch x := expr; expr {default:use(x)}
-}
-
-
-// Formatting of switch statement bodies.
-func _() {
-	switch {
-	}
-
-	switch x := 0; x {
-	case 1:
-		use(x)
-		use(x)  // followed by an empty line
-
-	case 2:  // followed by an empty line
-
-		use(x)  // followed by an empty line
-
-	case 3:  // no empty lines
-		use(x)
-		use(x)
-	}
-
-	switch x {
-	case 0:
-		use(x)
-	case 1:  // this comment should have no effect on the previous or next line
-		use(x)
-	}
-
-	switch x := 0; x {
-	case 1:
-		x = 0
-		// this comment should be indented
-	case 2:
-		x = 0
-	// this comment should not be indented, it is aligned with the next case
-	case 3:
-		x = 0
-		/* indented comment
-		   aligned
-		   aligned
-		*/
-		// bla
-		/* and more */
-	case 4:
-		x = 0
-	/* not indented comment
-	   aligned
-	   aligned
-	*/
-	// bla
-	/* and more */
-	case 5:
-	}
-}
-
-
-// Formatting of selected select statements.
-func _() {
-	select {
-	}
-	select { /* this comment should not be tab-aligned because the closing } is on the same line */ }
-	select { /* this comment should be tab-aligned */
-	}
-	select { // this comment should be tab-aligned
-	}
-	select { case <-c: }
-}
-
-
-// Formatting of for-statement headers for single-line for-loops.
-func _() {
-	for{}
-	for expr {}
-	for (expr) {}  // no parens printed
-	for;;{}  // no semicolons printed
-	for x :=expr;; {use( x)}
-	for; expr;{}  // no semicolons printed
-	for; ((expr));{}  // no semicolons and parens printed
-	for; ; expr = false {}
-	for x :=expr; expr; {use(x)}
-	for x := expr;; expr=false {use(x)}
-	for;expr;expr =false {}
-	for x := expr;expr;expr = false { use(x) }
-	for x := range []int{} { use(x) }
-	for x := range (([]int{})) { use(x) }  // no parens printed
-}
-
-
-// Formatting of for-statement headers for multi-line for-loops.
-func _() {
-	for{
-	}
-	for expr {
-	}
-	for (expr) {
-	}  // no parens printed
-	for;;{
-	}  // no semicolons printed
-	for x :=expr;; {use( x)
-	}
-	for; expr;{
-	}  // no semicolons printed
-	for; ((expr));{
-	}  // no semicolons and parens printed
-	for; ; expr = false {
-	}
-	for x :=expr; expr; {use(x)
-	}
-	for x := expr;; expr=false {use(x)
-	}
-	for;expr;expr =false {
-	}
-	for x := expr;expr;expr = false {
-	use(x)
-	}
-	for range []int{} {
-	println("foo")}
-	for x := range []int{} {
-	use(x) }
-	for x := range (([]int{})) {
-	use(x) }  // no parens printed
-}
-
-
-// Formatting of selected short single- and multi-line statements.
-func _() {
-	if cond {}
-	if cond {
-	} // multiple lines
-	if cond {} else {} // else clause always requires multiple lines
-
-	for {}
-	for i := 0; i < len(a); 1++ {}
-	for i := 0; i < len(a); 1++ { a[i] = i }
-	for i := 0; i < len(a); 1++ { a[i] = i
-	} // multiple lines
-
-	for range a{}
-	for _ = range a{}
-	for _, _ = range a{}
-	for i := range a {}
-	for i := range a { a[i] = i }
-	for i := range a { a[i] = i
-	} // multiple lines
-
-	go func() { for { a <- <-b } }()
-	defer func() { if x := recover(); x != nil { err = fmt.Sprintf("error: %s", x.msg) } }()
-}
-
-
-// Don't remove mandatory parentheses around composite literals in control clauses.
-func _() {
-	// strip parentheses - no composite literals or composite literals don't start with a type name
-	if (x) {}
-	if (((x))) {}
-	if ([]T{}) {}
-	if (([]T{})) {}
-	if ; (((([]T{})))) {}
-
-	for (x) {}
-	for (((x))) {}
-	for ([]T{}) {}
-	for (([]T{})) {}
-	for ; (((([]T{})))) ; {}
-
-	switch (x) {}
-	switch (((x))) {}
-	switch ([]T{}) {}
-	switch ; (((([]T{})))) {}
-
-	for _ = range ((([]T{T{42}}))) {}
-
-	// leave parentheses - composite literals start with a type name
-	if (T{}) {}
-	if ((T{})) {}
-	if ; ((((T{})))) {}
-
-	for (T{}) {}
-	for ((T{})) {}
-	for ; ((((T{})))) ; {}
-
-	switch (T{}) {}
-	switch ; ((((T{})))) {}
-
-	for _ = range (((T1{T{42}}))) {}
-
-	if x == (T{42}[0]) {}
-	if (x == T{42}[0]) {}
-	if (x == (T{42}[0])) {}
-	if (x == (((T{42}[0])))) {}
-	if (((x == (T{42}[0])))) {}
-	if x == a + b*(T{42}[0]) {}
-	if (x == a + b*T{42}[0]) {}
-	if (x == a + b*(T{42}[0])) {}
-	if (x == a + ((b * (T{42}[0])))) {}
-	if (((x == a + b * (T{42}[0])))) {}
-	if (((a + b * (T{42}[0])) == x)) {}
-	if (((a + b * (T{42}[0])))) == x {}
-
-	if (struct{x bool}{false}.x) {}
-	if (struct{x bool}{false}.x) == false {}
-	if (struct{x bool}{false}.x == false) {}
-}
-
-
-// Extra empty lines inside functions. Do respect source code line
-// breaks between statement boundaries but print at most one empty
-// line at a time.
-func _() {
-
-	const _ = 0
-
-	const _ = 1
-	type _ int
-	type _ float
-
-	var _ = 0
-	var x = 1
-
-	// Each use(x) call below should have at most one empty line before and after.
-	// Known bug: The first use call may have more than one empty line before
-	//            (see go/printer/nodes.go, func linebreak).
-
-
-
-	use(x)
-
-	if x < x {
-
-		use(x)
-
-	} else {
-
-		use(x)
-
-	}
-}
-
-
-// Formatting around labels.
-func _() {
-	L:
-}
-
-
-func _() {
-	// this comment should be indented
-	L: ;  // no semicolon needed
-}
-
-
-func _() {
-	switch 0 {
-	case 0:
-		L0: ;  // semicolon required
-	case 1:
-		L1: ;  // semicolon required
-	default:
-		L2: ;  // no semicolon needed
-	}
-}
-
-
-func _() {
-	f()
-L1:
-	f()
-L2:
-	;
-L3:
-}
-
-
-func _() {
-	// this comment should be indented
-	L:
-}
-
-
-func _() {
-	L: _ = 0
-}
-
-
-func _() {
-	// this comment should be indented
-	L: _ = 0
-}
-
-
-func _() {
-	for {
-	L1: _ = 0
-	L2:
-		_ = 0
-	}
-}
-
-
-func _() {
-		// this comment should be indented
-	for {
-	L1: _ = 0
-	L2:
-		_ = 0
-	}
-}
-
-
-func _() {
-	if true {
-		_ = 0
-	}
-	_ = 0  // the indentation here should not be affected by the long label name
-AnOverlongLabel:
-	_ = 0
-	
-	if true {
-		_ = 0
-	}
-	_ = 0
-
-L:	_ = 0
-}
-
-
-func _() {
-	for {
-		goto L
-	}
-L:
-
-	MoreCode()
-}
-
-
-func _() {
-	for {
-		goto L
-	}
-L:	// A comment on the same line as the label, followed by a single empty line.
-	// Known bug: There may be more than one empty line before MoreCode()
-	//            (see go/printer/nodes.go, func linebreak).
-
-
-
-
-	MoreCode()
-}
-
-
-func _() {
-	for {
-		goto L
-	}
-L:
-
-
-
-
-	// There should be a single empty line before this comment.
-	MoreCode()
-}
-
-
-func _() {
-	for {
-		goto AVeryLongLabelThatShouldNotAffectFormatting
-	}
-AVeryLongLabelThatShouldNotAffectFormatting:
-	// There should be a single empty line after this comment.
-
-	// There should be a single empty line before this comment.
-	MoreCode()
-}
-
-
-// Formatting of empty statements.
-func _() {
-	;;;;;;;;;;;;;;;;;;;;;;;;;
-}
-
-func _() {;;;;;;;;;;;;;;;;;;;;;;;;;
-}
-
-func _() {;;;;;;;;;;;;;;;;;;;;;;;;;}
-
-func _() {
-f();;;;;;;;;;;;;;;;;;;;;;;;;
-}
-
-func _() {
-L:;;;;;;;;;;;;
-}
-
-func _() {
-L:;;;;;;;;;;;;
-	f()
-}
diff --git a/third_party/golang/go/scanner/errors.go b/third_party/golang/go/scanner/errors.go
deleted file mode 100644
index 4eb3d5b740dbf..0000000000000
--- a/third_party/golang/go/scanner/errors.go
+++ /dev/null
@@ -1,125 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package scanner
-
-import (
-	"fmt"
-	"io"
-	"sort"
-
-	"k8s.io/kubernetes/third_party/golang/go/token"
-)
-
-// In an ErrorList, an error is represented by an *Error.
-// The position Pos, if valid, points to the beginning of
-// the offending token, and the error condition is described
-// by Msg.
-//
-type Error struct {
-	Pos token.Position
-	Msg string
-}
-
-// Error implements the error interface.
-func (e Error) Error() string {
-	if e.Pos.Filename != "" || e.Pos.IsValid() {
-		// don't print ""
-		// TODO(gri) reconsider the semantics of Position.IsValid
-		return e.Pos.String() + ": " + e.Msg
-	}
-	return e.Msg
-}
-
-// ErrorList is a list of *Errors.
-// The zero value for an ErrorList is an empty ErrorList ready to use.
-//
-type ErrorList []*Error
-
-// Add adds an Error with given position and error message to an ErrorList.
-func (p *ErrorList) Add(pos token.Position, msg string) {
-	*p = append(*p, &Error{pos, msg})
-}
-
-// Reset resets an ErrorList to no errors.
-func (p *ErrorList) Reset() { *p = (*p)[0:0] }
-
-// ErrorList implements the sort Interface.
-func (p ErrorList) Len() int      { return len(p) }
-func (p ErrorList) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
-
-func (p ErrorList) Less(i, j int) bool {
-	e := &p[i].Pos
-	f := &p[j].Pos
-	// Note that it is not sufficient to simply compare file offsets because
-	// the offsets do not reflect modified line information (through //line
-	// comments).
-	if e.Filename != f.Filename {
-		return e.Filename < f.Filename
-	}
-	if e.Line != f.Line {
-		return e.Line < f.Line
-	}
-	if e.Column != f.Column {
-		return e.Column < f.Column
-	}
-	return p[i].Msg < p[j].Msg
-}
-
-// Sort sorts an ErrorList. *Error entries are sorted by position,
-// other errors are sorted by error message, and before any *Error
-// entry.
-//
-func (p ErrorList) Sort() {
-	sort.Sort(p)
-}
-
-// RemoveMultiples sorts an ErrorList and removes all but the first error per line.
-func (p *ErrorList) RemoveMultiples() {
-	sort.Sort(p)
-	var last token.Position // initial last.Line is != any legal error line
-	i := 0
-	for _, e := range *p {
-		if e.Pos.Filename != last.Filename || e.Pos.Line != last.Line {
-			last = e.Pos
-			(*p)[i] = e
-			i++
-		}
-	}
-	(*p) = (*p)[0:i]
-}
-
-// An ErrorList implements the error interface.
-func (p ErrorList) Error() string {
-	switch len(p) {
-	case 0:
-		return "no errors"
-	case 1:
-		return p[0].Error()
-	}
-	return fmt.Sprintf("%s (and %d more errors)", p[0], len(p)-1)
-}
-
-// Err returns an error equivalent to this error list.
-// If the list is empty, Err returns nil.
-func (p ErrorList) Err() error {
-	if len(p) == 0 {
-		return nil
-	}
-	return p
-}
-
-// PrintError is a utility function that prints a list of errors to w,
-// one error per line, if the err parameter is an ErrorList. Otherwise
-// it prints the err string.
-//
-func PrintError(w io.Writer, err error) {
-	if list, ok := err.(ErrorList); ok {
-		for _, e := range list {
-			fmt.Fprintf(w, "%s\n", e)
-		}
-	} else if err != nil {
-		fmt.Fprintf(w, "%s\n", err)
-	}
-}
diff --git a/third_party/golang/go/scanner/example_test.go b/third_party/golang/go/scanner/example_test.go
deleted file mode 100644
index d4d2e25e0841d..0000000000000
--- a/third_party/golang/go/scanner/example_test.go
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package scanner_test
-
-import (
-	"fmt"
-	"k8s.io/kubernetes/third_party/golang/go/scanner"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-)
-
-func ExampleScanner_Scan() {
-	// src is the input that we want to tokenize.
-	src := []byte("cos(x) + 1i*sin(x) // Euler")
-
-	// Initialize the scanner.
-	var s scanner.Scanner
-	fset := token.NewFileSet()                      // positions are relative to fset
-	file := fset.AddFile("", fset.Base(), len(src)) // register input "file"
-	s.Init(file, src, nil /* no error handler */, scanner.ScanComments)
-
-	// Repeated calls to Scan yield the token sequence found in the input.
-	for {
-		pos, tok, lit := s.Scan()
-		if tok == token.EOF {
-			break
-		}
-		fmt.Printf("%s\t%s\t%q\n", fset.Position(pos), tok, lit)
-	}
-
-	// output:
-	// 1:1	IDENT	"cos"
-	// 1:4	(	""
-	// 1:5	IDENT	"x"
-	// 1:6	)	""
-	// 1:8	+	""
-	// 1:10	IMAG	"1i"
-	// 1:12	*	""
-	// 1:13	IDENT	"sin"
-	// 1:16	(	""
-	// 1:17	IDENT	"x"
-	// 1:18	)	""
-	// 1:20	;	"\n"
-	// 1:20	COMMENT	"// Euler"
-}
diff --git a/third_party/golang/go/scanner/scanner.go b/third_party/golang/go/scanner/scanner.go
deleted file mode 100644
index 0d7af1b2e4933..0000000000000
--- a/third_party/golang/go/scanner/scanner.go
+++ /dev/null
@@ -1,761 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package scanner implements a scanner for Go source text.
-// It takes a []byte as source which can then be tokenized
-// through repeated calls to the Scan method.
-//
-package scanner
-
-import (
-	"bytes"
-	"fmt"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-	"path/filepath"
-	"strconv"
-	"unicode"
-	"unicode/utf8"
-)
-
-// An ErrorHandler may be provided to Scanner.Init. If a syntax error is
-// encountered and a handler was installed, the handler is called with a
-// position and an error message. The position points to the beginning of
-// the offending token.
-//
-type ErrorHandler func(pos token.Position, msg string)
-
-// A Scanner holds the scanner's internal state while processing
-// a given text.  It can be allocated as part of another data
-// structure but must be initialized via Init before use.
-//
-type Scanner struct {
-	// immutable state
-	file *token.File  // source file handle
-	dir  string       // directory portion of file.Name()
-	src  []byte       // source
-	err  ErrorHandler // error reporting; or nil
-	mode Mode         // scanning mode
-
-	// scanning state
-	ch         rune // current character
-	offset     int  // character offset
-	rdOffset   int  // reading offset (position after current character)
-	lineOffset int  // current line offset
-	insertSemi bool // insert a semicolon before next newline
-
-	// public state - ok to modify
-	ErrorCount int // number of errors encountered
-}
-
-const bom = 0xFEFF // byte order mark, only permitted as very first character
-
-// Read the next Unicode char into s.ch.
-// s.ch < 0 means end-of-file.
-//
-func (s *Scanner) next() {
-	if s.rdOffset < len(s.src) {
-		s.offset = s.rdOffset
-		if s.ch == '\n' {
-			s.lineOffset = s.offset
-			s.file.AddLine(s.offset)
-		}
-		r, w := rune(s.src[s.rdOffset]), 1
-		switch {
-		case r == 0:
-			s.error(s.offset, "illegal character NUL")
-		case r >= 0x80:
-			// not ASCII
-			r, w = utf8.DecodeRune(s.src[s.rdOffset:])
-			if r == utf8.RuneError && w == 1 {
-				s.error(s.offset, "illegal UTF-8 encoding")
-			} else if r == bom && s.offset > 0 {
-				s.error(s.offset, "illegal byte order mark")
-			}
-		}
-		s.rdOffset += w
-		s.ch = r
-	} else {
-		s.offset = len(s.src)
-		if s.ch == '\n' {
-			s.lineOffset = s.offset
-			s.file.AddLine(s.offset)
-		}
-		s.ch = -1 // eof
-	}
-}
-
-// A mode value is a set of flags (or 0).
-// They control scanner behavior.
-//
-type Mode uint
-
-const (
-	ScanComments    Mode = 1 << iota // return comments as COMMENT tokens
-	dontInsertSemis                  // do not automatically insert semicolons - for testing only
-)
-
-// Init prepares the scanner s to tokenize the text src by setting the
-// scanner at the beginning of src. The scanner uses the file set file
-// for position information and it adds line information for each line.
-// It is ok to re-use the same file when re-scanning the same file as
-// line information which is already present is ignored. Init causes a
-// panic if the file size does not match the src size.
-//
-// Calls to Scan will invoke the error handler err if they encounter a
-// syntax error and err is not nil. Also, for each error encountered,
-// the Scanner field ErrorCount is incremented by one. The mode parameter
-// determines how comments are handled.
-//
-// Note that Init may call err if there is an error in the first character
-// of the file.
-//
-func (s *Scanner) Init(file *token.File, src []byte, err ErrorHandler, mode Mode) {
-	// Explicitly initialize all fields since a scanner may be reused.
-	if file.Size() != len(src) {
-		panic(fmt.Sprintf("file size (%d) does not match src len (%d)", file.Size(), len(src)))
-	}
-	s.file = file
-	s.dir, _ = filepath.Split(file.Name())
-	s.src = src
-	s.err = err
-	s.mode = mode
-
-	s.ch = ' '
-	s.offset = 0
-	s.rdOffset = 0
-	s.lineOffset = 0
-	s.insertSemi = false
-	s.ErrorCount = 0
-
-	s.next()
-	if s.ch == bom {
-		s.next() // ignore BOM at file beginning
-	}
-}
-
-func (s *Scanner) error(offs int, msg string) {
-	if s.err != nil {
-		s.err(s.file.Position(s.file.Pos(offs)), msg)
-	}
-	s.ErrorCount++
-}
-
-var prefix = []byte("//line ")
-
-func (s *Scanner) interpretLineComment(text []byte) {
-	if bytes.HasPrefix(text, prefix) {
-		// get filename and line number, if any
-		if i := bytes.LastIndex(text, []byte{':'}); i > 0 {
-			if line, err := strconv.Atoi(string(text[i+1:])); err == nil && line > 0 {
-				// valid //line filename:line comment
-				filename := string(bytes.TrimSpace(text[len(prefix):i]))
-				if filename != "" {
-					filename = filepath.Clean(filename)
-					if !filepath.IsAbs(filename) {
-						// make filename relative to current directory
-						filename = filepath.Join(s.dir, filename)
-					}
-				}
-				// update scanner position
-				s.file.AddLineInfo(s.lineOffset+len(text)+1, filename, line) // +len(text)+1 since comment applies to next line
-			}
-		}
-	}
-}
-
-func (s *Scanner) scanComment() string {
-	// initial '/' already consumed; s.ch == '/' || s.ch == '*'
-	offs := s.offset - 1 // position of initial '/'
-	hasCR := false
-
-	if s.ch == '/' {
-		//-style comment
-		s.next()
-		for s.ch != '\n' && s.ch >= 0 {
-			if s.ch == '\r' {
-				hasCR = true
-			}
-			s.next()
-		}
-		if offs == s.lineOffset {
-			// comment starts at the beginning of the current line
-			s.interpretLineComment(s.src[offs:s.offset])
-		}
-		goto exit
-	}
-
-	/*-style comment */
-	s.next()
-	for s.ch >= 0 {
-		ch := s.ch
-		if ch == '\r' {
-			hasCR = true
-		}
-		s.next()
-		if ch == '*' && s.ch == '/' {
-			s.next()
-			goto exit
-		}
-	}
-
-	s.error(offs, "comment not terminated")
-
-exit:
-	lit := s.src[offs:s.offset]
-	if hasCR {
-		lit = stripCR(lit)
-	}
-
-	return string(lit)
-}
-
-func (s *Scanner) findLineEnd() bool {
-	// initial '/' already consumed
-
-	defer func(offs int) {
-		// reset scanner state to where it was upon calling findLineEnd
-		s.ch = '/'
-		s.offset = offs
-		s.rdOffset = offs + 1
-		s.next() // consume initial '/' again
-	}(s.offset - 1)
-
-	// read ahead until a newline, EOF, or non-comment token is found
-	for s.ch == '/' || s.ch == '*' {
-		if s.ch == '/' {
-			//-style comment always contains a newline
-			return true
-		}
-		/*-style comment: look for newline */
-		s.next()
-		for s.ch >= 0 {
-			ch := s.ch
-			if ch == '\n' {
-				return true
-			}
-			s.next()
-			if ch == '*' && s.ch == '/' {
-				s.next()
-				break
-			}
-		}
-		s.skipWhitespace() // s.insertSemi is set
-		if s.ch < 0 || s.ch == '\n' {
-			return true
-		}
-		if s.ch != '/' {
-			// non-comment token
-			return false
-		}
-		s.next() // consume '/'
-	}
-
-	return false
-}
-
-func isLetter(ch rune) bool {
-	return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch == '_' || ch >= 0x80 && unicode.IsLetter(ch)
-}
-
-func isDigit(ch rune) bool {
-	return '0' <= ch && ch <= '9' || ch >= 0x80 && unicode.IsDigit(ch)
-}
-
-func (s *Scanner) scanIdentifier() string {
-	offs := s.offset
-	for isLetter(s.ch) || isDigit(s.ch) {
-		s.next()
-	}
-	return string(s.src[offs:s.offset])
-}
-
-func digitVal(ch rune) int {
-	switch {
-	case '0' <= ch && ch <= '9':
-		return int(ch - '0')
-	case 'a' <= ch && ch <= 'f':
-		return int(ch - 'a' + 10)
-	case 'A' <= ch && ch <= 'F':
-		return int(ch - 'A' + 10)
-	}
-	return 16 // larger than any legal digit val
-}
-
-func (s *Scanner) scanMantissa(base int) {
-	for digitVal(s.ch) < base {
-		s.next()
-	}
-}
-
-func (s *Scanner) scanNumber(seenDecimalPoint bool) (token.Token, string) {
-	// digitVal(s.ch) < 10
-	offs := s.offset
-	tok := token.INT
-
-	if seenDecimalPoint {
-		offs--
-		tok = token.FLOAT
-		s.scanMantissa(10)
-		goto exponent
-	}
-
-	if s.ch == '0' {
-		// int or float
-		offs := s.offset
-		s.next()
-		if s.ch == 'x' || s.ch == 'X' {
-			// hexadecimal int
-			s.next()
-			s.scanMantissa(16)
-			if s.offset-offs <= 2 {
-				// only scanned "0x" or "0X"
-				s.error(offs, "illegal hexadecimal number")
-			}
-		} else {
-			// octal int or float
-			seenDecimalDigit := false
-			s.scanMantissa(8)
-			if s.ch == '8' || s.ch == '9' {
-				// illegal octal int or float
-				seenDecimalDigit = true
-				s.scanMantissa(10)
-			}
-			if s.ch == '.' || s.ch == 'e' || s.ch == 'E' || s.ch == 'i' {
-				goto fraction
-			}
-			// octal int
-			if seenDecimalDigit {
-				s.error(offs, "illegal octal number")
-			}
-		}
-		goto exit
-	}
-
-	// decimal int or float
-	s.scanMantissa(10)
-
-fraction:
-	if s.ch == '.' {
-		tok = token.FLOAT
-		s.next()
-		s.scanMantissa(10)
-	}
-
-exponent:
-	if s.ch == 'e' || s.ch == 'E' {
-		tok = token.FLOAT
-		s.next()
-		if s.ch == '-' || s.ch == '+' {
-			s.next()
-		}
-		s.scanMantissa(10)
-	}
-
-	if s.ch == 'i' {
-		tok = token.IMAG
-		s.next()
-	}
-
-exit:
-	return tok, string(s.src[offs:s.offset])
-}
-
-// scanEscape parses an escape sequence where rune is the accepted
-// escaped quote. In case of a syntax error, it stops at the offending
-// character (without consuming it) and returns false. Otherwise
-// it returns true.
-func (s *Scanner) scanEscape(quote rune) bool {
-	offs := s.offset
-
-	var n int
-	var base, max uint32
-	switch s.ch {
-	case 'a', 'b', 'f', 'n', 'r', 't', 'v', '\\', quote:
-		s.next()
-		return true
-	case '0', '1', '2', '3', '4', '5', '6', '7':
-		n, base, max = 3, 8, 255
-	case 'x':
-		s.next()
-		n, base, max = 2, 16, 255
-	case 'u':
-		s.next()
-		n, base, max = 4, 16, unicode.MaxRune
-	case 'U':
-		s.next()
-		n, base, max = 8, 16, unicode.MaxRune
-	default:
-		msg := "unknown escape sequence"
-		if s.ch < 0 {
-			msg = "escape sequence not terminated"
-		}
-		s.error(offs, msg)
-		return false
-	}
-
-	var x uint32
-	for n > 0 {
-		d := uint32(digitVal(s.ch))
-		if d >= base {
-			msg := fmt.Sprintf("illegal character %#U in escape sequence", s.ch)
-			if s.ch < 0 {
-				msg = "escape sequence not terminated"
-			}
-			s.error(s.offset, msg)
-			return false
-		}
-		x = x*base + d
-		s.next()
-		n--
-	}
-
-	if x > max || 0xD800 <= x && x < 0xE000 {
-		s.error(offs, "escape sequence is invalid Unicode code point")
-		return false
-	}
-
-	return true
-}
-
-func (s *Scanner) scanRune() string {
-	// '\'' opening already consumed
-	offs := s.offset - 1
-
-	valid := true
-	n := 0
-	for {
-		ch := s.ch
-		if ch == '\n' || ch < 0 {
-			// only report error if we don't have one already
-			if valid {
-				s.error(offs, "rune literal not terminated")
-				valid = false
-			}
-			break
-		}
-		s.next()
-		if ch == '\'' {
-			break
-		}
-		n++
-		if ch == '\\' {
-			if !s.scanEscape('\'') {
-				valid = false
-			}
-			// continue to read to closing quote
-		}
-	}
-
-	if valid && n != 1 {
-		s.error(offs, "illegal rune literal")
-	}
-
-	return string(s.src[offs:s.offset])
-}
-
-func (s *Scanner) scanString() string {
-	// '"' opening already consumed
-	offs := s.offset - 1
-
-	for {
-		ch := s.ch
-		if ch == '\n' || ch < 0 {
-			s.error(offs, "string literal not terminated")
-			break
-		}
-		s.next()
-		if ch == '"' {
-			break
-		}
-		if ch == '\\' {
-			s.scanEscape('"')
-		}
-	}
-
-	return string(s.src[offs:s.offset])
-}
-
-func stripCR(b []byte) []byte {
-	c := make([]byte, len(b))
-	i := 0
-	for _, ch := range b {
-		if ch != '\r' {
-			c[i] = ch
-			i++
-		}
-	}
-	return c[:i]
-}
-
-func (s *Scanner) scanRawString() string {
-	// '`' opening already consumed
-	offs := s.offset - 1
-
-	hasCR := false
-	for {
-		ch := s.ch
-		if ch < 0 {
-			s.error(offs, "raw string literal not terminated")
-			break
-		}
-		s.next()
-		if ch == '`' {
-			break
-		}
-		if ch == '\r' {
-			hasCR = true
-		}
-	}
-
-	lit := s.src[offs:s.offset]
-	if hasCR {
-		lit = stripCR(lit)
-	}
-
-	return string(lit)
-}
-
-func (s *Scanner) skipWhitespace() {
-	for s.ch == ' ' || s.ch == '\t' || s.ch == '\n' && !s.insertSemi || s.ch == '\r' {
-		s.next()
-	}
-}
-
-// Helper functions for scanning multi-byte tokens such as >> += >>= .
-// Different routines recognize different length tok_i based on matches
-// of ch_i. If a token ends in '=', the result is tok1 or tok3
-// respectively. Otherwise, the result is tok0 if there was no other
-// matching character, or tok2 if the matching character was ch2.
-
-func (s *Scanner) switch2(tok0, tok1 token.Token) token.Token {
-	if s.ch == '=' {
-		s.next()
-		return tok1
-	}
-	return tok0
-}
-
-func (s *Scanner) switch3(tok0, tok1 token.Token, ch2 rune, tok2 token.Token) token.Token {
-	if s.ch == '=' {
-		s.next()
-		return tok1
-	}
-	if s.ch == ch2 {
-		s.next()
-		return tok2
-	}
-	return tok0
-}
-
-func (s *Scanner) switch4(tok0, tok1 token.Token, ch2 rune, tok2, tok3 token.Token) token.Token {
-	if s.ch == '=' {
-		s.next()
-		return tok1
-	}
-	if s.ch == ch2 {
-		s.next()
-		if s.ch == '=' {
-			s.next()
-			return tok3
-		}
-		return tok2
-	}
-	return tok0
-}
-
-// Scan scans the next token and returns the token position, the token,
-// and its literal string if applicable. The source end is indicated by
-// token.EOF.
-//
-// If the returned token is a literal (token.IDENT, token.INT, token.FLOAT,
-// token.IMAG, token.CHAR, token.STRING) or token.COMMENT, the literal string
-// has the corresponding value.
-//
-// If the returned token is a keyword, the literal string is the keyword.
-//
-// If the returned token is token.SEMICOLON, the corresponding
-// literal string is ";" if the semicolon was present in the source,
-// and "\n" if the semicolon was inserted because of a newline or
-// at EOF.
-//
-// If the returned token is token.ILLEGAL, the literal string is the
-// offending character.
-//
-// In all other cases, Scan returns an empty literal string.
-//
-// For more tolerant parsing, Scan will return a valid token if
-// possible even if a syntax error was encountered. Thus, even
-// if the resulting token sequence contains no illegal tokens,
-// a client may not assume that no error occurred. Instead it
-// must check the scanner's ErrorCount or the number of calls
-// of the error handler, if there was one installed.
-//
-// Scan adds line information to the file added to the file
-// set with Init. Token positions are relative to that file
-// and thus relative to the file set.
-//
-func (s *Scanner) Scan() (pos token.Pos, tok token.Token, lit string) {
-scanAgain:
-	s.skipWhitespace()
-
-	// current token start
-	pos = s.file.Pos(s.offset)
-
-	// determine token value
-	insertSemi := false
-	switch ch := s.ch; {
-	case isLetter(ch):
-		lit = s.scanIdentifier()
-		if len(lit) > 1 {
-			// keywords are longer than one letter - avoid lookup otherwise
-			tok = token.Lookup(lit)
-			switch tok {
-			case token.IDENT, token.BREAK, token.CONTINUE, token.FALLTHROUGH, token.RETURN:
-				insertSemi = true
-			}
-		} else {
-			insertSemi = true
-			tok = token.IDENT
-		}
-	case '0' <= ch && ch <= '9':
-		insertSemi = true
-		tok, lit = s.scanNumber(false)
-	default:
-		s.next() // always make progress
-		switch ch {
-		case -1:
-			if s.insertSemi {
-				s.insertSemi = false // EOF consumed
-				return pos, token.SEMICOLON, "\n"
-			}
-			tok = token.EOF
-		case '\n':
-			// we only reach here if s.insertSemi was
-			// set in the first place and exited early
-			// from s.skipWhitespace()
-			s.insertSemi = false // newline consumed
-			return pos, token.SEMICOLON, "\n"
-		case '"':
-			insertSemi = true
-			tok = token.STRING
-			lit = s.scanString()
-		case '\'':
-			insertSemi = true
-			tok = token.CHAR
-			lit = s.scanRune()
-		case '`':
-			insertSemi = true
-			tok = token.STRING
-			lit = s.scanRawString()
-		case ':':
-			tok = s.switch2(token.COLON, token.DEFINE)
-		case '.':
-			if '0' <= s.ch && s.ch <= '9' {
-				insertSemi = true
-				tok, lit = s.scanNumber(true)
-			} else if s.ch == '.' {
-				s.next()
-				if s.ch == '.' {
-					s.next()
-					tok = token.ELLIPSIS
-				}
-			} else {
-				tok = token.PERIOD
-			}
-		case ',':
-			tok = token.COMMA
-		case ';':
-			tok = token.SEMICOLON
-			lit = ";"
-		case '(':
-			tok = token.LPAREN
-		case ')':
-			insertSemi = true
-			tok = token.RPAREN
-		case '[':
-			tok = token.LBRACK
-		case ']':
-			insertSemi = true
-			tok = token.RBRACK
-		case '{':
-			tok = token.LBRACE
-		case '}':
-			insertSemi = true
-			tok = token.RBRACE
-		case '+':
-			tok = s.switch3(token.ADD, token.ADD_ASSIGN, '+', token.INC)
-			if tok == token.INC {
-				insertSemi = true
-			}
-		case '-':
-			tok = s.switch3(token.SUB, token.SUB_ASSIGN, '-', token.DEC)
-			if tok == token.DEC {
-				insertSemi = true
-			}
-		case '*':
-			tok = s.switch2(token.MUL, token.MUL_ASSIGN)
-		case '/':
-			if s.ch == '/' || s.ch == '*' {
-				// comment
-				if s.insertSemi && s.findLineEnd() {
-					// reset position to the beginning of the comment
-					s.ch = '/'
-					s.offset = s.file.Offset(pos)
-					s.rdOffset = s.offset + 1
-					s.insertSemi = false // newline consumed
-					return pos, token.SEMICOLON, "\n"
-				}
-				comment := s.scanComment()
-				if s.mode&ScanComments == 0 {
-					// skip comment
-					s.insertSemi = false // newline consumed
-					goto scanAgain
-				}
-				tok = token.COMMENT
-				lit = comment
-			} else {
-				tok = s.switch2(token.QUO, token.QUO_ASSIGN)
-			}
-		case '%':
-			tok = s.switch2(token.REM, token.REM_ASSIGN)
-		case '^':
-			tok = s.switch2(token.XOR, token.XOR_ASSIGN)
-		case '<':
-			if s.ch == '-' {
-				s.next()
-				tok = token.ARROW
-			} else {
-				tok = s.switch4(token.LSS, token.LEQ, '<', token.SHL, token.SHL_ASSIGN)
-			}
-		case '>':
-			tok = s.switch4(token.GTR, token.GEQ, '>', token.SHR, token.SHR_ASSIGN)
-		case '=':
-			tok = s.switch2(token.ASSIGN, token.EQL)
-		case '!':
-			tok = s.switch2(token.NOT, token.NEQ)
-		case '&':
-			if s.ch == '^' {
-				s.next()
-				tok = s.switch2(token.AND_NOT, token.AND_NOT_ASSIGN)
-			} else {
-				tok = s.switch3(token.AND, token.AND_ASSIGN, '&', token.LAND)
-			}
-		case '|':
-			tok = s.switch3(token.OR, token.OR_ASSIGN, '|', token.LOR)
-		default:
-			// next reports unexpected BOMs - don't repeat
-			if ch != bom {
-				s.error(s.file.Offset(pos), fmt.Sprintf("illegal character %#U", ch))
-			}
-			insertSemi = s.insertSemi // preserve insertSemi info
-			tok = token.ILLEGAL
-			lit = string(ch)
-		}
-	}
-	if s.mode&dontInsertSemis == 0 {
-		s.insertSemi = insertSemi
-	}
-
-	return
-}
diff --git a/third_party/golang/go/scanner/scanner_test.go b/third_party/golang/go/scanner/scanner_test.go
deleted file mode 100644
index 1852a7acd332e..0000000000000
--- a/third_party/golang/go/scanner/scanner_test.go
+++ /dev/null
@@ -1,811 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package scanner
-
-import (
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"runtime"
-	"testing"
-
-	"k8s.io/kubernetes/third_party/golang/go/token"
-)
-
-var fset = token.NewFileSet()
-
-const /* class */ (
-	special = iota
-	literal
-	operator
-	keyword
-)
-
-func tokenclass(tok token.Token) int {
-	switch {
-	case tok.IsLiteral():
-		return literal
-	case tok.IsOperator():
-		return operator
-	case tok.IsKeyword():
-		return keyword
-	}
-	return special
-}
-
-type elt struct {
-	tok   token.Token
-	lit   string
-	class int
-}
-
-var tokens = [...]elt{
-	// Special tokens
-	{token.COMMENT, "/* a comment */", special},
-	{token.COMMENT, "// a comment \n", special},
-	{token.COMMENT, "/*\r*/", special},
-	{token.COMMENT, "//\r\n", special},
-
-	// Identifiers and basic type literals
-	{token.IDENT, "foobar", literal},
-	{token.IDENT, "a۰۱۸", literal},
-	{token.IDENT, "foo६४", literal},
-	{token.IDENT, "bar９８７６", literal},
-	{token.IDENT, "ŝ", literal},    // was bug (issue 4000)
-	{token.IDENT, "ŝfoo", literal}, // was bug (issue 4000)
-	{token.INT, "0", literal},
-	{token.INT, "1", literal},
-	{token.INT, "123456789012345678890", literal},
-	{token.INT, "01234567", literal},
-	{token.INT, "0xcafebabe", literal},
-	{token.FLOAT, "0.", literal},
-	{token.FLOAT, ".0", literal},
-	{token.FLOAT, "3.14159265", literal},
-	{token.FLOAT, "1e0", literal},
-	{token.FLOAT, "1e+100", literal},
-	{token.FLOAT, "1e-100", literal},
-	{token.FLOAT, "2.71828e-1000", literal},
-	{token.IMAG, "0i", literal},
-	{token.IMAG, "1i", literal},
-	{token.IMAG, "012345678901234567889i", literal},
-	{token.IMAG, "123456789012345678890i", literal},
-	{token.IMAG, "0.i", literal},
-	{token.IMAG, ".0i", literal},
-	{token.IMAG, "3.14159265i", literal},
-	{token.IMAG, "1e0i", literal},
-	{token.IMAG, "1e+100i", literal},
-	{token.IMAG, "1e-100i", literal},
-	{token.IMAG, "2.71828e-1000i", literal},
-	{token.CHAR, "'a'", literal},
-	{token.CHAR, "'\\000'", literal},
-	{token.CHAR, "'\\xFF'", literal},
-	{token.CHAR, "'\\uff16'", literal},
-	{token.CHAR, "'\\U0000ff16'", literal},
-	{token.STRING, "`foobar`", literal},
-	{token.STRING, "`" + `foo
-	                        bar` +
-		"`",
-		literal,
-	},
-	{token.STRING, "`\r`", literal},
-	{token.STRING, "`foo\r\nbar`", literal},
-
-	// Operators and delimiters
-	{token.ADD, "+", operator},
-	{token.SUB, "-", operator},
-	{token.MUL, "*", operator},
-	{token.QUO, "/", operator},
-	{token.REM, "%", operator},
-
-	{token.AND, "&", operator},
-	{token.OR, "|", operator},
-	{token.XOR, "^", operator},
-	{token.SHL, "<<", operator},
-	{token.SHR, ">>", operator},
-	{token.AND_NOT, "&^", operator},
-
-	{token.ADD_ASSIGN, "+=", operator},
-	{token.SUB_ASSIGN, "-=", operator},
-	{token.MUL_ASSIGN, "*=", operator},
-	{token.QUO_ASSIGN, "/=", operator},
-	{token.REM_ASSIGN, "%=", operator},
-
-	{token.AND_ASSIGN, "&=", operator},
-	{token.OR_ASSIGN, "|=", operator},
-	{token.XOR_ASSIGN, "^=", operator},
-	{token.SHL_ASSIGN, "<<=", operator},
-	{token.SHR_ASSIGN, ">>=", operator},
-	{token.AND_NOT_ASSIGN, "&^=", operator},
-
-	{token.LAND, "&&", operator},
-	{token.LOR, "||", operator},
-	{token.ARROW, "<-", operator},
-	{token.INC, "++", operator},
-	{token.DEC, "--", operator},
-
-	{token.EQL, "==", operator},
-	{token.LSS, "<", operator},
-	{token.GTR, ">", operator},
-	{token.ASSIGN, "=", operator},
-	{token.NOT, "!", operator},
-
-	{token.NEQ, "!=", operator},
-	{token.LEQ, "<=", operator},
-	{token.GEQ, ">=", operator},
-	{token.DEFINE, ":=", operator},
-	{token.ELLIPSIS, "...", operator},
-
-	{token.LPAREN, "(", operator},
-	{token.LBRACK, "[", operator},
-	{token.LBRACE, "{", operator},
-	{token.COMMA, ",", operator},
-	{token.PERIOD, ".", operator},
-
-	{token.RPAREN, ")", operator},
-	{token.RBRACK, "]", operator},
-	{token.RBRACE, "}", operator},
-	{token.SEMICOLON, ";", operator},
-	{token.COLON, ":", operator},
-
-	// Keywords
-	{token.BREAK, "break", keyword},
-	{token.CASE, "case", keyword},
-	{token.CHAN, "chan", keyword},
-	{token.CONST, "const", keyword},
-	{token.CONTINUE, "continue", keyword},
-
-	{token.DEFAULT, "default", keyword},
-	{token.DEFER, "defer", keyword},
-	{token.ELSE, "else", keyword},
-	{token.FALLTHROUGH, "fallthrough", keyword},
-	{token.FOR, "for", keyword},
-
-	{token.FUNC, "func", keyword},
-	{token.GO, "go", keyword},
-	{token.GOTO, "goto", keyword},
-	{token.IF, "if", keyword},
-	{token.IMPORT, "import", keyword},
-
-	{token.INTERFACE, "interface", keyword},
-	{token.MAP, "map", keyword},
-	{token.PACKAGE, "package", keyword},
-	{token.RANGE, "range", keyword},
-	{token.RETURN, "return", keyword},
-
-	{token.SELECT, "select", keyword},
-	{token.STRUCT, "struct", keyword},
-	{token.SWITCH, "switch", keyword},
-	{token.TYPE, "type", keyword},
-	{token.VAR, "var", keyword},
-}
-
-const whitespace = "  \t  \n\n\n" // to separate tokens
-
-var source = func() []byte {
-	var src []byte
-	for _, t := range tokens {
-		src = append(src, t.lit...)
-		src = append(src, whitespace...)
-	}
-	return src
-}()
-
-func newlineCount(s string) int {
-	n := 0
-	for i := 0; i < len(s); i++ {
-		if s[i] == '\n' {
-			n++
-		}
-	}
-	return n
-}
-
-func checkPos(t *testing.T, lit string, p token.Pos, expected token.Position) {
-	pos := fset.Position(p)
-	if pos.Filename != expected.Filename {
-		t.Errorf("bad filename for %q: got %s, expected %s", lit, pos.Filename, expected.Filename)
-	}
-	if pos.Offset != expected.Offset {
-		t.Errorf("bad position for %q: got %d, expected %d", lit, pos.Offset, expected.Offset)
-	}
-	if pos.Line != expected.Line {
-		t.Errorf("bad line for %q: got %d, expected %d", lit, pos.Line, expected.Line)
-	}
-	if pos.Column != expected.Column {
-		t.Errorf("bad column for %q: got %d, expected %d", lit, pos.Column, expected.Column)
-	}
-}
-
-// Verify that calling Scan() provides the correct results.
-func TestScan(t *testing.T) {
-	whitespace_linecount := newlineCount(whitespace)
-
-	// error handler
-	eh := func(_ token.Position, msg string) {
-		t.Errorf("error handler called (msg = %s)", msg)
-	}
-
-	// verify scan
-	var s Scanner
-	s.Init(fset.AddFile("", fset.Base(), len(source)), source, eh, ScanComments|dontInsertSemis)
-
-	// set up expected position
-	epos := token.Position{
-		Filename: "",
-		Offset:   0,
-		Line:     1,
-		Column:   1,
-	}
-
-	index := 0
-	for {
-		pos, tok, lit := s.Scan()
-
-		// check position
-		if tok == token.EOF {
-			// correction for EOF
-			epos.Line = newlineCount(string(source))
-			epos.Column = 2
-		}
-		checkPos(t, lit, pos, epos)
-
-		// check token
-		e := elt{token.EOF, "", special}
-		if index < len(tokens) {
-			e = tokens[index]
-			index++
-		}
-		if tok != e.tok {
-			t.Errorf("bad token for %q: got %s, expected %s", lit, tok, e.tok)
-		}
-
-		// check token class
-		if tokenclass(tok) != e.class {
-			t.Errorf("bad class for %q: got %d, expected %d", lit, tokenclass(tok), e.class)
-		}
-
-		// check literal
-		elit := ""
-		switch e.tok {
-		case token.COMMENT:
-			// no CRs in comments
-			elit = string(stripCR([]byte(e.lit)))
-			//-style comment literal doesn't contain newline
-			if elit[1] == '/' {
-				elit = elit[0 : len(elit)-1]
-			}
-		case token.IDENT:
-			elit = e.lit
-		case token.SEMICOLON:
-			elit = ";"
-		default:
-			if e.tok.IsLiteral() {
-				// no CRs in raw string literals
-				elit = e.lit
-				if elit[0] == '`' {
-					elit = string(stripCR([]byte(elit)))
-				}
-			} else if e.tok.IsKeyword() {
-				elit = e.lit
-			}
-		}
-		if lit != elit {
-			t.Errorf("bad literal for %q: got %q, expected %q", lit, lit, elit)
-		}
-
-		if tok == token.EOF {
-			break
-		}
-
-		// update position
-		epos.Offset += len(e.lit) + len(whitespace)
-		epos.Line += newlineCount(e.lit) + whitespace_linecount
-
-	}
-
-	if s.ErrorCount != 0 {
-		t.Errorf("found %d errors", s.ErrorCount)
-	}
-}
-
-func checkSemi(t *testing.T, line string, mode Mode) {
-	var S Scanner
-	file := fset.AddFile("TestSemis", fset.Base(), len(line))
-	S.Init(file, []byte(line), nil, mode)
-	pos, tok, lit := S.Scan()
-	for tok != token.EOF {
-		if tok == token.ILLEGAL {
-			// the illegal token literal indicates what
-			// kind of semicolon literal to expect
-			semiLit := "\n"
-			if lit[0] == '#' {
-				semiLit = ";"
-			}
-			// next token must be a semicolon
-			semiPos := file.Position(pos)
-			semiPos.Offset++
-			semiPos.Column++
-			pos, tok, lit = S.Scan()
-			if tok == token.SEMICOLON {
-				if lit != semiLit {
-					t.Errorf(`bad literal for %q: got %q, expected %q`, line, lit, semiLit)
-				}
-				checkPos(t, line, pos, semiPos)
-			} else {
-				t.Errorf("bad token for %q: got %s, expected ;", line, tok)
-			}
-		} else if tok == token.SEMICOLON {
-			t.Errorf("bad token for %q: got ;, expected no ;", line)
-		}
-		pos, tok, lit = S.Scan()
-	}
-}
-
-var lines = []string{
-	// # indicates a semicolon present in the source
-	// $ indicates an automatically inserted semicolon
-	"",
-	"\ufeff#;", // first BOM is ignored
-	"#;",
-	"foo$\n",
-	"123$\n",
-	"1.2$\n",
-	"'x'$\n",
-	`"x"` + "$\n",
-	"`x`$\n",
-
-	"+\n",
-	"-\n",
-	"*\n",
-	"/\n",
-	"%\n",
-
-	"&\n",
-	"|\n",
-	"^\n",
-	"<<\n",
-	">>\n",
-	"&^\n",
-
-	"+=\n",
-	"-=\n",
-	"*=\n",
-	"/=\n",
-	"%=\n",
-
-	"&=\n",
-	"|=\n",
-	"^=\n",
-	"<<=\n",
-	">>=\n",
-	"&^=\n",
-
-	"&&\n",
-	"||\n",
-	"<-\n",
-	"++$\n",
-	"--$\n",
-
-	"==\n",
-	"<\n",
-	">\n",
-	"=\n",
-	"!\n",
-
-	"!=\n",
-	"<=\n",
-	">=\n",
-	":=\n",
-	"...\n",
-
-	"(\n",
-	"[\n",
-	"{\n",
-	",\n",
-	".\n",
-
-	")$\n",
-	"]$\n",
-	"}$\n",
-	"#;\n",
-	":\n",
-
-	"break$\n",
-	"case\n",
-	"chan\n",
-	"const\n",
-	"continue$\n",
-
-	"default\n",
-	"defer\n",
-	"else\n",
-	"fallthrough$\n",
-	"for\n",
-
-	"func\n",
-	"go\n",
-	"goto\n",
-	"if\n",
-	"import\n",
-
-	"interface\n",
-	"map\n",
-	"package\n",
-	"range\n",
-	"return$\n",
-
-	"select\n",
-	"struct\n",
-	"switch\n",
-	"type\n",
-	"var\n",
-
-	"foo$//comment\n",
-	"foo$//comment",
-	"foo$/*comment*/\n",
-	"foo$/*\n*/",
-	"foo$/*comment*/    \n",
-	"foo$/*\n*/    ",
-
-	"foo    $// comment\n",
-	"foo    $// comment",
-	"foo    $/*comment*/\n",
-	"foo    $/*\n*/",
-	"foo    $/*  */ /* \n */ bar$/**/\n",
-	"foo    $/*0*/ /*1*/ /*2*/\n",
-
-	"foo    $/*comment*/    \n",
-	"foo    $/*0*/ /*1*/ /*2*/    \n",
-	"foo	$/**/ /*-------------*/       /*----\n*/bar       $/*  \n*/baa$\n",
-	"foo    $/* an EOF terminates a line */",
-	"foo    $/* an EOF terminates a line */ /*",
-	"foo    $/* an EOF terminates a line */ //",
-
-	"package main$\n\nfunc main() {\n\tif {\n\t\treturn /* */ }$\n}$\n",
-	"package main$",
-}
-
-func TestSemis(t *testing.T) {
-	for _, line := range lines {
-		checkSemi(t, line, 0)
-		checkSemi(t, line, ScanComments)
-
-		// if the input ended in newlines, the input must tokenize the
-		// same with or without those newlines
-		for i := len(line) - 1; i >= 0 && line[i] == '\n'; i-- {
-			checkSemi(t, line[0:i], 0)
-			checkSemi(t, line[0:i], ScanComments)
-		}
-	}
-}
-
-type segment struct {
-	srcline  string // a line of source text
-	filename string // filename for current token
-	line     int    // line number for current token
-}
-
-var segments = []segment{
-	// exactly one token per line since the test consumes one token per segment
-	{"  line1", filepath.Join("dir", "TestLineComments"), 1},
-	{"\nline2", filepath.Join("dir", "TestLineComments"), 2},
-	{"\nline3  //line File1.go:100", filepath.Join("dir", "TestLineComments"), 3}, // bad line comment, ignored
-	{"\nline4", filepath.Join("dir", "TestLineComments"), 4},
-	{"\n//line File1.go:100\n  line100", filepath.Join("dir", "File1.go"), 100},
-	{"\n//line  \t :42\n  line1", "", 42},
-	{"\n//line File2.go:200\n  line200", filepath.Join("dir", "File2.go"), 200},
-	{"\n//line foo\t:42\n  line42", filepath.Join("dir", "foo"), 42},
-	{"\n //line foo:42\n  line44", filepath.Join("dir", "foo"), 44},           // bad line comment, ignored
-	{"\n//line foo 42\n  line46", filepath.Join("dir", "foo"), 46},            // bad line comment, ignored
-	{"\n//line foo:42 extra text\n  line48", filepath.Join("dir", "foo"), 48}, // bad line comment, ignored
-	{"\n//line ./foo:42\n  line42", filepath.Join("dir", "foo"), 42},
-	{"\n//line a/b/c/File1.go:100\n  line100", filepath.Join("dir", "a", "b", "c", "File1.go"), 100},
-}
-
-var unixsegments = []segment{
-	{"\n//line /bar:42\n  line42", "/bar", 42},
-}
-
-var winsegments = []segment{
-	{"\n//line c:\\bar:42\n  line42", "c:\\bar", 42},
-	{"\n//line c:\\dir\\File1.go:100\n  line100", "c:\\dir\\File1.go", 100},
-}
-
-// Verify that comments of the form "//line filename:line" are interpreted correctly.
-func TestLineComments(t *testing.T) {
-	segs := segments
-	if runtime.GOOS == "windows" {
-		segs = append(segs, winsegments...)
-	} else {
-		segs = append(segs, unixsegments...)
-	}
-
-	// make source
-	var src string
-	for _, e := range segs {
-		src += e.srcline
-	}
-
-	// verify scan
-	var S Scanner
-	file := fset.AddFile(filepath.Join("dir", "TestLineComments"), fset.Base(), len(src))
-	S.Init(file, []byte(src), nil, dontInsertSemis)
-	for _, s := range segs {
-		p, _, lit := S.Scan()
-		pos := file.Position(p)
-		checkPos(t, lit, p, token.Position{
-			Filename: s.filename,
-			Offset:   pos.Offset,
-			Line:     s.line,
-			Column:   pos.Column,
-		})
-	}
-
-	if S.ErrorCount != 0 {
-		t.Errorf("found %d errors", S.ErrorCount)
-	}
-}
-
-// Verify that initializing the same scanner more than once works correctly.
-func TestInit(t *testing.T) {
-	var s Scanner
-
-	// 1st init
-	src1 := "if true { }"
-	f1 := fset.AddFile("src1", fset.Base(), len(src1))
-	s.Init(f1, []byte(src1), nil, dontInsertSemis)
-	if f1.Size() != len(src1) {
-		t.Errorf("bad file size: got %d, expected %d", f1.Size(), len(src1))
-	}
-	s.Scan()              // if
-	s.Scan()              // true
-	_, tok, _ := s.Scan() // {
-	if tok != token.LBRACE {
-		t.Errorf("bad token: got %s, expected %s", tok, token.LBRACE)
-	}
-
-	// 2nd init
-	src2 := "go true { ]"
-	f2 := fset.AddFile("src2", fset.Base(), len(src2))
-	s.Init(f2, []byte(src2), nil, dontInsertSemis)
-	if f2.Size() != len(src2) {
-		t.Errorf("bad file size: got %d, expected %d", f2.Size(), len(src2))
-	}
-	_, tok, _ = s.Scan() // go
-	if tok != token.GO {
-		t.Errorf("bad token: got %s, expected %s", tok, token.GO)
-	}
-
-	if s.ErrorCount != 0 {
-		t.Errorf("found %d errors", s.ErrorCount)
-	}
-}
-
-func TestStdErrorHander(t *testing.T) {
-	const src = "@\n" + // illegal character, cause an error
-		"@ @\n" + // two errors on the same line
-		"//line File2:20\n" +
-		"@\n" + // different file, but same line
-		"//line File2:1\n" +
-		"@ @\n" + // same file, decreasing line number
-		"//line File1:1\n" +
-		"@ @ @" // original file, line 1 again
-
-	var list ErrorList
-	eh := func(pos token.Position, msg string) { list.Add(pos, msg) }
-
-	var s Scanner
-	s.Init(fset.AddFile("File1", fset.Base(), len(src)), []byte(src), eh, dontInsertSemis)
-	for {
-		if _, tok, _ := s.Scan(); tok == token.EOF {
-			break
-		}
-	}
-
-	if len(list) != s.ErrorCount {
-		t.Errorf("found %d errors, expected %d", len(list), s.ErrorCount)
-	}
-
-	if len(list) != 9 {
-		t.Errorf("found %d raw errors, expected 9", len(list))
-		PrintError(os.Stderr, list)
-	}
-
-	list.Sort()
-	if len(list) != 9 {
-		t.Errorf("found %d sorted errors, expected 9", len(list))
-		PrintError(os.Stderr, list)
-	}
-
-	list.RemoveMultiples()
-	if len(list) != 4 {
-		t.Errorf("found %d one-per-line errors, expected 4", len(list))
-		PrintError(os.Stderr, list)
-	}
-}
-
-type errorCollector struct {
-	cnt int            // number of errors encountered
-	msg string         // last error message encountered
-	pos token.Position // last error position encountered
-}
-
-func checkError(t *testing.T, src string, tok token.Token, pos int, lit, err string) {
-	var s Scanner
-	var h errorCollector
-	eh := func(pos token.Position, msg string) {
-		h.cnt++
-		h.msg = msg
-		h.pos = pos
-	}
-	s.Init(fset.AddFile("", fset.Base(), len(src)), []byte(src), eh, ScanComments|dontInsertSemis)
-	_, tok0, lit0 := s.Scan()
-	if tok0 != tok {
-		t.Errorf("%q: got %s, expected %s", src, tok0, tok)
-	}
-	if tok0 != token.ILLEGAL && lit0 != lit {
-		t.Errorf("%q: got literal %q, expected %q", src, lit0, lit)
-	}
-	cnt := 0
-	if err != "" {
-		cnt = 1
-	}
-	if h.cnt != cnt {
-		t.Errorf("%q: got cnt %d, expected %d", src, h.cnt, cnt)
-	}
-	if h.msg != err {
-		t.Errorf("%q: got msg %q, expected %q", src, h.msg, err)
-	}
-	if h.pos.Offset != pos {
-		t.Errorf("%q: got offset %d, expected %d", src, h.pos.Offset, pos)
-	}
-}
-
-var errors = []struct {
-	src string
-	tok token.Token
-	pos int
-	lit string
-	err string
-}{
-	{"\a", token.ILLEGAL, 0, "", "illegal character U+0007"},
-	{`#`, token.ILLEGAL, 0, "", "illegal character U+0023 '#'"},
-	{`…`, token.ILLEGAL, 0, "", "illegal character U+2026 '…'"},
-	{`' '`, token.CHAR, 0, `' '`, ""},
-	{`''`, token.CHAR, 0, `''`, "illegal rune literal"},
-	{`'12'`, token.CHAR, 0, `'12'`, "illegal rune literal"},
-	{`'123'`, token.CHAR, 0, `'123'`, "illegal rune literal"},
-	{`'\0'`, token.CHAR, 3, `'\0'`, "illegal character U+0027 ''' in escape sequence"},
-	{`'\07'`, token.CHAR, 4, `'\07'`, "illegal character U+0027 ''' in escape sequence"},
-	{`'\8'`, token.CHAR, 2, `'\8'`, "unknown escape sequence"},
-	{`'\08'`, token.CHAR, 3, `'\08'`, "illegal character U+0038 '8' in escape sequence"},
-	{`'\x'`, token.CHAR, 3, `'\x'`, "illegal character U+0027 ''' in escape sequence"},
-	{`'\x0'`, token.CHAR, 4, `'\x0'`, "illegal character U+0027 ''' in escape sequence"},
-	{`'\x0g'`, token.CHAR, 4, `'\x0g'`, "illegal character U+0067 'g' in escape sequence"},
-	{`'\u'`, token.CHAR, 3, `'\u'`, "illegal character U+0027 ''' in escape sequence"},
-	{`'\u0'`, token.CHAR, 4, `'\u0'`, "illegal character U+0027 ''' in escape sequence"},
-	{`'\u00'`, token.CHAR, 5, `'\u00'`, "illegal character U+0027 ''' in escape sequence"},
-	{`'\u000'`, token.CHAR, 6, `'\u000'`, "illegal character U+0027 ''' in escape sequence"},
-	{`'\u000`, token.CHAR, 6, `'\u000`, "escape sequence not terminated"},
-	{`'\u0000'`, token.CHAR, 0, `'\u0000'`, ""},
-	{`'\U'`, token.CHAR, 3, `'\U'`, "illegal character U+0027 ''' in escape sequence"},
-	{`'\U0'`, token.CHAR, 4, `'\U0'`, "illegal character U+0027 ''' in escape sequence"},
-	{`'\U00'`, token.CHAR, 5, `'\U00'`, "illegal character U+0027 ''' in escape sequence"},
-	{`'\U000'`, token.CHAR, 6, `'\U000'`, "illegal character U+0027 ''' in escape sequence"},
-	{`'\U0000'`, token.CHAR, 7, `'\U0000'`, "illegal character U+0027 ''' in escape sequence"},
-	{`'\U00000'`, token.CHAR, 8, `'\U00000'`, "illegal character U+0027 ''' in escape sequence"},
-	{`'\U000000'`, token.CHAR, 9, `'\U000000'`, "illegal character U+0027 ''' in escape sequence"},
-	{`'\U0000000'`, token.CHAR, 10, `'\U0000000'`, "illegal character U+0027 ''' in escape sequence"},
-	{`'\U0000000`, token.CHAR, 10, `'\U0000000`, "escape sequence not terminated"},
-	{`'\U00000000'`, token.CHAR, 0, `'\U00000000'`, ""},
-	{`'\Uffffffff'`, token.CHAR, 2, `'\Uffffffff'`, "escape sequence is invalid Unicode code point"},
-	{`'`, token.CHAR, 0, `'`, "rune literal not terminated"},
-	{`'\`, token.CHAR, 2, `'\`, "escape sequence not terminated"},
-	{"'\n", token.CHAR, 0, "'", "rune literal not terminated"},
-	{"'\n   ", token.CHAR, 0, "'", "rune literal not terminated"},
-	{`""`, token.STRING, 0, `""`, ""},
-	{`"abc`, token.STRING, 0, `"abc`, "string literal not terminated"},
-	{"\"abc\n", token.STRING, 0, `"abc`, "string literal not terminated"},
-	{"\"abc\n   ", token.STRING, 0, `"abc`, "string literal not terminated"},
-	{"``", token.STRING, 0, "``", ""},
-	{"`", token.STRING, 0, "`", "raw string literal not terminated"},
-	{"/**/", token.COMMENT, 0, "/**/", ""},
-	{"/*", token.COMMENT, 0, "/*", "comment not terminated"},
-	{"077", token.INT, 0, "077", ""},
-	{"078.", token.FLOAT, 0, "078.", ""},
-	{"07801234567.", token.FLOAT, 0, "07801234567.", ""},
-	{"078e0", token.FLOAT, 0, "078e0", ""},
-	{"078", token.INT, 0, "078", "illegal octal number"},
-	{"07800000009", token.INT, 0, "07800000009", "illegal octal number"},
-	{"0x", token.INT, 0, "0x", "illegal hexadecimal number"},
-	{"0X", token.INT, 0, "0X", "illegal hexadecimal number"},
-	{"\"abc\x00def\"", token.STRING, 4, "\"abc\x00def\"", "illegal character NUL"},
-	{"\"abc\x80def\"", token.STRING, 4, "\"abc\x80def\"", "illegal UTF-8 encoding"},
-	{"\ufeff\ufeff", token.ILLEGAL, 3, "\ufeff\ufeff", "illegal byte order mark"},                        // only first BOM is ignored
-	{"//\ufeff", token.COMMENT, 2, "//\ufeff", "illegal byte order mark"},                                // only first BOM is ignored
-	{"'\ufeff" + `'`, token.CHAR, 1, "'\ufeff" + `'`, "illegal byte order mark"},                         // only first BOM is ignored
-	{`"` + "abc\ufeffdef" + `"`, token.STRING, 4, `"` + "abc\ufeffdef" + `"`, "illegal byte order mark"}, // only first BOM is ignored
-}
-
-func TestScanErrors(t *testing.T) {
-	for _, e := range errors {
-		checkError(t, e.src, e.tok, e.pos, e.lit, e.err)
-	}
-}
-
-// Verify that no comments show up as literal values when skipping comments.
-func TestIssue10213(t *testing.T) {
-	var src = `
-		var (
-			A = 1 // foo
-		)
-
-		var (
-			B = 2
-			// foo
-		)
-
-		var C = 3 // foo
-
-		var D = 4
-		// foo
-
-		func anycode() {
-		// foo
-		}
-	`
-	var s Scanner
-	s.Init(fset.AddFile("", fset.Base(), len(src)), []byte(src), nil, 0)
-	for {
-		pos, tok, lit := s.Scan()
-		class := tokenclass(tok)
-		if lit != "" && class != keyword && class != literal && tok != token.SEMICOLON {
-			t.Errorf("%s: tok = %s, lit = %q", fset.Position(pos), tok, lit)
-		}
-		if tok <= token.EOF {
-			break
-		}
-	}
-}
-
-func BenchmarkScan(b *testing.B) {
-	b.StopTimer()
-	fset := token.NewFileSet()
-	file := fset.AddFile("", fset.Base(), len(source))
-	var s Scanner
-	b.StartTimer()
-	for i := 0; i < b.N; i++ {
-		s.Init(file, source, nil, ScanComments)
-		for {
-			_, tok, _ := s.Scan()
-			if tok == token.EOF {
-				break
-			}
-		}
-	}
-}
-
-func BenchmarkScanFile(b *testing.B) {
-	b.StopTimer()
-	const filename = "scanner.go"
-	src, err := ioutil.ReadFile(filename)
-	if err != nil {
-		panic(err)
-	}
-	fset := token.NewFileSet()
-	file := fset.AddFile(filename, fset.Base(), len(src))
-	b.SetBytes(int64(len(src)))
-	var s Scanner
-	b.StartTimer()
-	for i := 0; i < b.N; i++ {
-		s.Init(file, src, nil, ScanComments)
-		for {
-			_, tok, _ := s.Scan()
-			if tok == token.EOF {
-				break
-			}
-		}
-	}
-}
diff --git a/third_party/golang/go/token/position.go b/third_party/golang/go/token/position.go
deleted file mode 100644
index 33751779a3d9b..0000000000000
--- a/third_party/golang/go/token/position.go
+++ /dev/null
@@ -1,485 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package token
-
-import (
-	"fmt"
-	"sort"
-	"sync"
-)
-
-// -----------------------------------------------------------------------------
-// Positions
-
-// Position describes an arbitrary source position
-// including the file, line, and column location.
-// A Position is valid if the line number is > 0.
-//
-type Position struct {
-	Filename string // filename, if any
-	Offset   int    // offset, starting at 0
-	Line     int    // line number, starting at 1
-	Column   int    // column number, starting at 1 (byte count)
-}
-
-// IsValid reports whether the position is valid.
-func (pos *Position) IsValid() bool { return pos.Line > 0 }
-
-// String returns a string in one of several forms:
-//
-//	file:line:column    valid position with file name
-//	line:column         valid position without file name
-//	file                invalid position with file name
-//	-                   invalid position without file name
-//
-func (pos Position) String() string {
-	s := pos.Filename
-	if pos.IsValid() {
-		if s != "" {
-			s += ":"
-		}
-		s += fmt.Sprintf("%d:%d", pos.Line, pos.Column)
-	}
-	if s == "" {
-		s = "-"
-	}
-	return s
-}
-
-// Pos is a compact encoding of a source position within a file set.
-// It can be converted into a Position for a more convenient, but much
-// larger, representation.
-//
-// The Pos value for a given file is a number in the range [base, base+size],
-// where base and size are specified when adding the file to the file set via
-// AddFile.
-//
-// To create the Pos value for a specific source offset (measured in bytes),
-// first add the respective file to the current file set using FileSet.AddFile
-// and then call File.Pos(offset) for that file. Given a Pos value p
-// for a specific file set fset, the corresponding Position value is
-// obtained by calling fset.Position(p).
-//
-// Pos values can be compared directly with the usual comparison operators:
-// If two Pos values p and q are in the same file, comparing p and q is
-// equivalent to comparing the respective source file offsets. If p and q
-// are in different files, p < q is true if the file implied by p was added
-// to the respective file set before the file implied by q.
-//
-type Pos int
-
-// The zero value for Pos is NoPos; there is no file and line information
-// associated with it, and NoPos().IsValid() is false. NoPos is always
-// smaller than any other Pos value. The corresponding Position value
-// for NoPos is the zero value for Position.
-//
-const NoPos Pos = 0
-
-// IsValid reports whether the position is valid.
-func (p Pos) IsValid() bool {
-	return p != NoPos
-}
-
-// -----------------------------------------------------------------------------
-// File
-
-// A File is a handle for a file belonging to a FileSet.
-// A File has a name, size, and line offset table.
-//
-type File struct {
-	set  *FileSet
-	name string // file name as provided to AddFile
-	base int    // Pos value range for this file is [base...base+size]
-	size int    // file size as provided to AddFile
-
-	// lines and infos are protected by set.mutex
-	lines []int // lines contains the offset of the first character for each line (the first entry is always 0)
-	infos []lineInfo
-}
-
-// Name returns the file name of file f as registered with AddFile.
-func (f *File) Name() string {
-	return f.name
-}
-
-// Base returns the base offset of file f as registered with AddFile.
-func (f *File) Base() int {
-	return f.base
-}
-
-// Size returns the size of file f as registered with AddFile.
-func (f *File) Size() int {
-	return f.size
-}
-
-// LineCount returns the number of lines in file f.
-func (f *File) LineCount() int {
-	f.set.mutex.RLock()
-	n := len(f.lines)
-	f.set.mutex.RUnlock()
-	return n
-}
-
-// AddLine adds the line offset for a new line.
-// The line offset must be larger than the offset for the previous line
-// and smaller than the file size; otherwise the line offset is ignored.
-//
-func (f *File) AddLine(offset int) {
-	f.set.mutex.Lock()
-	if i := len(f.lines); (i == 0 || f.lines[i-1] < offset) && offset < f.size {
-		f.lines = append(f.lines, offset)
-	}
-	f.set.mutex.Unlock()
-}
-
-// MergeLine merges a line with the following line. It is akin to replacing
-// the newline character at the end of the line with a space (to not change the
-// remaining offsets). To obtain the line number, consult e.g. Position.Line.
-// MergeLine will panic if given an invalid line number.
-//
-func (f *File) MergeLine(line int) {
-	if line <= 0 {
-		panic("illegal line number (line numbering starts at 1)")
-	}
-	f.set.mutex.Lock()
-	defer f.set.mutex.Unlock()
-	if line >= len(f.lines) {
-		panic("illegal line number")
-	}
-	// To merge the line numbered  with the line numbered ,
-	// we need to remove the entry in lines corresponding to the line
-	// numbered . The entry in lines corresponding to the line
-	// numbered  is located at index , since indices in lines
-	// are 0-based and line numbers are 1-based.
-	copy(f.lines[line:], f.lines[line+1:])
-	f.lines = f.lines[:len(f.lines)-1]
-}
-
-// SetLines sets the line offsets for a file and reports whether it succeeded.
-// The line offsets are the offsets of the first character of each line;
-// for instance for the content "ab\nc\n" the line offsets are {0, 3}.
-// An empty file has an empty line offset table.
-// Each line offset must be larger than the offset for the previous line
-// and smaller than the file size; otherwise SetLines fails and returns
-// false.
-//
-func (f *File) SetLines(lines []int) bool {
-	// verify validity of lines table
-	size := f.size
-	for i, offset := range lines {
-		if i > 0 && offset <= lines[i-1] || size <= offset {
-			return false
-		}
-	}
-
-	// set lines table
-	f.set.mutex.Lock()
-	f.lines = lines
-	f.set.mutex.Unlock()
-	return true
-}
-
-// SetLinesForContent sets the line offsets for the given file content.
-// It ignores position-altering //line comments.
-func (f *File) SetLinesForContent(content []byte) {
-	var lines []int
-	line := 0
-	for offset, b := range content {
-		if line >= 0 {
-			lines = append(lines, line)
-		}
-		line = -1
-		if b == '\n' {
-			line = offset + 1
-		}
-	}
-
-	// set lines table
-	f.set.mutex.Lock()
-	f.lines = lines
-	f.set.mutex.Unlock()
-}
-
-// A lineInfo object describes alternative file and line number
-// information (such as provided via a //line comment in a .go
-// file) for a given file offset.
-type lineInfo struct {
-	// fields are exported to make them accessible to gob
-	Offset   int
-	Filename string
-	Line     int
-}
-
-// AddLineInfo adds alternative file and line number information for
-// a given file offset. The offset must be larger than the offset for
-// the previously added alternative line info and smaller than the
-// file size; otherwise the information is ignored.
-//
-// AddLineInfo is typically used to register alternative position
-// information for //line filename:line comments in source files.
-//
-func (f *File) AddLineInfo(offset int, filename string, line int) {
-	f.set.mutex.Lock()
-	if i := len(f.infos); i == 0 || f.infos[i-1].Offset < offset && offset < f.size {
-		f.infos = append(f.infos, lineInfo{offset, filename, line})
-	}
-	f.set.mutex.Unlock()
-}
-
-// Pos returns the Pos value for the given file offset;
-// the offset must be <= f.Size().
-// f.Pos(f.Offset(p)) == p.
-//
-func (f *File) Pos(offset int) Pos {
-	if offset > f.size {
-		panic("illegal file offset")
-	}
-	return Pos(f.base + offset)
-}
-
-// Offset returns the offset for the given file position p;
-// p must be a valid Pos value in that file.
-// f.Offset(f.Pos(offset)) == offset.
-//
-func (f *File) Offset(p Pos) int {
-	if int(p) < f.base || int(p) > f.base+f.size {
-		panic("illegal Pos value")
-	}
-	return int(p) - f.base
-}
-
-// Line returns the line number for the given file position p;
-// p must be a Pos value in that file or NoPos.
-//
-func (f *File) Line(p Pos) int {
-	return f.Position(p).Line
-}
-
-func searchLineInfos(a []lineInfo, x int) int {
-	return sort.Search(len(a), func(i int) bool { return a[i].Offset > x }) - 1
-}
-
-// unpack returns the filename and line and column number for a file offset.
-// If adjusted is set, unpack will return the filename and line information
-// possibly adjusted by //line comments; otherwise those comments are ignored.
-//
-func (f *File) unpack(offset int, adjusted bool) (filename string, line, column int) {
-	filename = f.name
-	if i := searchInts(f.lines, offset); i >= 0 {
-		line, column = i+1, offset-f.lines[i]+1
-	}
-	if adjusted && len(f.infos) > 0 {
-		// almost no files have extra line infos
-		if i := searchLineInfos(f.infos, offset); i >= 0 {
-			alt := &f.infos[i]
-			filename = alt.Filename
-			if i := searchInts(f.lines, alt.Offset); i >= 0 {
-				line += alt.Line - i - 1
-			}
-		}
-	}
-	return
-}
-
-func (f *File) position(p Pos, adjusted bool) (pos Position) {
-	offset := int(p) - f.base
-	pos.Offset = offset
-	pos.Filename, pos.Line, pos.Column = f.unpack(offset, adjusted)
-	return
-}
-
-// PositionFor returns the Position value for the given file position p.
-// If adjusted is set, the position may be adjusted by position-altering
-// //line comments; otherwise those comments are ignored.
-// p must be a Pos value in f or NoPos.
-//
-func (f *File) PositionFor(p Pos, adjusted bool) (pos Position) {
-	if p != NoPos {
-		if int(p) < f.base || int(p) > f.base+f.size {
-			panic("illegal Pos value")
-		}
-		pos = f.position(p, adjusted)
-	}
-	return
-}
-
-// Position returns the Position value for the given file position p.
-// Calling f.Position(p) is equivalent to calling f.PositionFor(p, true).
-//
-func (f *File) Position(p Pos) (pos Position) {
-	return f.PositionFor(p, true)
-}
-
-// -----------------------------------------------------------------------------
-// FileSet
-
-// A FileSet represents a set of source files.
-// Methods of file sets are synchronized; multiple goroutines
-// may invoke them concurrently.
-//
-type FileSet struct {
-	mutex sync.RWMutex // protects the file set
-	base  int          // base offset for the next file
-	files []*File      // list of files in the order added to the set
-	last  *File        // cache of last file looked up
-}
-
-// NewFileSet creates a new file set.
-func NewFileSet() *FileSet {
-	return &FileSet{
-		base: 1, // 0 == NoPos
-	}
-}
-
-// Base returns the minimum base offset that must be provided to
-// AddFile when adding the next file.
-//
-func (s *FileSet) Base() int {
-	s.mutex.RLock()
-	b := s.base
-	s.mutex.RUnlock()
-	return b
-
-}
-
-// AddFile adds a new file with a given filename, base offset, and file size
-// to the file set s and returns the file. Multiple files may have the same
-// name. The base offset must not be smaller than the FileSet's Base(), and
-// size must not be negative. As a special case, if a negative base is provided,
-// the current value of the FileSet's Base() is used instead.
-//
-// Adding the file will set the file set's Base() value to base + size + 1
-// as the minimum base value for the next file. The following relationship
-// exists between a Pos value p for a given file offset offs:
-//
-//	int(p) = base + offs
-//
-// with offs in the range [0, size] and thus p in the range [base, base+size].
-// For convenience, File.Pos may be used to create file-specific position
-// values from a file offset.
-//
-func (s *FileSet) AddFile(filename string, base, size int) *File {
-	s.mutex.Lock()
-	defer s.mutex.Unlock()
-	if base < 0 {
-		base = s.base
-	}
-	if base < s.base || size < 0 {
-		panic("illegal base or size")
-	}
-	// base >= s.base && size >= 0
-	f := &File{s, filename, base, size, []int{0}, nil}
-	base += size + 1 // +1 because EOF also has a position
-	if base < 0 {
-		panic("token.Pos offset overflow (> 2G of source code in file set)")
-	}
-	// add the file to the file set
-	s.base = base
-	s.files = append(s.files, f)
-	s.last = f
-	return f
-}
-
-// Iterate calls f for the files in the file set in the order they were added
-// until f returns false.
-//
-func (s *FileSet) Iterate(f func(*File) bool) {
-	for i := 0; ; i++ {
-		var file *File
-		s.mutex.RLock()
-		if i < len(s.files) {
-			file = s.files[i]
-		}
-		s.mutex.RUnlock()
-		if file == nil || !f(file) {
-			break
-		}
-	}
-}
-
-func searchFiles(a []*File, x int) int {
-	return sort.Search(len(a), func(i int) bool { return a[i].base > x }) - 1
-}
-
-func (s *FileSet) file(p Pos) *File {
-	s.mutex.RLock()
-	// common case: p is in last file
-	if f := s.last; f != nil && f.base <= int(p) && int(p) <= f.base+f.size {
-		s.mutex.RUnlock()
-		return f
-	}
-	// p is not in last file - search all files
-	if i := searchFiles(s.files, int(p)); i >= 0 {
-		f := s.files[i]
-		// f.base <= int(p) by definition of searchFiles
-		if int(p) <= f.base+f.size {
-			s.mutex.RUnlock()
-			s.mutex.Lock()
-			s.last = f // race is ok - s.last is only a cache
-			s.mutex.Unlock()
-			return f
-		}
-	}
-	s.mutex.RUnlock()
-	return nil
-}
-
-// File returns the file that contains the position p.
-// If no such file is found (for instance for p == NoPos),
-// the result is nil.
-//
-func (s *FileSet) File(p Pos) (f *File) {
-	if p != NoPos {
-		f = s.file(p)
-	}
-	return
-}
-
-// PositionFor converts a Pos p in the fileset into a Position value.
-// If adjusted is set, the position may be adjusted by position-altering
-// //line comments; otherwise those comments are ignored.
-// p must be a Pos value in s or NoPos.
-//
-func (s *FileSet) PositionFor(p Pos, adjusted bool) (pos Position) {
-	if p != NoPos {
-		if f := s.file(p); f != nil {
-			pos = f.position(p, adjusted)
-		}
-	}
-	return
-}
-
-// Position converts a Pos p in the fileset into a Position value.
-// Calling s.Position(p) is equivalent to calling s.PositionFor(p, true).
-//
-func (s *FileSet) Position(p Pos) (pos Position) {
-	return s.PositionFor(p, true)
-}
-
-// -----------------------------------------------------------------------------
-// Helper functions
-
-func searchInts(a []int, x int) int {
-	// This function body is a manually inlined version of:
-	//
-	//   return sort.Search(len(a), func(i int) bool { return a[i] > x }) - 1
-	//
-	// With better compiler optimizations, this may not be needed in the
-	// future, but at the moment this change improves the go/printer
-	// benchmark performance by ~30%. This has a direct impact on the
-	// speed of gofmt and thus seems worthwhile (2011-04-29).
-	// TODO(gri): Remove this when compilers have caught up.
-	i, j := 0, len(a)
-	for i < j {
-		h := i + (j-i)/2 // avoid overflow when computing h
-		// i ≤ h < j
-		if a[h] <= x {
-			i = h + 1
-		} else {
-			j = h
-		}
-	}
-	return i - 1
-}
diff --git a/third_party/golang/go/token/position_test.go b/third_party/golang/go/token/position_test.go
deleted file mode 100644
index d26939ce277e1..0000000000000
--- a/third_party/golang/go/token/position_test.go
+++ /dev/null
@@ -1,297 +0,0 @@
-// Copyright 2010 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package token
-
-import (
-	"fmt"
-	"math/rand"
-	"sync"
-	"testing"
-)
-
-func checkPos(t *testing.T, msg string, got, want Position) {
-	if got.Filename != want.Filename {
-		t.Errorf("%s: got filename = %q; want %q", msg, got.Filename, want.Filename)
-	}
-	if got.Offset != want.Offset {
-		t.Errorf("%s: got offset = %d; want %d", msg, got.Offset, want.Offset)
-	}
-	if got.Line != want.Line {
-		t.Errorf("%s: got line = %d; want %d", msg, got.Line, want.Line)
-	}
-	if got.Column != want.Column {
-		t.Errorf("%s: got column = %d; want %d", msg, got.Column, want.Column)
-	}
-}
-
-func TestNoPos(t *testing.T) {
-	if NoPos.IsValid() {
-		t.Errorf("NoPos should not be valid")
-	}
-	var fset *FileSet
-	checkPos(t, "nil NoPos", fset.Position(NoPos), Position{})
-	fset = NewFileSet()
-	checkPos(t, "fset NoPos", fset.Position(NoPos), Position{})
-}
-
-var tests = []struct {
-	filename string
-	source   []byte // may be nil
-	size     int
-	lines    []int
-}{
-	{"a", []byte{}, 0, []int{}},
-	{"b", []byte("01234"), 5, []int{0}},
-	{"c", []byte("\n\n\n\n\n\n\n\n\n"), 9, []int{0, 1, 2, 3, 4, 5, 6, 7, 8}},
-	{"d", nil, 100, []int{0, 5, 10, 20, 30, 70, 71, 72, 80, 85, 90, 99}},
-	{"e", nil, 777, []int{0, 80, 100, 120, 130, 180, 267, 455, 500, 567, 620}},
-	{"f", []byte("package p\n\nimport \"fmt\""), 23, []int{0, 10, 11}},
-	{"g", []byte("package p\n\nimport \"fmt\"\n"), 24, []int{0, 10, 11}},
-	{"h", []byte("package p\n\nimport \"fmt\"\n "), 25, []int{0, 10, 11, 24}},
-}
-
-func linecol(lines []int, offs int) (int, int) {
-	prevLineOffs := 0
-	for line, lineOffs := range lines {
-		if offs < lineOffs {
-			return line, offs - prevLineOffs + 1
-		}
-		prevLineOffs = lineOffs
-	}
-	return len(lines), offs - prevLineOffs + 1
-}
-
-func verifyPositions(t *testing.T, fset *FileSet, f *File, lines []int) {
-	for offs := 0; offs < f.Size(); offs++ {
-		p := f.Pos(offs)
-		offs2 := f.Offset(p)
-		if offs2 != offs {
-			t.Errorf("%s, Offset: got offset %d; want %d", f.Name(), offs2, offs)
-		}
-		line, col := linecol(lines, offs)
-		msg := fmt.Sprintf("%s (offs = %d, p = %d)", f.Name(), offs, p)
-		checkPos(t, msg, f.Position(f.Pos(offs)), Position{f.Name(), offs, line, col})
-		checkPos(t, msg, fset.Position(p), Position{f.Name(), offs, line, col})
-	}
-}
-
-func makeTestSource(size int, lines []int) []byte {
-	src := make([]byte, size)
-	for _, offs := range lines {
-		if offs > 0 {
-			src[offs-1] = '\n'
-		}
-	}
-	return src
-}
-
-func TestPositions(t *testing.T) {
-	const delta = 7 // a non-zero base offset increment
-	fset := NewFileSet()
-	for _, test := range tests {
-		// verify consistency of test case
-		if test.source != nil && len(test.source) != test.size {
-			t.Errorf("%s: inconsistent test case: got file size %d; want %d", test.filename, len(test.source), test.size)
-		}
-
-		// add file and verify name and size
-		f := fset.AddFile(test.filename, fset.Base()+delta, test.size)
-		if f.Name() != test.filename {
-			t.Errorf("got filename %q; want %q", f.Name(), test.filename)
-		}
-		if f.Size() != test.size {
-			t.Errorf("%s: got file size %d; want %d", f.Name(), f.Size(), test.size)
-		}
-		if fset.File(f.Pos(0)) != f {
-			t.Errorf("%s: f.Pos(0) was not found in f", f.Name())
-		}
-
-		// add lines individually and verify all positions
-		for i, offset := range test.lines {
-			f.AddLine(offset)
-			if f.LineCount() != i+1 {
-				t.Errorf("%s, AddLine: got line count %d; want %d", f.Name(), f.LineCount(), i+1)
-			}
-			// adding the same offset again should be ignored
-			f.AddLine(offset)
-			if f.LineCount() != i+1 {
-				t.Errorf("%s, AddLine: got unchanged line count %d; want %d", f.Name(), f.LineCount(), i+1)
-			}
-			verifyPositions(t, fset, f, test.lines[0:i+1])
-		}
-
-		// add lines with SetLines and verify all positions
-		if ok := f.SetLines(test.lines); !ok {
-			t.Errorf("%s: SetLines failed", f.Name())
-		}
-		if f.LineCount() != len(test.lines) {
-			t.Errorf("%s, SetLines: got line count %d; want %d", f.Name(), f.LineCount(), len(test.lines))
-		}
-		verifyPositions(t, fset, f, test.lines)
-
-		// add lines with SetLinesForContent and verify all positions
-		src := test.source
-		if src == nil {
-			// no test source available - create one from scratch
-			src = makeTestSource(test.size, test.lines)
-		}
-		f.SetLinesForContent(src)
-		if f.LineCount() != len(test.lines) {
-			t.Errorf("%s, SetLinesForContent: got line count %d; want %d", f.Name(), f.LineCount(), len(test.lines))
-		}
-		verifyPositions(t, fset, f, test.lines)
-	}
-}
-
-func TestLineInfo(t *testing.T) {
-	fset := NewFileSet()
-	f := fset.AddFile("foo", fset.Base(), 500)
-	lines := []int{0, 42, 77, 100, 210, 220, 277, 300, 333, 401}
-	// add lines individually and provide alternative line information
-	for _, offs := range lines {
-		f.AddLine(offs)
-		f.AddLineInfo(offs, "bar", 42)
-	}
-	// verify positions for all offsets
-	for offs := 0; offs <= f.Size(); offs++ {
-		p := f.Pos(offs)
-		_, col := linecol(lines, offs)
-		msg := fmt.Sprintf("%s (offs = %d, p = %d)", f.Name(), offs, p)
-		checkPos(t, msg, f.Position(f.Pos(offs)), Position{"bar", offs, 42, col})
-		checkPos(t, msg, fset.Position(p), Position{"bar", offs, 42, col})
-	}
-}
-
-func TestFiles(t *testing.T) {
-	fset := NewFileSet()
-	for i, test := range tests {
-		base := fset.Base()
-		if i%2 == 1 {
-			// Setting a negative base is equivalent to
-			// fset.Base(), so test some of each.
-			base = -1
-		}
-		fset.AddFile(test.filename, base, test.size)
-		j := 0
-		fset.Iterate(func(f *File) bool {
-			if f.Name() != tests[j].filename {
-				t.Errorf("got filename = %s; want %s", f.Name(), tests[j].filename)
-			}
-			j++
-			return true
-		})
-		if j != i+1 {
-			t.Errorf("got %d files; want %d", j, i+1)
-		}
-	}
-}
-
-// FileSet.File should return nil if Pos is past the end of the FileSet.
-func TestFileSetPastEnd(t *testing.T) {
-	fset := NewFileSet()
-	for _, test := range tests {
-		fset.AddFile(test.filename, fset.Base(), test.size)
-	}
-	if f := fset.File(Pos(fset.Base())); f != nil {
-		t.Errorf("got %v, want nil", f)
-	}
-}
-
-func TestFileSetCacheUnlikely(t *testing.T) {
-	fset := NewFileSet()
-	offsets := make(map[string]int)
-	for _, test := range tests {
-		offsets[test.filename] = fset.Base()
-		fset.AddFile(test.filename, fset.Base(), test.size)
-	}
-	for file, pos := range offsets {
-		f := fset.File(Pos(pos))
-		if f.Name() != file {
-			t.Errorf("got %q at position %d, want %q", f.Name(), pos, file)
-		}
-	}
-}
-
-// issue 4345. Test concurrent use of FileSet.Pos does not trigger a
-// race in the FileSet position cache.
-func TestFileSetRace(t *testing.T) {
-	fset := NewFileSet()
-	for i := 0; i < 100; i++ {
-		fset.AddFile(fmt.Sprintf("file-%d", i), fset.Base(), 1031)
-	}
-	max := int32(fset.Base())
-	var stop sync.WaitGroup
-	r := rand.New(rand.NewSource(7))
-	for i := 0; i < 2; i++ {
-		r := rand.New(rand.NewSource(r.Int63()))
-		stop.Add(1)
-		go func() {
-			for i := 0; i < 1000; i++ {
-				fset.Position(Pos(r.Int31n(max)))
-			}
-			stop.Done()
-		}()
-	}
-	stop.Wait()
-}
-
-func TestPositionFor(t *testing.T) {
-	src := []byte(`
-foo
-b
-ar
-//line :100
-foobar
-//line bar:3
-done
-`)
-
-	const filename = "foo"
-	fset := NewFileSet()
-	f := fset.AddFile(filename, fset.Base(), len(src))
-	f.SetLinesForContent(src)
-
-	// verify position info
-	for i, offs := range f.lines {
-		got1 := f.PositionFor(f.Pos(offs), false)
-		got2 := f.PositionFor(f.Pos(offs), true)
-		got3 := f.Position(f.Pos(offs))
-		want := Position{filename, offs, i + 1, 1}
-		checkPos(t, "1. PositionFor unadjusted", got1, want)
-		checkPos(t, "1. PositionFor adjusted", got2, want)
-		checkPos(t, "1. Position", got3, want)
-	}
-
-	// manually add //line info on lines l1, l2
-	const l1, l2 = 5, 7
-	f.AddLineInfo(f.lines[l1-1], "", 100)
-	f.AddLineInfo(f.lines[l2-1], "bar", 3)
-
-	// unadjusted position info must remain unchanged
-	for i, offs := range f.lines {
-		got1 := f.PositionFor(f.Pos(offs), false)
-		want := Position{filename, offs, i + 1, 1}
-		checkPos(t, "2. PositionFor unadjusted", got1, want)
-	}
-
-	// adjusted position info should have changed
-	for i, offs := range f.lines {
-		got2 := f.PositionFor(f.Pos(offs), true)
-		got3 := f.Position(f.Pos(offs))
-		want := Position{filename, offs, i + 1, 1}
-		// manually compute wanted filename and line
-		line := want.Line
-		if i+1 >= l1 {
-			want.Filename = ""
-			want.Line = line - l1 + 100
-		}
-		if i+1 >= l2 {
-			want.Filename = "bar"
-			want.Line = line - l2 + 3
-		}
-		checkPos(t, "3. PositionFor adjusted", got2, want)
-		checkPos(t, "3. Position", got3, want)
-	}
-}
diff --git a/third_party/golang/go/token/serialize.go b/third_party/golang/go/token/serialize.go
deleted file mode 100644
index 4adc8f9e33422..0000000000000
--- a/third_party/golang/go/token/serialize.go
+++ /dev/null
@@ -1,56 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package token
-
-type serializedFile struct {
-	// fields correspond 1:1 to fields with same (lower-case) name in File
-	Name  string
-	Base  int
-	Size  int
-	Lines []int
-	Infos []lineInfo
-}
-
-type serializedFileSet struct {
-	Base  int
-	Files []serializedFile
-}
-
-// Read calls decode to deserialize a file set into s; s must not be nil.
-func (s *FileSet) Read(decode func(interface{}) error) error {
-	var ss serializedFileSet
-	if err := decode(&ss); err != nil {
-		return err
-	}
-
-	s.mutex.Lock()
-	s.base = ss.Base
-	files := make([]*File, len(ss.Files))
-	for i := 0; i < len(ss.Files); i++ {
-		f := &ss.Files[i]
-		files[i] = &File{s, f.Name, f.Base, f.Size, f.Lines, f.Infos}
-	}
-	s.files = files
-	s.last = nil
-	s.mutex.Unlock()
-
-	return nil
-}
-
-// Write calls encode to serialize the file set s.
-func (s *FileSet) Write(encode func(interface{}) error) error {
-	var ss serializedFileSet
-
-	s.mutex.Lock()
-	ss.Base = s.base
-	files := make([]serializedFile, len(s.files))
-	for i, f := range s.files {
-		files[i] = serializedFile{f.name, f.base, f.size, f.lines, f.infos}
-	}
-	ss.Files = files
-	s.mutex.Unlock()
-
-	return encode(ss)
-}
diff --git a/third_party/golang/go/token/serialize_test.go b/third_party/golang/go/token/serialize_test.go
deleted file mode 100644
index 4e925adb6f264..0000000000000
--- a/third_party/golang/go/token/serialize_test.go
+++ /dev/null
@@ -1,111 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package token
-
-import (
-	"bytes"
-	"encoding/gob"
-	"fmt"
-	"testing"
-)
-
-// equal returns nil if p and q describe the same file set;
-// otherwise it returns an error describing the discrepancy.
-func equal(p, q *FileSet) error {
-	if p == q {
-		// avoid deadlock if p == q
-		return nil
-	}
-
-	// not strictly needed for the test
-	p.mutex.Lock()
-	q.mutex.Lock()
-	defer q.mutex.Unlock()
-	defer p.mutex.Unlock()
-
-	if p.base != q.base {
-		return fmt.Errorf("different bases: %d != %d", p.base, q.base)
-	}
-
-	if len(p.files) != len(q.files) {
-		return fmt.Errorf("different number of files: %d != %d", len(p.files), len(q.files))
-	}
-
-	for i, f := range p.files {
-		g := q.files[i]
-		if f.set != p {
-			return fmt.Errorf("wrong fileset for %q", f.name)
-		}
-		if g.set != q {
-			return fmt.Errorf("wrong fileset for %q", g.name)
-		}
-		if f.name != g.name {
-			return fmt.Errorf("different filenames: %q != %q", f.name, g.name)
-		}
-		if f.base != g.base {
-			return fmt.Errorf("different base for %q: %d != %d", f.name, f.base, g.base)
-		}
-		if f.size != g.size {
-			return fmt.Errorf("different size for %q: %d != %d", f.name, f.size, g.size)
-		}
-		for j, l := range f.lines {
-			m := g.lines[j]
-			if l != m {
-				return fmt.Errorf("different offsets for %q", f.name)
-			}
-		}
-		for j, l := range f.infos {
-			m := g.infos[j]
-			if l.Offset != m.Offset || l.Filename != m.Filename || l.Line != m.Line {
-				return fmt.Errorf("different infos for %q", f.name)
-			}
-		}
-	}
-
-	// we don't care about .last - it's just a cache
-	return nil
-}
-
-func checkSerialize(t *testing.T, p *FileSet) {
-	var buf bytes.Buffer
-	encode := func(x interface{}) error {
-		return gob.NewEncoder(&buf).Encode(x)
-	}
-	if err := p.Write(encode); err != nil {
-		t.Errorf("writing fileset failed: %s", err)
-		return
-	}
-	q := NewFileSet()
-	decode := func(x interface{}) error {
-		return gob.NewDecoder(&buf).Decode(x)
-	}
-	if err := q.Read(decode); err != nil {
-		t.Errorf("reading fileset failed: %s", err)
-		return
-	}
-	if err := equal(p, q); err != nil {
-		t.Errorf("filesets not identical: %s", err)
-	}
-}
-
-func TestSerialization(t *testing.T) {
-	p := NewFileSet()
-	checkSerialize(t, p)
-	// add some files
-	for i := 0; i < 10; i++ {
-		f := p.AddFile(fmt.Sprintf("file%d", i), p.Base()+i, i*100)
-		checkSerialize(t, p)
-		// add some lines and alternative file infos
-		line := 1000
-		for offs := 0; offs < f.Size(); offs += 40 + i {
-			f.AddLine(offs)
-			if offs%7 == 0 {
-				f.AddLineInfo(offs, fmt.Sprintf("file%d", offs), line)
-				line += 33
-			}
-		}
-		checkSerialize(t, p)
-	}
-}
diff --git a/third_party/golang/go/token/token.go b/third_party/golang/go/token/token.go
deleted file mode 100644
index 865f63f4a146c..0000000000000
--- a/third_party/golang/go/token/token.go
+++ /dev/null
@@ -1,308 +0,0 @@
-// Copyright 2009 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package token defines constants representing the lexical tokens of the Go
-// programming language and basic operations on tokens (printing, predicates).
-//
-package token
-
-import "strconv"
-
-// Token is the set of lexical tokens of the Go programming language.
-type Token int
-
-// The list of tokens.
-const (
-	// Special tokens
-	ILLEGAL Token = iota
-	EOF
-	COMMENT
-
-	literal_beg
-	// Identifiers and basic type literals
-	// (these tokens stand for classes of literals)
-	IDENT  // main
-	INT    // 12345
-	FLOAT  // 123.45
-	IMAG   // 123.45i
-	CHAR   // 'a'
-	STRING // "abc"
-	literal_end
-
-	operator_beg
-	// Operators and delimiters
-	ADD // +
-	SUB // -
-	MUL // *
-	QUO // /
-	REM // %
-
-	AND     // &
-	OR      // |
-	XOR     // ^
-	SHL     // <<
-	SHR     // >>
-	AND_NOT // &^
-
-	ADD_ASSIGN // +=
-	SUB_ASSIGN // -=
-	MUL_ASSIGN // *=
-	QUO_ASSIGN // /=
-	REM_ASSIGN // %=
-
-	AND_ASSIGN     // &=
-	OR_ASSIGN      // |=
-	XOR_ASSIGN     // ^=
-	SHL_ASSIGN     // <<=
-	SHR_ASSIGN     // >>=
-	AND_NOT_ASSIGN // &^=
-
-	LAND  // &&
-	LOR   // ||
-	ARROW // <-
-	INC   // ++
-	DEC   // --
-
-	EQL    // ==
-	LSS    // <
-	GTR    // >
-	ASSIGN // =
-	NOT    // !
-
-	NEQ      // !=
-	LEQ      // <=
-	GEQ      // >=
-	DEFINE   // :=
-	ELLIPSIS // ...
-
-	LPAREN // (
-	LBRACK // [
-	LBRACE // {
-	COMMA  // ,
-	PERIOD // .
-
-	RPAREN    // )
-	RBRACK    // ]
-	RBRACE    // }
-	SEMICOLON // ;
-	COLON     // :
-	operator_end
-
-	keyword_beg
-	// Keywords
-	BREAK
-	CASE
-	CHAN
-	CONST
-	CONTINUE
-
-	DEFAULT
-	DEFER
-	ELSE
-	FALLTHROUGH
-	FOR
-
-	FUNC
-	GO
-	GOTO
-	IF
-	IMPORT
-
-	INTERFACE
-	MAP
-	PACKAGE
-	RANGE
-	RETURN
-
-	SELECT
-	STRUCT
-	SWITCH
-	TYPE
-	VAR
-	keyword_end
-)
-
-var tokens = [...]string{
-	ILLEGAL: "ILLEGAL",
-
-	EOF:     "EOF",
-	COMMENT: "COMMENT",
-
-	IDENT:  "IDENT",
-	INT:    "INT",
-	FLOAT:  "FLOAT",
-	IMAG:   "IMAG",
-	CHAR:   "CHAR",
-	STRING: "STRING",
-
-	ADD: "+",
-	SUB: "-",
-	MUL: "*",
-	QUO: "/",
-	REM: "%",
-
-	AND:     "&",
-	OR:      "|",
-	XOR:     "^",
-	SHL:     "<<",
-	SHR:     ">>",
-	AND_NOT: "&^",
-
-	ADD_ASSIGN: "+=",
-	SUB_ASSIGN: "-=",
-	MUL_ASSIGN: "*=",
-	QUO_ASSIGN: "/=",
-	REM_ASSIGN: "%=",
-
-	AND_ASSIGN:     "&=",
-	OR_ASSIGN:      "|=",
-	XOR_ASSIGN:     "^=",
-	SHL_ASSIGN:     "<<=",
-	SHR_ASSIGN:     ">>=",
-	AND_NOT_ASSIGN: "&^=",
-
-	LAND:  "&&",
-	LOR:   "||",
-	ARROW: "<-",
-	INC:   "++",
-	DEC:   "--",
-
-	EQL:    "==",
-	LSS:    "<",
-	GTR:    ">",
-	ASSIGN: "=",
-	NOT:    "!",
-
-	NEQ:      "!=",
-	LEQ:      "<=",
-	GEQ:      ">=",
-	DEFINE:   ":=",
-	ELLIPSIS: "...",
-
-	LPAREN: "(",
-	LBRACK: "[",
-	LBRACE: "{",
-	COMMA:  ",",
-	PERIOD: ".",
-
-	RPAREN:    ")",
-	RBRACK:    "]",
-	RBRACE:    "}",
-	SEMICOLON: ";",
-	COLON:     ":",
-
-	BREAK:    "break",
-	CASE:     "case",
-	CHAN:     "chan",
-	CONST:    "const",
-	CONTINUE: "continue",
-
-	DEFAULT:     "default",
-	DEFER:       "defer",
-	ELSE:        "else",
-	FALLTHROUGH: "fallthrough",
-	FOR:         "for",
-
-	FUNC:   "func",
-	GO:     "go",
-	GOTO:   "goto",
-	IF:     "if",
-	IMPORT: "import",
-
-	INTERFACE: "interface",
-	MAP:       "map",
-	PACKAGE:   "package",
-	RANGE:     "range",
-	RETURN:    "return",
-
-	SELECT: "select",
-	STRUCT: "struct",
-	SWITCH: "switch",
-	TYPE:   "type",
-	VAR:    "var",
-}
-
-// String returns the string corresponding to the token tok.
-// For operators, delimiters, and keywords the string is the actual
-// token character sequence (e.g., for the token ADD, the string is
-// "+"). For all other tokens the string corresponds to the token
-// constant name (e.g. for the token IDENT, the string is "IDENT").
-//
-func (tok Token) String() string {
-	s := ""
-	if 0 <= tok && tok < Token(len(tokens)) {
-		s = tokens[tok]
-	}
-	if s == "" {
-		s = "token(" + strconv.Itoa(int(tok)) + ")"
-	}
-	return s
-}
-
-// A set of constants for precedence-based expression parsing.
-// Non-operators have lowest precedence, followed by operators
-// starting with precedence 1 up to unary operators. The highest
-// precedence serves as "catch-all" precedence for selector,
-// indexing, and other operator and delimiter tokens.
-//
-const (
-	LowestPrec  = 0 // non-operators
-	UnaryPrec   = 6
-	HighestPrec = 7
-)
-
-// Precedence returns the operator precedence of the binary
-// operator op. If op is not a binary operator, the result
-// is LowestPrecedence.
-//
-func (op Token) Precedence() int {
-	switch op {
-	case LOR:
-		return 1
-	case LAND:
-		return 2
-	case EQL, NEQ, LSS, LEQ, GTR, GEQ:
-		return 3
-	case ADD, SUB, OR, XOR:
-		return 4
-	case MUL, QUO, REM, SHL, SHR, AND, AND_NOT:
-		return 5
-	}
-	return LowestPrec
-}
-
-var keywords map[string]Token
-
-func init() {
-	keywords = make(map[string]Token)
-	for i := keyword_beg + 1; i < keyword_end; i++ {
-		keywords[tokens[i]] = i
-	}
-}
-
-// Lookup maps an identifier to its keyword token or IDENT (if not a keyword).
-//
-func Lookup(ident string) Token {
-	if tok, is_keyword := keywords[ident]; is_keyword {
-		return tok
-	}
-	return IDENT
-}
-
-// Predicates
-
-// IsLiteral returns true for tokens corresponding to identifiers
-// and basic type literals; it returns false otherwise.
-//
-func (tok Token) IsLiteral() bool { return literal_beg < tok && tok < literal_end }
-
-// IsOperator returns true for tokens corresponding to operators and
-// delimiters; it returns false otherwise.
-//
-func (tok Token) IsOperator() bool { return operator_beg < tok && tok < operator_end }
-
-// IsKeyword returns true for tokens corresponding to keywords;
-// it returns false otherwise.
-//
-func (tok Token) IsKeyword() bool { return keyword_beg < tok && tok < keyword_end }
diff --git a/third_party/golang/go/types/api.go b/third_party/golang/go/types/api.go
deleted file mode 100644
index 2377362dc323d..0000000000000
--- a/third_party/golang/go/types/api.go
+++ /dev/null
@@ -1,336 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package types declares the data types and implements
-// the algorithms for type-checking of Go packages. Use
-// Config.Check to invoke the type checker for a package.
-// Alternatively, create a new type checked with NewChecker
-// and invoke it incrementally by calling Checker.Files.
-//
-// Type-checking consists of several interdependent phases:
-//
-// Name resolution maps each identifier (ast.Ident) in the program to the
-// language object (Object) it denotes.
-// Use Info.{Defs,Uses,Implicits} for the results of name resolution.
-//
-// Constant folding computes the exact constant value (constant.Value)
-// for every expression (ast.Expr) that is a compile-time constant.
-// Use Info.Types[expr].Value for the results of constant folding.
-//
-// Type inference computes the type (Type) of every expression (ast.Expr)
-// and checks for compliance with the language specification.
-// Use Info.Types[expr].Type for the results of type inference.
-//
-package types
-
-import (
-	"bytes"
-	"fmt"
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"k8s.io/kubernetes/third_party/golang/go/constant"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-)
-
-// An Error describes a type-checking error; it implements the error interface.
-// A "soft" error is an error that still permits a valid interpretation of a
-// package (such as "unused variable"); "hard" errors may lead to unpredictable
-// behavior if ignored.
-type Error struct {
-	Fset *token.FileSet // file set for interpretation of Pos
-	Pos  token.Pos      // error position
-	Msg  string         // error message
-	Soft bool           // if set, error is "soft"
-}
-
-// Error returns an error string formatted as follows:
-// filename:line:column: message
-func (err Error) Error() string {
-	return fmt.Sprintf("%s: %s", err.Fset.Position(err.Pos), err.Msg)
-}
-
-// An importer resolves import paths to Packages.
-// See go/importer for existing implementations.
-type Importer interface {
-	// Import returns the imported package for the given import
-	// path, or an error if the package couldn't be imported.
-	// Import is responsible for returning the same package for
-	// matching import paths.
-	Import(path string) (*Package, error)
-}
-
-// A Config specifies the configuration for type checking.
-// The zero value for Config is a ready-to-use default configuration.
-type Config struct {
-	// If IgnoreFuncBodies is set, function bodies are not
-	// type-checked.
-	IgnoreFuncBodies bool
-
-	// If FakeImportC is set, `import "C"` (for packages requiring Cgo)
-	// declares an empty "C" package and errors are omitted for qualified
-	// identifiers referring to package C (which won't find an object).
-	// This feature is intended for the standard library cmd/api tool.
-	//
-	// Caution: Effects may be unpredictable due to follow-up errors.
-	//          Do not use casually!
-	FakeImportC bool
-
-	// If Error != nil, it is called with each error found
-	// during type checking; err has dynamic type Error.
-	// Secondary errors (for instance, to enumerate all types
-	// involved in an invalid recursive type declaration) have
-	// error strings that start with a '\t' character.
-	// If Error == nil, type-checking stops with the first
-	// error found.
-	Error func(err error)
-
-	// Importer is called for each import declaration except when
-	// importing package "unsafe". An error is reported if an
-	// importer is needed but none was installed.
-	Importer Importer
-
-	// If Sizes != nil, it provides the sizing functions for package unsafe.
-	// Otherwise &StdSizes{WordSize: 8, MaxAlign: 8} is used instead.
-	Sizes Sizes
-
-	// If DisableUnusedImportCheck is set, packages are not checked
-	// for unused imports.
-	DisableUnusedImportCheck bool
-}
-
-// Info holds result type information for a type-checked package.
-// Only the information for which a map is provided is collected.
-// If the package has type errors, the collected information may
-// be incomplete.
-type Info struct {
-	// Types maps expressions to their types, and for constant
-	// expressions, their values. Invalid expressions are omitted.
-	//
-	// For (possibly parenthesized) identifiers denoting built-in
-	// functions, the recorded signatures are call-site specific:
-	// if the call result is not a constant, the recorded type is
-	// an argument-specific signature. Otherwise, the recorded type
-	// is invalid.
-	//
-	// Identifiers on the lhs of declarations (i.e., the identifiers
-	// which are being declared) are collected in the Defs map.
-	// Identifiers denoting packages are collected in the Uses maps.
-	Types map[ast.Expr]TypeAndValue
-
-	// Defs maps identifiers to the objects they define (including
-	// package names, dots "." of dot-imports, and blank "_" identifiers).
-	// For identifiers that do not denote objects (e.g., the package name
-	// in package clauses, or symbolic variables t in t := x.(type) of
-	// type switch headers), the corresponding objects are nil.
-	//
-	// For an anonymous field, Defs returns the field *Var it defines.
-	//
-	// Invariant: Defs[id] == nil || Defs[id].Pos() == id.Pos()
-	Defs map[*ast.Ident]Object
-
-	// Uses maps identifiers to the objects they denote.
-	//
-	// For an anonymous field, Uses returns the *TypeName it denotes.
-	//
-	// Invariant: Uses[id].Pos() != id.Pos()
-	Uses map[*ast.Ident]Object
-
-	// Implicits maps nodes to their implicitly declared objects, if any.
-	// The following node and object types may appear:
-	//
-	//	node               declared object
-	//
-	//	*ast.ImportSpec    *PkgName for dot-imports and imports without renames
-	//	*ast.CaseClause    type-specific *Var for each type switch case clause (incl. default)
-	//      *ast.Field         anonymous struct field or parameter *Var
-	//
-	Implicits map[ast.Node]Object
-
-	// Selections maps selector expressions (excluding qualified identifiers)
-	// to their corresponding selections.
-	Selections map[*ast.SelectorExpr]*Selection
-
-	// Scopes maps ast.Nodes to the scopes they define. Package scopes are not
-	// associated with a specific node but with all files belonging to a package.
-	// Thus, the package scope can be found in the type-checked Package object.
-	// Scopes nest, with the Universe scope being the outermost scope, enclosing
-	// the package scope, which contains (one or more) files scopes, which enclose
-	// function scopes which in turn enclose statement and function literal scopes.
-	// Note that even though package-level functions are declared in the package
-	// scope, the function scopes are embedded in the file scope of the file
-	// containing the function declaration.
-	//
-	// The following node types may appear in Scopes:
-	//
-	//	*ast.File
-	//	*ast.FuncType
-	//	*ast.BlockStmt
-	//	*ast.IfStmt
-	//	*ast.SwitchStmt
-	//	*ast.TypeSwitchStmt
-	//	*ast.CaseClause
-	//	*ast.CommClause
-	//	*ast.ForStmt
-	//	*ast.RangeStmt
-	//
-	Scopes map[ast.Node]*Scope
-
-	// InitOrder is the list of package-level initializers in the order in which
-	// they must be executed. Initializers referring to variables related by an
-	// initialization dependency appear in topological order, the others appear
-	// in source order. Variables without an initialization expression do not
-	// appear in this list.
-	InitOrder []*Initializer
-}
-
-// TypeOf returns the type of expression e, or nil if not found.
-// Precondition: the Types, Uses and Defs maps are populated.
-//
-func (info *Info) TypeOf(e ast.Expr) Type {
-	if t, ok := info.Types[e]; ok {
-		return t.Type
-	}
-	if id, _ := e.(*ast.Ident); id != nil {
-		if obj := info.ObjectOf(id); obj != nil {
-			return obj.Type()
-		}
-	}
-	return nil
-}
-
-// ObjectOf returns the object denoted by the specified id,
-// or nil if not found.
-//
-// If id is an anonymous struct field, ObjectOf returns the field (*Var)
-// it uses, not the type (*TypeName) it defines.
-//
-// Precondition: the Uses and Defs maps are populated.
-//
-func (info *Info) ObjectOf(id *ast.Ident) Object {
-	if obj, _ := info.Defs[id]; obj != nil {
-		return obj
-	}
-	return info.Uses[id]
-}
-
-// TypeAndValue reports the type and value (for constants)
-// of the corresponding expression.
-type TypeAndValue struct {
-	mode  operandMode
-	Type  Type
-	Value constant.Value
-}
-
-// TODO(gri) Consider eliminating the IsVoid predicate. Instead, report
-// "void" values as regular values but with the empty tuple type.
-
-// IsVoid reports whether the corresponding expression
-// is a function call without results.
-func (tv TypeAndValue) IsVoid() bool {
-	return tv.mode == novalue
-}
-
-// IsType reports whether the corresponding expression specifies a type.
-func (tv TypeAndValue) IsType() bool {
-	return tv.mode == typexpr
-}
-
-// IsBuiltin reports whether the corresponding expression denotes
-// a (possibly parenthesized) built-in function.
-func (tv TypeAndValue) IsBuiltin() bool {
-	return tv.mode == builtin
-}
-
-// IsValue reports whether the corresponding expression is a value.
-// Builtins are not considered values. Constant values have a non-
-// nil Value.
-func (tv TypeAndValue) IsValue() bool {
-	switch tv.mode {
-	case constant_, variable, mapindex, value, commaok:
-		return true
-	}
-	return false
-}
-
-// IsNil reports whether the corresponding expression denotes the
-// predeclared value nil.
-func (tv TypeAndValue) IsNil() bool {
-	return tv.mode == value && tv.Type == Typ[UntypedNil]
-}
-
-// Addressable reports whether the corresponding expression
-// is addressable (https://golang.org/ref/spec#Address_operators).
-func (tv TypeAndValue) Addressable() bool {
-	return tv.mode == variable
-}
-
-// Assignable reports whether the corresponding expression
-// is assignable to (provided a value of the right type).
-func (tv TypeAndValue) Assignable() bool {
-	return tv.mode == variable || tv.mode == mapindex
-}
-
-// HasOk reports whether the corresponding expression may be
-// used on the lhs of a comma-ok assignment.
-func (tv TypeAndValue) HasOk() bool {
-	return tv.mode == commaok || tv.mode == mapindex
-}
-
-// An Initializer describes a package-level variable, or a list of variables in case
-// of a multi-valued initialization expression, and the corresponding initialization
-// expression.
-type Initializer struct {
-	Lhs []*Var // var Lhs = Rhs
-	Rhs ast.Expr
-}
-
-func (init *Initializer) String() string {
-	var buf bytes.Buffer
-	for i, lhs := range init.Lhs {
-		if i > 0 {
-			buf.WriteString(", ")
-		}
-		buf.WriteString(lhs.Name())
-	}
-	buf.WriteString(" = ")
-	WriteExpr(&buf, init.Rhs)
-	return buf.String()
-}
-
-// Check type-checks a package and returns the resulting package object,
-// the first error if any, and if info != nil, additional type information.
-// The package is marked as complete if no errors occurred, otherwise it is
-// incomplete. See Config.Error for controlling behavior in the presence of
-// errors.
-//
-// The package is specified by a list of *ast.Files and corresponding
-// file set, and the package path the package is identified with.
-// The clean path must not be empty or dot (".").
-func (conf *Config) Check(path string, fset *token.FileSet, files []*ast.File, info *Info) (*Package, error) {
-	pkg := NewPackage(path, "")
-	return pkg, NewChecker(conf, fset, pkg, info).Files(files)
-}
-
-// AssertableTo reports whether a value of type V can be asserted to have type T.
-func AssertableTo(V *Interface, T Type) bool {
-	m, _ := assertableTo(V, T)
-	return m == nil
-}
-
-// AssignableTo reports whether a value of type V is assignable to a variable of type T.
-func AssignableTo(V, T Type) bool {
-	x := operand{mode: value, typ: V}
-	return x.assignableTo(nil, T) // config not needed for non-constant x
-}
-
-// ConvertibleTo reports whether a value of type V is convertible to a value of type T.
-func ConvertibleTo(V, T Type) bool {
-	x := operand{mode: value, typ: V}
-	return x.convertibleTo(nil, T) // config not needed for non-constant x
-}
-
-// Implements reports whether type V implements interface T.
-func Implements(V Type, T *Interface) bool {
-	f, _ := MissingMethod(V, T, true)
-	return f == nil
-}
diff --git a/third_party/golang/go/types/assignments.go b/third_party/golang/go/types/assignments.go
deleted file mode 100644
index 89a719c7dda37..0000000000000
--- a/third_party/golang/go/types/assignments.go
+++ /dev/null
@@ -1,328 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements initialization and assignment checks.
-
-package types
-
-import (
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-)
-
-// assignment reports whether x can be assigned to a variable of type T,
-// if necessary by attempting to convert untyped values to the appropriate
-// type. If x.mode == invalid upon return, then assignment has already
-// issued an error message and the caller doesn't have to report another.
-// Use T == nil to indicate assignment to an untyped blank identifier.
-//
-// TODO(gri) Should find a better way to handle in-band errors.
-//
-func (check *Checker) assignment(x *operand, T Type) bool {
-	switch x.mode {
-	case invalid:
-		return true // error reported before
-	case constant_, variable, mapindex, value, commaok:
-		// ok
-	default:
-		unreachable()
-	}
-
-	// x must be a single value
-	// (tuple types are never named - no need for underlying type)
-	if t, _ := x.typ.(*Tuple); t != nil {
-		assert(t.Len() > 1)
-		check.errorf(x.pos(), "%d-valued expression %s used as single value", t.Len(), x)
-		x.mode = invalid
-		return false
-	}
-
-	if isUntyped(x.typ) {
-		target := T
-		// spec: "If an untyped constant is assigned to a variable of interface
-		// type or the blank identifier, the constant is first converted to type
-		// bool, rune, int, float64, complex128 or string respectively, depending
-		// on whether the value is a boolean, rune, integer, floating-point, complex,
-		// or string constant."
-		if T == nil || IsInterface(T) {
-			if T == nil && x.typ == Typ[UntypedNil] {
-				check.errorf(x.pos(), "use of untyped nil")
-				x.mode = invalid
-				return false
-			}
-			target = defaultType(x.typ)
-		}
-		check.convertUntyped(x, target)
-		if x.mode == invalid {
-			return false
-		}
-	}
-
-	// spec: "If a left-hand side is the blank identifier, any typed or
-	// non-constant value except for the predeclared identifier nil may
-	// be assigned to it."
-	return T == nil || x.assignableTo(check.conf, T)
-}
-
-func (check *Checker) initConst(lhs *Const, x *operand) {
-	if x.mode == invalid || x.typ == Typ[Invalid] || lhs.typ == Typ[Invalid] {
-		if lhs.typ == nil {
-			lhs.typ = Typ[Invalid]
-		}
-		return
-	}
-
-	// rhs must be a constant
-	if x.mode != constant_ {
-		check.errorf(x.pos(), "%s is not constant", x)
-		if lhs.typ == nil {
-			lhs.typ = Typ[Invalid]
-		}
-		return
-	}
-	assert(isConstType(x.typ))
-
-	// If the lhs doesn't have a type yet, use the type of x.
-	if lhs.typ == nil {
-		lhs.typ = x.typ
-	}
-
-	if !check.assignment(x, lhs.typ) {
-		if x.mode != invalid {
-			check.errorf(x.pos(), "cannot define constant %s (type %s) as %s", lhs.Name(), lhs.typ, x)
-		}
-		return
-	}
-
-	lhs.val = x.val
-}
-
-// If result is set, lhs is a function result parameter and x is a return result.
-func (check *Checker) initVar(lhs *Var, x *operand, result bool) Type {
-	if x.mode == invalid || x.typ == Typ[Invalid] || lhs.typ == Typ[Invalid] {
-		if lhs.typ == nil {
-			lhs.typ = Typ[Invalid]
-		}
-		return nil
-	}
-
-	// If the lhs doesn't have a type yet, use the type of x.
-	if lhs.typ == nil {
-		typ := x.typ
-		if isUntyped(typ) {
-			// convert untyped types to default types
-			if typ == Typ[UntypedNil] {
-				check.errorf(x.pos(), "use of untyped nil")
-				lhs.typ = Typ[Invalid]
-				return nil
-			}
-			typ = defaultType(typ)
-		}
-		lhs.typ = typ
-	}
-
-	if !check.assignment(x, lhs.typ) {
-		if x.mode != invalid {
-			if result {
-				// don't refer to lhs.name because it may be an anonymous result parameter
-				check.errorf(x.pos(), "cannot return %s as value of type %s", x, lhs.typ)
-			} else {
-				check.errorf(x.pos(), "cannot initialize %s with %s", lhs, x)
-			}
-		}
-		return nil
-	}
-
-	return x.typ
-}
-
-func (check *Checker) assignVar(lhs ast.Expr, x *operand) Type {
-	if x.mode == invalid || x.typ == Typ[Invalid] {
-		return nil
-	}
-
-	// Determine if the lhs is a (possibly parenthesized) identifier.
-	ident, _ := unparen(lhs).(*ast.Ident)
-
-	// Don't evaluate lhs if it is the blank identifier.
-	if ident != nil && ident.Name == "_" {
-		check.recordDef(ident, nil)
-		if !check.assignment(x, nil) {
-			assert(x.mode == invalid)
-			x.typ = nil
-		}
-		return x.typ
-	}
-
-	// If the lhs is an identifier denoting a variable v, this assignment
-	// is not a 'use' of v. Remember current value of v.used and restore
-	// after evaluating the lhs via check.expr.
-	var v *Var
-	var v_used bool
-	if ident != nil {
-		if _, obj := check.scope.LookupParent(ident.Name, token.NoPos); obj != nil {
-			v, _ = obj.(*Var)
-			if v != nil {
-				v_used = v.used
-			}
-		}
-	}
-
-	var z operand
-	check.expr(&z, lhs)
-	if v != nil {
-		v.used = v_used // restore v.used
-	}
-
-	if z.mode == invalid || z.typ == Typ[Invalid] {
-		return nil
-	}
-
-	// spec: "Each left-hand side operand must be addressable, a map index
-	// expression, or the blank identifier. Operands may be parenthesized."
-	switch z.mode {
-	case invalid:
-		return nil
-	case variable, mapindex:
-		// ok
-	default:
-		check.errorf(z.pos(), "cannot assign to %s", &z)
-		return nil
-	}
-
-	if !check.assignment(x, z.typ) {
-		if x.mode != invalid {
-			check.errorf(x.pos(), "cannot assign %s to %s", x, &z)
-		}
-		return nil
-	}
-
-	return x.typ
-}
-
-// If returnPos is valid, initVars is called to type-check the assignment of
-// return expressions, and returnPos is the position of the return statement.
-func (check *Checker) initVars(lhs []*Var, rhs []ast.Expr, returnPos token.Pos) {
-	l := len(lhs)
-	get, r, commaOk := unpack(func(x *operand, i int) { check.expr(x, rhs[i]) }, len(rhs), l == 2 && !returnPos.IsValid())
-	if get == nil || l != r {
-		// invalidate lhs and use rhs
-		for _, obj := range lhs {
-			if obj.typ == nil {
-				obj.typ = Typ[Invalid]
-			}
-		}
-		if get == nil {
-			return // error reported by unpack
-		}
-		check.useGetter(get, r)
-		if returnPos.IsValid() {
-			check.errorf(returnPos, "wrong number of return values (want %d, got %d)", l, r)
-			return
-		}
-		check.errorf(rhs[0].Pos(), "assignment count mismatch (%d vs %d)", l, r)
-		return
-	}
-
-	var x operand
-	if commaOk {
-		var a [2]Type
-		for i := range a {
-			get(&x, i)
-			a[i] = check.initVar(lhs[i], &x, returnPos.IsValid())
-		}
-		check.recordCommaOkTypes(rhs[0], a)
-		return
-	}
-
-	for i, lhs := range lhs {
-		get(&x, i)
-		check.initVar(lhs, &x, returnPos.IsValid())
-	}
-}
-
-func (check *Checker) assignVars(lhs, rhs []ast.Expr) {
-	l := len(lhs)
-	get, r, commaOk := unpack(func(x *operand, i int) { check.expr(x, rhs[i]) }, len(rhs), l == 2)
-	if get == nil {
-		return // error reported by unpack
-	}
-	if l != r {
-		check.useGetter(get, r)
-		check.errorf(rhs[0].Pos(), "assignment count mismatch (%d vs %d)", l, r)
-		return
-	}
-
-	var x operand
-	if commaOk {
-		var a [2]Type
-		for i := range a {
-			get(&x, i)
-			a[i] = check.assignVar(lhs[i], &x)
-		}
-		check.recordCommaOkTypes(rhs[0], a)
-		return
-	}
-
-	for i, lhs := range lhs {
-		get(&x, i)
-		check.assignVar(lhs, &x)
-	}
-}
-
-func (check *Checker) shortVarDecl(pos token.Pos, lhs, rhs []ast.Expr) {
-	scope := check.scope
-
-	// collect lhs variables
-	var newVars []*Var
-	var lhsVars = make([]*Var, len(lhs))
-	for i, lhs := range lhs {
-		var obj *Var
-		if ident, _ := lhs.(*ast.Ident); ident != nil {
-			// Use the correct obj if the ident is redeclared. The
-			// variable's scope starts after the declaration; so we
-			// must use Scope.Lookup here and call Scope.Insert
-			// (via check.declare) later.
-			name := ident.Name
-			if alt := scope.Lookup(name); alt != nil {
-				// redeclared object must be a variable
-				if alt, _ := alt.(*Var); alt != nil {
-					obj = alt
-				} else {
-					check.errorf(lhs.Pos(), "cannot assign to %s", lhs)
-				}
-				check.recordUse(ident, alt)
-			} else {
-				// declare new variable, possibly a blank (_) variable
-				obj = NewVar(ident.Pos(), check.pkg, name, nil)
-				if name != "_" {
-					newVars = append(newVars, obj)
-				}
-				check.recordDef(ident, obj)
-			}
-		} else {
-			check.errorf(lhs.Pos(), "cannot declare %s", lhs)
-		}
-		if obj == nil {
-			obj = NewVar(lhs.Pos(), check.pkg, "_", nil) // dummy variable
-		}
-		lhsVars[i] = obj
-	}
-
-	check.initVars(lhsVars, rhs, token.NoPos)
-
-	// declare new variables
-	if len(newVars) > 0 {
-		// spec: "The scope of a constant or variable identifier declared inside
-		// a function begins at the end of the ConstSpec or VarSpec (ShortVarDecl
-		// for short variable declarations) and ends at the end of the innermost
-		// containing block."
-		scopePos := rhs[len(rhs)-1].End()
-		for _, obj := range newVars {
-			check.declare(scope, nil, obj, scopePos) // recordObject already called
-		}
-	} else {
-		check.softErrorf(pos, "no new variables on left side of :=")
-	}
-}
diff --git a/third_party/golang/go/types/builtins.go b/third_party/golang/go/types/builtins.go
deleted file mode 100644
index 5812d9bb1d85e..0000000000000
--- a/third_party/golang/go/types/builtins.go
+++ /dev/null
@@ -1,627 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements typechecking of builtin function calls.
-
-package types
-
-import (
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"k8s.io/kubernetes/third_party/golang/go/constant"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-)
-
-// builtin type-checks a call to the built-in specified by id and
-// returns true if the call is valid, with *x holding the result;
-// but x.expr is not set. If the call is invalid, the result is
-// false, and *x is undefined.
-//
-func (check *Checker) builtin(x *operand, call *ast.CallExpr, id builtinId) (_ bool) {
-	// append is the only built-in that permits the use of ... for the last argument
-	bin := predeclaredFuncs[id]
-	if call.Ellipsis.IsValid() && id != _Append {
-		check.invalidOp(call.Ellipsis, "invalid use of ... with built-in %s", bin.name)
-		check.use(call.Args...)
-		return
-	}
-
-	// For len(x) and cap(x) we need to know if x contains any function calls or
-	// receive operations. Save/restore current setting and set hasCallOrRecv to
-	// false for the evaluation of x so that we can check it afterwards.
-	// Note: We must do this _before_ calling unpack because unpack evaluates the
-	//       first argument before we even call arg(x, 0)!
-	if id == _Len || id == _Cap {
-		defer func(b bool) {
-			check.hasCallOrRecv = b
-		}(check.hasCallOrRecv)
-		check.hasCallOrRecv = false
-	}
-
-	// determine actual arguments
-	var arg getter
-	nargs := len(call.Args)
-	switch id {
-	default:
-		// make argument getter
-		arg, nargs, _ = unpack(func(x *operand, i int) { check.expr(x, call.Args[i]) }, nargs, false)
-		if arg == nil {
-			return
-		}
-		// evaluate first argument, if present
-		if nargs > 0 {
-			arg(x, 0)
-			if x.mode == invalid {
-				return
-			}
-		}
-	case _Make, _New, _Offsetof, _Trace:
-		// arguments require special handling
-	}
-
-	// check argument count
-	{
-		msg := ""
-		if nargs < bin.nargs {
-			msg = "not enough"
-		} else if !bin.variadic && nargs > bin.nargs {
-			msg = "too many"
-		}
-		if msg != "" {
-			check.invalidOp(call.Rparen, "%s arguments for %s (expected %d, found %d)", msg, call, bin.nargs, nargs)
-			return
-		}
-	}
-
-	switch id {
-	case _Append:
-		// append(s S, x ...T) S, where T is the element type of S
-		// spec: "The variadic function append appends zero or more values x to s of type
-		// S, which must be a slice type, and returns the resulting slice, also of type S.
-		// The values x are passed to a parameter of type ...T where T is the element type
-		// of S and the respective parameter passing rules apply."
-		S := x.typ
-		var T Type
-		if s, _ := S.Underlying().(*Slice); s != nil {
-			T = s.elem
-		} else {
-			check.invalidArg(x.pos(), "%s is not a slice", x)
-			return
-		}
-
-		// remember arguments that have been evaluated already
-		alist := []operand{*x}
-
-		// spec: "As a special case, append also accepts a first argument assignable
-		// to type []byte with a second argument of string type followed by ... .
-		// This form appends the bytes of the string.
-		if nargs == 2 && call.Ellipsis.IsValid() && x.assignableTo(check.conf, NewSlice(universeByte)) {
-			arg(x, 1)
-			if x.mode == invalid {
-				return
-			}
-			if isString(x.typ) {
-				if check.Types != nil {
-					sig := makeSig(S, S, x.typ)
-					sig.variadic = true
-					check.recordBuiltinType(call.Fun, sig)
-				}
-				x.mode = value
-				x.typ = S
-				break
-			}
-			alist = append(alist, *x)
-			// fallthrough
-		}
-
-		// check general case by creating custom signature
-		sig := makeSig(S, S, NewSlice(T)) // []T required for variadic signature
-		sig.variadic = true
-		check.arguments(x, call, sig, func(x *operand, i int) {
-			// only evaluate arguments that have not been evaluated before
-			if i < len(alist) {
-				*x = alist[i]
-				return
-			}
-			arg(x, i)
-		}, nargs)
-		// ok to continue even if check.arguments reported errors
-
-		x.mode = value
-		x.typ = S
-		if check.Types != nil {
-			check.recordBuiltinType(call.Fun, sig)
-		}
-
-	case _Cap, _Len:
-		// cap(x)
-		// len(x)
-		mode := invalid
-		var typ Type
-		var val constant.Value
-		switch typ = implicitArrayDeref(x.typ.Underlying()); t := typ.(type) {
-		case *Basic:
-			if isString(t) && id == _Len {
-				if x.mode == constant_ {
-					mode = constant_
-					val = constant.MakeInt64(int64(len(constant.StringVal(x.val))))
-				} else {
-					mode = value
-				}
-			}
-
-		case *Array:
-			mode = value
-			// spec: "The expressions len(s) and cap(s) are constants
-			// if the type of s is an array or pointer to an array and
-			// the expression s does not contain channel receives or
-			// function calls; in this case s is not evaluated."
-			if !check.hasCallOrRecv {
-				mode = constant_
-				val = constant.MakeInt64(t.len)
-			}
-
-		case *Slice, *Chan:
-			mode = value
-
-		case *Map:
-			if id == _Len {
-				mode = value
-			}
-		}
-
-		if mode == invalid {
-			check.invalidArg(x.pos(), "%s for %s", x, bin.name)
-			return
-		}
-
-		x.mode = mode
-		x.typ = Typ[Int]
-		x.val = val
-		if check.Types != nil && mode != constant_ {
-			check.recordBuiltinType(call.Fun, makeSig(x.typ, typ))
-		}
-
-	case _Close:
-		// close(c)
-		c, _ := x.typ.Underlying().(*Chan)
-		if c == nil {
-			check.invalidArg(x.pos(), "%s is not a channel", x)
-			return
-		}
-		if c.dir == RecvOnly {
-			check.invalidArg(x.pos(), "%s must not be a receive-only channel", x)
-			return
-		}
-
-		x.mode = novalue
-		if check.Types != nil {
-			check.recordBuiltinType(call.Fun, makeSig(nil, c))
-		}
-
-	case _Complex:
-		// complex(x, y realT) complexT
-		if !check.complexArg(x) {
-			return
-		}
-
-		var y operand
-		arg(&y, 1)
-		if y.mode == invalid {
-			return
-		}
-		if !check.complexArg(&y) {
-			return
-		}
-
-		check.convertUntyped(x, y.typ)
-		if x.mode == invalid {
-			return
-		}
-		check.convertUntyped(&y, x.typ)
-		if y.mode == invalid {
-			return
-		}
-
-		if !Identical(x.typ, y.typ) {
-			check.invalidArg(x.pos(), "mismatched types %s and %s", x.typ, y.typ)
-			return
-		}
-
-		if x.mode == constant_ && y.mode == constant_ {
-			x.val = constant.BinaryOp(x.val, token.ADD, constant.MakeImag(y.val))
-		} else {
-			x.mode = value
-		}
-
-		realT := x.typ
-		complexT := Typ[Invalid]
-		switch realT.Underlying().(*Basic).kind {
-		case Float32:
-			complexT = Typ[Complex64]
-		case Float64:
-			complexT = Typ[Complex128]
-		case UntypedInt, UntypedRune, UntypedFloat:
-			if x.mode == constant_ {
-				realT = defaultType(realT).(*Basic)
-				complexT = Typ[UntypedComplex]
-			} else {
-				// untyped but not constant; probably because one
-				// operand is a non-constant shift of untyped lhs
-				realT = Typ[Float64]
-				complexT = Typ[Complex128]
-			}
-		default:
-			check.invalidArg(x.pos(), "float32 or float64 arguments expected")
-			return
-		}
-
-		x.typ = complexT
-		if check.Types != nil && x.mode != constant_ {
-			check.recordBuiltinType(call.Fun, makeSig(complexT, realT, realT))
-		}
-
-		if x.mode != constant_ {
-			// The arguments have now their final types, which at run-
-			// time will be materialized. Update the expression trees.
-			// If the current types are untyped, the materialized type
-			// is the respective default type.
-			// (If the result is constant, the arguments are never
-			// materialized and there is nothing to do.)
-			check.updateExprType(x.expr, realT, true)
-			check.updateExprType(y.expr, realT, true)
-		}
-
-	case _Copy:
-		// copy(x, y []T) int
-		var dst Type
-		if t, _ := x.typ.Underlying().(*Slice); t != nil {
-			dst = t.elem
-		}
-
-		var y operand
-		arg(&y, 1)
-		if y.mode == invalid {
-			return
-		}
-		var src Type
-		switch t := y.typ.Underlying().(type) {
-		case *Basic:
-			if isString(y.typ) {
-				src = universeByte
-			}
-		case *Slice:
-			src = t.elem
-		}
-
-		if dst == nil || src == nil {
-			check.invalidArg(x.pos(), "copy expects slice arguments; found %s and %s", x, &y)
-			return
-		}
-
-		if !Identical(dst, src) {
-			check.invalidArg(x.pos(), "arguments to copy %s and %s have different element types %s and %s", x, &y, dst, src)
-			return
-		}
-
-		if check.Types != nil {
-			check.recordBuiltinType(call.Fun, makeSig(Typ[Int], x.typ, y.typ))
-		}
-		x.mode = value
-		x.typ = Typ[Int]
-
-	case _Delete:
-		// delete(m, k)
-		m, _ := x.typ.Underlying().(*Map)
-		if m == nil {
-			check.invalidArg(x.pos(), "%s is not a map", x)
-			return
-		}
-		arg(x, 1) // k
-		if x.mode == invalid {
-			return
-		}
-
-		if !x.assignableTo(check.conf, m.key) {
-			check.invalidArg(x.pos(), "%s is not assignable to %s", x, m.key)
-			return
-		}
-
-		x.mode = novalue
-		if check.Types != nil {
-			check.recordBuiltinType(call.Fun, makeSig(nil, m, m.key))
-		}
-
-	case _Imag, _Real:
-		// imag(complexT) realT
-		// real(complexT) realT
-		if !isComplex(x.typ) {
-			check.invalidArg(x.pos(), "%s must be a complex number", x)
-			return
-		}
-		if x.mode == constant_ {
-			if id == _Real {
-				x.val = constant.Real(x.val)
-			} else {
-				x.val = constant.Imag(x.val)
-			}
-		} else {
-			x.mode = value
-		}
-		var k BasicKind
-		switch x.typ.Underlying().(*Basic).kind {
-		case Complex64:
-			k = Float32
-		case Complex128:
-			k = Float64
-		case UntypedComplex:
-			k = UntypedFloat
-		default:
-			unreachable()
-		}
-
-		if check.Types != nil && x.mode != constant_ {
-			check.recordBuiltinType(call.Fun, makeSig(Typ[k], x.typ))
-		}
-		x.typ = Typ[k]
-
-	case _Make:
-		// make(T, n)
-		// make(T, n, m)
-		// (no argument evaluated yet)
-		arg0 := call.Args[0]
-		T := check.typ(arg0)
-		if T == Typ[Invalid] {
-			return
-		}
-
-		var min int // minimum number of arguments
-		switch T.Underlying().(type) {
-		case *Slice:
-			min = 2
-		case *Map, *Chan:
-			min = 1
-		default:
-			check.invalidArg(arg0.Pos(), "cannot make %s; type must be slice, map, or channel", arg0)
-			return
-		}
-		if nargs < min || min+1 < nargs {
-			check.errorf(call.Pos(), "%s expects %d or %d arguments; found %d", call, min, min+1, nargs)
-			return
-		}
-		var sizes []int64 // constant integer arguments, if any
-		for _, arg := range call.Args[1:] {
-			if s, ok := check.index(arg, -1); ok && s >= 0 {
-				sizes = append(sizes, s)
-			}
-		}
-		if len(sizes) == 2 && sizes[0] > sizes[1] {
-			check.invalidArg(call.Args[1].Pos(), "length and capacity swapped")
-			// safe to continue
-		}
-		x.mode = value
-		x.typ = T
-		if check.Types != nil {
-			params := [...]Type{T, Typ[Int], Typ[Int]}
-			check.recordBuiltinType(call.Fun, makeSig(x.typ, params[:1+len(sizes)]...))
-		}
-
-	case _New:
-		// new(T)
-		// (no argument evaluated yet)
-		T := check.typ(call.Args[0])
-		if T == Typ[Invalid] {
-			return
-		}
-
-		x.mode = value
-		x.typ = &Pointer{base: T}
-		if check.Types != nil {
-			check.recordBuiltinType(call.Fun, makeSig(x.typ, T))
-		}
-
-	case _Panic:
-		// panic(x)
-		T := new(Interface)
-		if !check.assignment(x, T) {
-			assert(x.mode == invalid)
-			return
-		}
-
-		x.mode = novalue
-		if check.Types != nil {
-			check.recordBuiltinType(call.Fun, makeSig(nil, T))
-		}
-
-	case _Print, _Println:
-		// print(x, y, ...)
-		// println(x, y, ...)
-		var params []Type
-		if nargs > 0 {
-			params = make([]Type, nargs)
-			for i := 0; i < nargs; i++ {
-				if i > 0 {
-					arg(x, i) // first argument already evaluated
-				}
-				if !check.assignment(x, nil) {
-					assert(x.mode == invalid)
-					return
-				}
-				params[i] = x.typ
-			}
-		}
-
-		x.mode = novalue
-		if check.Types != nil {
-			check.recordBuiltinType(call.Fun, makeSig(nil, params...))
-		}
-
-	case _Recover:
-		// recover() interface{}
-		x.mode = value
-		x.typ = new(Interface)
-		if check.Types != nil {
-			check.recordBuiltinType(call.Fun, makeSig(x.typ))
-		}
-
-	case _Alignof:
-		// unsafe.Alignof(x T) uintptr
-		if !check.assignment(x, nil) {
-			assert(x.mode == invalid)
-			return
-		}
-
-		x.mode = constant_
-		x.val = constant.MakeInt64(check.conf.alignof(x.typ))
-		x.typ = Typ[Uintptr]
-		// result is constant - no need to record signature
-
-	case _Offsetof:
-		// unsafe.Offsetof(x T) uintptr, where x must be a selector
-		// (no argument evaluated yet)
-		arg0 := call.Args[0]
-		selx, _ := unparen(arg0).(*ast.SelectorExpr)
-		if selx == nil {
-			check.invalidArg(arg0.Pos(), "%s is not a selector expression", arg0)
-			check.use(arg0)
-			return
-		}
-
-		check.expr(x, selx.X)
-		if x.mode == invalid {
-			return
-		}
-
-		base := derefStructPtr(x.typ)
-		sel := selx.Sel.Name
-		obj, index, indirect := LookupFieldOrMethod(base, false, check.pkg, sel)
-		switch obj.(type) {
-		case nil:
-			check.invalidArg(x.pos(), "%s has no single field %s", base, sel)
-			return
-		case *Func:
-			// TODO(gri) Using derefStructPtr may result in methods being found
-			// that don't actually exist. An error either way, but the error
-			// message is confusing. See: https://play.golang.org/p/al75v23kUy ,
-			// but go/types reports: "invalid argument: x.m is a method value".
-			check.invalidArg(arg0.Pos(), "%s is a method value", arg0)
-			return
-		}
-		if indirect {
-			check.invalidArg(x.pos(), "field %s is embedded via a pointer in %s", sel, base)
-			return
-		}
-
-		// TODO(gri) Should we pass x.typ instead of base (and indirect report if derefStructPtr indirected)?
-		check.recordSelection(selx, FieldVal, base, obj, index, false)
-
-		offs := check.conf.offsetof(base, index)
-		x.mode = constant_
-		x.val = constant.MakeInt64(offs)
-		x.typ = Typ[Uintptr]
-		// result is constant - no need to record signature
-
-	case _Sizeof:
-		// unsafe.Sizeof(x T) uintptr
-		if !check.assignment(x, nil) {
-			assert(x.mode == invalid)
-			return
-		}
-
-		x.mode = constant_
-		x.val = constant.MakeInt64(check.conf.sizeof(x.typ))
-		x.typ = Typ[Uintptr]
-		// result is constant - no need to record signature
-
-	case _Assert:
-		// assert(pred) causes a typechecker error if pred is false.
-		// The result of assert is the value of pred if there is no error.
-		// Note: assert is only available in self-test mode.
-		if x.mode != constant_ || !isBoolean(x.typ) {
-			check.invalidArg(x.pos(), "%s is not a boolean constant", x)
-			return
-		}
-		if x.val.Kind() != constant.Bool {
-			check.errorf(x.pos(), "internal error: value of %s should be a boolean constant", x)
-			return
-		}
-		if !constant.BoolVal(x.val) {
-			check.errorf(call.Pos(), "%s failed", call)
-			// compile-time assertion failure - safe to continue
-		}
-		// result is constant - no need to record signature
-
-	case _Trace:
-		// trace(x, y, z, ...) dumps the positions, expressions, and
-		// values of its arguments. The result of trace is the value
-		// of the first argument.
-		// Note: trace is only available in self-test mode.
-		// (no argument evaluated yet)
-		if nargs == 0 {
-			check.dump("%s: trace() without arguments", call.Pos())
-			x.mode = novalue
-			break
-		}
-		var t operand
-		x1 := x
-		for _, arg := range call.Args {
-			check.rawExpr(x1, arg, nil) // permit trace for types, e.g.: new(trace(T))
-			check.dump("%s: %s", x1.pos(), x1)
-			x1 = &t // use incoming x only for first argument
-		}
-		// trace is only available in test mode - no need to record signature
-
-	default:
-		unreachable()
-	}
-
-	return true
-}
-
-// makeSig makes a signature for the given argument and result types.
-// Default types are used for untyped arguments, and res may be nil.
-func makeSig(res Type, args ...Type) *Signature {
-	list := make([]*Var, len(args))
-	for i, param := range args {
-		list[i] = NewVar(token.NoPos, nil, "", defaultType(param))
-	}
-	params := NewTuple(list...)
-	var result *Tuple
-	if res != nil {
-		assert(!isUntyped(res))
-		result = NewTuple(NewVar(token.NoPos, nil, "", res))
-	}
-	return &Signature{params: params, results: result}
-}
-
-// implicitArrayDeref returns A if typ is of the form *A and A is an array;
-// otherwise it returns typ.
-//
-func implicitArrayDeref(typ Type) Type {
-	if p, ok := typ.(*Pointer); ok {
-		if a, ok := p.base.Underlying().(*Array); ok {
-			return a
-		}
-	}
-	return typ
-}
-
-// unparen returns e with any enclosing parentheses stripped.
-func unparen(e ast.Expr) ast.Expr {
-	for {
-		p, ok := e.(*ast.ParenExpr)
-		if !ok {
-			return e
-		}
-		e = p.X
-	}
-}
-
-func (check *Checker) complexArg(x *operand) bool {
-	t, _ := x.typ.Underlying().(*Basic)
-	if t != nil && (t.info&IsFloat != 0 || t.kind == UntypedInt || t.kind == UntypedRune) {
-		return true
-	}
-	check.invalidArg(x.pos(), "%s must be a float32, float64, or an untyped non-complex numeric constant", x)
-	return false
-}
diff --git a/third_party/golang/go/types/call.go b/third_party/golang/go/types/call.go
deleted file mode 100644
index 086ac19b7477d..0000000000000
--- a/third_party/golang/go/types/call.go
+++ /dev/null
@@ -1,441 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements typechecking of call and selector expressions.
-
-package types
-
-import (
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-)
-
-func (check *Checker) call(x *operand, e *ast.CallExpr) exprKind {
-	check.exprOrType(x, e.Fun)
-
-	switch x.mode {
-	case invalid:
-		check.use(e.Args...)
-		x.mode = invalid
-		x.expr = e
-		return statement
-
-	case typexpr:
-		// conversion
-		T := x.typ
-		x.mode = invalid
-		switch n := len(e.Args); n {
-		case 0:
-			check.errorf(e.Rparen, "missing argument in conversion to %s", T)
-		case 1:
-			check.expr(x, e.Args[0])
-			if x.mode != invalid {
-				check.conversion(x, T)
-			}
-		default:
-			check.errorf(e.Args[n-1].Pos(), "too many arguments in conversion to %s", T)
-		}
-		x.expr = e
-		return conversion
-
-	case builtin:
-		id := x.id
-		if !check.builtin(x, e, id) {
-			x.mode = invalid
-		}
-		x.expr = e
-		// a non-constant result implies a function call
-		if x.mode != invalid && x.mode != constant_ {
-			check.hasCallOrRecv = true
-		}
-		return predeclaredFuncs[id].kind
-
-	default:
-		// function/method call
-		sig, _ := x.typ.Underlying().(*Signature)
-		if sig == nil {
-			check.invalidOp(x.pos(), "cannot call non-function %s", x)
-			x.mode = invalid
-			x.expr = e
-			return statement
-		}
-
-		arg, n, _ := unpack(func(x *operand, i int) { check.expr(x, e.Args[i]) }, len(e.Args), false)
-		if arg == nil {
-			x.mode = invalid
-			x.expr = e
-			return statement
-		}
-
-		check.arguments(x, e, sig, arg, n)
-
-		// determine result
-		switch sig.results.Len() {
-		case 0:
-			x.mode = novalue
-		case 1:
-			x.mode = value
-			x.typ = sig.results.vars[0].typ // unpack tuple
-		default:
-			x.mode = value
-			x.typ = sig.results
-		}
-		x.expr = e
-		check.hasCallOrRecv = true
-
-		return statement
-	}
-}
-
-// use type-checks each argument.
-// Useful to make sure expressions are evaluated
-// (and variables are "used") in the presence of other errors.
-func (check *Checker) use(arg ...ast.Expr) {
-	var x operand
-	for _, e := range arg {
-		check.rawExpr(&x, e, nil)
-	}
-}
-
-// useGetter is like use, but takes a getter instead of a list of expressions.
-// It should be called instead of use if a getter is present to avoid repeated
-// evaluation of the first argument (since the getter was likely obtained via
-// unpack, which may have evaluated the first argument already).
-func (check *Checker) useGetter(get getter, n int) {
-	var x operand
-	for i := 0; i < n; i++ {
-		get(&x, i)
-	}
-}
-
-// A getter sets x as the i'th operand, where 0 <= i < n and n is the total
-// number of operands (context-specific, and maintained elsewhere). A getter
-// type-checks the i'th operand; the details of the actual check are getter-
-// specific.
-type getter func(x *operand, i int)
-
-// unpack takes a getter get and a number of operands n. If n == 1, unpack
-// calls the incoming getter for the first operand. If that operand is
-// invalid, unpack returns (nil, 0, false). Otherwise, if that operand is a
-// function call, or a comma-ok expression and allowCommaOk is set, the result
-// is a new getter and operand count providing access to the function results,
-// or comma-ok values, respectively. The third result value reports if it
-// is indeed the comma-ok case. In all other cases, the incoming getter and
-// operand count are returned unchanged, and the third result value is false.
-//
-// In other words, if there's exactly one operand that - after type-checking
-// by calling get - stands for multiple operands, the resulting getter provides
-// access to those operands instead.
-//
-// If the returned getter is called at most once for a given operand index i
-// (including i == 0), that operand is guaranteed to cause only one call of
-// the incoming getter with that i.
-//
-func unpack(get getter, n int, allowCommaOk bool) (getter, int, bool) {
-	if n == 1 {
-		// possibly result of an n-valued function call or comma,ok value
-		var x0 operand
-		get(&x0, 0)
-		if x0.mode == invalid {
-			return nil, 0, false
-		}
-
-		if t, ok := x0.typ.(*Tuple); ok {
-			// result of an n-valued function call
-			return func(x *operand, i int) {
-				x.mode = value
-				x.expr = x0.expr
-				x.typ = t.At(i).typ
-			}, t.Len(), false
-		}
-
-		if x0.mode == mapindex || x0.mode == commaok {
-			// comma-ok value
-			if allowCommaOk {
-				a := [2]Type{x0.typ, Typ[UntypedBool]}
-				return func(x *operand, i int) {
-					x.mode = value
-					x.expr = x0.expr
-					x.typ = a[i]
-				}, 2, true
-			}
-			x0.mode = value
-		}
-
-		// single value
-		return func(x *operand, i int) {
-			if i != 0 {
-				unreachable()
-			}
-			*x = x0
-		}, 1, false
-	}
-
-	// zero or multiple values
-	return get, n, false
-}
-
-// arguments checks argument passing for the call with the given signature.
-// The arg function provides the operand for the i'th argument.
-func (check *Checker) arguments(x *operand, call *ast.CallExpr, sig *Signature, arg getter, n int) {
-	if call.Ellipsis.IsValid() {
-		// last argument is of the form x...
-		if len(call.Args) == 1 && n > 1 {
-			// f()... is not permitted if f() is multi-valued
-			check.errorf(call.Ellipsis, "cannot use ... with %d-valued expression %s", n, call.Args[0])
-			check.useGetter(arg, n)
-			return
-		}
-		if !sig.variadic {
-			check.errorf(call.Ellipsis, "cannot use ... in call to non-variadic %s", call.Fun)
-			check.useGetter(arg, n)
-			return
-		}
-	}
-
-	// evaluate arguments
-	for i := 0; i < n; i++ {
-		arg(x, i)
-		if x.mode != invalid {
-			var ellipsis token.Pos
-			if i == n-1 && call.Ellipsis.IsValid() {
-				ellipsis = call.Ellipsis
-			}
-			check.argument(sig, i, x, ellipsis)
-		}
-	}
-
-	// check argument count
-	if sig.variadic {
-		// a variadic function accepts an "empty"
-		// last argument: count one extra
-		n++
-	}
-	if n < sig.params.Len() {
-		check.errorf(call.Rparen, "too few arguments in call to %s", call.Fun)
-		// ok to continue
-	}
-}
-
-// argument checks passing of argument x to the i'th parameter of the given signature.
-// If ellipsis is valid, the argument is followed by ... at that position in the call.
-func (check *Checker) argument(sig *Signature, i int, x *operand, ellipsis token.Pos) {
-	n := sig.params.Len()
-
-	// determine parameter type
-	var typ Type
-	switch {
-	case i < n:
-		typ = sig.params.vars[i].typ
-	case sig.variadic:
-		typ = sig.params.vars[n-1].typ
-		if debug {
-			if _, ok := typ.(*Slice); !ok {
-				check.dump("%s: expected unnamed slice type, got %s", sig.params.vars[n-1].Pos(), typ)
-			}
-		}
-	default:
-		check.errorf(x.pos(), "too many arguments")
-		return
-	}
-
-	if ellipsis.IsValid() {
-		// argument is of the form x...
-		if i != n-1 {
-			check.errorf(ellipsis, "can only use ... with matching parameter")
-			return
-		}
-		switch t := x.typ.Underlying().(type) {
-		case *Slice:
-			// ok
-		case *Tuple:
-			check.errorf(ellipsis, "cannot use ... with %d-valued expression %s", t.Len(), x)
-			return
-		default:
-			check.errorf(x.pos(), "cannot use %s as parameter of type %s", x, typ)
-			return
-		}
-	} else if sig.variadic && i >= n-1 {
-		// use the variadic parameter slice's element type
-		typ = typ.(*Slice).elem
-	}
-
-	if !check.assignment(x, typ) && x.mode != invalid {
-		check.errorf(x.pos(), "cannot pass argument %s to parameter of type %s", x, typ)
-	}
-}
-
-func (check *Checker) selector(x *operand, e *ast.SelectorExpr) {
-	// these must be declared before the "goto Error" statements
-	var (
-		obj      Object
-		index    []int
-		indirect bool
-	)
-
-	sel := e.Sel.Name
-	// If the identifier refers to a package, handle everything here
-	// so we don't need a "package" mode for operands: package names
-	// can only appear in qualified identifiers which are mapped to
-	// selector expressions.
-	if ident, ok := e.X.(*ast.Ident); ok {
-		_, obj := check.scope.LookupParent(ident.Name, check.pos)
-		if pkg, _ := obj.(*PkgName); pkg != nil {
-			assert(pkg.pkg == check.pkg)
-			check.recordUse(ident, pkg)
-			pkg.used = true
-			exp := pkg.imported.scope.Lookup(sel)
-			if exp == nil {
-				if !pkg.imported.fake {
-					check.errorf(e.Pos(), "%s not declared by package %s", sel, ident)
-				}
-				goto Error
-			}
-			if !exp.Exported() {
-				check.errorf(e.Pos(), "%s not exported by package %s", sel, ident)
-				// ok to continue
-			}
-			check.recordUse(e.Sel, exp)
-			// Simplified version of the code for *ast.Idents:
-			// - imported objects are always fully initialized
-			switch exp := exp.(type) {
-			case *Const:
-				assert(exp.Val() != nil)
-				x.mode = constant_
-				x.typ = exp.typ
-				x.val = exp.val
-			case *TypeName:
-				x.mode = typexpr
-				x.typ = exp.typ
-			case *Var:
-				x.mode = variable
-				x.typ = exp.typ
-			case *Func:
-				x.mode = value
-				x.typ = exp.typ
-			case *Builtin:
-				x.mode = builtin
-				x.typ = exp.typ
-				x.id = exp.id
-			default:
-				unreachable()
-			}
-			x.expr = e
-			return
-		}
-	}
-
-	check.exprOrType(x, e.X)
-	if x.mode == invalid {
-		goto Error
-	}
-
-	obj, index, indirect = LookupFieldOrMethod(x.typ, x.mode == variable, check.pkg, sel)
-	if obj == nil {
-		switch {
-		case index != nil:
-			// TODO(gri) should provide actual type where the conflict happens
-			check.invalidOp(e.Pos(), "ambiguous selector %s", sel)
-		case indirect:
-			check.invalidOp(e.Pos(), "%s is not in method set of %s", sel, x.typ)
-		default:
-			check.invalidOp(e.Pos(), "%s has no field or method %s", x, sel)
-		}
-		goto Error
-	}
-
-	if x.mode == typexpr {
-		// method expression
-		m, _ := obj.(*Func)
-		if m == nil {
-			check.invalidOp(e.Pos(), "%s has no method %s", x, sel)
-			goto Error
-		}
-
-		check.recordSelection(e, MethodExpr, x.typ, m, index, indirect)
-
-		// the receiver type becomes the type of the first function
-		// argument of the method expression's function type
-		var params []*Var
-		sig := m.typ.(*Signature)
-		if sig.params != nil {
-			params = sig.params.vars
-		}
-		x.mode = value
-		x.typ = &Signature{
-			params:   NewTuple(append([]*Var{NewVar(token.NoPos, check.pkg, "", x.typ)}, params...)...),
-			results:  sig.results,
-			variadic: sig.variadic,
-		}
-
-		check.addDeclDep(m)
-
-	} else {
-		// regular selector
-		switch obj := obj.(type) {
-		case *Var:
-			check.recordSelection(e, FieldVal, x.typ, obj, index, indirect)
-			if x.mode == variable || indirect {
-				x.mode = variable
-			} else {
-				x.mode = value
-			}
-			x.typ = obj.typ
-
-		case *Func:
-			// TODO(gri) If we needed to take into account the receiver's
-			// addressability, should we report the type &(x.typ) instead?
-			check.recordSelection(e, MethodVal, x.typ, obj, index, indirect)
-
-			if debug {
-				// Verify that LookupFieldOrMethod and MethodSet.Lookup agree.
-				typ := x.typ
-				if x.mode == variable {
-					// If typ is not an (unnamed) pointer or an interface,
-					// use *typ instead, because the method set of *typ
-					// includes the methods of typ.
-					// Variables are addressable, so we can always take their
-					// address.
-					if _, ok := typ.(*Pointer); !ok && !IsInterface(typ) {
-						typ = &Pointer{base: typ}
-					}
-				}
-				// If we created a synthetic pointer type above, we will throw
-				// away the method set computed here after use.
-				// TODO(gri) Method set computation should probably always compute
-				// both, the value and the pointer receiver method set and represent
-				// them in a single structure.
-				// TODO(gri) Consider also using a method set cache for the lifetime
-				// of checker once we rely on MethodSet lookup instead of individual
-				// lookup.
-				mset := NewMethodSet(typ)
-				if m := mset.Lookup(check.pkg, sel); m == nil || m.obj != obj {
-					check.dump("%s: (%s).%v -> %s", e.Pos(), typ, obj.name, m)
-					check.dump("%s\n", mset)
-					panic("method sets and lookup don't agree")
-				}
-			}
-
-			x.mode = value
-
-			// remove receiver
-			sig := *obj.typ.(*Signature)
-			sig.recv = nil
-			x.typ = &sig
-
-			check.addDeclDep(obj)
-
-		default:
-			unreachable()
-		}
-	}
-
-	// everything went well
-	x.expr = e
-	return
-
-Error:
-	x.mode = invalid
-	x.expr = e
-}
diff --git a/third_party/golang/go/types/check.go b/third_party/golang/go/types/check.go
deleted file mode 100644
index 950c3fc023a26..0000000000000
--- a/third_party/golang/go/types/check.go
+++ /dev/null
@@ -1,358 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements the Check function, which drives type-checking.
-
-package types
-
-import (
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"k8s.io/kubernetes/third_party/golang/go/constant"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-)
-
-// debugging/development support
-const (
-	debug = false // leave on during development
-	trace = false // turn on for detailed type resolution traces
-)
-
-// If Strict is set, the type-checker enforces additional
-// rules not specified by the Go 1 spec, but which will
-// catch guaranteed run-time errors if the respective
-// code is executed. In other words, programs passing in
-// Strict mode are Go 1 compliant, but not all Go 1 programs
-// will pass in Strict mode. The additional rules are:
-//
-// - A type assertion x.(T) where T is an interface type
-//   is invalid if any (statically known) method that exists
-//   for both x and T have different signatures.
-//
-const strict = false
-
-// exprInfo stores information about an untyped expression.
-type exprInfo struct {
-	isLhs bool // expression is lhs operand of a shift with delayed type-check
-	mode  operandMode
-	typ   *Basic
-	val   constant.Value // constant value; or nil (if not a constant)
-}
-
-// funcInfo stores the information required for type-checking a function.
-type funcInfo struct {
-	name string    // for debugging/tracing only
-	decl *declInfo // for cycle detection
-	sig  *Signature
-	body *ast.BlockStmt
-}
-
-// A context represents the context within which an object is type-checked.
-type context struct {
-	decl          *declInfo      // package-level declaration whose init expression/function body is checked
-	scope         *Scope         // top-most scope for lookups
-	iota          constant.Value // value of iota in a constant declaration; nil otherwise
-	sig           *Signature     // function signature if inside a function; nil otherwise
-	hasLabel      bool           // set if a function makes use of labels (only ~1% of functions); unused outside functions
-	hasCallOrRecv bool           // set if an expression contains a function call or channel receive operation
-}
-
-// A Checker maintains the state of the type checker.
-// It must be created with NewChecker.
-type Checker struct {
-	// package information
-	// (initialized by NewChecker, valid for the life-time of checker)
-	conf *Config
-	fset *token.FileSet
-	pkg  *Package
-	*Info
-	objMap map[Object]*declInfo // maps package-level object to declaration info
-
-	// information collected during type-checking of a set of package files
-	// (initialized by Files, valid only for the duration of check.Files;
-	// maps and lists are allocated on demand)
-	files            []*ast.File                       // package files
-	unusedDotImports map[*Scope]map[*Package]token.Pos // positions of unused dot-imported packages for each file scope
-
-	firstErr error                 // first error encountered
-	methods  map[string][]*Func    // maps type names to associated methods
-	untyped  map[ast.Expr]exprInfo // map of expressions without final type
-	funcs    []funcInfo            // list of functions to type-check
-	delayed  []func()              // delayed checks requiring fully setup types
-
-	// context within which the current object is type-checked
-	// (valid only for the duration of type-checking a specific object)
-	context
-	pos token.Pos // if valid, identifiers are looked up as if at position pos (used by Eval)
-
-	// debugging
-	indent int // indentation for tracing
-}
-
-// addUnusedImport adds the position of a dot-imported package
-// pkg to the map of dot imports for the given file scope.
-func (check *Checker) addUnusedDotImport(scope *Scope, pkg *Package, pos token.Pos) {
-	mm := check.unusedDotImports
-	if mm == nil {
-		mm = make(map[*Scope]map[*Package]token.Pos)
-		check.unusedDotImports = mm
-	}
-	m := mm[scope]
-	if m == nil {
-		m = make(map[*Package]token.Pos)
-		mm[scope] = m
-	}
-	m[pkg] = pos
-}
-
-// addDeclDep adds the dependency edge (check.decl -> to) if check.decl exists
-func (check *Checker) addDeclDep(to Object) {
-	from := check.decl
-	if from == nil {
-		return // not in a package-level init expression
-	}
-	if _, found := check.objMap[to]; !found {
-		return // to is not a package-level object
-	}
-	from.addDep(to)
-}
-
-func (check *Checker) assocMethod(tname string, meth *Func) {
-	m := check.methods
-	if m == nil {
-		m = make(map[string][]*Func)
-		check.methods = m
-	}
-	m[tname] = append(m[tname], meth)
-}
-
-func (check *Checker) rememberUntyped(e ast.Expr, lhs bool, mode operandMode, typ *Basic, val constant.Value) {
-	m := check.untyped
-	if m == nil {
-		m = make(map[ast.Expr]exprInfo)
-		check.untyped = m
-	}
-	m[e] = exprInfo{lhs, mode, typ, val}
-}
-
-func (check *Checker) later(name string, decl *declInfo, sig *Signature, body *ast.BlockStmt) {
-	check.funcs = append(check.funcs, funcInfo{name, decl, sig, body})
-}
-
-func (check *Checker) delay(f func()) {
-	check.delayed = append(check.delayed, f)
-}
-
-// NewChecker returns a new Checker instance for a given package.
-// Package files may be added incrementally via checker.Files.
-func NewChecker(conf *Config, fset *token.FileSet, pkg *Package, info *Info) *Checker {
-	// make sure we have a configuration
-	if conf == nil {
-		conf = new(Config)
-	}
-
-	// make sure we have an info struct
-	if info == nil {
-		info = new(Info)
-	}
-
-	return &Checker{
-		conf:   conf,
-		fset:   fset,
-		pkg:    pkg,
-		Info:   info,
-		objMap: make(map[Object]*declInfo),
-	}
-}
-
-// initFiles initializes the files-specific portion of checker.
-// The provided files must all belong to the same package.
-func (check *Checker) initFiles(files []*ast.File) {
-	// start with a clean slate (check.Files may be called multiple times)
-	check.files = nil
-	check.unusedDotImports = nil
-
-	check.firstErr = nil
-	check.methods = nil
-	check.untyped = nil
-	check.funcs = nil
-	check.delayed = nil
-
-	// determine package name and collect valid files
-	pkg := check.pkg
-	for _, file := range files {
-		switch name := file.Name.Name; pkg.name {
-		case "":
-			if name != "_" {
-				pkg.name = name
-			} else {
-				check.errorf(file.Name.Pos(), "invalid package name _")
-			}
-			fallthrough
-
-		case name:
-			check.files = append(check.files, file)
-
-		default:
-			check.errorf(file.Package, "package %s; expected %s", name, pkg.name)
-			// ignore this file
-		}
-	}
-}
-
-// A bailout panic is used for early termination.
-type bailout struct{}
-
-func (check *Checker) handleBailout(err *error) {
-	switch p := recover().(type) {
-	case nil, bailout:
-		// normal return or early exit
-		*err = check.firstErr
-	default:
-		// re-panic
-		panic(p)
-	}
-}
-
-// Files checks the provided files as part of the checker's package.
-func (check *Checker) Files(files []*ast.File) (err error) {
-	defer check.handleBailout(&err)
-
-	check.initFiles(files)
-
-	check.collectObjects()
-
-	check.packageObjects(check.resolveOrder())
-
-	check.functionBodies()
-
-	check.initOrder()
-
-	if !check.conf.DisableUnusedImportCheck {
-		check.unusedImports()
-	}
-
-	// perform delayed checks
-	for _, f := range check.delayed {
-		f()
-	}
-
-	check.recordUntyped()
-
-	check.pkg.complete = true
-	return
-}
-
-func (check *Checker) recordUntyped() {
-	if !debug && check.Types == nil {
-		return // nothing to do
-	}
-
-	for x, info := range check.untyped {
-		if debug && isTyped(info.typ) {
-			check.dump("%s: %s (type %s) is typed", x.Pos(), x, info.typ)
-			unreachable()
-		}
-		check.recordTypeAndValue(x, info.mode, info.typ, info.val)
-	}
-}
-
-func (check *Checker) recordTypeAndValue(x ast.Expr, mode operandMode, typ Type, val constant.Value) {
-	assert(x != nil)
-	assert(typ != nil)
-	if mode == invalid {
-		return // omit
-	}
-	assert(typ != nil)
-	if mode == constant_ {
-		assert(val != nil)
-		assert(typ == Typ[Invalid] || isConstType(typ))
-	}
-	if m := check.Types; m != nil {
-		m[x] = TypeAndValue{mode, typ, val}
-	}
-}
-
-func (check *Checker) recordBuiltinType(f ast.Expr, sig *Signature) {
-	// f must be a (possibly parenthesized) identifier denoting a built-in
-	// (built-ins in package unsafe always produce a constant result and
-	// we don't record their signatures, so we don't see qualified idents
-	// here): record the signature for f and possible children.
-	for {
-		check.recordTypeAndValue(f, builtin, sig, nil)
-		switch p := f.(type) {
-		case *ast.Ident:
-			return // we're done
-		case *ast.ParenExpr:
-			f = p.X
-		default:
-			unreachable()
-		}
-	}
-}
-
-func (check *Checker) recordCommaOkTypes(x ast.Expr, a [2]Type) {
-	assert(x != nil)
-	if a[0] == nil || a[1] == nil {
-		return
-	}
-	assert(isTyped(a[0]) && isTyped(a[1]) && isBoolean(a[1]))
-	if m := check.Types; m != nil {
-		for {
-			tv := m[x]
-			assert(tv.Type != nil) // should have been recorded already
-			pos := x.Pos()
-			tv.Type = NewTuple(
-				NewVar(pos, check.pkg, "", a[0]),
-				NewVar(pos, check.pkg, "", a[1]),
-			)
-			m[x] = tv
-			// if x is a parenthesized expression (p.X), update p.X
-			p, _ := x.(*ast.ParenExpr)
-			if p == nil {
-				break
-			}
-			x = p.X
-		}
-	}
-}
-
-func (check *Checker) recordDef(id *ast.Ident, obj Object) {
-	assert(id != nil)
-	if m := check.Defs; m != nil {
-		m[id] = obj
-	}
-}
-
-func (check *Checker) recordUse(id *ast.Ident, obj Object) {
-	assert(id != nil)
-	assert(obj != nil)
-	if m := check.Uses; m != nil {
-		m[id] = obj
-	}
-}
-
-func (check *Checker) recordImplicit(node ast.Node, obj Object) {
-	assert(node != nil)
-	assert(obj != nil)
-	if m := check.Implicits; m != nil {
-		m[node] = obj
-	}
-}
-
-func (check *Checker) recordSelection(x *ast.SelectorExpr, kind SelectionKind, recv Type, obj Object, index []int, indirect bool) {
-	assert(obj != nil && (recv == nil || len(index) > 0))
-	check.recordUse(x.Sel, obj)
-	// TODO(gri) Should we also call recordTypeAndValue?
-	if m := check.Selections; m != nil {
-		m[x] = &Selection{kind, recv, obj, index, indirect}
-	}
-}
-
-func (check *Checker) recordScope(node ast.Node, scope *Scope) {
-	assert(node != nil)
-	assert(scope != nil)
-	if m := check.Scopes; m != nil {
-		m[node] = scope
-	}
-}
diff --git a/third_party/golang/go/types/conversions.go b/third_party/golang/go/types/conversions.go
deleted file mode 100644
index 7105e00a83bd4..0000000000000
--- a/third_party/golang/go/types/conversions.go
+++ /dev/null
@@ -1,146 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements typechecking of conversions.
-
-package types
-
-import "k8s.io/kubernetes/third_party/golang/go/constant"
-
-// Conversion type-checks the conversion T(x).
-// The result is in x.
-func (check *Checker) conversion(x *operand, T Type) {
-	constArg := x.mode == constant_
-
-	var ok bool
-	switch {
-	case constArg && isConstType(T):
-		// constant conversion
-		switch t := T.Underlying().(*Basic); {
-		case representableConst(x.val, check.conf, t.kind, &x.val):
-			ok = true
-		case isInteger(x.typ) && isString(t):
-			codepoint := int64(-1)
-			if i, ok := constant.Int64Val(x.val); ok {
-				codepoint = i
-			}
-			// If codepoint < 0 the absolute value is too large (or unknown) for
-			// conversion. This is the same as converting any other out-of-range
-			// value - let string(codepoint) do the work.
-			x.val = constant.MakeString(string(codepoint))
-			ok = true
-		}
-	case x.convertibleTo(check.conf, T):
-		// non-constant conversion
-		x.mode = value
-		ok = true
-	}
-
-	if !ok {
-		check.errorf(x.pos(), "cannot convert %s to %s", x, T)
-		x.mode = invalid
-		return
-	}
-
-	// The conversion argument types are final. For untyped values the
-	// conversion provides the type, per the spec: "A constant may be
-	// given a type explicitly by a constant declaration or conversion,...".
-	final := x.typ
-	if isUntyped(x.typ) {
-		final = T
-		// - For conversions to interfaces, use the argument's default type.
-		// - For conversions of untyped constants to non-constant types, also
-		//   use the default type (e.g., []byte("foo") should report string
-		//   not []byte as type for the constant "foo").
-		// - Keep untyped nil for untyped nil arguments.
-		if IsInterface(T) || constArg && !isConstType(T) {
-			final = defaultType(x.typ)
-		}
-		check.updateExprType(x.expr, final, true)
-	}
-
-	x.typ = T
-}
-
-func (x *operand) convertibleTo(conf *Config, T Type) bool {
-	// "x is assignable to T"
-	if x.assignableTo(conf, T) {
-		return true
-	}
-
-	// "x's type and T have identical underlying types"
-	V := x.typ
-	Vu := V.Underlying()
-	Tu := T.Underlying()
-	if Identical(Vu, Tu) {
-		return true
-	}
-
-	// "x's type and T are unnamed pointer types and their pointer base types have identical underlying types"
-	if V, ok := V.(*Pointer); ok {
-		if T, ok := T.(*Pointer); ok {
-			if Identical(V.base.Underlying(), T.base.Underlying()) {
-				return true
-			}
-		}
-	}
-
-	// "x's type and T are both integer or floating point types"
-	if (isInteger(V) || isFloat(V)) && (isInteger(T) || isFloat(T)) {
-		return true
-	}
-
-	// "x's type and T are both complex types"
-	if isComplex(V) && isComplex(T) {
-		return true
-	}
-
-	// "x is an integer or a slice of bytes or runes and T is a string type"
-	if (isInteger(V) || isBytesOrRunes(Vu)) && isString(T) {
-		return true
-	}
-
-	// "x is a string and T is a slice of bytes or runes"
-	if isString(V) && isBytesOrRunes(Tu) {
-		return true
-	}
-
-	// package unsafe:
-	// "any pointer or value of underlying type uintptr can be converted into a unsafe.Pointer"
-	if (isPointer(Vu) || isUintptr(Vu)) && isUnsafePointer(T) {
-		return true
-	}
-	// "and vice versa"
-	if isUnsafePointer(V) && (isPointer(Tu) || isUintptr(Tu)) {
-		return true
-	}
-
-	return false
-}
-
-func isUintptr(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.kind == Uintptr
-}
-
-func isUnsafePointer(typ Type) bool {
-	// TODO(gri): Is this (typ.Underlying() instead of just typ) correct?
-	//            The spec does not say so, but gc claims it is. See also
-	//            issue 6326.
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.kind == UnsafePointer
-}
-
-func isPointer(typ Type) bool {
-	_, ok := typ.Underlying().(*Pointer)
-	return ok
-}
-
-func isBytesOrRunes(typ Type) bool {
-	if s, ok := typ.(*Slice); ok {
-		t, ok := s.elem.Underlying().(*Basic)
-		return ok && (t.kind == Byte || t.kind == Rune)
-	}
-	return false
-}
diff --git a/third_party/golang/go/types/decl.go b/third_party/golang/go/types/decl.go
deleted file mode 100644
index 816b900c1818b..0000000000000
--- a/third_party/golang/go/types/decl.go
+++ /dev/null
@@ -1,430 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package types
-
-import (
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"k8s.io/kubernetes/third_party/golang/go/constant"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-)
-
-func (check *Checker) reportAltDecl(obj Object) {
-	if pos := obj.Pos(); pos.IsValid() {
-		// We use "other" rather than "previous" here because
-		// the first declaration seen may not be textually
-		// earlier in the source.
-		check.errorf(pos, "\tother declaration of %s", obj.Name()) // secondary error, \t indented
-	}
-}
-
-func (check *Checker) declare(scope *Scope, id *ast.Ident, obj Object, pos token.Pos) {
-	// spec: "The blank identifier, represented by the underscore
-	// character _, may be used in a declaration like any other
-	// identifier but the declaration does not introduce a new
-	// binding."
-	if obj.Name() != "_" {
-		if alt := scope.Insert(obj); alt != nil {
-			check.errorf(obj.Pos(), "%s redeclared in this block", obj.Name())
-			check.reportAltDecl(alt)
-			return
-		}
-		obj.setScopePos(pos)
-	}
-	if id != nil {
-		check.recordDef(id, obj)
-	}
-}
-
-// objDecl type-checks the declaration of obj in its respective (file) context.
-// See check.typ for the details on def and path.
-func (check *Checker) objDecl(obj Object, def *Named, path []*TypeName) {
-	if obj.Type() != nil {
-		return // already checked - nothing to do
-	}
-
-	if trace {
-		check.trace(obj.Pos(), "-- declaring %s", obj.Name())
-		check.indent++
-		defer func() {
-			check.indent--
-			check.trace(obj.Pos(), "=> %s", obj)
-		}()
-	}
-
-	d := check.objMap[obj]
-	if d == nil {
-		check.dump("%s: %s should have been declared", obj.Pos(), obj.Name())
-		unreachable()
-	}
-
-	// save/restore current context and setup object context
-	defer func(ctxt context) {
-		check.context = ctxt
-	}(check.context)
-	check.context = context{
-		scope: d.file,
-	}
-
-	// Const and var declarations must not have initialization
-	// cycles. We track them by remembering the current declaration
-	// in check.decl. Initialization expressions depending on other
-	// consts, vars, or functions, add dependencies to the current
-	// check.decl.
-	switch obj := obj.(type) {
-	case *Const:
-		check.decl = d // new package-level const decl
-		check.constDecl(obj, d.typ, d.init)
-	case *Var:
-		check.decl = d // new package-level var decl
-		check.varDecl(obj, d.lhs, d.typ, d.init)
-	case *TypeName:
-		// invalid recursive types are detected via path
-		check.typeDecl(obj, d.typ, def, path)
-	case *Func:
-		// functions may be recursive - no need to track dependencies
-		check.funcDecl(obj, d)
-	default:
-		unreachable()
-	}
-}
-
-func (check *Checker) constDecl(obj *Const, typ, init ast.Expr) {
-	assert(obj.typ == nil)
-
-	if obj.visited {
-		obj.typ = Typ[Invalid]
-		return
-	}
-	obj.visited = true
-
-	// use the correct value of iota
-	assert(check.iota == nil)
-	check.iota = obj.val
-	defer func() { check.iota = nil }()
-
-	// provide valid constant value under all circumstances
-	obj.val = constant.MakeUnknown()
-
-	// determine type, if any
-	if typ != nil {
-		t := check.typ(typ)
-		if !isConstType(t) {
-			check.errorf(typ.Pos(), "invalid constant type %s", t)
-			obj.typ = Typ[Invalid]
-			return
-		}
-		obj.typ = t
-	}
-
-	// check initialization
-	var x operand
-	if init != nil {
-		check.expr(&x, init)
-	}
-	check.initConst(obj, &x)
-}
-
-func (check *Checker) varDecl(obj *Var, lhs []*Var, typ, init ast.Expr) {
-	assert(obj.typ == nil)
-
-	if obj.visited {
-		obj.typ = Typ[Invalid]
-		return
-	}
-	obj.visited = true
-
-	// var declarations cannot use iota
-	assert(check.iota == nil)
-
-	// determine type, if any
-	if typ != nil {
-		obj.typ = check.typ(typ)
-	}
-
-	// check initialization
-	if init == nil {
-		if typ == nil {
-			// error reported before by arityMatch
-			obj.typ = Typ[Invalid]
-		}
-		return
-	}
-
-	if lhs == nil || len(lhs) == 1 {
-		assert(lhs == nil || lhs[0] == obj)
-		var x operand
-		check.expr(&x, init)
-		check.initVar(obj, &x, false)
-		return
-	}
-
-	if debug {
-		// obj must be one of lhs
-		found := false
-		for _, lhs := range lhs {
-			if obj == lhs {
-				found = true
-				break
-			}
-		}
-		if !found {
-			panic("inconsistent lhs")
-		}
-	}
-	check.initVars(lhs, []ast.Expr{init}, token.NoPos)
-}
-
-// underlying returns the underlying type of typ; possibly by following
-// forward chains of named types. Such chains only exist while named types
-// are incomplete.
-func underlying(typ Type) Type {
-	for {
-		n, _ := typ.(*Named)
-		if n == nil {
-			break
-		}
-		typ = n.underlying
-	}
-	return typ
-}
-
-func (n *Named) setUnderlying(typ Type) {
-	if n != nil {
-		n.underlying = typ
-	}
-}
-
-func (check *Checker) typeDecl(obj *TypeName, typ ast.Expr, def *Named, path []*TypeName) {
-	assert(obj.typ == nil)
-
-	// type declarations cannot use iota
-	assert(check.iota == nil)
-
-	named := &Named{obj: obj}
-	def.setUnderlying(named)
-	obj.typ = named // make sure recursive type declarations terminate
-
-	// determine underlying type of named
-	check.typExpr(typ, named, append(path, obj))
-
-	// The underlying type of named may be itself a named type that is
-	// incomplete:
-	//
-	//	type (
-	//		A B
-	//		B *C
-	//		C A
-	//	)
-	//
-	// The type of C is the (named) type of A which is incomplete,
-	// and which has as its underlying type the named type B.
-	// Determine the (final, unnamed) underlying type by resolving
-	// any forward chain (they always end in an unnamed type).
-	named.underlying = underlying(named.underlying)
-
-	// check and add associated methods
-	// TODO(gri) It's easy to create pathological cases where the
-	// current approach is incorrect: In general we need to know
-	// and add all methods _before_ type-checking the type.
-	// See https://play.golang.org/p/WMpE0q2wK8
-	check.addMethodDecls(obj)
-}
-
-func (check *Checker) addMethodDecls(obj *TypeName) {
-	// get associated methods
-	methods := check.methods[obj.name]
-	if len(methods) == 0 {
-		return // no methods
-	}
-	delete(check.methods, obj.name)
-
-	// use an objset to check for name conflicts
-	var mset objset
-
-	// spec: "If the base type is a struct type, the non-blank method
-	// and field names must be distinct."
-	base := obj.typ.(*Named)
-	if t, _ := base.underlying.(*Struct); t != nil {
-		for _, fld := range t.fields {
-			if fld.name != "_" {
-				assert(mset.insert(fld) == nil)
-			}
-		}
-	}
-
-	// Checker.Files may be called multiple times; additional package files
-	// may add methods to already type-checked types. Add pre-existing methods
-	// so that we can detect redeclarations.
-	for _, m := range base.methods {
-		assert(m.name != "_")
-		assert(mset.insert(m) == nil)
-	}
-
-	// type-check methods
-	for _, m := range methods {
-		// spec: "For a base type, the non-blank names of methods bound
-		// to it must be unique."
-		if m.name != "_" {
-			if alt := mset.insert(m); alt != nil {
-				switch alt.(type) {
-				case *Var:
-					check.errorf(m.pos, "field and method with the same name %s", m.name)
-				case *Func:
-					check.errorf(m.pos, "method %s already declared for %s", m.name, base)
-				default:
-					unreachable()
-				}
-				check.reportAltDecl(alt)
-				continue
-			}
-		}
-		check.objDecl(m, nil, nil)
-		// methods with blank _ names cannot be found - don't keep them
-		if m.name != "_" {
-			base.methods = append(base.methods, m)
-		}
-	}
-}
-
-func (check *Checker) funcDecl(obj *Func, decl *declInfo) {
-	assert(obj.typ == nil)
-
-	// func declarations cannot use iota
-	assert(check.iota == nil)
-
-	sig := new(Signature)
-	obj.typ = sig // guard against cycles
-	fdecl := decl.fdecl
-	check.funcType(sig, fdecl.Recv, fdecl.Type)
-	if sig.recv == nil && obj.name == "init" && (sig.params.Len() > 0 || sig.results.Len() > 0) {
-		check.errorf(fdecl.Pos(), "func init must have no arguments and no return values")
-		// ok to continue
-	}
-
-	// function body must be type-checked after global declarations
-	// (functions implemented elsewhere have no body)
-	if !check.conf.IgnoreFuncBodies && fdecl.Body != nil {
-		check.later(obj.name, decl, sig, fdecl.Body)
-	}
-}
-
-func (check *Checker) declStmt(decl ast.Decl) {
-	pkg := check.pkg
-
-	switch d := decl.(type) {
-	case *ast.BadDecl:
-		// ignore
-
-	case *ast.GenDecl:
-		var last *ast.ValueSpec // last ValueSpec with type or init exprs seen
-		for iota, spec := range d.Specs {
-			switch s := spec.(type) {
-			case *ast.ValueSpec:
-				switch d.Tok {
-				case token.CONST:
-					// determine which init exprs to use
-					switch {
-					case s.Type != nil || len(s.Values) > 0:
-						last = s
-					case last == nil:
-						last = new(ast.ValueSpec) // make sure last exists
-					}
-
-					// declare all constants
-					lhs := make([]*Const, len(s.Names))
-					for i, name := range s.Names {
-						obj := NewConst(name.Pos(), pkg, name.Name, nil, constant.MakeInt64(int64(iota)))
-						lhs[i] = obj
-
-						var init ast.Expr
-						if i < len(last.Values) {
-							init = last.Values[i]
-						}
-
-						check.constDecl(obj, last.Type, init)
-					}
-
-					check.arityMatch(s, last)
-
-					// spec: "The scope of a constant or variable identifier declared
-					// inside a function begins at the end of the ConstSpec or VarSpec
-					// (ShortVarDecl for short variable declarations) and ends at the
-					// end of the innermost containing block."
-					scopePos := s.End()
-					for i, name := range s.Names {
-						check.declare(check.scope, name, lhs[i], scopePos)
-					}
-
-				case token.VAR:
-					lhs0 := make([]*Var, len(s.Names))
-					for i, name := range s.Names {
-						lhs0[i] = NewVar(name.Pos(), pkg, name.Name, nil)
-					}
-
-					// initialize all variables
-					for i, obj := range lhs0 {
-						var lhs []*Var
-						var init ast.Expr
-						switch len(s.Values) {
-						case len(s.Names):
-							// lhs and rhs match
-							init = s.Values[i]
-						case 1:
-							// rhs is expected to be a multi-valued expression
-							lhs = lhs0
-							init = s.Values[0]
-						default:
-							if i < len(s.Values) {
-								init = s.Values[i]
-							}
-						}
-						check.varDecl(obj, lhs, s.Type, init)
-						if len(s.Values) == 1 {
-							// If we have a single lhs variable we are done either way.
-							// If we have a single rhs expression, it must be a multi-
-							// valued expression, in which case handling the first lhs
-							// variable will cause all lhs variables to have a type
-							// assigned, and we are done as well.
-							if debug {
-								for _, obj := range lhs0 {
-									assert(obj.typ != nil)
-								}
-							}
-							break
-						}
-					}
-
-					check.arityMatch(s, nil)
-
-					// declare all variables
-					// (only at this point are the variable scopes (parents) set)
-					scopePos := s.End() // see constant declarations
-					for i, name := range s.Names {
-						// see constant declarations
-						check.declare(check.scope, name, lhs0[i], scopePos)
-					}
-
-				default:
-					check.invalidAST(s.Pos(), "invalid token %s", d.Tok)
-				}
-
-			case *ast.TypeSpec:
-				obj := NewTypeName(s.Name.Pos(), pkg, s.Name.Name, nil)
-				// spec: "The scope of a type identifier declared inside a function
-				// begins at the identifier in the TypeSpec and ends at the end of
-				// the innermost containing block."
-				scopePos := s.Name.Pos()
-				check.declare(check.scope, s.Name, obj, scopePos)
-				check.typeDecl(obj, s.Type, nil, nil)
-
-			default:
-				check.invalidAST(s.Pos(), "const, type, or var declaration expected")
-			}
-		}
-
-	default:
-		check.invalidAST(d.Pos(), "unknown ast.Decl node %T", d)
-	}
-}
diff --git a/third_party/golang/go/types/errors.go b/third_party/golang/go/types/errors.go
deleted file mode 100644
index 4c51965ff19a2..0000000000000
--- a/third_party/golang/go/types/errors.go
+++ /dev/null
@@ -1,103 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements various error reporters.
-
-package types
-
-import (
-	"fmt"
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-	"strings"
-)
-
-func assert(p bool) {
-	if !p {
-		panic("assertion failed")
-	}
-}
-
-func unreachable() {
-	panic("unreachable")
-}
-
-func (check *Checker) qualifier(pkg *Package) string {
-	if pkg != check.pkg {
-		return pkg.path
-	}
-	return ""
-}
-
-func (check *Checker) sprintf(format string, args ...interface{}) string {
-	for i, arg := range args {
-		switch a := arg.(type) {
-		case nil:
-			arg = ""
-		case operand:
-			panic("internal error: should always pass *operand")
-		case *operand:
-			arg = operandString(a, check.qualifier)
-		case token.Pos:
-			arg = check.fset.Position(a).String()
-		case ast.Expr:
-			arg = ExprString(a)
-		case Object:
-			arg = ObjectString(a, check.qualifier)
-		case Type:
-			arg = TypeString(a, check.qualifier)
-		}
-		args[i] = arg
-	}
-	return fmt.Sprintf(format, args...)
-}
-
-func (check *Checker) trace(pos token.Pos, format string, args ...interface{}) {
-	fmt.Printf("%s:\t%s%s\n",
-		check.fset.Position(pos),
-		strings.Repeat(".  ", check.indent),
-		check.sprintf(format, args...),
-	)
-}
-
-// dump is only needed for debugging
-func (check *Checker) dump(format string, args ...interface{}) {
-	fmt.Println(check.sprintf(format, args...))
-}
-
-func (check *Checker) err(pos token.Pos, msg string, soft bool) {
-	err := Error{check.fset, pos, msg, soft}
-	if check.firstErr == nil {
-		check.firstErr = err
-	}
-	f := check.conf.Error
-	if f == nil {
-		panic(bailout{}) // report only first error
-	}
-	f(err)
-}
-
-func (check *Checker) error(pos token.Pos, msg string) {
-	check.err(pos, msg, false)
-}
-
-func (check *Checker) errorf(pos token.Pos, format string, args ...interface{}) {
-	check.err(pos, check.sprintf(format, args...), false)
-}
-
-func (check *Checker) softErrorf(pos token.Pos, format string, args ...interface{}) {
-	check.err(pos, check.sprintf(format, args...), true)
-}
-
-func (check *Checker) invalidAST(pos token.Pos, format string, args ...interface{}) {
-	check.errorf(pos, "invalid AST: "+format, args...)
-}
-
-func (check *Checker) invalidArg(pos token.Pos, format string, args ...interface{}) {
-	check.errorf(pos, "invalid argument: "+format, args...)
-}
-
-func (check *Checker) invalidOp(pos token.Pos, format string, args ...interface{}) {
-	check.errorf(pos, "invalid operation: "+format, args...)
-}
diff --git a/third_party/golang/go/types/eval.go b/third_party/golang/go/types/eval.go
deleted file mode 100644
index af98adc7004a3..0000000000000
--- a/third_party/golang/go/types/eval.go
+++ /dev/null
@@ -1,83 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package types
-
-import (
-	"fmt"
-	"k8s.io/kubernetes/third_party/golang/go/parser"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-)
-
-// Eval returns the type and, if constant, the value for the
-// expression expr, evaluated at position pos of package pkg,
-// which must have been derived from type-checking an AST with
-// complete position information relative to the provided file
-// set.
-//
-// If the expression contains function literals, their bodies
-// are ignored (i.e., the bodies are not type-checked).
-//
-// If pkg == nil, the Universe scope is used and the provided
-// position pos is ignored. If pkg != nil, and pos is invalid,
-// the package scope is used. Otherwise, pos must belong to the
-// package.
-//
-// An error is returned if pos is not within the package or
-// if the node cannot be evaluated.
-//
-// Note: Eval should not be used instead of running Check to compute
-// types and values, but in addition to Check. Eval will re-evaluate
-// its argument each time, and it also does not know about the context
-// in which an expression is used (e.g., an assignment). Thus, top-
-// level untyped constants will return an untyped type rather then the
-// respective context-specific type.
-//
-func Eval(fset *token.FileSet, pkg *Package, pos token.Pos, expr string) (tv TypeAndValue, err error) {
-	// determine scope
-	var scope *Scope
-	if pkg == nil {
-		scope = Universe
-		pos = token.NoPos
-	} else if !pos.IsValid() {
-		scope = pkg.scope
-	} else {
-		// The package scope extent (position information) may be
-		// incorrect (files spread accross a wide range of fset
-		// positions) - ignore it and just consider its children
-		// (file scopes).
-		for _, fscope := range pkg.scope.children {
-			if scope = fscope.Innermost(pos); scope != nil {
-				break
-			}
-		}
-		if scope == nil || debug {
-			s := scope
-			for s != nil && s != pkg.scope {
-				s = s.parent
-			}
-			// s == nil || s == pkg.scope
-			if s == nil {
-				return TypeAndValue{}, fmt.Errorf("no position %s found in package %s", fset.Position(pos), pkg.name)
-			}
-		}
-	}
-
-	// parse expressions
-	node, err := parser.ParseExprFrom(fset, "eval", expr, 0)
-	if err != nil {
-		return TypeAndValue{}, err
-	}
-
-	// initialize checker
-	check := NewChecker(nil, fset, pkg, nil)
-	check.scope = scope
-	check.pos = pos
-	defer check.handleBailout(&err)
-
-	// evaluate node
-	var x operand
-	check.rawExpr(&x, node, nil)
-	return TypeAndValue{x.mode, x.typ, x.val}, err
-}
diff --git a/third_party/golang/go/types/expr.go b/third_party/golang/go/types/expr.go
deleted file mode 100644
index c89bff1e56aaa..0000000000000
--- a/third_party/golang/go/types/expr.go
+++ /dev/null
@@ -1,1496 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements typechecking of expressions.
-
-package types
-
-import (
-	"fmt"
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"k8s.io/kubernetes/third_party/golang/go/constant"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-	"math"
-)
-
-/*
-Basic algorithm:
-
-Expressions are checked recursively, top down. Expression checker functions
-are generally of the form:
-
-  func f(x *operand, e *ast.Expr, ...)
-
-where e is the expression to be checked, and x is the result of the check.
-The check performed by f may fail in which case x.mode == invalid, and
-related error messages will have been issued by f.
-
-If a hint argument is present, it is the composite literal element type
-of an outer composite literal; it is used to type-check composite literal
-elements that have no explicit type specification in the source
-(e.g.: []T{{...}, {...}}, the hint is the type T in this case).
-
-All expressions are checked via rawExpr, which dispatches according
-to expression kind. Upon returning, rawExpr is recording the types and
-constant values for all expressions that have an untyped type (those types
-may change on the way up in the expression tree). Usually these are constants,
-but the results of comparisons or non-constant shifts of untyped constants
-may also be untyped, but not constant.
-
-Untyped expressions may eventually become fully typed (i.e., not untyped),
-typically when the value is assigned to a variable, or is used otherwise.
-The updateExprType method is used to record this final type and update
-the recorded types: the type-checked expression tree is again traversed down,
-and the new type is propagated as needed. Untyped constant expression values
-that become fully typed must now be representable by the full type (constant
-sub-expression trees are left alone except for their roots). This mechanism
-ensures that a client sees the actual (run-time) type an untyped value would
-have. It also permits type-checking of lhs shift operands "as if the shift
-were not present": when updateExprType visits an untyped lhs shift operand
-and assigns it it's final type, that type must be an integer type, and a
-constant lhs must be representable as an integer.
-
-When an expression gets its final type, either on the way out from rawExpr,
-on the way down in updateExprType, or at the end of the type checker run,
-the type (and constant value, if any) is recorded via Info.Types, if present.
-*/
-
-type opPredicates map[token.Token]func(Type) bool
-
-var unaryOpPredicates = opPredicates{
-	token.ADD: isNumeric,
-	token.SUB: isNumeric,
-	token.XOR: isInteger,
-	token.NOT: isBoolean,
-}
-
-func (check *Checker) op(m opPredicates, x *operand, op token.Token) bool {
-	if pred := m[op]; pred != nil {
-		if !pred(x.typ) {
-			check.invalidOp(x.pos(), "operator %s not defined for %s", op, x)
-			return false
-		}
-	} else {
-		check.invalidAST(x.pos(), "unknown operator %s", op)
-		return false
-	}
-	return true
-}
-
-// The unary expression e may be nil. It's passed in for better error messages only.
-func (check *Checker) unary(x *operand, e *ast.UnaryExpr, op token.Token) {
-	switch op {
-	case token.AND:
-		// spec: "As an exception to the addressability
-		// requirement x may also be a composite literal."
-		if _, ok := unparen(x.expr).(*ast.CompositeLit); !ok && x.mode != variable {
-			check.invalidOp(x.pos(), "cannot take address of %s", x)
-			x.mode = invalid
-			return
-		}
-		x.mode = value
-		x.typ = &Pointer{base: x.typ}
-		return
-
-	case token.ARROW:
-		typ, ok := x.typ.Underlying().(*Chan)
-		if !ok {
-			check.invalidOp(x.pos(), "cannot receive from non-channel %s", x)
-			x.mode = invalid
-			return
-		}
-		if typ.dir == SendOnly {
-			check.invalidOp(x.pos(), "cannot receive from send-only channel %s", x)
-			x.mode = invalid
-			return
-		}
-		x.mode = commaok
-		x.typ = typ.elem
-		check.hasCallOrRecv = true
-		return
-	}
-
-	if !check.op(unaryOpPredicates, x, op) {
-		x.mode = invalid
-		return
-	}
-
-	if x.mode == constant_ {
-		typ := x.typ.Underlying().(*Basic)
-		var prec uint
-		if isUnsigned(typ) {
-			prec = uint(check.conf.sizeof(typ) * 8)
-		}
-		x.val = constant.UnaryOp(op, x.val, prec)
-		// Typed constants must be representable in
-		// their type after each constant operation.
-		if isTyped(typ) {
-			if e != nil {
-				x.expr = e // for better error message
-			}
-			check.representable(x, typ)
-		}
-		return
-	}
-
-	x.mode = value
-	// x.typ remains unchanged
-}
-
-func isShift(op token.Token) bool {
-	return op == token.SHL || op == token.SHR
-}
-
-func isComparison(op token.Token) bool {
-	// Note: tokens are not ordered well to make this much easier
-	switch op {
-	case token.EQL, token.NEQ, token.LSS, token.LEQ, token.GTR, token.GEQ:
-		return true
-	}
-	return false
-}
-
-func fitsFloat32(x constant.Value) bool {
-	f32, _ := constant.Float32Val(x)
-	f := float64(f32)
-	return !math.IsInf(f, 0)
-}
-
-func roundFloat32(x constant.Value) constant.Value {
-	f32, _ := constant.Float32Val(x)
-	f := float64(f32)
-	if !math.IsInf(f, 0) {
-		return constant.MakeFloat64(f)
-	}
-	return nil
-}
-
-func fitsFloat64(x constant.Value) bool {
-	f, _ := constant.Float64Val(x)
-	return !math.IsInf(f, 0)
-}
-
-func roundFloat64(x constant.Value) constant.Value {
-	f, _ := constant.Float64Val(x)
-	if !math.IsInf(f, 0) {
-		return constant.MakeFloat64(f)
-	}
-	return nil
-}
-
-// representableConst reports whether x can be represented as
-// value of the given basic type kind and for the configuration
-// provided (only needed for int/uint sizes).
-//
-// If rounded != nil, *rounded is set to the rounded value of x for
-// representable floating-point values; it is left alone otherwise.
-// It is ok to provide the addressof the first argument for rounded.
-func representableConst(x constant.Value, conf *Config, as BasicKind, rounded *constant.Value) bool {
-	switch x.Kind() {
-	case constant.Unknown:
-		return true
-
-	case constant.Bool:
-		return as == Bool || as == UntypedBool
-
-	case constant.Int:
-		if x, ok := constant.Int64Val(x); ok {
-			switch as {
-			case Int:
-				var s = uint(conf.sizeof(Typ[as])) * 8
-				return int64(-1)<<(s-1) <= x && x <= int64(1)<<(s-1)-1
-			case Int8:
-				const s = 8
-				return -1<<(s-1) <= x && x <= 1<<(s-1)-1
-			case Int16:
-				const s = 16
-				return -1<<(s-1) <= x && x <= 1<<(s-1)-1
-			case Int32:
-				const s = 32
-				return -1<<(s-1) <= x && x <= 1<<(s-1)-1
-			case Int64:
-				return true
-			case Uint, Uintptr:
-				if s := uint(conf.sizeof(Typ[as])) * 8; s < 64 {
-					return 0 <= x && x <= int64(1)<= 0 && n <= int(s)
-		case Uint64:
-			return constant.Sign(x) >= 0 && n <= 64
-		case Float32, Complex64:
-			if rounded == nil {
-				return fitsFloat32(x)
-			}
-			r := roundFloat32(x)
-			if r != nil {
-				*rounded = r
-				return true
-			}
-		case Float64, Complex128:
-			if rounded == nil {
-				return fitsFloat64(x)
-			}
-			r := roundFloat64(x)
-			if r != nil {
-				*rounded = r
-				return true
-			}
-		case UntypedInt, UntypedFloat, UntypedComplex:
-			return true
-		}
-
-	case constant.Float:
-		switch as {
-		case Float32, Complex64:
-			if rounded == nil {
-				return fitsFloat32(x)
-			}
-			r := roundFloat32(x)
-			if r != nil {
-				*rounded = r
-				return true
-			}
-		case Float64, Complex128:
-			if rounded == nil {
-				return fitsFloat64(x)
-			}
-			r := roundFloat64(x)
-			if r != nil {
-				*rounded = r
-				return true
-			}
-		case UntypedFloat, UntypedComplex:
-			return true
-		}
-
-	case constant.Complex:
-		switch as {
-		case Complex64:
-			if rounded == nil {
-				return fitsFloat32(constant.Real(x)) && fitsFloat32(constant.Imag(x))
-			}
-			re := roundFloat32(constant.Real(x))
-			im := roundFloat32(constant.Imag(x))
-			if re != nil && im != nil {
-				*rounded = constant.BinaryOp(re, token.ADD, constant.MakeImag(im))
-				return true
-			}
-		case Complex128:
-			if rounded == nil {
-				return fitsFloat64(constant.Real(x)) && fitsFloat64(constant.Imag(x))
-			}
-			re := roundFloat64(constant.Real(x))
-			im := roundFloat64(constant.Imag(x))
-			if re != nil && im != nil {
-				*rounded = constant.BinaryOp(re, token.ADD, constant.MakeImag(im))
-				return true
-			}
-		case UntypedComplex:
-			return true
-		}
-
-	case constant.String:
-		return as == String || as == UntypedString
-
-	default:
-		unreachable()
-	}
-
-	return false
-}
-
-// representable checks that a constant operand is representable in the given basic type.
-func (check *Checker) representable(x *operand, typ *Basic) {
-	assert(x.mode == constant_)
-	if !representableConst(x.val, check.conf, typ.kind, &x.val) {
-		var msg string
-		if isNumeric(x.typ) && isNumeric(typ) {
-			// numeric conversion : error msg
-			//
-			// integer -> integer : overflows
-			// integer -> float   : overflows (actually not possible)
-			// float   -> integer : truncated
-			// float   -> float   : overflows
-			//
-			if !isInteger(x.typ) && isInteger(typ) {
-				msg = "%s truncated to %s"
-			} else {
-				msg = "%s overflows %s"
-			}
-		} else {
-			msg = "cannot convert %s to %s"
-		}
-		check.errorf(x.pos(), msg, x, typ)
-		x.mode = invalid
-	}
-}
-
-// updateExprType updates the type of x to typ and invokes itself
-// recursively for the operands of x, depending on expression kind.
-// If typ is still an untyped and not the final type, updateExprType
-// only updates the recorded untyped type for x and possibly its
-// operands. Otherwise (i.e., typ is not an untyped type anymore,
-// or it is the final type for x), the type and value are recorded.
-// Also, if x is a constant, it must be representable as a value of typ,
-// and if x is the (formerly untyped) lhs operand of a non-constant
-// shift, it must be an integer value.
-//
-func (check *Checker) updateExprType(x ast.Expr, typ Type, final bool) {
-	old, found := check.untyped[x]
-	if !found {
-		return // nothing to do
-	}
-
-	// update operands of x if necessary
-	switch x := x.(type) {
-	case *ast.BadExpr,
-		*ast.FuncLit,
-		*ast.CompositeLit,
-		*ast.IndexExpr,
-		*ast.SliceExpr,
-		*ast.TypeAssertExpr,
-		*ast.StarExpr,
-		*ast.KeyValueExpr,
-		*ast.ArrayType,
-		*ast.StructType,
-		*ast.FuncType,
-		*ast.InterfaceType,
-		*ast.MapType,
-		*ast.ChanType:
-		// These expression are never untyped - nothing to do.
-		// The respective sub-expressions got their final types
-		// upon assignment or use.
-		if debug {
-			check.dump("%s: found old type(%s): %s (new: %s)", x.Pos(), x, old.typ, typ)
-			unreachable()
-		}
-		return
-
-	case *ast.CallExpr:
-		// Resulting in an untyped constant (e.g., built-in complex).
-		// The respective calls take care of calling updateExprType
-		// for the arguments if necessary.
-
-	case *ast.Ident, *ast.BasicLit, *ast.SelectorExpr:
-		// An identifier denoting a constant, a constant literal,
-		// or a qualified identifier (imported untyped constant).
-		// No operands to take care of.
-
-	case *ast.ParenExpr:
-		check.updateExprType(x.X, typ, final)
-
-	case *ast.UnaryExpr:
-		// If x is a constant, the operands were constants.
-		// They don't need to be updated since they never
-		// get "materialized" into a typed value; and they
-		// will be processed at the end of the type check.
-		if old.val != nil {
-			break
-		}
-		check.updateExprType(x.X, typ, final)
-
-	case *ast.BinaryExpr:
-		if old.val != nil {
-			break // see comment for unary expressions
-		}
-		if isComparison(x.Op) {
-			// The result type is independent of operand types
-			// and the operand types must have final types.
-		} else if isShift(x.Op) {
-			// The result type depends only on lhs operand.
-			// The rhs type was updated when checking the shift.
-			check.updateExprType(x.X, typ, final)
-		} else {
-			// The operand types match the result type.
-			check.updateExprType(x.X, typ, final)
-			check.updateExprType(x.Y, typ, final)
-		}
-
-	default:
-		unreachable()
-	}
-
-	// If the new type is not final and still untyped, just
-	// update the recorded type.
-	if !final && isUntyped(typ) {
-		old.typ = typ.Underlying().(*Basic)
-		check.untyped[x] = old
-		return
-	}
-
-	// Otherwise we have the final (typed or untyped type).
-	// Remove it from the map of yet untyped expressions.
-	delete(check.untyped, x)
-
-	// If x is the lhs of a shift, its final type must be integer.
-	// We already know from the shift check that it is representable
-	// as an integer if it is a constant.
-	if old.isLhs && !isInteger(typ) {
-		check.invalidOp(x.Pos(), "shifted operand %s (type %s) must be integer", x, typ)
-		return
-	}
-
-	// Everything's fine, record final type and value for x.
-	check.recordTypeAndValue(x, old.mode, typ, old.val)
-}
-
-// updateExprVal updates the value of x to val.
-func (check *Checker) updateExprVal(x ast.Expr, val constant.Value) {
-	if info, ok := check.untyped[x]; ok {
-		info.val = val
-		check.untyped[x] = info
-	}
-}
-
-// convertUntyped attempts to set the type of an untyped value to the target type.
-func (check *Checker) convertUntyped(x *operand, target Type) {
-	if x.mode == invalid || isTyped(x.typ) || target == Typ[Invalid] {
-		return
-	}
-
-	// TODO(gri) Sloppy code - clean up. This function is central
-	//           to assignment and expression checking.
-
-	if isUntyped(target) {
-		// both x and target are untyped
-		xkind := x.typ.(*Basic).kind
-		tkind := target.(*Basic).kind
-		if isNumeric(x.typ) && isNumeric(target) {
-			if xkind < tkind {
-				x.typ = target
-				check.updateExprType(x.expr, target, false)
-			}
-		} else if xkind != tkind {
-			goto Error
-		}
-		return
-	}
-
-	// typed target
-	switch t := target.Underlying().(type) {
-	case *Basic:
-		if x.mode == constant_ {
-			check.representable(x, t)
-			if x.mode == invalid {
-				return
-			}
-			// expression value may have been rounded - update if needed
-			// TODO(gri) A floating-point value may silently underflow to
-			// zero. If it was negative, the sign is lost. See issue 6898.
-			check.updateExprVal(x.expr, x.val)
-		} else {
-			// Non-constant untyped values may appear as the
-			// result of comparisons (untyped bool), intermediate
-			// (delayed-checked) rhs operands of shifts, and as
-			// the value nil.
-			switch x.typ.(*Basic).kind {
-			case UntypedBool:
-				if !isBoolean(target) {
-					goto Error
-				}
-			case UntypedInt, UntypedRune, UntypedFloat, UntypedComplex:
-				if !isNumeric(target) {
-					goto Error
-				}
-			case UntypedString:
-				// Non-constant untyped string values are not
-				// permitted by the spec and should not occur.
-				unreachable()
-			case UntypedNil:
-				// Unsafe.Pointer is a basic type that includes nil.
-				if !hasNil(target) {
-					goto Error
-				}
-			default:
-				goto Error
-			}
-		}
-	case *Interface:
-		if !x.isNil() && !t.Empty() /* empty interfaces are ok */ {
-			goto Error
-		}
-		// Update operand types to the default type rather then
-		// the target (interface) type: values must have concrete
-		// dynamic types. If the value is nil, keep it untyped
-		// (this is important for tools such as go vet which need
-		// the dynamic type for argument checking of say, print
-		// functions)
-		if x.isNil() {
-			target = Typ[UntypedNil]
-		} else {
-			// cannot assign untyped values to non-empty interfaces
-			if !t.Empty() {
-				goto Error
-			}
-			target = defaultType(x.typ)
-		}
-	case *Pointer, *Signature, *Slice, *Map, *Chan:
-		if !x.isNil() {
-			goto Error
-		}
-		// keep nil untyped - see comment for interfaces, above
-		target = Typ[UntypedNil]
-	default:
-		goto Error
-	}
-
-	x.typ = target
-	check.updateExprType(x.expr, target, true) // UntypedNils are final
-	return
-
-Error:
-	check.errorf(x.pos(), "cannot convert %s to %s", x, target)
-	x.mode = invalid
-}
-
-func (check *Checker) comparison(x, y *operand, op token.Token) {
-	// spec: "In any comparison, the first operand must be assignable
-	// to the type of the second operand, or vice versa."
-	err := ""
-	if x.assignableTo(check.conf, y.typ) || y.assignableTo(check.conf, x.typ) {
-		defined := false
-		switch op {
-		case token.EQL, token.NEQ:
-			// spec: "The equality operators == and != apply to operands that are comparable."
-			defined = Comparable(x.typ) || x.isNil() && hasNil(y.typ) || y.isNil() && hasNil(x.typ)
-		case token.LSS, token.LEQ, token.GTR, token.GEQ:
-			// spec: The ordering operators <, <=, >, and >= apply to operands that are ordered."
-			defined = isOrdered(x.typ)
-		default:
-			unreachable()
-		}
-		if !defined {
-			typ := x.typ
-			if x.isNil() {
-				typ = y.typ
-			}
-			err = check.sprintf("operator %s not defined for %s", op, typ)
-		}
-	} else {
-		err = check.sprintf("mismatched types %s and %s", x.typ, y.typ)
-	}
-
-	if err != "" {
-		check.errorf(x.pos(), "cannot compare %s %s %s (%s)", x.expr, op, y.expr, err)
-		x.mode = invalid
-		return
-	}
-
-	if x.mode == constant_ && y.mode == constant_ {
-		x.val = constant.MakeBool(constant.Compare(x.val, op, y.val))
-		// The operands are never materialized; no need to update
-		// their types.
-	} else {
-		x.mode = value
-		// The operands have now their final types, which at run-
-		// time will be materialized. Update the expression trees.
-		// If the current types are untyped, the materialized type
-		// is the respective default type.
-		check.updateExprType(x.expr, defaultType(x.typ), true)
-		check.updateExprType(y.expr, defaultType(y.typ), true)
-	}
-
-	// spec: "Comparison operators compare two operands and yield
-	//        an untyped boolean value."
-	x.typ = Typ[UntypedBool]
-}
-
-func (check *Checker) shift(x, y *operand, op token.Token) {
-	untypedx := isUntyped(x.typ)
-
-	// The lhs must be of integer type or be representable
-	// as an integer; otherwise the shift has no chance.
-	if !x.isInteger() {
-		check.invalidOp(x.pos(), "shifted operand %s must be integer", x)
-		x.mode = invalid
-		return
-	}
-
-	// spec: "The right operand in a shift expression must have unsigned
-	// integer type or be an untyped constant that can be converted to
-	// unsigned integer type."
-	switch {
-	case isInteger(y.typ) && isUnsigned(y.typ):
-		// nothing to do
-	case isUntyped(y.typ):
-		check.convertUntyped(y, Typ[UntypedInt])
-		if y.mode == invalid {
-			x.mode = invalid
-			return
-		}
-	default:
-		check.invalidOp(y.pos(), "shift count %s must be unsigned integer", y)
-		x.mode = invalid
-		return
-	}
-
-	if x.mode == constant_ {
-		if y.mode == constant_ {
-			// rhs must be an integer value
-			if !y.isInteger() {
-				check.invalidOp(y.pos(), "shift count %s must be unsigned integer", y)
-				x.mode = invalid
-				return
-			}
-			// rhs must be within reasonable bounds
-			const stupidShift = 1023 - 1 + 52 // so we can express smallestFloat64
-			s, ok := constant.Uint64Val(y.val)
-			if !ok || s > stupidShift {
-				check.invalidOp(y.pos(), "stupid shift count %s", y)
-				x.mode = invalid
-				return
-			}
-			// The lhs is representable as an integer but may not be an integer
-			// (e.g., 2.0, an untyped float) - this can only happen for untyped
-			// non-integer numeric constants. Correct the type so that the shift
-			// result is of integer type.
-			if !isInteger(x.typ) {
-				x.typ = Typ[UntypedInt]
-			}
-			x.val = constant.Shift(x.val, op, uint(s))
-			return
-		}
-
-		// non-constant shift with constant lhs
-		if untypedx {
-			// spec: "If the left operand of a non-constant shift
-			// expression is an untyped constant, the type of the
-			// constant is what it would be if the shift expression
-			// were replaced by its left operand alone.".
-			//
-			// Delay operand checking until we know the final type:
-			// The lhs expression must be in the untyped map, mark
-			// the entry as lhs shift operand.
-			info, found := check.untyped[x.expr]
-			assert(found)
-			info.isLhs = true
-			check.untyped[x.expr] = info
-			// keep x's type
-			x.mode = value
-			return
-		}
-	}
-
-	// constant rhs must be >= 0
-	if y.mode == constant_ && constant.Sign(y.val) < 0 {
-		check.invalidOp(y.pos(), "shift count %s must not be negative", y)
-	}
-
-	// non-constant shift - lhs must be an integer
-	if !isInteger(x.typ) {
-		check.invalidOp(x.pos(), "shifted operand %s must be integer", x)
-		x.mode = invalid
-		return
-	}
-
-	x.mode = value
-}
-
-var binaryOpPredicates = opPredicates{
-	token.ADD: func(typ Type) bool { return isNumeric(typ) || isString(typ) },
-	token.SUB: isNumeric,
-	token.MUL: isNumeric,
-	token.QUO: isNumeric,
-	token.REM: isInteger,
-
-	token.AND:     isInteger,
-	token.OR:      isInteger,
-	token.XOR:     isInteger,
-	token.AND_NOT: isInteger,
-
-	token.LAND: isBoolean,
-	token.LOR:  isBoolean,
-}
-
-// The binary expression e may be nil. It's passed in for better error messages only.
-func (check *Checker) binary(x *operand, e *ast.BinaryExpr, lhs, rhs ast.Expr, op token.Token) {
-	var y operand
-
-	check.expr(x, lhs)
-	check.expr(&y, rhs)
-
-	if x.mode == invalid {
-		return
-	}
-	if y.mode == invalid {
-		x.mode = invalid
-		x.expr = y.expr
-		return
-	}
-
-	if isShift(op) {
-		check.shift(x, &y, op)
-		return
-	}
-
-	check.convertUntyped(x, y.typ)
-	if x.mode == invalid {
-		return
-	}
-	check.convertUntyped(&y, x.typ)
-	if y.mode == invalid {
-		x.mode = invalid
-		return
-	}
-
-	if isComparison(op) {
-		check.comparison(x, &y, op)
-		return
-	}
-
-	if !Identical(x.typ, y.typ) {
-		// only report an error if we have valid types
-		// (otherwise we had an error reported elsewhere already)
-		if x.typ != Typ[Invalid] && y.typ != Typ[Invalid] {
-			check.invalidOp(x.pos(), "mismatched types %s and %s", x.typ, y.typ)
-		}
-		x.mode = invalid
-		return
-	}
-
-	if !check.op(binaryOpPredicates, x, op) {
-		x.mode = invalid
-		return
-	}
-
-	if (op == token.QUO || op == token.REM) && (x.mode == constant_ || isInteger(x.typ)) && y.mode == constant_ && constant.Sign(y.val) == 0 {
-		check.invalidOp(y.pos(), "division by zero")
-		x.mode = invalid
-		return
-	}
-
-	if x.mode == constant_ && y.mode == constant_ {
-		typ := x.typ.Underlying().(*Basic)
-		// force integer division of integer operands
-		if op == token.QUO && isInteger(typ) {
-			op = token.QUO_ASSIGN
-		}
-		x.val = constant.BinaryOp(x.val, op, y.val)
-		// Typed constants must be representable in
-		// their type after each constant operation.
-		if isTyped(typ) {
-			if e != nil {
-				x.expr = e // for better error message
-			}
-			check.representable(x, typ)
-		}
-		return
-	}
-
-	x.mode = value
-	// x.typ is unchanged
-}
-
-// index checks an index expression for validity.
-// If max >= 0, it is the upper bound for index.
-// If index is valid and the result i >= 0, then i is the constant value of index.
-func (check *Checker) index(index ast.Expr, max int64) (i int64, valid bool) {
-	var x operand
-	check.expr(&x, index)
-	if x.mode == invalid {
-		return
-	}
-
-	// an untyped constant must be representable as Int
-	check.convertUntyped(&x, Typ[Int])
-	if x.mode == invalid {
-		return
-	}
-
-	// the index must be of integer type
-	if !isInteger(x.typ) {
-		check.invalidArg(x.pos(), "index %s must be integer", &x)
-		return
-	}
-
-	// a constant index i must be in bounds
-	if x.mode == constant_ {
-		if constant.Sign(x.val) < 0 {
-			check.invalidArg(x.pos(), "index %s must not be negative", &x)
-			return
-		}
-		i, valid = constant.Int64Val(x.val)
-		if !valid || max >= 0 && i >= max {
-			check.errorf(x.pos(), "index %s is out of bounds", &x)
-			return i, false
-		}
-		// 0 <= i [ && i < max ]
-		return i, true
-	}
-
-	return -1, true
-}
-
-// indexElts checks the elements (elts) of an array or slice composite literal
-// against the literal's element type (typ), and the element indices against
-// the literal length if known (length >= 0). It returns the length of the
-// literal (maximum index value + 1).
-//
-func (check *Checker) indexedElts(elts []ast.Expr, typ Type, length int64) int64 {
-	visited := make(map[int64]bool, len(elts))
-	var index, max int64
-	for _, e := range elts {
-		// determine and check index
-		validIndex := false
-		eval := e
-		if kv, _ := e.(*ast.KeyValueExpr); kv != nil {
-			if i, ok := check.index(kv.Key, length); ok {
-				if i >= 0 {
-					index = i
-					validIndex = true
-				} else {
-					check.errorf(e.Pos(), "index %s must be integer constant", kv.Key)
-				}
-			}
-			eval = kv.Value
-		} else if length >= 0 && index >= length {
-			check.errorf(e.Pos(), "index %d is out of bounds (>= %d)", index, length)
-		} else {
-			validIndex = true
-		}
-
-		// if we have a valid index, check for duplicate entries
-		if validIndex {
-			if visited[index] {
-				check.errorf(e.Pos(), "duplicate index %d in array or slice literal", index)
-			}
-			visited[index] = true
-		}
-		index++
-		if index > max {
-			max = index
-		}
-
-		// check element against composite literal element type
-		var x operand
-		check.exprWithHint(&x, eval, typ)
-		if !check.assignment(&x, typ) && x.mode != invalid {
-			check.errorf(x.pos(), "cannot use %s as %s value in array or slice literal", &x, typ)
-		}
-	}
-	return max
-}
-
-// exprKind describes the kind of an expression; the kind
-// determines if an expression is valid in 'statement context'.
-type exprKind int
-
-const (
-	conversion exprKind = iota
-	expression
-	statement
-)
-
-// rawExpr typechecks expression e and initializes x with the expression
-// value or type. If an error occurred, x.mode is set to invalid.
-// If hint != nil, it is the type of a composite literal element.
-//
-func (check *Checker) rawExpr(x *operand, e ast.Expr, hint Type) exprKind {
-	if trace {
-		check.trace(e.Pos(), "%s", e)
-		check.indent++
-		defer func() {
-			check.indent--
-			check.trace(e.Pos(), "=> %s", x)
-		}()
-	}
-
-	kind := check.exprInternal(x, e, hint)
-
-	// convert x into a user-friendly set of values
-	// TODO(gri) this code can be simplified
-	var typ Type
-	var val constant.Value
-	switch x.mode {
-	case invalid:
-		typ = Typ[Invalid]
-	case novalue:
-		typ = (*Tuple)(nil)
-	case constant_:
-		typ = x.typ
-		val = x.val
-	default:
-		typ = x.typ
-	}
-	assert(x.expr != nil && typ != nil)
-
-	if isUntyped(typ) {
-		// delay type and value recording until we know the type
-		// or until the end of type checking
-		check.rememberUntyped(x.expr, false, x.mode, typ.(*Basic), val)
-	} else {
-		check.recordTypeAndValue(e, x.mode, typ, val)
-	}
-
-	return kind
-}
-
-// exprInternal contains the core of type checking of expressions.
-// Must only be called by rawExpr.
-//
-func (check *Checker) exprInternal(x *operand, e ast.Expr, hint Type) exprKind {
-	// make sure x has a valid state in case of bailout
-	// (was issue 5770)
-	x.mode = invalid
-	x.typ = Typ[Invalid]
-
-	switch e := e.(type) {
-	case *ast.BadExpr:
-		goto Error // error was reported before
-
-	case *ast.Ident:
-		check.ident(x, e, nil, nil)
-
-	case *ast.Ellipsis:
-		// ellipses are handled explicitly where they are legal
-		// (array composite literals and parameter lists)
-		check.error(e.Pos(), "invalid use of '...'")
-		goto Error
-
-	case *ast.BasicLit:
-		x.setConst(e.Kind, e.Value)
-		if x.mode == invalid {
-			check.invalidAST(e.Pos(), "invalid literal %v", e.Value)
-			goto Error
-		}
-
-	case *ast.FuncLit:
-		if sig, ok := check.typ(e.Type).(*Signature); ok {
-			// Anonymous functions are considered part of the
-			// init expression/func declaration which contains
-			// them: use existing package-level declaration info.
-			check.funcBody(check.decl, "", sig, e.Body)
-			x.mode = value
-			x.typ = sig
-		} else {
-			check.invalidAST(e.Pos(), "invalid function literal %s", e)
-			goto Error
-		}
-
-	case *ast.CompositeLit:
-		typ := hint
-		openArray := false
-		if e.Type != nil {
-			// [...]T array types may only appear with composite literals.
-			// Check for them here so we don't have to handle ... in general.
-			typ = nil
-			if atyp, _ := e.Type.(*ast.ArrayType); atyp != nil && atyp.Len != nil {
-				if ellip, _ := atyp.Len.(*ast.Ellipsis); ellip != nil && ellip.Elt == nil {
-					// We have an "open" [...]T array type.
-					// Create a new ArrayType with unknown length (-1)
-					// and finish setting it up after analyzing the literal.
-					typ = &Array{len: -1, elem: check.typ(atyp.Elt)}
-					openArray = true
-				}
-			}
-			if typ == nil {
-				typ = check.typ(e.Type)
-			}
-		}
-		if typ == nil {
-			// TODO(gri) provide better error messages depending on context
-			check.error(e.Pos(), "missing type in composite literal")
-			goto Error
-		}
-
-		switch typ, _ := deref(typ); utyp := typ.Underlying().(type) {
-		case *Struct:
-			if len(e.Elts) == 0 {
-				break
-			}
-			fields := utyp.fields
-			if _, ok := e.Elts[0].(*ast.KeyValueExpr); ok {
-				// all elements must have keys
-				visited := make([]bool, len(fields))
-				for _, e := range e.Elts {
-					kv, _ := e.(*ast.KeyValueExpr)
-					if kv == nil {
-						check.error(e.Pos(), "mixture of field:value and value elements in struct literal")
-						continue
-					}
-					key, _ := kv.Key.(*ast.Ident)
-					if key == nil {
-						check.errorf(kv.Pos(), "invalid field name %s in struct literal", kv.Key)
-						continue
-					}
-					i := fieldIndex(utyp.fields, check.pkg, key.Name)
-					if i < 0 {
-						check.errorf(kv.Pos(), "unknown field %s in struct literal", key.Name)
-						continue
-					}
-					fld := fields[i]
-					check.recordUse(key, fld)
-					// 0 <= i < len(fields)
-					if visited[i] {
-						check.errorf(kv.Pos(), "duplicate field name %s in struct literal", key.Name)
-						continue
-					}
-					visited[i] = true
-					check.expr(x, kv.Value)
-					etyp := fld.typ
-					if !check.assignment(x, etyp) {
-						if x.mode != invalid {
-							check.errorf(x.pos(), "cannot use %s as %s value in struct literal", x, etyp)
-						}
-						continue
-					}
-				}
-			} else {
-				// no element must have a key
-				for i, e := range e.Elts {
-					if kv, _ := e.(*ast.KeyValueExpr); kv != nil {
-						check.error(kv.Pos(), "mixture of field:value and value elements in struct literal")
-						continue
-					}
-					check.expr(x, e)
-					if i >= len(fields) {
-						check.error(x.pos(), "too many values in struct literal")
-						break // cannot continue
-					}
-					// i < len(fields)
-					fld := fields[i]
-					if !fld.Exported() && fld.pkg != check.pkg {
-						check.errorf(x.pos(), "implicit assignment to unexported field %s in %s literal", fld.name, typ)
-						continue
-					}
-					etyp := fld.typ
-					if !check.assignment(x, etyp) {
-						if x.mode != invalid {
-							check.errorf(x.pos(), "cannot use %s as %s value in struct literal", x, etyp)
-						}
-						continue
-					}
-				}
-				if len(e.Elts) < len(fields) {
-					check.error(e.Rbrace, "too few values in struct literal")
-					// ok to continue
-				}
-			}
-
-		case *Array:
-			n := check.indexedElts(e.Elts, utyp.elem, utyp.len)
-			// if we have an "open" [...]T array, set the length now that we know it
-			if openArray {
-				utyp.len = n
-			}
-
-		case *Slice:
-			check.indexedElts(e.Elts, utyp.elem, -1)
-
-		case *Map:
-			visited := make(map[interface{}][]Type, len(e.Elts))
-			for _, e := range e.Elts {
-				kv, _ := e.(*ast.KeyValueExpr)
-				if kv == nil {
-					check.error(e.Pos(), "missing key in map literal")
-					continue
-				}
-				check.exprWithHint(x, kv.Key, utyp.key)
-				if !check.assignment(x, utyp.key) {
-					if x.mode != invalid {
-						check.errorf(x.pos(), "cannot use %s as %s key in map literal", x, utyp.key)
-					}
-					continue
-				}
-				if x.mode == constant_ {
-					duplicate := false
-					// if the key is of interface type, the type is also significant when checking for duplicates
-					if _, ok := utyp.key.Underlying().(*Interface); ok {
-						for _, vtyp := range visited[x.val] {
-							if Identical(vtyp, x.typ) {
-								duplicate = true
-								break
-							}
-						}
-						visited[x.val] = append(visited[x.val], x.typ)
-					} else {
-						_, duplicate = visited[x.val]
-						visited[x.val] = nil
-					}
-					if duplicate {
-						check.errorf(x.pos(), "duplicate key %s in map literal", x.val)
-						continue
-					}
-				}
-				check.exprWithHint(x, kv.Value, utyp.elem)
-				if !check.assignment(x, utyp.elem) {
-					if x.mode != invalid {
-						check.errorf(x.pos(), "cannot use %s as %s value in map literal", x, utyp.elem)
-					}
-					continue
-				}
-			}
-
-		default:
-			// if utyp is invalid, an error was reported before
-			if utyp != Typ[Invalid] {
-				check.errorf(e.Pos(), "invalid composite literal type %s", typ)
-				goto Error
-			}
-		}
-
-		x.mode = value
-		x.typ = typ
-
-	case *ast.ParenExpr:
-		kind := check.rawExpr(x, e.X, nil)
-		x.expr = e
-		return kind
-
-	case *ast.SelectorExpr:
-		check.selector(x, e)
-
-	case *ast.IndexExpr:
-		check.expr(x, e.X)
-		if x.mode == invalid {
-			goto Error
-		}
-
-		valid := false
-		length := int64(-1) // valid if >= 0
-		switch typ := x.typ.Underlying().(type) {
-		case *Basic:
-			if isString(typ) {
-				valid = true
-				if x.mode == constant_ {
-					length = int64(len(constant.StringVal(x.val)))
-				}
-				// an indexed string always yields a byte value
-				// (not a constant) even if the string and the
-				// index are constant
-				x.mode = value
-				x.typ = universeByte // use 'byte' name
-			}
-
-		case *Array:
-			valid = true
-			length = typ.len
-			if x.mode != variable {
-				x.mode = value
-			}
-			x.typ = typ.elem
-
-		case *Pointer:
-			if typ, _ := typ.base.Underlying().(*Array); typ != nil {
-				valid = true
-				length = typ.len
-				x.mode = variable
-				x.typ = typ.elem
-			}
-
-		case *Slice:
-			valid = true
-			x.mode = variable
-			x.typ = typ.elem
-
-		case *Map:
-			var key operand
-			check.expr(&key, e.Index)
-			if !check.assignment(&key, typ.key) {
-				if key.mode != invalid {
-					check.invalidOp(key.pos(), "cannot use %s as map index of type %s", &key, typ.key)
-				}
-				goto Error
-			}
-			x.mode = mapindex
-			x.typ = typ.elem
-			x.expr = e
-			return expression
-		}
-
-		if !valid {
-			check.invalidOp(x.pos(), "cannot index %s", x)
-			goto Error
-		}
-
-		if e.Index == nil {
-			check.invalidAST(e.Pos(), "missing index for %s", x)
-			goto Error
-		}
-
-		check.index(e.Index, length)
-		// ok to continue
-
-	case *ast.SliceExpr:
-		check.expr(x, e.X)
-		if x.mode == invalid {
-			goto Error
-		}
-
-		valid := false
-		length := int64(-1) // valid if >= 0
-		switch typ := x.typ.Underlying().(type) {
-		case *Basic:
-			if isString(typ) {
-				if slice3(e) {
-					check.invalidOp(x.pos(), "3-index slice of string")
-					goto Error
-				}
-				valid = true
-				if x.mode == constant_ {
-					length = int64(len(constant.StringVal(x.val)))
-				}
-				// spec: "For untyped string operands the result
-				// is a non-constant value of type string."
-				if typ.kind == UntypedString {
-					x.typ = Typ[String]
-				}
-			}
-
-		case *Array:
-			valid = true
-			length = typ.len
-			if x.mode != variable {
-				check.invalidOp(x.pos(), "cannot slice %s (value not addressable)", x)
-				goto Error
-			}
-			x.typ = &Slice{elem: typ.elem}
-
-		case *Pointer:
-			if typ, _ := typ.base.Underlying().(*Array); typ != nil {
-				valid = true
-				length = typ.len
-				x.typ = &Slice{elem: typ.elem}
-			}
-
-		case *Slice:
-			valid = true
-			// x.typ doesn't change
-		}
-
-		if !valid {
-			check.invalidOp(x.pos(), "cannot slice %s", x)
-			goto Error
-		}
-
-		x.mode = value
-
-		// spec: "Only the first index may be omitted; it defaults to 0."
-		if slice3(e) && (e.High == nil || sliceMax(e) == nil) {
-			check.error(e.Rbrack, "2nd and 3rd index required in 3-index slice")
-			goto Error
-		}
-
-		// check indices
-		var ind [3]int64
-		for i, expr := range []ast.Expr{e.Low, e.High, sliceMax(e)} {
-			x := int64(-1)
-			switch {
-			case expr != nil:
-				// The "capacity" is only known statically for strings, arrays,
-				// and pointers to arrays, and it is the same as the length for
-				// those types.
-				max := int64(-1)
-				if length >= 0 {
-					max = length + 1
-				}
-				if t, ok := check.index(expr, max); ok && t >= 0 {
-					x = t
-				}
-			case i == 0:
-				// default is 0 for the first index
-				x = 0
-			case length >= 0:
-				// default is length (== capacity) otherwise
-				x = length
-			}
-			ind[i] = x
-		}
-
-		// constant indices must be in range
-		// (check.index already checks that existing indices >= 0)
-	L:
-		for i, x := range ind[:len(ind)-1] {
-			if x > 0 {
-				for _, y := range ind[i+1:] {
-					if y >= 0 && x > y {
-						check.errorf(e.Rbrack, "invalid slice indices: %d > %d", x, y)
-						break L // only report one error, ok to continue
-					}
-				}
-			}
-		}
-
-	case *ast.TypeAssertExpr:
-		check.expr(x, e.X)
-		if x.mode == invalid {
-			goto Error
-		}
-		xtyp, _ := x.typ.Underlying().(*Interface)
-		if xtyp == nil {
-			check.invalidOp(x.pos(), "%s is not an interface", x)
-			goto Error
-		}
-		// x.(type) expressions are handled explicitly in type switches
-		if e.Type == nil {
-			check.invalidAST(e.Pos(), "use of .(type) outside type switch")
-			goto Error
-		}
-		T := check.typ(e.Type)
-		if T == Typ[Invalid] {
-			goto Error
-		}
-		check.typeAssertion(x.pos(), x, xtyp, T)
-		x.mode = commaok
-		x.typ = T
-
-	case *ast.CallExpr:
-		return check.call(x, e)
-
-	case *ast.StarExpr:
-		check.exprOrType(x, e.X)
-		switch x.mode {
-		case invalid:
-			goto Error
-		case typexpr:
-			x.typ = &Pointer{base: x.typ}
-		default:
-			if typ, ok := x.typ.Underlying().(*Pointer); ok {
-				x.mode = variable
-				x.typ = typ.base
-			} else {
-				check.invalidOp(x.pos(), "cannot indirect %s", x)
-				goto Error
-			}
-		}
-
-	case *ast.UnaryExpr:
-		check.expr(x, e.X)
-		if x.mode == invalid {
-			goto Error
-		}
-		check.unary(x, e, e.Op)
-		if x.mode == invalid {
-			goto Error
-		}
-		if e.Op == token.ARROW {
-			x.expr = e
-			return statement // receive operations may appear in statement context
-		}
-
-	case *ast.BinaryExpr:
-		check.binary(x, e, e.X, e.Y, e.Op)
-		if x.mode == invalid {
-			goto Error
-		}
-
-	case *ast.KeyValueExpr:
-		// key:value expressions are handled in composite literals
-		check.invalidAST(e.Pos(), "no key:value expected")
-		goto Error
-
-	case *ast.ArrayType, *ast.StructType, *ast.FuncType,
-		*ast.InterfaceType, *ast.MapType, *ast.ChanType:
-		x.mode = typexpr
-		x.typ = check.typ(e)
-		// Note: rawExpr (caller of exprInternal) will call check.recordTypeAndValue
-		// even though check.typ has already called it. This is fine as both
-		// times the same expression and type are recorded. It is also not a
-		// performance issue because we only reach here for composite literal
-		// types, which are comparatively rare.
-
-	default:
-		panic(fmt.Sprintf("%s: unknown expression type %T", check.fset.Position(e.Pos()), e))
-	}
-
-	// everything went well
-	x.expr = e
-	return expression
-
-Error:
-	x.mode = invalid
-	x.expr = e
-	return statement // avoid follow-up errors
-}
-
-// typeAssertion checks that x.(T) is legal; xtyp must be the type of x.
-func (check *Checker) typeAssertion(pos token.Pos, x *operand, xtyp *Interface, T Type) {
-	method, wrongType := assertableTo(xtyp, T)
-	if method == nil {
-		return
-	}
-
-	var msg string
-	if wrongType {
-		msg = "wrong type for method"
-	} else {
-		msg = "missing method"
-	}
-	check.errorf(pos, "%s cannot have dynamic type %s (%s %s)", x, T, msg, method.name)
-}
-
-// expr typechecks expression e and initializes x with the expression value.
-// If an error occurred, x.mode is set to invalid.
-//
-func (check *Checker) expr(x *operand, e ast.Expr) {
-	check.rawExpr(x, e, nil)
-	var msg string
-	switch x.mode {
-	default:
-		return
-	case novalue:
-		msg = "used as value"
-	case builtin:
-		msg = "must be called"
-	case typexpr:
-		msg = "is not an expression"
-	}
-	check.errorf(x.pos(), "%s %s", x, msg)
-	x.mode = invalid
-}
-
-// exprWithHint typechecks expression e and initializes x with the expression value.
-// If an error occurred, x.mode is set to invalid.
-// If hint != nil, it is the type of a composite literal element.
-//
-func (check *Checker) exprWithHint(x *operand, e ast.Expr, hint Type) {
-	assert(hint != nil)
-	check.rawExpr(x, e, hint)
-	var msg string
-	switch x.mode {
-	default:
-		return
-	case novalue:
-		msg = "used as value"
-	case builtin:
-		msg = "must be called"
-	case typexpr:
-		msg = "is not an expression"
-	}
-	check.errorf(x.pos(), "%s %s", x, msg)
-	x.mode = invalid
-}
-
-// exprOrType typechecks expression or type e and initializes x with the expression value or type.
-// If an error occurred, x.mode is set to invalid.
-//
-func (check *Checker) exprOrType(x *operand, e ast.Expr) {
-	check.rawExpr(x, e, nil)
-	if x.mode == novalue {
-		check.errorf(x.pos(), "%s used as value or type", x)
-		x.mode = invalid
-	}
-}
diff --git a/third_party/golang/go/types/exprstring.go b/third_party/golang/go/types/exprstring.go
deleted file mode 100644
index 2e75aae92d8fa..0000000000000
--- a/third_party/golang/go/types/exprstring.go
+++ /dev/null
@@ -1,220 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements printing of expressions.
-
-package types
-
-import (
-	"bytes"
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-)
-
-// ExprString returns the (possibly simplified) string representation for x.
-func ExprString(x ast.Expr) string {
-	var buf bytes.Buffer
-	WriteExpr(&buf, x)
-	return buf.String()
-}
-
-// WriteExpr writes the (possibly simplified) string representation for x to buf.
-func WriteExpr(buf *bytes.Buffer, x ast.Expr) {
-	// The AST preserves source-level parentheses so there is
-	// no need to introduce them here to correct for different
-	// operator precedences. (This assumes that the AST was
-	// generated by a Go parser.)
-
-	switch x := x.(type) {
-	default:
-		buf.WriteString("(bad expr)") // nil, ast.BadExpr, ast.KeyValueExpr
-
-	case *ast.Ident:
-		buf.WriteString(x.Name)
-
-	case *ast.Ellipsis:
-		buf.WriteString("...")
-		if x.Elt != nil {
-			WriteExpr(buf, x.Elt)
-		}
-
-	case *ast.BasicLit:
-		buf.WriteString(x.Value)
-
-	case *ast.FuncLit:
-		buf.WriteByte('(')
-		WriteExpr(buf, x.Type)
-		buf.WriteString(" literal)") // simplified
-
-	case *ast.CompositeLit:
-		buf.WriteByte('(')
-		WriteExpr(buf, x.Type)
-		buf.WriteString(" literal)") // simplified
-
-	case *ast.ParenExpr:
-		buf.WriteByte('(')
-		WriteExpr(buf, x.X)
-		buf.WriteByte(')')
-
-	case *ast.SelectorExpr:
-		WriteExpr(buf, x.X)
-		buf.WriteByte('.')
-		buf.WriteString(x.Sel.Name)
-
-	case *ast.IndexExpr:
-		WriteExpr(buf, x.X)
-		buf.WriteByte('[')
-		WriteExpr(buf, x.Index)
-		buf.WriteByte(']')
-
-	case *ast.SliceExpr:
-		WriteExpr(buf, x.X)
-		buf.WriteByte('[')
-		if x.Low != nil {
-			WriteExpr(buf, x.Low)
-		}
-		buf.WriteByte(':')
-		if x.High != nil {
-			WriteExpr(buf, x.High)
-		}
-		if x.Slice3 {
-			buf.WriteByte(':')
-			if x.Max != nil {
-				WriteExpr(buf, x.Max)
-			}
-		}
-		buf.WriteByte(']')
-
-	case *ast.TypeAssertExpr:
-		WriteExpr(buf, x.X)
-		buf.WriteString(".(")
-		WriteExpr(buf, x.Type)
-		buf.WriteByte(')')
-
-	case *ast.CallExpr:
-		WriteExpr(buf, x.Fun)
-		buf.WriteByte('(')
-		for i, arg := range x.Args {
-			if i > 0 {
-				buf.WriteString(", ")
-			}
-			WriteExpr(buf, arg)
-		}
-		if x.Ellipsis.IsValid() {
-			buf.WriteString("...")
-		}
-		buf.WriteByte(')')
-
-	case *ast.StarExpr:
-		buf.WriteByte('*')
-		WriteExpr(buf, x.X)
-
-	case *ast.UnaryExpr:
-		buf.WriteString(x.Op.String())
-		WriteExpr(buf, x.X)
-
-	case *ast.BinaryExpr:
-		WriteExpr(buf, x.X)
-		buf.WriteByte(' ')
-		buf.WriteString(x.Op.String())
-		buf.WriteByte(' ')
-		WriteExpr(buf, x.Y)
-
-	case *ast.ArrayType:
-		buf.WriteByte('[')
-		if x.Len != nil {
-			WriteExpr(buf, x.Len)
-		}
-		buf.WriteByte(']')
-		WriteExpr(buf, x.Elt)
-
-	case *ast.StructType:
-		buf.WriteString("struct{")
-		writeFieldList(buf, x.Fields, "; ", false)
-		buf.WriteByte('}')
-
-	case *ast.FuncType:
-		buf.WriteString("func")
-		writeSigExpr(buf, x)
-
-	case *ast.InterfaceType:
-		buf.WriteString("interface{")
-		writeFieldList(buf, x.Methods, "; ", true)
-		buf.WriteByte('}')
-
-	case *ast.MapType:
-		buf.WriteString("map[")
-		WriteExpr(buf, x.Key)
-		buf.WriteByte(']')
-		WriteExpr(buf, x.Value)
-
-	case *ast.ChanType:
-		var s string
-		switch x.Dir {
-		case ast.SEND:
-			s = "chan<- "
-		case ast.RECV:
-			s = "<-chan "
-		default:
-			s = "chan "
-		}
-		buf.WriteString(s)
-		WriteExpr(buf, x.Value)
-	}
-}
-
-func writeSigExpr(buf *bytes.Buffer, sig *ast.FuncType) {
-	buf.WriteByte('(')
-	writeFieldList(buf, sig.Params, ", ", false)
-	buf.WriteByte(')')
-
-	res := sig.Results
-	n := res.NumFields()
-	if n == 0 {
-		// no result
-		return
-	}
-
-	buf.WriteByte(' ')
-	if n == 1 && len(res.List[0].Names) == 0 {
-		// single unnamed result
-		WriteExpr(buf, res.List[0].Type)
-		return
-	}
-
-	// multiple or named result(s)
-	buf.WriteByte('(')
-	writeFieldList(buf, res, ", ", false)
-	buf.WriteByte(')')
-}
-
-func writeFieldList(buf *bytes.Buffer, fields *ast.FieldList, sep string, iface bool) {
-	for i, f := range fields.List {
-		if i > 0 {
-			buf.WriteString(sep)
-		}
-
-		// field list names
-		for i, name := range f.Names {
-			if i > 0 {
-				buf.WriteString(", ")
-			}
-			buf.WriteString(name.Name)
-		}
-
-		// types of interface methods consist of signatures only
-		if sig, _ := f.Type.(*ast.FuncType); sig != nil && iface {
-			writeSigExpr(buf, sig)
-			continue
-		}
-
-		// named fields are separated with a blank from the field type
-		if len(f.Names) > 0 {
-			buf.WriteByte(' ')
-		}
-
-		WriteExpr(buf, f.Type)
-
-		// ignore tag
-	}
-}
diff --git a/third_party/golang/go/types/go11.go b/third_party/golang/go/types/go11.go
deleted file mode 100644
index ee509f034d410..0000000000000
--- a/third_party/golang/go/types/go11.go
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright 2013 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build !go1.2
-
-package types
-
-import "k8s.io/kubernetes/third_party/golang/go/ast"
-
-func slice3(x *ast.SliceExpr) bool {
-	return false
-}
-
-func sliceMax(x *ast.SliceExpr) ast.Expr {
-	return nil
-}
diff --git a/third_party/golang/go/types/go12.go b/third_party/golang/go/types/go12.go
deleted file mode 100644
index 03f1b39790efc..0000000000000
--- a/third_party/golang/go/types/go12.go
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright 2013 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build go1.2
-
-package types
-
-import "k8s.io/kubernetes/third_party/golang/go/ast"
-
-func slice3(x *ast.SliceExpr) bool {
-	return x.Slice3
-}
-
-func sliceMax(x *ast.SliceExpr) ast.Expr {
-	return x.Max
-}
diff --git a/third_party/golang/go/types/initorder.go b/third_party/golang/go/types/initorder.go
deleted file mode 100644
index 0fd567b26910e..0000000000000
--- a/third_party/golang/go/types/initorder.go
+++ /dev/null
@@ -1,222 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package types
-
-import (
-	"container/heap"
-	"fmt"
-)
-
-// initOrder computes the Info.InitOrder for package variables.
-func (check *Checker) initOrder() {
-	// An InitOrder may already have been computed if a package is
-	// built from several calls to (*Checker).Files.  Clear it.
-	check.Info.InitOrder = check.Info.InitOrder[:0]
-
-	// compute the object dependency graph and
-	// initialize a priority queue with the list
-	// of graph nodes
-	pq := nodeQueue(dependencyGraph(check.objMap))
-	heap.Init(&pq)
-
-	const debug = false
-	if debug {
-		fmt.Printf("package %s: object dependency graph\n", check.pkg.Name())
-		for _, n := range pq {
-			for _, o := range n.out {
-				fmt.Printf("\t%s -> %s\n", n.obj.Name(), o.obj.Name())
-			}
-		}
-		fmt.Println()
-		fmt.Printf("package %s: initialization order\n", check.pkg.Name())
-	}
-
-	// determine initialization order by removing the highest priority node
-	// (the one with the fewest dependencies) and its edges from the graph,
-	// repeatedly, until there are no nodes left.
-	// In a valid Go program, those nodes always have zero dependencies (after
-	// removing all incoming dependencies), otherwise there are initialization
-	// cycles.
-	mark := 0
-	emitted := make(map[*declInfo]bool)
-	for len(pq) > 0 {
-		// get the next node
-		n := heap.Pop(&pq).(*objNode)
-
-		// if n still depends on other nodes, we have a cycle
-		if n.in > 0 {
-			mark++ // mark nodes using a different value each time
-			cycle := findPath(n, n, mark)
-			if i := valIndex(cycle); i >= 0 {
-				check.reportCycle(cycle, i)
-			}
-			// ok to continue, but the variable initialization order
-			// will be incorrect at this point since it assumes no
-			// cycle errors
-		}
-
-		// reduce dependency count of all dependent nodes
-		// and update priority queue
-		for _, out := range n.out {
-			out.in--
-			heap.Fix(&pq, out.index)
-		}
-
-		// record the init order for variables with initializers only
-		v, _ := n.obj.(*Var)
-		info := check.objMap[v]
-		if v == nil || !info.hasInitializer() {
-			continue
-		}
-
-		// n:1 variable declarations such as: a, b = f()
-		// introduce a node for each lhs variable (here: a, b);
-		// but they all have the same initializer - emit only
-		// one, for the first variable seen
-		if emitted[info] {
-			continue // initializer already emitted, if any
-		}
-		emitted[info] = true
-
-		infoLhs := info.lhs // possibly nil (see declInfo.lhs field comment)
-		if infoLhs == nil {
-			infoLhs = []*Var{v}
-		}
-		init := &Initializer{infoLhs, info.init}
-		check.Info.InitOrder = append(check.Info.InitOrder, init)
-
-		if debug {
-			fmt.Printf("\t%s\n", init)
-		}
-	}
-
-	if debug {
-		fmt.Println()
-	}
-}
-
-// findPath returns the (reversed) list of nodes z, ... c, b, a,
-// such that there is a path (list of edges) from a to z.
-// If there is no such path, the result is nil.
-// Nodes marked with the value mark are considered "visited";
-// unvisited nodes are marked during the graph search.
-func findPath(a, z *objNode, mark int) []*objNode {
-	if a.mark == mark {
-		return nil // node already seen
-	}
-	a.mark = mark
-
-	for _, n := range a.out {
-		if n == z {
-			return []*objNode{z}
-		}
-		if P := findPath(n, z, mark); P != nil {
-			return append(P, n)
-		}
-	}
-
-	return nil
-}
-
-// valIndex returns the index of the first constant or variable in a,
-// if any; or a value < 0.
-func valIndex(a []*objNode) int {
-	for i, n := range a {
-		switch n.obj.(type) {
-		case *Const, *Var:
-			return i
-		}
-	}
-	return -1
-}
-
-// reportCycle reports an error for the cycle starting at i.
-func (check *Checker) reportCycle(cycle []*objNode, i int) {
-	obj := cycle[i].obj
-	check.errorf(obj.Pos(), "initialization cycle for %s", obj.Name())
-	// print cycle
-	for _ = range cycle {
-		check.errorf(obj.Pos(), "\t%s refers to", obj.Name()) // secondary error, \t indented
-		i++
-		if i >= len(cycle) {
-			i = 0
-		}
-		obj = cycle[i].obj
-	}
-	check.errorf(obj.Pos(), "\t%s", obj.Name())
-}
-
-// An objNode represents a node in the object dependency graph.
-// Each node b in a.out represents an edge a->b indicating that
-// b depends on a.
-// Nodes may be marked for cycle detection. A node n is marked
-// if n.mark corresponds to the current mark value.
-type objNode struct {
-	obj   Object     // object represented by this node
-	in    int        // number of nodes this node depends on
-	out   []*objNode // list of nodes that depend on this node
-	index int        // node index in list of nodes
-	mark  int        // for cycle detection
-}
-
-// dependencyGraph computes the transposed object dependency graph
-// from the given objMap. The transposed graph is returned as a list
-// of nodes; an edge d->n indicates that node n depends on node d.
-func dependencyGraph(objMap map[Object]*declInfo) []*objNode {
-	// M maps each object to its corresponding node
-	M := make(map[Object]*objNode, len(objMap))
-	for obj := range objMap {
-		M[obj] = &objNode{obj: obj}
-	}
-
-	// G is the graph of nodes n
-	G := make([]*objNode, len(M))
-	i := 0
-	for obj, n := range M {
-		deps := objMap[obj].deps
-		n.in = len(deps)
-		for d := range deps {
-			d := M[d]                // node n depends on node d
-			d.out = append(d.out, n) // add edge d->n
-		}
-
-		G[i] = n
-		n.index = i
-		i++
-	}
-
-	return G
-}
-
-// nodeQueue implements the container/heap interface;
-// a nodeQueue may be used as a priority queue.
-type nodeQueue []*objNode
-
-func (a nodeQueue) Len() int { return len(a) }
-
-func (a nodeQueue) Swap(i, j int) {
-	x, y := a[i], a[j]
-	a[i], a[j] = y, x
-	x.index, y.index = j, i
-}
-
-func (a nodeQueue) Less(i, j int) bool {
-	x, y := a[i], a[j]
-	// nodes are prioritized by number of incoming dependencies (1st key)
-	// and source order (2nd key)
-	return x.in < y.in || x.in == y.in && x.obj.order() < y.obj.order()
-}
-
-func (a *nodeQueue) Push(x interface{}) {
-	panic("unreachable")
-}
-
-func (a *nodeQueue) Pop() interface{} {
-	n := len(*a)
-	x := (*a)[n-1]
-	x.index = -1 // for safety
-	*a = (*a)[:n-1]
-	return x
-}
diff --git a/third_party/golang/go/types/labels.go b/third_party/golang/go/types/labels.go
deleted file mode 100644
index 651b61242de3c..0000000000000
--- a/third_party/golang/go/types/labels.go
+++ /dev/null
@@ -1,268 +0,0 @@
-// Copyright 2013 The Go Authors.  All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package types
-
-import (
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-)
-
-// labels checks correct label use in body.
-func (check *Checker) labels(body *ast.BlockStmt) {
-	// set of all labels in this body
-	all := NewScope(nil, body.Pos(), body.End(), "label")
-
-	fwdJumps := check.blockBranches(all, nil, nil, body.List)
-
-	// If there are any forward jumps left, no label was found for
-	// the corresponding goto statements. Either those labels were
-	// never defined, or they are inside blocks and not reachable
-	// for the respective gotos.
-	for _, jmp := range fwdJumps {
-		var msg string
-		name := jmp.Label.Name
-		if alt := all.Lookup(name); alt != nil {
-			msg = "goto %s jumps into block"
-			alt.(*Label).used = true // avoid another error
-		} else {
-			msg = "label %s not declared"
-		}
-		check.errorf(jmp.Label.Pos(), msg, name)
-	}
-
-	// spec: "It is illegal to define a label that is never used."
-	for _, obj := range all.elems {
-		if lbl := obj.(*Label); !lbl.used {
-			check.softErrorf(lbl.pos, "label %s declared but not used", lbl.name)
-		}
-	}
-}
-
-// A block tracks label declarations in a block and its enclosing blocks.
-type block struct {
-	parent *block                      // enclosing block
-	lstmt  *ast.LabeledStmt            // labeled statement to which this block belongs, or nil
-	labels map[string]*ast.LabeledStmt // allocated lazily
-}
-
-// insert records a new label declaration for the current block.
-// The label must not have been declared before in any block.
-func (b *block) insert(s *ast.LabeledStmt) {
-	name := s.Label.Name
-	if debug {
-		assert(b.gotoTarget(name) == nil)
-	}
-	labels := b.labels
-	if labels == nil {
-		labels = make(map[string]*ast.LabeledStmt)
-		b.labels = labels
-	}
-	labels[name] = s
-}
-
-// gotoTarget returns the labeled statement in the current
-// or an enclosing block with the given label name, or nil.
-func (b *block) gotoTarget(name string) *ast.LabeledStmt {
-	for s := b; s != nil; s = s.parent {
-		if t := s.labels[name]; t != nil {
-			return t
-		}
-	}
-	return nil
-}
-
-// enclosingTarget returns the innermost enclosing labeled
-// statement with the given label name, or nil.
-func (b *block) enclosingTarget(name string) *ast.LabeledStmt {
-	for s := b; s != nil; s = s.parent {
-		if t := s.lstmt; t != nil && t.Label.Name == name {
-			return t
-		}
-	}
-	return nil
-}
-
-// blockBranches processes a block's statement list and returns the set of outgoing forward jumps.
-// all is the scope of all declared labels, parent the set of labels declared in the immediately
-// enclosing block, and lstmt is the labeled statement this block is associated with (or nil).
-func (check *Checker) blockBranches(all *Scope, parent *block, lstmt *ast.LabeledStmt, list []ast.Stmt) []*ast.BranchStmt {
-	b := &block{parent: parent, lstmt: lstmt}
-
-	var (
-		varDeclPos         token.Pos
-		fwdJumps, badJumps []*ast.BranchStmt
-	)
-
-	// All forward jumps jumping over a variable declaration are possibly
-	// invalid (they may still jump out of the block and be ok).
-	// recordVarDecl records them for the given position.
-	recordVarDecl := func(pos token.Pos) {
-		varDeclPos = pos
-		badJumps = append(badJumps[:0], fwdJumps...) // copy fwdJumps to badJumps
-	}
-
-	jumpsOverVarDecl := func(jmp *ast.BranchStmt) bool {
-		if varDeclPos.IsValid() {
-			for _, bad := range badJumps {
-				if jmp == bad {
-					return true
-				}
-			}
-		}
-		return false
-	}
-
-	blockBranches := func(lstmt *ast.LabeledStmt, list []ast.Stmt) {
-		// Unresolved forward jumps inside the nested block
-		// become forward jumps in the current block.
-		fwdJumps = append(fwdJumps, check.blockBranches(all, b, lstmt, list)...)
-	}
-
-	var stmtBranches func(ast.Stmt)
-	stmtBranches = func(s ast.Stmt) {
-		switch s := s.(type) {
-		case *ast.DeclStmt:
-			if d, _ := s.Decl.(*ast.GenDecl); d != nil && d.Tok == token.VAR {
-				recordVarDecl(d.Pos())
-			}
-
-		case *ast.LabeledStmt:
-			// declare non-blank label
-			if name := s.Label.Name; name != "_" {
-				lbl := NewLabel(s.Label.Pos(), check.pkg, name)
-				if alt := all.Insert(lbl); alt != nil {
-					check.softErrorf(lbl.pos, "label %s already declared", name)
-					check.reportAltDecl(alt)
-					// ok to continue
-				} else {
-					b.insert(s)
-					check.recordDef(s.Label, lbl)
-				}
-				// resolve matching forward jumps and remove them from fwdJumps
-				i := 0
-				for _, jmp := range fwdJumps {
-					if jmp.Label.Name == name {
-						// match
-						lbl.used = true
-						check.recordUse(jmp.Label, lbl)
-						if jumpsOverVarDecl(jmp) {
-							check.softErrorf(
-								jmp.Label.Pos(),
-								"goto %s jumps over variable declaration at line %d",
-								name,
-								check.fset.Position(varDeclPos).Line,
-							)
-							// ok to continue
-						}
-					} else {
-						// no match - record new forward jump
-						fwdJumps[i] = jmp
-						i++
-					}
-				}
-				fwdJumps = fwdJumps[:i]
-				lstmt = s
-			}
-			stmtBranches(s.Stmt)
-
-		case *ast.BranchStmt:
-			if s.Label == nil {
-				return // checked in 1st pass (check.stmt)
-			}
-
-			// determine and validate target
-			name := s.Label.Name
-			switch s.Tok {
-			case token.BREAK:
-				// spec: "If there is a label, it must be that of an enclosing
-				// "for", "switch", or "select" statement, and that is the one
-				// whose execution terminates."
-				valid := false
-				if t := b.enclosingTarget(name); t != nil {
-					switch t.Stmt.(type) {
-					case *ast.SwitchStmt, *ast.TypeSwitchStmt, *ast.SelectStmt, *ast.ForStmt, *ast.RangeStmt:
-						valid = true
-					}
-				}
-				if !valid {
-					check.errorf(s.Label.Pos(), "invalid break label %s", name)
-					return
-				}
-
-			case token.CONTINUE:
-				// spec: "If there is a label, it must be that of an enclosing
-				// "for" statement, and that is the one whose execution advances."
-				valid := false
-				if t := b.enclosingTarget(name); t != nil {
-					switch t.Stmt.(type) {
-					case *ast.ForStmt, *ast.RangeStmt:
-						valid = true
-					}
-				}
-				if !valid {
-					check.errorf(s.Label.Pos(), "invalid continue label %s", name)
-					return
-				}
-
-			case token.GOTO:
-				if b.gotoTarget(name) == nil {
-					// label may be declared later - add branch to forward jumps
-					fwdJumps = append(fwdJumps, s)
-					return
-				}
-
-			default:
-				check.invalidAST(s.Pos(), "branch statement: %s %s", s.Tok, name)
-				return
-			}
-
-			// record label use
-			obj := all.Lookup(name)
-			obj.(*Label).used = true
-			check.recordUse(s.Label, obj)
-
-		case *ast.AssignStmt:
-			if s.Tok == token.DEFINE {
-				recordVarDecl(s.Pos())
-			}
-
-		case *ast.BlockStmt:
-			blockBranches(lstmt, s.List)
-
-		case *ast.IfStmt:
-			stmtBranches(s.Body)
-			if s.Else != nil {
-				stmtBranches(s.Else)
-			}
-
-		case *ast.CaseClause:
-			blockBranches(nil, s.Body)
-
-		case *ast.SwitchStmt:
-			stmtBranches(s.Body)
-
-		case *ast.TypeSwitchStmt:
-			stmtBranches(s.Body)
-
-		case *ast.CommClause:
-			blockBranches(nil, s.Body)
-
-		case *ast.SelectStmt:
-			stmtBranches(s.Body)
-
-		case *ast.ForStmt:
-			stmtBranches(s.Body)
-
-		case *ast.RangeStmt:
-			stmtBranches(s.Body)
-		}
-	}
-
-	for _, s := range list {
-		stmtBranches(s)
-	}
-
-	return fwdJumps
-}
diff --git a/third_party/golang/go/types/lookup.go b/third_party/golang/go/types/lookup.go
deleted file mode 100644
index 3caca5519b63c..0000000000000
--- a/third_party/golang/go/types/lookup.go
+++ /dev/null
@@ -1,341 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements various field and method lookup functions.
-
-package types
-
-// LookupFieldOrMethod looks up a field or method with given package and name
-// in T and returns the corresponding *Var or *Func, an index sequence, and a
-// bool indicating if there were any pointer indirections on the path to the
-// field or method. If addressable is set, T is the type of an addressable
-// variable (only matters for method lookups).
-//
-// The last index entry is the field or method index in the (possibly embedded)
-// type where the entry was found, either:
-//
-//	1) the list of declared methods of a named type; or
-//	2) the list of all methods (method set) of an interface type; or
-//	3) the list of fields of a struct type.
-//
-// The earlier index entries are the indices of the anonymous struct fields
-// traversed to get to the found entry, starting at depth 0.
-//
-// If no entry is found, a nil object is returned. In this case, the returned
-// index and indirect values have the following meaning:
-//
-//	- If index != nil, the index sequence points to an ambiguous entry
-//	(the same name appeared more than once at the same embedding level).
-//
-//	- If indirect is set, a method with a pointer receiver type was found
-//      but there was no pointer on the path from the actual receiver type to
-//	the method's formal receiver base type, nor was the receiver addressable.
-//
-func LookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (obj Object, index []int, indirect bool) {
-	// Methods cannot be associated to a named pointer type
-	// (spec: "The type denoted by T is called the receiver base type;
-	// it must not be a pointer or interface type and it must be declared
-	// in the same package as the method.").
-	// Thus, if we have a named pointer type, proceed with the underlying
-	// pointer type but discard the result if it is a method since we would
-	// not have found it for T (see also issue 8590).
-	if t, _ := T.(*Named); t != nil {
-		if p, _ := t.underlying.(*Pointer); p != nil {
-			obj, index, indirect = lookupFieldOrMethod(p, false, pkg, name)
-			if _, ok := obj.(*Func); ok {
-				return nil, nil, false
-			}
-			return
-		}
-	}
-
-	return lookupFieldOrMethod(T, addressable, pkg, name)
-}
-
-// TODO(gri) The named type consolidation and seen maps below must be
-//           indexed by unique keys for a given type. Verify that named
-//           types always have only one representation (even when imported
-//           indirectly via different packages.)
-
-func lookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (obj Object, index []int, indirect bool) {
-	// WARNING: The code in this function is extremely subtle - do not modify casually!
-	//          This function and NewMethodSet should be kept in sync.
-
-	if name == "_" {
-		return // blank fields/methods are never found
-	}
-
-	typ, isPtr := deref(T)
-	named, _ := typ.(*Named)
-
-	// *typ where typ is an interface has no methods.
-	if isPtr {
-		utyp := typ
-		if named != nil {
-			utyp = named.underlying
-		}
-		if _, ok := utyp.(*Interface); ok {
-			return
-		}
-	}
-
-	// Start with typ as single entry at shallowest depth.
-	// If typ is not a named type, insert a nil type instead.
-	current := []embeddedType{{named, nil, isPtr, false}}
-
-	// named types that we have seen already, allocated lazily
-	var seen map[*Named]bool
-
-	// search current depth
-	for len(current) > 0 {
-		var next []embeddedType // embedded types found at current depth
-
-		// look for (pkg, name) in all types at current depth
-		for _, e := range current {
-			// The very first time only, e.typ may be nil.
-			// In this case, we don't have a named type and
-			// we simply continue with the underlying type.
-			if e.typ != nil {
-				if seen[e.typ] {
-					// We have seen this type before, at a more shallow depth
-					// (note that multiples of this type at the current depth
-					// were consolidated before). The type at that depth shadows
-					// this same type at the current depth, so we can ignore
-					// this one.
-					continue
-				}
-				if seen == nil {
-					seen = make(map[*Named]bool)
-				}
-				seen[e.typ] = true
-
-				// look for a matching attached method
-				if i, m := lookupMethod(e.typ.methods, pkg, name); m != nil {
-					// potential match
-					assert(m.typ != nil)
-					index = concat(e.index, i)
-					if obj != nil || e.multiples {
-						return nil, index, false // collision
-					}
-					obj = m
-					indirect = e.indirect
-					continue // we can't have a matching field or interface method
-				}
-
-				// continue with underlying type
-				typ = e.typ.underlying
-			}
-
-			switch t := typ.(type) {
-			case *Struct:
-				// look for a matching field and collect embedded types
-				for i, f := range t.fields {
-					if f.sameId(pkg, name) {
-						assert(f.typ != nil)
-						index = concat(e.index, i)
-						if obj != nil || e.multiples {
-							return nil, index, false // collision
-						}
-						obj = f
-						indirect = e.indirect
-						continue // we can't have a matching interface method
-					}
-					// Collect embedded struct fields for searching the next
-					// lower depth, but only if we have not seen a match yet
-					// (if we have a match it is either the desired field or
-					// we have a name collision on the same depth; in either
-					// case we don't need to look further).
-					// Embedded fields are always of the form T or *T where
-					// T is a named type. If e.typ appeared multiple times at
-					// this depth, f.typ appears multiple times at the next
-					// depth.
-					if obj == nil && f.anonymous {
-						// Ignore embedded basic types - only user-defined
-						// named types can have methods or struct fields.
-						typ, isPtr := deref(f.typ)
-						if t, _ := typ.(*Named); t != nil {
-							next = append(next, embeddedType{t, concat(e.index, i), e.indirect || isPtr, e.multiples})
-						}
-					}
-				}
-
-			case *Interface:
-				// look for a matching method
-				// TODO(gri) t.allMethods is sorted - use binary search
-				if i, m := lookupMethod(t.allMethods, pkg, name); m != nil {
-					assert(m.typ != nil)
-					index = concat(e.index, i)
-					if obj != nil || e.multiples {
-						return nil, index, false // collision
-					}
-					obj = m
-					indirect = e.indirect
-				}
-			}
-		}
-
-		if obj != nil {
-			// found a potential match
-			// spec: "A method call x.m() is valid if the method set of (the type of) x
-			//        contains m and the argument list can be assigned to the parameter
-			//        list of m. If x is addressable and &x's method set contains m, x.m()
-			//        is shorthand for (&x).m()".
-			if f, _ := obj.(*Func); f != nil && ptrRecv(f) && !indirect && !addressable {
-				return nil, nil, true // pointer/addressable receiver required
-			}
-			return
-		}
-
-		current = consolidateMultiples(next)
-	}
-
-	return nil, nil, false // not found
-}
-
-// embeddedType represents an embedded named type
-type embeddedType struct {
-	typ       *Named // nil means use the outer typ variable instead
-	index     []int  // embedded field indices, starting with index at depth 0
-	indirect  bool   // if set, there was a pointer indirection on the path to this field
-	multiples bool   // if set, typ appears multiple times at this depth
-}
-
-// consolidateMultiples collects multiple list entries with the same type
-// into a single entry marked as containing multiples. The result is the
-// consolidated list.
-func consolidateMultiples(list []embeddedType) []embeddedType {
-	if len(list) <= 1 {
-		return list // at most one entry - nothing to do
-	}
-
-	n := 0                       // number of entries w/ unique type
-	prev := make(map[*Named]int) // index at which type was previously seen
-	for _, e := range list {
-		if i, found := prev[e.typ]; found {
-			list[i].multiples = true
-			// ignore this entry
-		} else {
-			prev[e.typ] = n
-			list[n] = e
-			n++
-		}
-	}
-	return list[:n]
-}
-
-// MissingMethod returns (nil, false) if V implements T, otherwise it
-// returns a missing method required by T and whether it is missing or
-// just has the wrong type.
-//
-// For non-interface types V, or if static is set, V implements T if all
-// methods of T are present in V. Otherwise (V is an interface and static
-// is not set), MissingMethod only checks that methods of T which are also
-// present in V have matching types (e.g., for a type assertion x.(T) where
-// x is of interface type V).
-//
-func MissingMethod(V Type, T *Interface, static bool) (method *Func, wrongType bool) {
-	// fast path for common case
-	if T.Empty() {
-		return
-	}
-
-	// TODO(gri) Consider using method sets here. Might be more efficient.
-
-	if ityp, _ := V.Underlying().(*Interface); ityp != nil {
-		// TODO(gri) allMethods is sorted - can do this more efficiently
-		for _, m := range T.allMethods {
-			_, obj := lookupMethod(ityp.allMethods, m.pkg, m.name)
-			switch {
-			case obj == nil:
-				if static {
-					return m, false
-				}
-			case !Identical(obj.Type(), m.typ):
-				return m, true
-			}
-		}
-		return
-	}
-
-	// A concrete type implements T if it implements all methods of T.
-	for _, m := range T.allMethods {
-		obj, _, _ := lookupFieldOrMethod(V, false, m.pkg, m.name)
-
-		f, _ := obj.(*Func)
-		if f == nil {
-			return m, false
-		}
-
-		if !Identical(f.typ, m.typ) {
-			return m, true
-		}
-	}
-
-	return
-}
-
-// assertableTo reports whether a value of type V can be asserted to have type T.
-// It returns (nil, false) as affirmative answer. Otherwise it returns a missing
-// method required by V and whether it is missing or just has the wrong type.
-func assertableTo(V *Interface, T Type) (method *Func, wrongType bool) {
-	// no static check is required if T is an interface
-	// spec: "If T is an interface type, x.(T) asserts that the
-	//        dynamic type of x implements the interface T."
-	if _, ok := T.Underlying().(*Interface); ok && !strict {
-		return
-	}
-	return MissingMethod(T, V, false)
-}
-
-// deref dereferences typ if it is a *Pointer and returns its base and true.
-// Otherwise it returns (typ, false).
-func deref(typ Type) (Type, bool) {
-	if p, _ := typ.(*Pointer); p != nil {
-		return p.base, true
-	}
-	return typ, false
-}
-
-// derefStructPtr dereferences typ if it is a (named or unnamed) pointer to a
-// (named or unnamed) struct and returns its base. Otherwise it returns typ.
-func derefStructPtr(typ Type) Type {
-	if p, _ := typ.Underlying().(*Pointer); p != nil {
-		if _, ok := p.base.Underlying().(*Struct); ok {
-			return p.base
-		}
-	}
-	return typ
-}
-
-// concat returns the result of concatenating list and i.
-// The result does not share its underlying array with list.
-func concat(list []int, i int) []int {
-	var t []int
-	t = append(t, list...)
-	return append(t, i)
-}
-
-// fieldIndex returns the index for the field with matching package and name, or a value < 0.
-func fieldIndex(fields []*Var, pkg *Package, name string) int {
-	if name != "_" {
-		for i, f := range fields {
-			if f.sameId(pkg, name) {
-				return i
-			}
-		}
-	}
-	return -1
-}
-
-// lookupMethod returns the index of and method with matching package and name, or (-1, nil).
-func lookupMethod(methods []*Func, pkg *Package, name string) (int, *Func) {
-	if name != "_" {
-		for i, m := range methods {
-			if m.sameId(pkg, name) {
-				return i, m
-			}
-		}
-	}
-	return -1, nil
-}
diff --git a/third_party/golang/go/types/methodset.go b/third_party/golang/go/types/methodset.go
deleted file mode 100644
index b27f2dac34a25..0000000000000
--- a/third_party/golang/go/types/methodset.go
+++ /dev/null
@@ -1,268 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements method sets.
-
-package types
-
-import (
-	"bytes"
-	"fmt"
-	"sort"
-)
-
-// A MethodSet is an ordered set of concrete or abstract (interface) methods;
-// a method is a MethodVal selection, and they are ordered by ascending m.Obj().Id().
-// The zero value for a MethodSet is a ready-to-use empty method set.
-type MethodSet struct {
-	list []*Selection
-}
-
-func (s *MethodSet) String() string {
-	if s.Len() == 0 {
-		return "MethodSet {}"
-	}
-
-	var buf bytes.Buffer
-	fmt.Fprintln(&buf, "MethodSet {")
-	for _, f := range s.list {
-		fmt.Fprintf(&buf, "\t%s\n", f)
-	}
-	fmt.Fprintln(&buf, "}")
-	return buf.String()
-}
-
-// Len returns the number of methods in s.
-func (s *MethodSet) Len() int { return len(s.list) }
-
-// At returns the i'th method in s for 0 <= i < s.Len().
-func (s *MethodSet) At(i int) *Selection { return s.list[i] }
-
-// Lookup returns the method with matching package and name, or nil if not found.
-func (s *MethodSet) Lookup(pkg *Package, name string) *Selection {
-	if s.Len() == 0 {
-		return nil
-	}
-
-	key := Id(pkg, name)
-	i := sort.Search(len(s.list), func(i int) bool {
-		m := s.list[i]
-		return m.obj.Id() >= key
-	})
-	if i < len(s.list) {
-		m := s.list[i]
-		if m.obj.Id() == key {
-			return m
-		}
-	}
-	return nil
-}
-
-// Shared empty method set.
-var emptyMethodSet MethodSet
-
-// NewMethodSet returns the method set for the given type T.
-// It always returns a non-nil method set, even if it is empty.
-func NewMethodSet(T Type) *MethodSet {
-	// WARNING: The code in this function is extremely subtle - do not modify casually!
-	//          This function and lookupFieldOrMethod should be kept in sync.
-
-	// method set up to the current depth, allocated lazily
-	var base methodSet
-
-	typ, isPtr := deref(T)
-	named, _ := typ.(*Named)
-
-	// *typ where typ is an interface has no methods.
-	if isPtr {
-		utyp := typ
-		if named != nil {
-			utyp = named.underlying
-		}
-		if _, ok := utyp.(*Interface); ok {
-			return &emptyMethodSet
-		}
-	}
-
-	// Start with typ as single entry at shallowest depth.
-	// If typ is not a named type, insert a nil type instead.
-	current := []embeddedType{{named, nil, isPtr, false}}
-
-	// named types that we have seen already, allocated lazily
-	var seen map[*Named]bool
-
-	// collect methods at current depth
-	for len(current) > 0 {
-		var next []embeddedType // embedded types found at current depth
-
-		// field and method sets at current depth, allocated lazily
-		var fset fieldSet
-		var mset methodSet
-
-		for _, e := range current {
-			// The very first time only, e.typ may be nil.
-			// In this case, we don't have a named type and
-			// we simply continue with the underlying type.
-			if e.typ != nil {
-				if seen[e.typ] {
-					// We have seen this type before, at a more shallow depth
-					// (note that multiples of this type at the current depth
-					// were consolidated before). The type at that depth shadows
-					// this same type at the current depth, so we can ignore
-					// this one.
-					continue
-				}
-				if seen == nil {
-					seen = make(map[*Named]bool)
-				}
-				seen[e.typ] = true
-
-				mset = mset.add(e.typ.methods, e.index, e.indirect, e.multiples)
-
-				// continue with underlying type
-				typ = e.typ.underlying
-			}
-
-			switch t := typ.(type) {
-			case *Struct:
-				for i, f := range t.fields {
-					fset = fset.add(f, e.multiples)
-
-					// Embedded fields are always of the form T or *T where
-					// T is a named type. If typ appeared multiple times at
-					// this depth, f.Type appears multiple times at the next
-					// depth.
-					if f.anonymous {
-						// Ignore embedded basic types - only user-defined
-						// named types can have methods or struct fields.
-						typ, isPtr := deref(f.typ)
-						if t, _ := typ.(*Named); t != nil {
-							next = append(next, embeddedType{t, concat(e.index, i), e.indirect || isPtr, e.multiples})
-						}
-					}
-				}
-
-			case *Interface:
-				mset = mset.add(t.allMethods, e.index, true, e.multiples)
-			}
-		}
-
-		// Add methods and collisions at this depth to base if no entries with matching
-		// names exist already.
-		for k, m := range mset {
-			if _, found := base[k]; !found {
-				// Fields collide with methods of the same name at this depth.
-				if _, found := fset[k]; found {
-					m = nil // collision
-				}
-				if base == nil {
-					base = make(methodSet)
-				}
-				base[k] = m
-			}
-		}
-
-		// Multiple fields with matching names collide at this depth and shadow all
-		// entries further down; add them as collisions to base if no entries with
-		// matching names exist already.
-		for k, f := range fset {
-			if f == nil {
-				if _, found := base[k]; !found {
-					if base == nil {
-						base = make(methodSet)
-					}
-					base[k] = nil // collision
-				}
-			}
-		}
-
-		current = consolidateMultiples(next)
-	}
-
-	if len(base) == 0 {
-		return &emptyMethodSet
-	}
-
-	// collect methods
-	var list []*Selection
-	for _, m := range base {
-		if m != nil {
-			m.recv = T
-			list = append(list, m)
-		}
-	}
-	sort.Sort(byUniqueName(list))
-	return &MethodSet{list}
-}
-
-// A fieldSet is a set of fields and name collisions.
-// A collision indicates that multiple fields with the
-// same unique id appeared.
-type fieldSet map[string]*Var // a nil entry indicates a name collision
-
-// Add adds field f to the field set s.
-// If multiples is set, f appears multiple times
-// and is treated as a collision.
-func (s fieldSet) add(f *Var, multiples bool) fieldSet {
-	if s == nil {
-		s = make(fieldSet)
-	}
-	key := f.Id()
-	// if f is not in the set, add it
-	if !multiples {
-		if _, found := s[key]; !found {
-			s[key] = f
-			return s
-		}
-	}
-	s[key] = nil // collision
-	return s
-}
-
-// A methodSet is a set of methods and name collisions.
-// A collision indicates that multiple methods with the
-// same unique id appeared.
-type methodSet map[string]*Selection // a nil entry indicates a name collision
-
-// Add adds all functions in list to the method set s.
-// If multiples is set, every function in list appears multiple times
-// and is treated as a collision.
-func (s methodSet) add(list []*Func, index []int, indirect bool, multiples bool) methodSet {
-	if len(list) == 0 {
-		return s
-	}
-	if s == nil {
-		s = make(methodSet)
-	}
-	for i, f := range list {
-		key := f.Id()
-		// if f is not in the set, add it
-		if !multiples {
-			// TODO(gri) A found method may not be added because it's not in the method set
-			// (!indirect && ptrRecv(f)). A 2nd method on the same level may be in the method
-			// set and may not collide with the first one, thus leading to a false positive.
-			// Is that possible? Investigate.
-			if _, found := s[key]; !found && (indirect || !ptrRecv(f)) {
-				s[key] = &Selection{MethodVal, nil, f, concat(index, i), indirect}
-				continue
-			}
-		}
-		s[key] = nil // collision
-	}
-	return s
-}
-
-// ptrRecv reports whether the receiver is of the form *T.
-// The receiver must exist.
-func ptrRecv(f *Func) bool {
-	_, isPtr := deref(f.typ.(*Signature).recv.typ)
-	return isPtr
-}
-
-// byUniqueName function lists can be sorted by their unique names.
-type byUniqueName []*Selection
-
-func (a byUniqueName) Len() int           { return len(a) }
-func (a byUniqueName) Less(i, j int) bool { return a[i].obj.Id() < a[j].obj.Id() }
-func (a byUniqueName) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
diff --git a/third_party/golang/go/types/object.go b/third_party/golang/go/types/object.go
deleted file mode 100644
index a6e68cde6ea24..0000000000000
--- a/third_party/golang/go/types/object.go
+++ /dev/null
@@ -1,360 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package types
-
-import (
-	"bytes"
-	"fmt"
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"k8s.io/kubernetes/third_party/golang/go/constant"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-)
-
-// TODO(gri) Document factory, accessor methods, and fields. General clean-up.
-
-// An Object describes a named language entity such as a package,
-// constant, type, variable, function (incl. methods), or label.
-// All objects implement the Object interface.
-//
-type Object interface {
-	Parent() *Scope // scope in which this object is declared
-	Pos() token.Pos // position of object identifier in declaration
-	Pkg() *Package  // nil for objects in the Universe scope and labels
-	Name() string   // package local object name
-	Type() Type     // object type
-	Exported() bool // reports whether the name starts with a capital letter
-	Id() string     // object id (see Id below)
-
-	// String returns a human-readable string of the object.
-	String() string
-
-	// order reflects a package-level object's source order: if object
-	// a is before object b in the source, then a.order() < b.order().
-	// order returns a value > 0 for package-level objects; it returns
-	// 0 for all other objects (including objects in file scopes).
-	order() uint32
-
-	// setOrder sets the order number of the object. It must be > 0.
-	setOrder(uint32)
-
-	// setParent sets the parent scope of the object.
-	setParent(*Scope)
-
-	// sameId reports whether obj.Id() and Id(pkg, name) are the same.
-	sameId(pkg *Package, name string) bool
-
-	// scopePos returns the start position of the scope of this Object
-	scopePos() token.Pos
-
-	// setScopePos sets the start position of the scope for this Object.
-	setScopePos(pos token.Pos)
-}
-
-// Id returns name if it is exported, otherwise it
-// returns the name qualified with the package path.
-func Id(pkg *Package, name string) string {
-	if ast.IsExported(name) {
-		return name
-	}
-	// unexported names need the package path for differentiation
-	// (if there's no package, make sure we don't start with '.'
-	// as that may change the order of methods between a setup
-	// inside a package and outside a package - which breaks some
-	// tests)
-	path := "_"
-	// TODO(gri): shouldn't !ast.IsExported(name) => pkg != nil be an precondition?
-	// if pkg == nil {
-	// 	panic("nil package in lookup of unexported name")
-	// }
-	if pkg != nil {
-		path = pkg.path
-		if path == "" {
-			path = "_"
-		}
-	}
-	return path + "." + name
-}
-
-// An object implements the common parts of an Object.
-type object struct {
-	parent    *Scope
-	pos       token.Pos
-	pkg       *Package
-	name      string
-	typ       Type
-	order_    uint32
-	scopePos_ token.Pos
-}
-
-func (obj *object) Parent() *Scope      { return obj.parent }
-func (obj *object) Pos() token.Pos      { return obj.pos }
-func (obj *object) Pkg() *Package       { return obj.pkg }
-func (obj *object) Name() string        { return obj.name }
-func (obj *object) Type() Type          { return obj.typ }
-func (obj *object) Exported() bool      { return ast.IsExported(obj.name) }
-func (obj *object) Id() string          { return Id(obj.pkg, obj.name) }
-func (obj *object) String() string      { panic("abstract") }
-func (obj *object) order() uint32       { return obj.order_ }
-func (obj *object) scopePos() token.Pos { return obj.scopePos_ }
-
-func (obj *object) setParent(parent *Scope)   { obj.parent = parent }
-func (obj *object) setOrder(order uint32)     { assert(order > 0); obj.order_ = order }
-func (obj *object) setScopePos(pos token.Pos) { obj.scopePos_ = pos }
-
-func (obj *object) sameId(pkg *Package, name string) bool {
-	// spec:
-	// "Two identifiers are different if they are spelled differently,
-	// or if they appear in different packages and are not exported.
-	// Otherwise, they are the same."
-	if name != obj.name {
-		return false
-	}
-	// obj.Name == name
-	if obj.Exported() {
-		return true
-	}
-	// not exported, so packages must be the same (pkg == nil for
-	// fields in Universe scope; this can only happen for types
-	// introduced via Eval)
-	if pkg == nil || obj.pkg == nil {
-		return pkg == obj.pkg
-	}
-	// pkg != nil && obj.pkg != nil
-	return pkg.path == obj.pkg.path
-}
-
-// A PkgName represents an imported Go package.
-type PkgName struct {
-	object
-	imported *Package
-	used     bool // set if the package was used
-}
-
-func NewPkgName(pos token.Pos, pkg *Package, name string, imported *Package) *PkgName {
-	return &PkgName{object{nil, pos, pkg, name, Typ[Invalid], 0, token.NoPos}, imported, false}
-}
-
-// Imported returns the package that was imported.
-// It is distinct from Pkg(), which is the package containing the import statement.
-func (obj *PkgName) Imported() *Package { return obj.imported }
-
-// A Const represents a declared constant.
-type Const struct {
-	object
-	val     constant.Value
-	visited bool // for initialization cycle detection
-}
-
-func NewConst(pos token.Pos, pkg *Package, name string, typ Type, val constant.Value) *Const {
-	return &Const{object{nil, pos, pkg, name, typ, 0, token.NoPos}, val, false}
-}
-
-func (obj *Const) Val() constant.Value { return obj.val }
-
-// A TypeName represents a declared type.
-type TypeName struct {
-	object
-}
-
-func NewTypeName(pos token.Pos, pkg *Package, name string, typ Type) *TypeName {
-	return &TypeName{object{nil, pos, pkg, name, typ, 0, token.NoPos}}
-}
-
-// A Variable represents a declared variable (including function parameters and results, and struct fields).
-type Var struct {
-	object
-	anonymous bool // if set, the variable is an anonymous struct field, and name is the type name
-	visited   bool // for initialization cycle detection
-	isField   bool // var is struct field
-	used      bool // set if the variable was used
-}
-
-func NewVar(pos token.Pos, pkg *Package, name string, typ Type) *Var {
-	return &Var{object: object{nil, pos, pkg, name, typ, 0, token.NoPos}}
-}
-
-func NewParam(pos token.Pos, pkg *Package, name string, typ Type) *Var {
-	return &Var{object: object{nil, pos, pkg, name, typ, 0, token.NoPos}, used: true} // parameters are always 'used'
-}
-
-func NewField(pos token.Pos, pkg *Package, name string, typ Type, anonymous bool) *Var {
-	return &Var{object: object{nil, pos, pkg, name, typ, 0, token.NoPos}, anonymous: anonymous, isField: true}
-}
-
-func (obj *Var) Anonymous() bool { return obj.anonymous }
-
-func (obj *Var) IsField() bool { return obj.isField }
-
-// A Func represents a declared function, concrete method, or abstract
-// (interface) method.  Its Type() is always a *Signature.
-// An abstract method may belong to many interfaces due to embedding.
-type Func struct {
-	object
-}
-
-func NewFunc(pos token.Pos, pkg *Package, name string, sig *Signature) *Func {
-	// don't store a nil signature
-	var typ Type
-	if sig != nil {
-		typ = sig
-	}
-	return &Func{object{nil, pos, pkg, name, typ, 0, token.NoPos}}
-}
-
-// FullName returns the package- or receiver-type-qualified name of
-// function or method obj.
-func (obj *Func) FullName() string {
-	var buf bytes.Buffer
-	writeFuncName(&buf, obj, nil)
-	return buf.String()
-}
-
-func (obj *Func) Scope() *Scope {
-	return obj.typ.(*Signature).scope
-}
-
-// A Label represents a declared label.
-type Label struct {
-	object
-	used bool // set if the label was used
-}
-
-func NewLabel(pos token.Pos, pkg *Package, name string) *Label {
-	return &Label{object{pos: pos, pkg: pkg, name: name, typ: Typ[Invalid]}, false}
-}
-
-// A Builtin represents a built-in function.
-// Builtins don't have a valid type.
-type Builtin struct {
-	object
-	id builtinId
-}
-
-func newBuiltin(id builtinId) *Builtin {
-	return &Builtin{object{name: predeclaredFuncs[id].name, typ: Typ[Invalid]}, id}
-}
-
-// Nil represents the predeclared value nil.
-type Nil struct {
-	object
-}
-
-func writeObject(buf *bytes.Buffer, obj Object, qf Qualifier) {
-	typ := obj.Type()
-	switch obj := obj.(type) {
-	case *PkgName:
-		fmt.Fprintf(buf, "package %s", obj.Name())
-		if path := obj.imported.path; path != "" && path != obj.name {
-			fmt.Fprintf(buf, " (%q)", path)
-		}
-		return
-
-	case *Const:
-		buf.WriteString("const")
-
-	case *TypeName:
-		buf.WriteString("type")
-		typ = typ.Underlying()
-
-	case *Var:
-		if obj.isField {
-			buf.WriteString("field")
-		} else {
-			buf.WriteString("var")
-		}
-
-	case *Func:
-		buf.WriteString("func ")
-		writeFuncName(buf, obj, qf)
-		if typ != nil {
-			WriteSignature(buf, typ.(*Signature), qf)
-		}
-		return
-
-	case *Label:
-		buf.WriteString("label")
-		typ = nil
-
-	case *Builtin:
-		buf.WriteString("builtin")
-		typ = nil
-
-	case *Nil:
-		buf.WriteString("nil")
-		return
-
-	default:
-		panic(fmt.Sprintf("writeObject(%T)", obj))
-	}
-
-	buf.WriteByte(' ')
-
-	// For package-level objects, qualify the name.
-	if obj.Pkg() != nil && obj.Pkg().scope.Lookup(obj.Name()) == obj {
-		writePackage(buf, obj.Pkg(), qf)
-	}
-	buf.WriteString(obj.Name())
-	if typ != nil {
-		buf.WriteByte(' ')
-		WriteType(buf, typ, qf)
-	}
-}
-
-func writePackage(buf *bytes.Buffer, pkg *Package, qf Qualifier) {
-	if pkg == nil {
-		return
-	}
-	var s string
-	if qf != nil {
-		s = qf(pkg)
-	} else {
-		s = pkg.Path()
-	}
-	if s != "" {
-		buf.WriteString(s)
-		buf.WriteByte('.')
-	}
-}
-
-// ObjectString returns the string form of obj.
-// The Qualifier controls the printing of
-// package-level objects, and may be nil.
-func ObjectString(obj Object, qf Qualifier) string {
-	var buf bytes.Buffer
-	writeObject(&buf, obj, qf)
-	return buf.String()
-}
-
-func (obj *PkgName) String() string  { return ObjectString(obj, nil) }
-func (obj *Const) String() string    { return ObjectString(obj, nil) }
-func (obj *TypeName) String() string { return ObjectString(obj, nil) }
-func (obj *Var) String() string      { return ObjectString(obj, nil) }
-func (obj *Func) String() string     { return ObjectString(obj, nil) }
-func (obj *Label) String() string    { return ObjectString(obj, nil) }
-func (obj *Builtin) String() string  { return ObjectString(obj, nil) }
-func (obj *Nil) String() string      { return ObjectString(obj, nil) }
-
-func writeFuncName(buf *bytes.Buffer, f *Func, qf Qualifier) {
-	if f.typ != nil {
-		sig := f.typ.(*Signature)
-		if recv := sig.Recv(); recv != nil {
-			buf.WriteByte('(')
-			if _, ok := recv.Type().(*Interface); ok {
-				// gcimporter creates abstract methods of
-				// named interfaces using the interface type
-				// (not the named type) as the receiver.
-				// Don't print it in full.
-				buf.WriteString("interface")
-			} else {
-				WriteType(buf, recv.Type(), qf)
-			}
-			buf.WriteByte(')')
-			buf.WriteByte('.')
-		} else if f.pkg != nil {
-			writePackage(buf, f.pkg, qf)
-		}
-	}
-	buf.WriteString(f.name)
-}
diff --git a/third_party/golang/go/types/objset.go b/third_party/golang/go/types/objset.go
deleted file mode 100644
index 55eb74addbae5..0000000000000
--- a/third_party/golang/go/types/objset.go
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements objsets.
-//
-// An objset is similar to a Scope but objset elements
-// are identified by their unique id, instead of their
-// object name.
-
-package types
-
-// An objset is a set of objects identified by their unique id.
-// The zero value for objset is a ready-to-use empty objset.
-type objset map[string]Object // initialized lazily
-
-// insert attempts to insert an object obj into objset s.
-// If s already contains an alternative object alt with
-// the same name, insert leaves s unchanged and returns alt.
-// Otherwise it inserts obj and returns nil.
-func (s *objset) insert(obj Object) Object {
-	id := obj.Id()
-	if alt := (*s)[id]; alt != nil {
-		return alt
-	}
-	if *s == nil {
-		*s = make(map[string]Object)
-	}
-	(*s)[id] = obj
-	return nil
-}
diff --git a/third_party/golang/go/types/operand.go b/third_party/golang/go/types/operand.go
deleted file mode 100644
index 4549bdf1a352a..0000000000000
--- a/third_party/golang/go/types/operand.go
+++ /dev/null
@@ -1,287 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file defines operands and associated operations.
-
-package types
-
-import (
-	"bytes"
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"k8s.io/kubernetes/third_party/golang/go/constant"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-)
-
-// An operandMode specifies the (addressing) mode of an operand.
-type operandMode byte
-
-const (
-	invalid   operandMode = iota // operand is invalid
-	novalue                      // operand represents no value (result of a function call w/o result)
-	builtin                      // operand is a built-in function
-	typexpr                      // operand is a type
-	constant_                    // operand is a constant; the operand's typ is a Basic type
-	variable                     // operand is an addressable variable
-	mapindex                     // operand is a map index expression (acts like a variable on lhs, commaok on rhs of an assignment)
-	value                        // operand is a computed value
-	commaok                      // like value, but operand may be used in a comma,ok expression
-)
-
-var operandModeString = [...]string{
-	invalid:   "invalid operand",
-	novalue:   "no value",
-	builtin:   "built-in",
-	typexpr:   "type",
-	constant_: "constant",
-	variable:  "variable",
-	mapindex:  "map index expression",
-	value:     "value",
-	commaok:   "comma, ok expression",
-}
-
-// An operand represents an intermediate value during type checking.
-// Operands have an (addressing) mode, the expression evaluating to
-// the operand, the operand's type, a value for constants, and an id
-// for built-in functions.
-// The zero value of operand is a ready to use invalid operand.
-//
-type operand struct {
-	mode operandMode
-	expr ast.Expr
-	typ  Type
-	val  constant.Value
-	id   builtinId
-}
-
-// pos returns the position of the expression corresponding to x.
-// If x is invalid the position is token.NoPos.
-//
-func (x *operand) pos() token.Pos {
-	// x.expr may not be set if x is invalid
-	if x.expr == nil {
-		return token.NoPos
-	}
-	return x.expr.Pos()
-}
-
-// Operand string formats
-// (not all "untyped" cases can appear due to the type system,
-// but they fall out naturally here)
-//
-// mode       format
-//
-// invalid     (                                   )
-// novalue     (                                   )
-// builtin     (                                   )
-// typexpr     (                                   )
-//
-// constant    (                     )
-// constant    (                      of type )
-// constant    (                )
-// constant    (                 of type )
-//
-// variable    (                     )
-// variable    (                      of type )
-//
-// mapindex    (                     )
-// mapindex    (                      of type )
-//
-// value       (                     )
-// value       (                      of type )
-//
-// commaok     (                     )
-// commaok     (                      of type )
-//
-func operandString(x *operand, qf Qualifier) string {
-	var buf bytes.Buffer
-
-	var expr string
-	if x.expr != nil {
-		expr = ExprString(x.expr)
-	} else {
-		switch x.mode {
-		case builtin:
-			expr = predeclaredFuncs[x.id].name
-		case typexpr:
-			expr = TypeString(x.typ, qf)
-		case constant_:
-			expr = x.val.String()
-		}
-	}
-
-	//  (
-	if expr != "" {
-		buf.WriteString(expr)
-		buf.WriteString(" (")
-	}
-
-	// 
-	hasType := false
-	switch x.mode {
-	case invalid, novalue, builtin, typexpr:
-		// no type
-	default:
-		// has type
-		if isUntyped(x.typ) {
-			buf.WriteString(x.typ.(*Basic).name)
-			buf.WriteByte(' ')
-			break
-		}
-		hasType = true
-	}
-
-	// 
-	buf.WriteString(operandModeString[x.mode])
-
-	// 
-	if x.mode == constant_ {
-		if s := x.val.String(); s != expr {
-			buf.WriteByte(' ')
-			buf.WriteString(s)
-		}
-	}
-
-	// 
-	if hasType {
-		if x.typ != Typ[Invalid] {
-			buf.WriteString(" of type ")
-			WriteType(&buf, x.typ, qf)
-		} else {
-			buf.WriteString(" with invalid type")
-		}
-	}
-
-	// )
-	if expr != "" {
-		buf.WriteByte(')')
-	}
-
-	return buf.String()
-}
-
-func (x *operand) String() string {
-	return operandString(x, nil)
-}
-
-// setConst sets x to the untyped constant for literal lit.
-func (x *operand) setConst(tok token.Token, lit string) {
-	val := constant.MakeFromLiteral(lit, tok, 0)
-	if val == nil {
-		// TODO(gri) Should we make it an unknown constant instead?
-		x.mode = invalid
-		return
-	}
-
-	var kind BasicKind
-	switch tok {
-	case token.INT:
-		kind = UntypedInt
-	case token.FLOAT:
-		kind = UntypedFloat
-	case token.IMAG:
-		kind = UntypedComplex
-	case token.CHAR:
-		kind = UntypedRune
-	case token.STRING:
-		kind = UntypedString
-	}
-
-	x.mode = constant_
-	x.typ = Typ[kind]
-	x.val = val
-}
-
-// isNil reports whether x is the nil value.
-func (x *operand) isNil() bool {
-	return x.mode == value && x.typ == Typ[UntypedNil]
-}
-
-// TODO(gri) The functions operand.assignableTo, checker.convertUntyped,
-//           checker.representable, and checker.assignment are
-//           overlapping in functionality. Need to simplify and clean up.
-
-// assignableTo reports whether x is assignable to a variable of type T.
-func (x *operand) assignableTo(conf *Config, T Type) bool {
-	if x.mode == invalid || T == Typ[Invalid] {
-		return true // avoid spurious errors
-	}
-
-	V := x.typ
-
-	// x's type is identical to T
-	if Identical(V, T) {
-		return true
-	}
-
-	Vu := V.Underlying()
-	Tu := T.Underlying()
-
-	// T is an interface type and x implements T
-	// (Do this check first as it might succeed early.)
-	if Ti, ok := Tu.(*Interface); ok {
-		if Implements(x.typ, Ti) {
-			return true
-		}
-	}
-
-	// x's type V and T have identical underlying types
-	// and at least one of V or T is not a named type
-	if Identical(Vu, Tu) && (!isNamed(V) || !isNamed(T)) {
-		return true
-	}
-
-	// x is a bidirectional channel value, T is a channel
-	// type, x's type V and T have identical element types,
-	// and at least one of V or T is not a named type
-	if Vc, ok := Vu.(*Chan); ok && Vc.dir == SendRecv {
-		if Tc, ok := Tu.(*Chan); ok && Identical(Vc.elem, Tc.elem) {
-			return !isNamed(V) || !isNamed(T)
-		}
-	}
-
-	// x is the predeclared identifier nil and T is a pointer,
-	// function, slice, map, channel, or interface type
-	if x.isNil() {
-		switch t := Tu.(type) {
-		case *Basic:
-			if t.kind == UnsafePointer {
-				return true
-			}
-		case *Pointer, *Signature, *Slice, *Map, *Chan, *Interface:
-			return true
-		}
-		return false
-	}
-
-	// x is an untyped constant representable by a value of type T
-	// TODO(gri) This is borrowing from checker.convertUntyped and
-	//           checker.representable. Need to clean up.
-	if isUntyped(Vu) {
-		switch t := Tu.(type) {
-		case *Basic:
-			if x.mode == constant_ {
-				return representableConst(x.val, conf, t.kind, nil)
-			}
-			// The result of a comparison is an untyped boolean,
-			// but may not be a constant.
-			if Vb, _ := Vu.(*Basic); Vb != nil {
-				return Vb.kind == UntypedBool && isBoolean(Tu)
-			}
-		case *Interface:
-			return x.isNil() || t.Empty()
-		case *Pointer, *Signature, *Slice, *Map, *Chan:
-			return x.isNil()
-		}
-	}
-
-	return false
-}
-
-// isInteger reports whether x is value of integer type
-// or an untyped constant representable as an integer.
-func (x *operand) isInteger() bool {
-	return x.mode == invalid ||
-		isInteger(x.typ) ||
-		isUntyped(x.typ) && x.mode == constant_ && representableConst(x.val, nil, UntypedInt, nil) // no *Config required for UntypedInt
-}
diff --git a/third_party/golang/go/types/ordering.go b/third_party/golang/go/types/ordering.go
deleted file mode 100644
index c87f5227f318b..0000000000000
--- a/third_party/golang/go/types/ordering.go
+++ /dev/null
@@ -1,127 +0,0 @@
-// Copyright 2014 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements resolveOrder.
-
-package types
-
-import (
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"sort"
-)
-
-// resolveOrder computes the order in which package-level objects
-// must be type-checked.
-//
-// Interface types appear first in the list, sorted topologically
-// by dependencies on embedded interfaces that are also declared
-// in this package, followed by all other objects sorted in source
-// order.
-//
-// TODO(gri) Consider sorting all types by dependencies here, and
-// in the process check _and_ report type cycles. This may simplify
-// the full type-checking phase.
-//
-func (check *Checker) resolveOrder() []Object {
-	var ifaces, others []Object
-
-	// collect interface types with their dependencies, and all other objects
-	for obj := range check.objMap {
-		if ityp := check.interfaceFor(obj); ityp != nil {
-			ifaces = append(ifaces, obj)
-			// determine dependencies on embedded interfaces
-			for _, f := range ityp.Methods.List {
-				if len(f.Names) == 0 {
-					// Embedded interface: The type must be a (possibly
-					// qualified) identifier denoting another interface.
-					// Imported interfaces are already fully resolved,
-					// so we can ignore qualified identifiers.
-					if ident, _ := f.Type.(*ast.Ident); ident != nil {
-						embedded := check.pkg.scope.Lookup(ident.Name)
-						if check.interfaceFor(embedded) != nil {
-							check.objMap[obj].addDep(embedded)
-						}
-					}
-				}
-			}
-		} else {
-			others = append(others, obj)
-		}
-	}
-
-	// final object order
-	var order []Object
-
-	// sort interface types topologically by dependencies,
-	// and in source order if there are no dependencies
-	sort.Sort(inSourceOrder(ifaces))
-	if debug {
-		for _, obj := range ifaces {
-			assert(check.objMap[obj].mark == 0)
-		}
-	}
-	for _, obj := range ifaces {
-		check.appendInPostOrder(&order, obj)
-	}
-
-	// sort everything else in source order
-	sort.Sort(inSourceOrder(others))
-
-	return append(order, others...)
-}
-
-// interfaceFor returns the AST interface denoted by obj, or nil.
-func (check *Checker) interfaceFor(obj Object) *ast.InterfaceType {
-	tname, _ := obj.(*TypeName)
-	if tname == nil {
-		return nil // not a type
-	}
-	d := check.objMap[obj]
-	if d == nil {
-		check.dump("%s: %s should have been declared", obj.Pos(), obj.Name())
-		unreachable()
-	}
-	if d.typ == nil {
-		return nil // invalid AST - ignore (will be handled later)
-	}
-	ityp, _ := d.typ.(*ast.InterfaceType)
-	return ityp
-}
-
-func (check *Checker) appendInPostOrder(order *[]Object, obj Object) {
-	d := check.objMap[obj]
-	if d.mark != 0 {
-		// We've already seen this object; either because it's
-		// already added to order, or because we have a cycle.
-		// In both cases we stop. Cycle errors are reported
-		// when type-checking types.
-		return
-	}
-	d.mark = 1
-
-	for _, obj := range orderedSetObjects(d.deps) {
-		check.appendInPostOrder(order, obj)
-	}
-
-	*order = append(*order, obj)
-}
-
-func orderedSetObjects(set map[Object]bool) []Object {
-	list := make([]Object, len(set))
-	i := 0
-	for obj := range set {
-		// we don't care about the map element value
-		list[i] = obj
-		i++
-	}
-	sort.Sort(inSourceOrder(list))
-	return list
-}
-
-// inSourceOrder implements the sort.Sort interface.
-type inSourceOrder []Object
-
-func (a inSourceOrder) Len() int           { return len(a) }
-func (a inSourceOrder) Less(i, j int) bool { return a[i].order() < a[j].order() }
-func (a inSourceOrder) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
diff --git a/third_party/golang/go/types/package.go b/third_party/golang/go/types/package.go
deleted file mode 100644
index 2849103966b1c..0000000000000
--- a/third_party/golang/go/types/package.go
+++ /dev/null
@@ -1,65 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package types
-
-import (
-	"fmt"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-)
-
-// A Package describes a Go package.
-type Package struct {
-	path     string
-	name     string
-	scope    *Scope
-	complete bool
-	imports  []*Package
-	fake     bool // scope lookup errors are silently dropped if package is fake (internal use only)
-}
-
-// NewPackage returns a new Package for the given package path and name;
-// the name must not be the blank identifier.
-// The package is not complete and contains no explicit imports.
-func NewPackage(path, name string) *Package {
-	if name == "_" {
-		panic("invalid package name _")
-	}
-	scope := NewScope(Universe, token.NoPos, token.NoPos, fmt.Sprintf("package %q", path))
-	return &Package{path: path, name: name, scope: scope}
-}
-
-// Path returns the package path.
-func (pkg *Package) Path() string { return pkg.path }
-
-// Name returns the package name.
-func (pkg *Package) Name() string { return pkg.name }
-
-// Scope returns the (complete or incomplete) package scope
-// holding the objects declared at package level (TypeNames,
-// Consts, Vars, and Funcs).
-func (pkg *Package) Scope() *Scope { return pkg.scope }
-
-// A package is complete if its scope contains (at least) all
-// exported objects; otherwise it is incomplete.
-func (pkg *Package) Complete() bool { return pkg.complete }
-
-// MarkComplete marks a package as complete.
-func (pkg *Package) MarkComplete() { pkg.complete = true }
-
-// Imports returns the list of packages directly imported by
-// pkg; the list is in source order. Package unsafe is excluded.
-//
-// If pkg was loaded from export data, Imports includes packages that
-// provide package-level objects referenced by pkg.  This may be more or
-// less than the set of packages directly imported by pkg's source code.
-func (pkg *Package) Imports() []*Package { return pkg.imports }
-
-// SetImports sets the list of explicitly imported packages to list.
-// It is the caller's responsibility to make sure list elements are unique.
-func (pkg *Package) SetImports(list []*Package) { pkg.imports = list }
-
-func (pkg *Package) String() string {
-	return fmt.Sprintf("package %s (%q)", pkg.name, pkg.path)
-}
diff --git a/third_party/golang/go/types/predicates.go b/third_party/golang/go/types/predicates.go
deleted file mode 100644
index 993c6d290b13a..0000000000000
--- a/third_party/golang/go/types/predicates.go
+++ /dev/null
@@ -1,309 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements commonly used type predicates.
-
-package types
-
-import "sort"
-
-func isNamed(typ Type) bool {
-	if _, ok := typ.(*Basic); ok {
-		return ok
-	}
-	_, ok := typ.(*Named)
-	return ok
-}
-
-func isBoolean(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsBoolean != 0
-}
-
-func isInteger(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsInteger != 0
-}
-
-func isUnsigned(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsUnsigned != 0
-}
-
-func isFloat(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsFloat != 0
-}
-
-func isComplex(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsComplex != 0
-}
-
-func isNumeric(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsNumeric != 0
-}
-
-func isString(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsString != 0
-}
-
-func isTyped(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return !ok || t.info&IsUntyped == 0
-}
-
-func isUntyped(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsUntyped != 0
-}
-
-func isOrdered(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsOrdered != 0
-}
-
-func isConstType(typ Type) bool {
-	t, ok := typ.Underlying().(*Basic)
-	return ok && t.info&IsConstType != 0
-}
-
-// IsInterface reports whether typ is an interface type.
-func IsInterface(typ Type) bool {
-	_, ok := typ.Underlying().(*Interface)
-	return ok
-}
-
-// Comparable reports whether values of type T are comparable.
-func Comparable(T Type) bool {
-	switch t := T.Underlying().(type) {
-	case *Basic:
-		// assume invalid types to be comparable
-		// to avoid follow-up errors
-		return t.kind != UntypedNil
-	case *Pointer, *Interface, *Chan:
-		return true
-	case *Struct:
-		for _, f := range t.fields {
-			if !Comparable(f.typ) {
-				return false
-			}
-		}
-		return true
-	case *Array:
-		return Comparable(t.elem)
-	}
-	return false
-}
-
-// hasNil reports whether a type includes the nil value.
-func hasNil(typ Type) bool {
-	switch t := typ.Underlying().(type) {
-	case *Basic:
-		return t.kind == UnsafePointer
-	case *Slice, *Pointer, *Signature, *Interface, *Map, *Chan:
-		return true
-	}
-	return false
-}
-
-// Identical reports whether x and y are identical.
-func Identical(x, y Type) bool {
-	return identical(x, y, nil)
-}
-
-// An ifacePair is a node in a stack of interface type pairs compared for identity.
-type ifacePair struct {
-	x, y *Interface
-	prev *ifacePair
-}
-
-func (p *ifacePair) identical(q *ifacePair) bool {
-	return p.x == q.x && p.y == q.y || p.x == q.y && p.y == q.x
-}
-
-func identical(x, y Type, p *ifacePair) bool {
-	if x == y {
-		return true
-	}
-
-	switch x := x.(type) {
-	case *Basic:
-		// Basic types are singletons except for the rune and byte
-		// aliases, thus we cannot solely rely on the x == y check
-		// above.
-		if y, ok := y.(*Basic); ok {
-			return x.kind == y.kind
-		}
-
-	case *Array:
-		// Two array types are identical if they have identical element types
-		// and the same array length.
-		if y, ok := y.(*Array); ok {
-			return x.len == y.len && identical(x.elem, y.elem, p)
-		}
-
-	case *Slice:
-		// Two slice types are identical if they have identical element types.
-		if y, ok := y.(*Slice); ok {
-			return identical(x.elem, y.elem, p)
-		}
-
-	case *Struct:
-		// Two struct types are identical if they have the same sequence of fields,
-		// and if corresponding fields have the same names, and identical types,
-		// and identical tags. Two anonymous fields are considered to have the same
-		// name. Lower-case field names from different packages are always different.
-		if y, ok := y.(*Struct); ok {
-			if x.NumFields() == y.NumFields() {
-				for i, f := range x.fields {
-					g := y.fields[i]
-					if f.anonymous != g.anonymous ||
-						x.Tag(i) != y.Tag(i) ||
-						!f.sameId(g.pkg, g.name) ||
-						!identical(f.typ, g.typ, p) {
-						return false
-					}
-				}
-				return true
-			}
-		}
-
-	case *Pointer:
-		// Two pointer types are identical if they have identical base types.
-		if y, ok := y.(*Pointer); ok {
-			return identical(x.base, y.base, p)
-		}
-
-	case *Tuple:
-		// Two tuples types are identical if they have the same number of elements
-		// and corresponding elements have identical types.
-		if y, ok := y.(*Tuple); ok {
-			if x.Len() == y.Len() {
-				if x != nil {
-					for i, v := range x.vars {
-						w := y.vars[i]
-						if !identical(v.typ, w.typ, p) {
-							return false
-						}
-					}
-				}
-				return true
-			}
-		}
-
-	case *Signature:
-		// Two function types are identical if they have the same number of parameters
-		// and result values, corresponding parameter and result types are identical,
-		// and either both functions are variadic or neither is. Parameter and result
-		// names are not required to match.
-		if y, ok := y.(*Signature); ok {
-			return x.variadic == y.variadic &&
-				identical(x.params, y.params, p) &&
-				identical(x.results, y.results, p)
-		}
-
-	case *Interface:
-		// Two interface types are identical if they have the same set of methods with
-		// the same names and identical function types. Lower-case method names from
-		// different packages are always different. The order of the methods is irrelevant.
-		if y, ok := y.(*Interface); ok {
-			a := x.allMethods
-			b := y.allMethods
-			if len(a) == len(b) {
-				// Interface types are the only types where cycles can occur
-				// that are not "terminated" via named types; and such cycles
-				// can only be created via method parameter types that are
-				// anonymous interfaces (directly or indirectly) embedding
-				// the current interface. Example:
-				//
-				//    type T interface {
-				//        m() interface{T}
-				//    }
-				//
-				// If two such (differently named) interfaces are compared,
-				// endless recursion occurs if the cycle is not detected.
-				//
-				// If x and y were compared before, they must be equal
-				// (if they were not, the recursion would have stopped);
-				// search the ifacePair stack for the same pair.
-				//
-				// This is a quadratic algorithm, but in practice these stacks
-				// are extremely short (bounded by the nesting depth of interface
-				// type declarations that recur via parameter types, an extremely
-				// rare occurrence). An alternative implementation might use a
-				// "visited" map, but that is probably less efficient overall.
-				q := &ifacePair{x, y, p}
-				for p != nil {
-					if p.identical(q) {
-						return true // same pair was compared before
-					}
-					p = p.prev
-				}
-				if debug {
-					assert(sort.IsSorted(byUniqueMethodName(a)))
-					assert(sort.IsSorted(byUniqueMethodName(b)))
-				}
-				for i, f := range a {
-					g := b[i]
-					if f.Id() != g.Id() || !identical(f.typ, g.typ, q) {
-						return false
-					}
-				}
-				return true
-			}
-		}
-
-	case *Map:
-		// Two map types are identical if they have identical key and value types.
-		if y, ok := y.(*Map); ok {
-			return identical(x.key, y.key, p) && identical(x.elem, y.elem, p)
-		}
-
-	case *Chan:
-		// Two channel types are identical if they have identical value types
-		// and the same direction.
-		if y, ok := y.(*Chan); ok {
-			return x.dir == y.dir && identical(x.elem, y.elem, p)
-		}
-
-	case *Named:
-		// Two named types are identical if their type names originate
-		// in the same type declaration.
-		if y, ok := y.(*Named); ok {
-			return x.obj == y.obj
-		}
-
-	default:
-		unreachable()
-	}
-
-	return false
-}
-
-// defaultType returns the default "typed" type for an "untyped" type;
-// it returns the incoming type for all other types. The default type
-// for untyped nil is untyped nil.
-//
-func defaultType(typ Type) Type {
-	if t, ok := typ.(*Basic); ok {
-		switch t.kind {
-		case UntypedBool:
-			return Typ[Bool]
-		case UntypedInt:
-			return Typ[Int]
-		case UntypedRune:
-			return universeRune // use 'rune' name
-		case UntypedFloat:
-			return Typ[Float64]
-		case UntypedComplex:
-			return Typ[Complex128]
-		case UntypedString:
-			return Typ[String]
-		}
-	}
-	return typ
-}
diff --git a/third_party/golang/go/types/resolver.go b/third_party/golang/go/types/resolver.go
deleted file mode 100644
index dec38a64c2c09..0000000000000
--- a/third_party/golang/go/types/resolver.go
+++ /dev/null
@@ -1,445 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package types
-
-import (
-	"fmt"
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"k8s.io/kubernetes/third_party/golang/go/constant"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-	pathLib "path"
-	"strconv"
-	"strings"
-	"unicode"
-)
-
-// A declInfo describes a package-level const, type, var, or func declaration.
-type declInfo struct {
-	file  *Scope        // scope of file containing this declaration
-	lhs   []*Var        // lhs of n:1 variable declarations, or nil
-	typ   ast.Expr      // type, or nil
-	init  ast.Expr      // init expression, or nil
-	fdecl *ast.FuncDecl // func declaration, or nil
-
-	deps map[Object]bool // type and init dependencies; lazily allocated
-	mark int             // for dependency analysis
-}
-
-// hasInitializer reports whether the declared object has an initialization
-// expression or function body.
-func (d *declInfo) hasInitializer() bool {
-	return d.init != nil || d.fdecl != nil && d.fdecl.Body != nil
-}
-
-// addDep adds obj as a dependency to d.
-func (d *declInfo) addDep(obj Object) {
-	m := d.deps
-	if m == nil {
-		m = make(map[Object]bool)
-		d.deps = m
-	}
-	m[obj] = true
-}
-
-// arityMatch checks that the lhs and rhs of a const or var decl
-// have the appropriate number of names and init exprs. For const
-// decls, init is the value spec providing the init exprs; for
-// var decls, init is nil (the init exprs are in s in this case).
-func (check *Checker) arityMatch(s, init *ast.ValueSpec) {
-	l := len(s.Names)
-	r := len(s.Values)
-	if init != nil {
-		r = len(init.Values)
-	}
-
-	switch {
-	case init == nil && r == 0:
-		// var decl w/o init expr
-		if s.Type == nil {
-			check.errorf(s.Pos(), "missing type or init expr")
-		}
-	case l < r:
-		if l < len(s.Values) {
-			// init exprs from s
-			n := s.Values[l]
-			check.errorf(n.Pos(), "extra init expr %s", n)
-			// TODO(gri) avoid declared but not used error here
-		} else {
-			// init exprs "inherited"
-			check.errorf(s.Pos(), "extra init expr at %s", init.Pos())
-			// TODO(gri) avoid declared but not used error here
-		}
-	case l > r && (init != nil || r != 1):
-		n := s.Names[r]
-		check.errorf(n.Pos(), "missing init expr for %s", n)
-	}
-}
-
-func validatedImportPath(path string) (string, error) {
-	s, err := strconv.Unquote(path)
-	if err != nil {
-		return "", err
-	}
-	if s == "" {
-		return "", fmt.Errorf("empty string")
-	}
-	const illegalChars = `!"#$%&'()*,:;<=>?[\]^{|}` + "`\uFFFD"
-	for _, r := range s {
-		if !unicode.IsGraphic(r) || unicode.IsSpace(r) || strings.ContainsRune(illegalChars, r) {
-			return s, fmt.Errorf("invalid character %#U", r)
-		}
-	}
-	return s, nil
-}
-
-// declarePkgObj declares obj in the package scope, records its ident -> obj mapping,
-// and updates check.objMap. The object must not be a function or method.
-func (check *Checker) declarePkgObj(ident *ast.Ident, obj Object, d *declInfo) {
-	assert(ident.Name == obj.Name())
-
-	// spec: "A package-scope or file-scope identifier with name init
-	// may only be declared to be a function with this (func()) signature."
-	if ident.Name == "init" {
-		check.errorf(ident.Pos(), "cannot declare init - must be func")
-		return
-	}
-
-	check.declare(check.pkg.scope, ident, obj, token.NoPos)
-	check.objMap[obj] = d
-	obj.setOrder(uint32(len(check.objMap)))
-}
-
-// filename returns a filename suitable for debugging output.
-func (check *Checker) filename(fileNo int) string {
-	file := check.files[fileNo]
-	if pos := file.Pos(); pos.IsValid() {
-		return check.fset.File(pos).Name()
-	}
-	return fmt.Sprintf("file[%d]", fileNo)
-}
-
-// collectObjects collects all file and package objects and inserts them
-// into their respective scopes. It also performs imports and associates
-// methods with receiver base type names.
-func (check *Checker) collectObjects() {
-	pkg := check.pkg
-
-	// pkgImports is the set of packages already imported by any package file seen
-	// so far. Used to avoid duplicate entries in pkg.imports. Allocate and populate
-	// it (pkg.imports may not be empty if we are checking test files incrementally).
-	var pkgImports = make(map[*Package]bool)
-	for _, imp := range pkg.imports {
-		pkgImports[imp] = true
-	}
-
-	for fileNo, file := range check.files {
-		// The package identifier denotes the current package,
-		// but there is no corresponding package object.
-		check.recordDef(file.Name, nil)
-
-		// Use the actual source file extent rather than *ast.File extent since the
-		// latter doesn't include comments which appear at the start or end of the file.
-		// Be conservative and use the *ast.File extent if we don't have a *token.File.
-		pos, end := file.Pos(), file.End()
-		if f := check.fset.File(file.Pos()); f != nil {
-			pos, end = token.Pos(f.Base()), token.Pos(f.Base()+f.Size())
-		}
-		fileScope := NewScope(check.pkg.scope, pos, end, check.filename(fileNo))
-		check.recordScope(file, fileScope)
-
-		for _, decl := range file.Decls {
-			switch d := decl.(type) {
-			case *ast.BadDecl:
-				// ignore
-
-			case *ast.GenDecl:
-				var last *ast.ValueSpec // last ValueSpec with type or init exprs seen
-				for iota, spec := range d.Specs {
-					switch s := spec.(type) {
-					case *ast.ImportSpec:
-						// import package
-						var imp *Package
-						path, err := validatedImportPath(s.Path.Value)
-						if err != nil {
-							check.errorf(s.Path.Pos(), "invalid import path (%s)", err)
-							continue
-						}
-						if path == "C" && check.conf.FakeImportC {
-							// TODO(gri) shouldn't create a new one each time
-							imp = NewPackage("C", "C")
-							imp.fake = true
-						} else if path == "unsafe" {
-							// package "unsafe" is known to the language
-							imp = Unsafe
-						} else {
-							if importer := check.conf.Importer; importer != nil {
-								imp, err = importer.Import(path)
-								if imp == nil && err == nil {
-									err = fmt.Errorf("Config.Importer.Import(%s) returned nil but no error", path)
-								}
-							} else {
-								err = fmt.Errorf("Config.Importer not installed")
-							}
-							if err != nil {
-								check.errorf(s.Path.Pos(), "could not import %s (%s)", path, err)
-								continue
-							}
-						}
-
-						// add package to list of explicit imports
-						// (this functionality is provided as a convenience
-						// for clients; it is not needed for type-checking)
-						if !pkgImports[imp] {
-							pkgImports[imp] = true
-							if imp != Unsafe {
-								pkg.imports = append(pkg.imports, imp)
-							}
-						}
-
-						// local name overrides imported package name
-						name := imp.name
-						if s.Name != nil {
-							name = s.Name.Name
-							if name == "init" {
-								check.errorf(s.Name.Pos(), "cannot declare init - must be func")
-								continue
-							}
-						}
-
-						obj := NewPkgName(s.Pos(), pkg, name, imp)
-						if s.Name != nil {
-							// in a dot-import, the dot represents the package
-							check.recordDef(s.Name, obj)
-						} else {
-							check.recordImplicit(s, obj)
-						}
-
-						// add import to file scope
-						if name == "." {
-							// merge imported scope with file scope
-							for _, obj := range imp.scope.elems {
-								// A package scope may contain non-exported objects,
-								// do not import them!
-								if obj.Exported() {
-									// TODO(gri) When we import a package, we create
-									// a new local package object. We should do the
-									// same for each dot-imported object. That way
-									// they can have correct position information.
-									// (We must not modify their existing position
-									// information because the same package - found
-									// via Config.Packages - may be dot-imported in
-									// another package!)
-									check.declare(fileScope, nil, obj, token.NoPos)
-									check.recordImplicit(s, obj)
-								}
-							}
-							// add position to set of dot-import positions for this file
-							// (this is only needed for "imported but not used" errors)
-							check.addUnusedDotImport(fileScope, imp, s.Pos())
-						} else {
-							// declare imported package object in file scope
-							check.declare(fileScope, nil, obj, token.NoPos)
-						}
-
-					case *ast.ValueSpec:
-						switch d.Tok {
-						case token.CONST:
-							// determine which initialization expressions to use
-							switch {
-							case s.Type != nil || len(s.Values) > 0:
-								last = s
-							case last == nil:
-								last = new(ast.ValueSpec) // make sure last exists
-							}
-
-							// declare all constants
-							for i, name := range s.Names {
-								obj := NewConst(name.Pos(), pkg, name.Name, nil, constant.MakeInt64(int64(iota)))
-
-								var init ast.Expr
-								if i < len(last.Values) {
-									init = last.Values[i]
-								}
-
-								d := &declInfo{file: fileScope, typ: last.Type, init: init}
-								check.declarePkgObj(name, obj, d)
-							}
-
-							check.arityMatch(s, last)
-
-						case token.VAR:
-							lhs := make([]*Var, len(s.Names))
-							// If there's exactly one rhs initializer, use
-							// the same declInfo d1 for all lhs variables
-							// so that each lhs variable depends on the same
-							// rhs initializer (n:1 var declaration).
-							var d1 *declInfo
-							if len(s.Values) == 1 {
-								// The lhs elements are only set up after the for loop below,
-								// but that's ok because declareVar only collects the declInfo
-								// for a later phase.
-								d1 = &declInfo{file: fileScope, lhs: lhs, typ: s.Type, init: s.Values[0]}
-							}
-
-							// declare all variables
-							for i, name := range s.Names {
-								obj := NewVar(name.Pos(), pkg, name.Name, nil)
-								lhs[i] = obj
-
-								d := d1
-								if d == nil {
-									// individual assignments
-									var init ast.Expr
-									if i < len(s.Values) {
-										init = s.Values[i]
-									}
-									d = &declInfo{file: fileScope, typ: s.Type, init: init}
-								}
-
-								check.declarePkgObj(name, obj, d)
-							}
-
-							check.arityMatch(s, nil)
-
-						default:
-							check.invalidAST(s.Pos(), "invalid token %s", d.Tok)
-						}
-
-					case *ast.TypeSpec:
-						obj := NewTypeName(s.Name.Pos(), pkg, s.Name.Name, nil)
-						check.declarePkgObj(s.Name, obj, &declInfo{file: fileScope, typ: s.Type})
-
-					default:
-						check.invalidAST(s.Pos(), "unknown ast.Spec node %T", s)
-					}
-				}
-
-			case *ast.FuncDecl:
-				name := d.Name.Name
-				obj := NewFunc(d.Name.Pos(), pkg, name, nil)
-				if d.Recv == nil {
-					// regular function
-					if name == "init" {
-						// don't declare init functions in the package scope - they are invisible
-						obj.parent = pkg.scope
-						check.recordDef(d.Name, obj)
-						// init functions must have a body
-						if d.Body == nil {
-							check.softErrorf(obj.pos, "missing function body")
-						}
-					} else {
-						check.declare(pkg.scope, d.Name, obj, token.NoPos)
-					}
-				} else {
-					// method
-					check.recordDef(d.Name, obj)
-					// Associate method with receiver base type name, if possible.
-					// Ignore methods that have an invalid receiver, or a blank _
-					// receiver name. They will be type-checked later, with regular
-					// functions.
-					if list := d.Recv.List; len(list) > 0 {
-						typ := list[0].Type
-						if ptr, _ := typ.(*ast.StarExpr); ptr != nil {
-							typ = ptr.X
-						}
-						if base, _ := typ.(*ast.Ident); base != nil && base.Name != "_" {
-							check.assocMethod(base.Name, obj)
-						}
-					}
-				}
-				info := &declInfo{file: fileScope, fdecl: d}
-				check.objMap[obj] = info
-				obj.setOrder(uint32(len(check.objMap)))
-
-			default:
-				check.invalidAST(d.Pos(), "unknown ast.Decl node %T", d)
-			}
-		}
-	}
-
-	// verify that objects in package and file scopes have different names
-	for _, scope := range check.pkg.scope.children /* file scopes */ {
-		for _, obj := range scope.elems {
-			if alt := pkg.scope.Lookup(obj.Name()); alt != nil {
-				if pkg, ok := obj.(*PkgName); ok {
-					check.errorf(alt.Pos(), "%s already declared through import of %s", alt.Name(), pkg.Imported())
-					check.reportAltDecl(pkg)
-				} else {
-					check.errorf(alt.Pos(), "%s already declared through dot-import of %s", alt.Name(), obj.Pkg())
-					// TODO(gri) dot-imported objects don't have a position; reportAltDecl won't print anything
-					check.reportAltDecl(obj)
-				}
-			}
-		}
-	}
-}
-
-// packageObjects typechecks all package objects in objList, but not function bodies.
-func (check *Checker) packageObjects(objList []Object) {
-	// add new methods to already type-checked types (from a prior Checker.Files call)
-	for _, obj := range objList {
-		if obj, _ := obj.(*TypeName); obj != nil && obj.typ != nil {
-			check.addMethodDecls(obj)
-		}
-	}
-
-	// pre-allocate space for type declaration paths so that the underlying array is reused
-	typePath := make([]*TypeName, 0, 8)
-
-	for _, obj := range objList {
-		check.objDecl(obj, nil, typePath)
-	}
-
-	// At this point we may have a non-empty check.methods map; this means that not all
-	// entries were deleted at the end of typeDecl because the respective receiver base
-	// types were not found. In that case, an error was reported when declaring those
-	// methods. We can now safely discard this map.
-	check.methods = nil
-}
-
-// functionBodies typechecks all function bodies.
-func (check *Checker) functionBodies() {
-	for _, f := range check.funcs {
-		check.funcBody(f.decl, f.name, f.sig, f.body)
-	}
-}
-
-// unusedImports checks for unused imports.
-func (check *Checker) unusedImports() {
-	// if function bodies are not checked, packages' uses are likely missing - don't check
-	if check.conf.IgnoreFuncBodies {
-		return
-	}
-
-	// spec: "It is illegal (...) to directly import a package without referring to
-	// any of its exported identifiers. To import a package solely for its side-effects
-	// (initialization), use the blank identifier as explicit package name."
-
-	// check use of regular imported packages
-	for _, scope := range check.pkg.scope.children /* file scopes */ {
-		for _, obj := range scope.elems {
-			if obj, ok := obj.(*PkgName); ok {
-				// Unused "blank imports" are automatically ignored
-				// since _ identifiers are not entered into scopes.
-				if !obj.used {
-					path := obj.imported.path
-					base := pathLib.Base(path)
-					if obj.name == base {
-						check.softErrorf(obj.pos, "%q imported but not used", path)
-					} else {
-						check.softErrorf(obj.pos, "%q imported but not used as %s", path, obj.name)
-					}
-				}
-			}
-		}
-	}
-
-	// check use of dot-imported packages
-	for _, unusedDotImports := range check.unusedDotImports {
-		for pkg, pos := range unusedDotImports {
-			check.softErrorf(pos, "%q imported but not used", pkg.path)
-		}
-	}
-}
diff --git a/third_party/golang/go/types/return.go b/third_party/golang/go/types/return.go
deleted file mode 100644
index 1b44a47e2fa5c..0000000000000
--- a/third_party/golang/go/types/return.go
+++ /dev/null
@@ -1,185 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements isTerminating.
-
-package types
-
-import (
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-)
-
-// isTerminating reports if s is a terminating statement.
-// If s is labeled, label is the label name; otherwise s
-// is "".
-func (check *Checker) isTerminating(s ast.Stmt, label string) bool {
-	switch s := s.(type) {
-	default:
-		unreachable()
-
-	case *ast.BadStmt, *ast.DeclStmt, *ast.EmptyStmt, *ast.SendStmt,
-		*ast.IncDecStmt, *ast.AssignStmt, *ast.GoStmt, *ast.DeferStmt,
-		*ast.RangeStmt:
-		// no chance
-
-	case *ast.LabeledStmt:
-		return check.isTerminating(s.Stmt, s.Label.Name)
-
-	case *ast.ExprStmt:
-		// the predeclared (possibly parenthesized) panic() function is terminating
-		if call, _ := unparen(s.X).(*ast.CallExpr); call != nil {
-			if id, _ := call.Fun.(*ast.Ident); id != nil {
-				if _, obj := check.scope.LookupParent(id.Name, token.NoPos); obj != nil {
-					if b, _ := obj.(*Builtin); b != nil && b.id == _Panic {
-						return true
-					}
-				}
-			}
-		}
-
-	case *ast.ReturnStmt:
-		return true
-
-	case *ast.BranchStmt:
-		if s.Tok == token.GOTO || s.Tok == token.FALLTHROUGH {
-			return true
-		}
-
-	case *ast.BlockStmt:
-		return check.isTerminatingList(s.List, "")
-
-	case *ast.IfStmt:
-		if s.Else != nil &&
-			check.isTerminating(s.Body, "") &&
-			check.isTerminating(s.Else, "") {
-			return true
-		}
-
-	case *ast.SwitchStmt:
-		return check.isTerminatingSwitch(s.Body, label)
-
-	case *ast.TypeSwitchStmt:
-		return check.isTerminatingSwitch(s.Body, label)
-
-	case *ast.SelectStmt:
-		for _, s := range s.Body.List {
-			cc := s.(*ast.CommClause)
-			if !check.isTerminatingList(cc.Body, "") || hasBreakList(cc.Body, label, true) {
-				return false
-			}
-
-		}
-		return true
-
-	case *ast.ForStmt:
-		if s.Cond == nil && !hasBreak(s.Body, label, true) {
-			return true
-		}
-	}
-
-	return false
-}
-
-func (check *Checker) isTerminatingList(list []ast.Stmt, label string) bool {
-	n := len(list)
-	return n > 0 && check.isTerminating(list[n-1], label)
-}
-
-func (check *Checker) isTerminatingSwitch(body *ast.BlockStmt, label string) bool {
-	hasDefault := false
-	for _, s := range body.List {
-		cc := s.(*ast.CaseClause)
-		if cc.List == nil {
-			hasDefault = true
-		}
-		if !check.isTerminatingList(cc.Body, "") || hasBreakList(cc.Body, label, true) {
-			return false
-		}
-	}
-	return hasDefault
-}
-
-// TODO(gri) For nested breakable statements, the current implementation of hasBreak
-//	     will traverse the same subtree repeatedly, once for each label. Replace
-//           with a single-pass label/break matching phase.
-
-// hasBreak reports if s is or contains a break statement
-// referring to the label-ed statement or implicit-ly the
-// closest outer breakable statement.
-func hasBreak(s ast.Stmt, label string, implicit bool) bool {
-	switch s := s.(type) {
-	default:
-		unreachable()
-
-	case *ast.BadStmt, *ast.DeclStmt, *ast.EmptyStmt, *ast.ExprStmt,
-		*ast.SendStmt, *ast.IncDecStmt, *ast.AssignStmt, *ast.GoStmt,
-		*ast.DeferStmt, *ast.ReturnStmt:
-		// no chance
-
-	case *ast.LabeledStmt:
-		return hasBreak(s.Stmt, label, implicit)
-
-	case *ast.BranchStmt:
-		if s.Tok == token.BREAK {
-			if s.Label == nil {
-				return implicit
-			}
-			if s.Label.Name == label {
-				return true
-			}
-		}
-
-	case *ast.BlockStmt:
-		return hasBreakList(s.List, label, implicit)
-
-	case *ast.IfStmt:
-		if hasBreak(s.Body, label, implicit) ||
-			s.Else != nil && hasBreak(s.Else, label, implicit) {
-			return true
-		}
-
-	case *ast.CaseClause:
-		return hasBreakList(s.Body, label, implicit)
-
-	case *ast.SwitchStmt:
-		if label != "" && hasBreak(s.Body, label, false) {
-			return true
-		}
-
-	case *ast.TypeSwitchStmt:
-		if label != "" && hasBreak(s.Body, label, false) {
-			return true
-		}
-
-	case *ast.CommClause:
-		return hasBreakList(s.Body, label, implicit)
-
-	case *ast.SelectStmt:
-		if label != "" && hasBreak(s.Body, label, false) {
-			return true
-		}
-
-	case *ast.ForStmt:
-		if label != "" && hasBreak(s.Body, label, false) {
-			return true
-		}
-
-	case *ast.RangeStmt:
-		if label != "" && hasBreak(s.Body, label, false) {
-			return true
-		}
-	}
-
-	return false
-}
-
-func hasBreakList(list []ast.Stmt, label string, implicit bool) bool {
-	for _, s := range list {
-		if hasBreak(s, label, implicit) {
-			return true
-		}
-	}
-	return false
-}
diff --git a/third_party/golang/go/types/scope.go b/third_party/golang/go/types/scope.go
deleted file mode 100644
index a352490b82927..0000000000000
--- a/third_party/golang/go/types/scope.go
+++ /dev/null
@@ -1,191 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements Scopes.
-
-package types
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"sort"
-	"strings"
-
-	"k8s.io/kubernetes/third_party/golang/go/token"
-)
-
-// TODO(gri) Provide scopes with a name or other mechanism so that
-//           objects can use that information for better printing.
-
-// A Scope maintains a set of objects and links to its containing
-// (parent) and contained (children) scopes. Objects may be inserted
-// and looked up by name. The zero value for Scope is a ready-to-use
-// empty scope.
-type Scope struct {
-	parent   *Scope
-	children []*Scope
-	elems    map[string]Object // lazily allocated
-	pos, end token.Pos         // scope extent; may be invalid
-	comment  string            // for debugging only
-}
-
-// NewScope returns a new, empty scope contained in the given parent
-// scope, if any.  The comment is for debugging only.
-func NewScope(parent *Scope, pos, end token.Pos, comment string) *Scope {
-	s := &Scope{parent, nil, nil, pos, end, comment}
-	// don't add children to Universe scope!
-	if parent != nil && parent != Universe {
-		parent.children = append(parent.children, s)
-	}
-	return s
-}
-
-// Parent returns the scope's containing (parent) scope.
-func (s *Scope) Parent() *Scope { return s.parent }
-
-// Len() returns the number of scope elements.
-func (s *Scope) Len() int { return len(s.elems) }
-
-// Names returns the scope's element names in sorted order.
-func (s *Scope) Names() []string {
-	names := make([]string, len(s.elems))
-	i := 0
-	for name := range s.elems {
-		names[i] = name
-		i++
-	}
-	sort.Strings(names)
-	return names
-}
-
-// NumChildren() returns the number of scopes nested in s.
-func (s *Scope) NumChildren() int { return len(s.children) }
-
-// Child returns the i'th child scope for 0 <= i < NumChildren().
-func (s *Scope) Child(i int) *Scope { return s.children[i] }
-
-// Lookup returns the object in scope s with the given name if such an
-// object exists; otherwise the result is nil.
-func (s *Scope) Lookup(name string) Object {
-	return s.elems[name]
-}
-
-// LookupParent follows the parent chain of scopes starting with s until
-// it finds a scope where Lookup(name) returns a non-nil object, and then
-// returns that scope and object. If a valid position pos is provided,
-// only objects that were declared at or before pos are considered.
-// If no such scope and object exists, the result is (nil, nil).
-//
-// Note that obj.Parent() may be different from the returned scope if the
-// object was inserted into the scope and already had a parent at that
-// time (see Insert, below). This can only happen for dot-imported objects
-// whose scope is the scope of the package that exported them.
-func (s *Scope) LookupParent(name string, pos token.Pos) (*Scope, Object) {
-	for ; s != nil; s = s.parent {
-		if obj := s.elems[name]; obj != nil && (!pos.IsValid() || obj.scopePos() <= pos) {
-			return s, obj
-		}
-	}
-	return nil, nil
-}
-
-// Insert attempts to insert an object obj into scope s.
-// If s already contains an alternative object alt with
-// the same name, Insert leaves s unchanged and returns alt.
-// Otherwise it inserts obj, sets the object's parent scope
-// if not already set, and returns nil.
-func (s *Scope) Insert(obj Object) Object {
-	name := obj.Name()
-	if alt := s.elems[name]; alt != nil {
-		return alt
-	}
-	if s.elems == nil {
-		s.elems = make(map[string]Object)
-	}
-	s.elems[name] = obj
-	if obj.Parent() == nil {
-		obj.setParent(s)
-	}
-	return nil
-}
-
-// Pos and End describe the scope's source code extent [pos, end).
-// The results are guaranteed to be valid only if the type-checked
-// AST has complete position information. The extent is undefined
-// for Universe and package scopes.
-func (s *Scope) Pos() token.Pos { return s.pos }
-func (s *Scope) End() token.Pos { return s.end }
-
-// Contains returns true if pos is within the scope's extent.
-// The result is guaranteed to be valid only if the type-checked
-// AST has complete position information.
-func (s *Scope) Contains(pos token.Pos) bool {
-	return s.pos <= pos && pos < s.end
-}
-
-// Innermost returns the innermost (child) scope containing
-// pos. If pos is not within any scope, the result is nil.
-// The result is also nil for the Universe scope.
-// The result is guaranteed to be valid only if the type-checked
-// AST has complete position information.
-func (s *Scope) Innermost(pos token.Pos) *Scope {
-	// Package scopes do not have extents since they may be
-	// discontiguous, so iterate over the package's files.
-	if s.parent == Universe {
-		for _, s := range s.children {
-			if inner := s.Innermost(pos); inner != nil {
-				return inner
-			}
-		}
-	}
-
-	if s.Contains(pos) {
-		for _, s := range s.children {
-			if s.Contains(pos) {
-				return s.Innermost(pos)
-			}
-		}
-		return s
-	}
-	return nil
-}
-
-// WriteTo writes a string representation of the scope to w,
-// with the scope elements sorted by name.
-// The level of indentation is controlled by n >= 0, with
-// n == 0 for no indentation.
-// If recurse is set, it also writes nested (children) scopes.
-func (s *Scope) WriteTo(w io.Writer, n int, recurse bool) {
-	const ind = ".  "
-	indn := strings.Repeat(ind, n)
-
-	fmt.Fprintf(w, "%s%s scope %p {", indn, s.comment, s)
-	if len(s.elems) == 0 {
-		fmt.Fprintf(w, "}\n")
-		return
-	}
-
-	fmt.Fprintln(w)
-	indn1 := indn + ind
-	for _, name := range s.Names() {
-		fmt.Fprintf(w, "%s%s\n", indn1, s.elems[name])
-	}
-
-	if recurse {
-		for _, s := range s.children {
-			fmt.Fprintln(w)
-			s.WriteTo(w, n+1, recurse)
-		}
-	}
-
-	fmt.Fprintf(w, "%s}", indn)
-}
-
-// String returns a string representation of the scope, for debugging.
-func (s *Scope) String() string {
-	var buf bytes.Buffer
-	s.WriteTo(&buf, 0, false)
-	return buf.String()
-}
diff --git a/third_party/golang/go/types/selection.go b/third_party/golang/go/types/selection.go
deleted file mode 100644
index 124e0d39f02b9..0000000000000
--- a/third_party/golang/go/types/selection.go
+++ /dev/null
@@ -1,143 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements Selections.
-
-package types
-
-import (
-	"bytes"
-	"fmt"
-)
-
-// SelectionKind describes the kind of a selector expression x.f
-// (excluding qualified identifiers).
-type SelectionKind int
-
-const (
-	FieldVal   SelectionKind = iota // x.f is a struct field selector
-	MethodVal                       // x.f is a method selector
-	MethodExpr                      // x.f is a method expression
-)
-
-// A Selection describes a selector expression x.f.
-// For the declarations:
-//
-//	type T struct{ x int; E }
-//	type E struct{}
-//	func (e E) m() {}
-//	var p *T
-//
-// the following relations exist:
-//
-//	Selector    Kind          Recv    Obj    Type               Index     Indirect
-//
-//	p.x         FieldVal      T       x      int                {0}       true
-//	p.m         MethodVal     *T      m      func (e *T) m()    {1, 0}    true
-//	T.m         MethodExpr    T       m      func m(_ T)        {1, 0}    false
-//
-type Selection struct {
-	kind     SelectionKind
-	recv     Type   // type of x
-	obj      Object // object denoted by x.f
-	index    []int  // path from x to x.f
-	indirect bool   // set if there was any pointer indirection on the path
-}
-
-// Kind returns the selection kind.
-func (s *Selection) Kind() SelectionKind { return s.kind }
-
-// Recv returns the type of x in x.f.
-func (s *Selection) Recv() Type { return s.recv }
-
-// Obj returns the object denoted by x.f; a *Var for
-// a field selection, and a *Func in all other cases.
-func (s *Selection) Obj() Object { return s.obj }
-
-// Type returns the type of x.f, which may be different from the type of f.
-// See Selection for more information.
-func (s *Selection) Type() Type {
-	switch s.kind {
-	case MethodVal:
-		// The type of x.f is a method with its receiver type set
-		// to the type of x.
-		sig := *s.obj.(*Func).typ.(*Signature)
-		recv := *sig.recv
-		recv.typ = s.recv
-		sig.recv = &recv
-		return &sig
-
-	case MethodExpr:
-		// The type of x.f is a function (without receiver)
-		// and an additional first argument with the same type as x.
-		// TODO(gri) Similar code is already in call.go - factor!
-		// TODO(gri) Compute this eagerly to avoid allocations.
-		sig := *s.obj.(*Func).typ.(*Signature)
-		arg0 := *sig.recv
-		sig.recv = nil
-		arg0.typ = s.recv
-		var params []*Var
-		if sig.params != nil {
-			params = sig.params.vars
-		}
-		sig.params = NewTuple(append([]*Var{&arg0}, params...)...)
-		return &sig
-	}
-
-	// In all other cases, the type of x.f is the type of x.
-	return s.obj.Type()
-}
-
-// Index describes the path from x to f in x.f.
-// The last index entry is the field or method index of the type declaring f;
-// either:
-//
-//	1) the list of declared methods of a named type; or
-//	2) the list of methods of an interface type; or
-//	3) the list of fields of a struct type.
-//
-// The earlier index entries are the indices of the embedded fields implicitly
-// traversed to get from (the type of) x to f, starting at embedding depth 0.
-func (s *Selection) Index() []int { return s.index }
-
-// Indirect reports whether any pointer indirection was required to get from
-// x to f in x.f.
-func (s *Selection) Indirect() bool { return s.indirect }
-
-func (s *Selection) String() string { return SelectionString(s, nil) }
-
-// SelectionString returns the string form of s.
-// The Qualifier controls the printing of
-// package-level objects, and may be nil.
-//
-// Examples:
-//	"field (T) f int"
-//	"method (T) f(X) Y"
-//	"method expr (T) f(X) Y"
-//
-func SelectionString(s *Selection, qf Qualifier) string {
-	var k string
-	switch s.kind {
-	case FieldVal:
-		k = "field "
-	case MethodVal:
-		k = "method "
-	case MethodExpr:
-		k = "method expr "
-	default:
-		unreachable()
-	}
-	var buf bytes.Buffer
-	buf.WriteString(k)
-	buf.WriteByte('(')
-	WriteType(&buf, s.Recv(), qf)
-	fmt.Fprintf(&buf, ") %s", s.obj.Name())
-	if T := s.Type(); s.kind == FieldVal {
-		buf.WriteByte(' ')
-		WriteType(&buf, T, qf)
-	} else {
-		WriteSignature(&buf, T.(*Signature), qf)
-	}
-	return buf.String()
-}
diff --git a/third_party/golang/go/types/sizes.go b/third_party/golang/go/types/sizes.go
deleted file mode 100644
index 56fb310c29476..0000000000000
--- a/third_party/golang/go/types/sizes.go
+++ /dev/null
@@ -1,211 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements Sizes.
-
-package types
-
-// Sizes defines the sizing functions for package unsafe.
-type Sizes interface {
-	// Alignof returns the alignment of a variable of type T.
-	// Alignof must implement the alignment guarantees required by the spec.
-	Alignof(T Type) int64
-
-	// Offsetsof returns the offsets of the given struct fields, in bytes.
-	// Offsetsof must implement the offset guarantees required by the spec.
-	Offsetsof(fields []*Var) []int64
-
-	// Sizeof returns the size of a variable of type T.
-	// Sizeof must implement the size guarantees required by the spec.
-	Sizeof(T Type) int64
-}
-
-// StdSizes is a convenience type for creating commonly used Sizes.
-// It makes the following simplifying assumptions:
-//
-//	- The size of explicitly sized basic types (int16, etc.) is the
-//	  specified size.
-//	- The size of strings and interfaces is 2*WordSize.
-//	- The size of slices is 3*WordSize.
-//	- The size of an array of n elements corresponds to the size of
-//	  a struct of n consecutive fields of the array's element type.
-//      - The size of a struct is the offset of the last field plus that
-//	  field's size. As with all element types, if the struct is used
-//	  in an array its size must first be aligned to a multiple of the
-//	  struct's alignment.
-//	- All other types have size WordSize.
-//	- Arrays and structs are aligned per spec definition; all other
-//	  types are naturally aligned with a maximum alignment MaxAlign.
-//
-// *StdSizes implements Sizes.
-//
-type StdSizes struct {
-	WordSize int64 // word size in bytes - must be >= 4 (32bits)
-	MaxAlign int64 // maximum alignment in bytes - must be >= 1
-}
-
-func (s *StdSizes) Alignof(T Type) int64 {
-	// For arrays and structs, alignment is defined in terms
-	// of alignment of the elements and fields, respectively.
-	switch t := T.Underlying().(type) {
-	case *Array:
-		// spec: "For a variable x of array type: unsafe.Alignof(x)
-		// is the same as unsafe.Alignof(x[0]), but at least 1."
-		return s.Alignof(t.elem)
-	case *Struct:
-		// spec: "For a variable x of struct type: unsafe.Alignof(x)
-		// is the largest of the values unsafe.Alignof(x.f) for each
-		// field f of x, but at least 1."
-		max := int64(1)
-		for _, f := range t.fields {
-			if a := s.Alignof(f.typ); a > max {
-				max = a
-			}
-		}
-		return max
-	}
-	a := s.Sizeof(T) // may be 0
-	// spec: "For a variable x of any type: unsafe.Alignof(x) is at least 1."
-	if a < 1 {
-		return 1
-	}
-	if a > s.MaxAlign {
-		return s.MaxAlign
-	}
-	return a
-}
-
-func (s *StdSizes) Offsetsof(fields []*Var) []int64 {
-	offsets := make([]int64, len(fields))
-	var o int64
-	for i, f := range fields {
-		a := s.Alignof(f.typ)
-		o = align(o, a)
-		offsets[i] = o
-		o += s.Sizeof(f.typ)
-	}
-	return offsets
-}
-
-var basicSizes = [...]byte{
-	Bool:       1,
-	Int8:       1,
-	Int16:      2,
-	Int32:      4,
-	Int64:      8,
-	Uint8:      1,
-	Uint16:     2,
-	Uint32:     4,
-	Uint64:     8,
-	Float32:    4,
-	Float64:    8,
-	Complex64:  8,
-	Complex128: 16,
-}
-
-func (s *StdSizes) Sizeof(T Type) int64 {
-	switch t := T.Underlying().(type) {
-	case *Basic:
-		assert(isTyped(T))
-		k := t.kind
-		if int(k) < len(basicSizes) {
-			if s := basicSizes[k]; s > 0 {
-				return int64(s)
-			}
-		}
-		if k == String {
-			return s.WordSize * 2
-		}
-	case *Array:
-		n := t.len
-		if n == 0 {
-			return 0
-		}
-		a := s.Alignof(t.elem)
-		z := s.Sizeof(t.elem)
-		return align(z, a)*(n-1) + z
-	case *Slice:
-		return s.WordSize * 3
-	case *Struct:
-		n := t.NumFields()
-		if n == 0 {
-			return 0
-		}
-		offsets := t.offsets
-		if t.offsets == nil {
-			// compute offsets on demand
-			offsets = s.Offsetsof(t.fields)
-			t.offsets = offsets
-		}
-		return offsets[n-1] + s.Sizeof(t.fields[n-1].typ)
-	case *Interface:
-		return s.WordSize * 2
-	}
-	return s.WordSize // catch-all
-}
-
-// stdSizes is used if Config.Sizes == nil.
-var stdSizes = StdSizes{8, 8}
-
-func (conf *Config) alignof(T Type) int64 {
-	if s := conf.Sizes; s != nil {
-		if a := s.Alignof(T); a >= 1 {
-			return a
-		}
-		panic("Config.Sizes.Alignof returned an alignment < 1")
-	}
-	return stdSizes.Alignof(T)
-}
-
-func (conf *Config) offsetsof(T *Struct) []int64 {
-	offsets := T.offsets
-	if offsets == nil && T.NumFields() > 0 {
-		// compute offsets on demand
-		if s := conf.Sizes; s != nil {
-			offsets = s.Offsetsof(T.fields)
-			// sanity checks
-			if len(offsets) != T.NumFields() {
-				panic("Config.Sizes.Offsetsof returned the wrong number of offsets")
-			}
-			for _, o := range offsets {
-				if o < 0 {
-					panic("Config.Sizes.Offsetsof returned an offset < 0")
-				}
-			}
-		} else {
-			offsets = stdSizes.Offsetsof(T.fields)
-		}
-		T.offsets = offsets
-	}
-	return offsets
-}
-
-// offsetof returns the offset of the field specified via
-// the index sequence relative to typ. All embedded fields
-// must be structs (rather than pointer to structs).
-func (conf *Config) offsetof(typ Type, index []int) int64 {
-	var o int64
-	for _, i := range index {
-		s := typ.Underlying().(*Struct)
-		o += conf.offsetsof(s)[i]
-		typ = s.fields[i].typ
-	}
-	return o
-}
-
-func (conf *Config) sizeof(T Type) int64 {
-	if s := conf.Sizes; s != nil {
-		if z := s.Sizeof(T); z >= 0 {
-			return z
-		}
-		panic("Config.Sizes.Sizeof returned a size < 0")
-	}
-	return stdSizes.Sizeof(T)
-}
-
-// align returns the smallest y >= x such that y % a == 0.
-func align(x, a int64) int64 {
-	y := x + a - 1
-	return y - y%a
-}
diff --git a/third_party/golang/go/types/stmt.go b/third_party/golang/go/types/stmt.go
deleted file mode 100644
index d8a129a0b1689..0000000000000
--- a/third_party/golang/go/types/stmt.go
+++ /dev/null
@@ -1,744 +0,0 @@
-// Copyright 2012 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements typechecking of statements.
-
-package types
-
-import (
-	"fmt"
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"k8s.io/kubernetes/third_party/golang/go/constant"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-)
-
-func (check *Checker) funcBody(decl *declInfo, name string, sig *Signature, body *ast.BlockStmt) {
-	if trace {
-		if name == "" {
-			name = ""
-		}
-		fmt.Printf("--- %s: %s {\n", name, sig)
-		defer fmt.Println("--- ")
-	}
-
-	// set function scope extent
-	sig.scope.pos = body.Pos()
-	sig.scope.end = body.End()
-
-	// save/restore current context and setup function context
-	// (and use 0 indentation at function start)
-	defer func(ctxt context, indent int) {
-		check.context = ctxt
-		check.indent = indent
-	}(check.context, check.indent)
-	check.context = context{
-		decl:  decl,
-		scope: sig.scope,
-		sig:   sig,
-	}
-	check.indent = 0
-
-	check.stmtList(0, body.List)
-
-	if check.hasLabel {
-		check.labels(body)
-	}
-
-	if sig.results.Len() > 0 && !check.isTerminating(body, "") {
-		check.error(body.Rbrace, "missing return")
-	}
-
-	// spec: "Implementation restriction: A compiler may make it illegal to
-	// declare a variable inside a function body if the variable is never used."
-	// (One could check each scope after use, but that distributes this check
-	// over several places because CloseScope is not always called explicitly.)
-	check.usage(sig.scope)
-}
-
-func (check *Checker) usage(scope *Scope) {
-	for _, obj := range scope.elems {
-		if v, _ := obj.(*Var); v != nil && !v.used {
-			check.softErrorf(v.pos, "%s declared but not used", v.name)
-		}
-	}
-	for _, scope := range scope.children {
-		check.usage(scope)
-	}
-}
-
-// stmtContext is a bitset describing which
-// control-flow statements are permissible.
-type stmtContext uint
-
-const (
-	breakOk stmtContext = 1 << iota
-	continueOk
-	fallthroughOk
-)
-
-func (check *Checker) simpleStmt(s ast.Stmt) {
-	if s != nil {
-		check.stmt(0, s)
-	}
-}
-
-func (check *Checker) stmtList(ctxt stmtContext, list []ast.Stmt) {
-	ok := ctxt&fallthroughOk != 0
-	inner := ctxt &^ fallthroughOk
-	for i, s := range list {
-		inner := inner
-		if ok && i+1 == len(list) {
-			inner |= fallthroughOk
-		}
-		check.stmt(inner, s)
-	}
-}
-
-func (check *Checker) multipleDefaults(list []ast.Stmt) {
-	var first ast.Stmt
-	for _, s := range list {
-		var d ast.Stmt
-		switch c := s.(type) {
-		case *ast.CaseClause:
-			if len(c.List) == 0 {
-				d = s
-			}
-		case *ast.CommClause:
-			if c.Comm == nil {
-				d = s
-			}
-		default:
-			check.invalidAST(s.Pos(), "case/communication clause expected")
-		}
-		if d != nil {
-			if first != nil {
-				check.errorf(d.Pos(), "multiple defaults (first at %s)", first.Pos())
-			} else {
-				first = d
-			}
-		}
-	}
-}
-
-func (check *Checker) openScope(s ast.Stmt, comment string) {
-	scope := NewScope(check.scope, s.Pos(), s.End(), comment)
-	check.recordScope(s, scope)
-	check.scope = scope
-}
-
-func (check *Checker) closeScope() {
-	check.scope = check.scope.Parent()
-}
-
-func assignOp(op token.Token) token.Token {
-	// token_test.go verifies the token ordering this function relies on
-	if token.ADD_ASSIGN <= op && op <= token.AND_NOT_ASSIGN {
-		return op + (token.ADD - token.ADD_ASSIGN)
-	}
-	return token.ILLEGAL
-}
-
-func (check *Checker) suspendedCall(keyword string, call *ast.CallExpr) {
-	var x operand
-	var msg string
-	switch check.rawExpr(&x, call, nil) {
-	case conversion:
-		msg = "requires function call, not conversion"
-	case expression:
-		msg = "discards result of"
-	case statement:
-		return
-	default:
-		unreachable()
-	}
-	check.errorf(x.pos(), "%s %s %s", keyword, msg, &x)
-}
-
-func (check *Checker) caseValues(x operand /* copy argument (not *operand!) */, values []ast.Expr) {
-	// No duplicate checking for now. See issue 4524.
-	for _, e := range values {
-		var y operand
-		check.expr(&y, e)
-		if y.mode == invalid {
-			return
-		}
-		// TODO(gri) The convertUntyped call pair below appears in other places. Factor!
-		// Order matters: By comparing y against x, error positions are at the case values.
-		check.convertUntyped(&y, x.typ)
-		if y.mode == invalid {
-			return
-		}
-		check.convertUntyped(&x, y.typ)
-		if x.mode == invalid {
-			return
-		}
-		check.comparison(&y, &x, token.EQL)
-	}
-}
-
-func (check *Checker) caseTypes(x *operand, xtyp *Interface, types []ast.Expr, seen map[Type]token.Pos) (T Type) {
-L:
-	for _, e := range types {
-		T = check.typOrNil(e)
-		if T == Typ[Invalid] {
-			continue
-		}
-		// complain about duplicate types
-		// TODO(gri) use a type hash to avoid quadratic algorithm
-		for t, pos := range seen {
-			if T == nil && t == nil || T != nil && t != nil && Identical(T, t) {
-				// talk about "case" rather than "type" because of nil case
-				check.error(e.Pos(), "duplicate case in type switch")
-				check.errorf(pos, "\tprevious case %s", T) // secondary error, \t indented
-				continue L
-			}
-		}
-		seen[T] = e.Pos()
-		if T != nil {
-			check.typeAssertion(e.Pos(), x, xtyp, T)
-		}
-	}
-	return
-}
-
-// stmt typechecks statement s.
-func (check *Checker) stmt(ctxt stmtContext, s ast.Stmt) {
-	// statements cannot use iota in general
-	// (constant declarations set it explicitly)
-	assert(check.iota == nil)
-
-	// statements must end with the same top scope as they started with
-	if debug {
-		defer func(scope *Scope) {
-			// don't check if code is panicking
-			if p := recover(); p != nil {
-				panic(p)
-			}
-			assert(scope == check.scope)
-		}(check.scope)
-	}
-
-	inner := ctxt &^ fallthroughOk
-	switch s := s.(type) {
-	case *ast.BadStmt, *ast.EmptyStmt:
-		// ignore
-
-	case *ast.DeclStmt:
-		check.declStmt(s.Decl)
-
-	case *ast.LabeledStmt:
-		check.hasLabel = true
-		check.stmt(ctxt, s.Stmt)
-
-	case *ast.ExprStmt:
-		// spec: "With the exception of specific built-in functions,
-		// function and method calls and receive operations can appear
-		// in statement context. Such statements may be parenthesized."
-		var x operand
-		kind := check.rawExpr(&x, s.X, nil)
-		var msg string
-		switch x.mode {
-		default:
-			if kind == statement {
-				return
-			}
-			msg = "is not used"
-		case builtin:
-			msg = "must be called"
-		case typexpr:
-			msg = "is not an expression"
-		}
-		check.errorf(x.pos(), "%s %s", &x, msg)
-
-	case *ast.SendStmt:
-		var ch, x operand
-		check.expr(&ch, s.Chan)
-		check.expr(&x, s.Value)
-		if ch.mode == invalid || x.mode == invalid {
-			return
-		}
-		if tch, ok := ch.typ.Underlying().(*Chan); !ok || tch.dir == RecvOnly || !check.assignment(&x, tch.elem) {
-			if x.mode != invalid {
-				check.invalidOp(ch.pos(), "cannot send %s to channel %s", &x, &ch)
-			}
-		}
-
-	case *ast.IncDecStmt:
-		var op token.Token
-		switch s.Tok {
-		case token.INC:
-			op = token.ADD
-		case token.DEC:
-			op = token.SUB
-		default:
-			check.invalidAST(s.TokPos, "unknown inc/dec operation %s", s.Tok)
-			return
-		}
-		var x operand
-		Y := &ast.BasicLit{ValuePos: s.X.Pos(), Kind: token.INT, Value: "1"} // use x's position
-		check.binary(&x, nil, s.X, Y, op)
-		if x.mode == invalid {
-			return
-		}
-		check.assignVar(s.X, &x)
-
-	case *ast.AssignStmt:
-		switch s.Tok {
-		case token.ASSIGN, token.DEFINE:
-			if len(s.Lhs) == 0 {
-				check.invalidAST(s.Pos(), "missing lhs in assignment")
-				return
-			}
-			if s.Tok == token.DEFINE {
-				check.shortVarDecl(s.TokPos, s.Lhs, s.Rhs)
-			} else {
-				// regular assignment
-				check.assignVars(s.Lhs, s.Rhs)
-			}
-
-		default:
-			// assignment operations
-			if len(s.Lhs) != 1 || len(s.Rhs) != 1 {
-				check.errorf(s.TokPos, "assignment operation %s requires single-valued expressions", s.Tok)
-				return
-			}
-			op := assignOp(s.Tok)
-			if op == token.ILLEGAL {
-				check.invalidAST(s.TokPos, "unknown assignment operation %s", s.Tok)
-				return
-			}
-			var x operand
-			check.binary(&x, nil, s.Lhs[0], s.Rhs[0], op)
-			if x.mode == invalid {
-				return
-			}
-			check.assignVar(s.Lhs[0], &x)
-		}
-
-	case *ast.GoStmt:
-		check.suspendedCall("go", s.Call)
-
-	case *ast.DeferStmt:
-		check.suspendedCall("defer", s.Call)
-
-	case *ast.ReturnStmt:
-		res := check.sig.results
-		if res.Len() > 0 {
-			// function returns results
-			// (if one, say the first, result parameter is named, all of them are named)
-			if len(s.Results) == 0 && res.vars[0].name != "" {
-				// spec: "Implementation restriction: A compiler may disallow an empty expression
-				// list in a "return" statement if a different entity (constant, type, or variable)
-				// with the same name as a result parameter is in scope at the place of the return."
-				for _, obj := range res.vars {
-					if _, alt := check.scope.LookupParent(obj.name, check.pos); alt != nil && alt != obj {
-						check.errorf(s.Pos(), "result parameter %s not in scope at return", obj.name)
-						check.errorf(alt.Pos(), "\tinner declaration of %s", obj)
-						// ok to continue
-					}
-				}
-			} else {
-				// return has results or result parameters are unnamed
-				check.initVars(res.vars, s.Results, s.Return)
-			}
-		} else if len(s.Results) > 0 {
-			check.error(s.Results[0].Pos(), "no result values expected")
-			check.use(s.Results...)
-		}
-
-	case *ast.BranchStmt:
-		if s.Label != nil {
-			check.hasLabel = true
-			return // checked in 2nd pass (check.labels)
-		}
-		switch s.Tok {
-		case token.BREAK:
-			if ctxt&breakOk == 0 {
-				check.error(s.Pos(), "break not in for, switch, or select statement")
-			}
-		case token.CONTINUE:
-			if ctxt&continueOk == 0 {
-				check.error(s.Pos(), "continue not in for statement")
-			}
-		case token.FALLTHROUGH:
-			if ctxt&fallthroughOk == 0 {
-				check.error(s.Pos(), "fallthrough statement out of place")
-			}
-		default:
-			check.invalidAST(s.Pos(), "branch statement: %s", s.Tok)
-		}
-
-	case *ast.BlockStmt:
-		check.openScope(s, "block")
-		defer check.closeScope()
-
-		check.stmtList(inner, s.List)
-
-	case *ast.IfStmt:
-		check.openScope(s, "if")
-		defer check.closeScope()
-
-		check.simpleStmt(s.Init)
-		var x operand
-		check.expr(&x, s.Cond)
-		if x.mode != invalid && !isBoolean(x.typ) {
-			check.error(s.Cond.Pos(), "non-boolean condition in if statement")
-		}
-		check.stmt(inner, s.Body)
-		if s.Else != nil {
-			check.stmt(inner, s.Else)
-		}
-
-	case *ast.SwitchStmt:
-		inner |= breakOk
-		check.openScope(s, "switch")
-		defer check.closeScope()
-
-		check.simpleStmt(s.Init)
-		var x operand
-		if s.Tag != nil {
-			check.expr(&x, s.Tag)
-		} else {
-			// spec: "A missing switch expression is
-			// equivalent to the boolean value true."
-			x.mode = constant_
-			x.typ = Typ[Bool]
-			x.val = constant.MakeBool(true)
-			x.expr = &ast.Ident{NamePos: s.Body.Lbrace, Name: "true"}
-		}
-
-		check.multipleDefaults(s.Body.List)
-
-		for i, c := range s.Body.List {
-			clause, _ := c.(*ast.CaseClause)
-			if clause == nil {
-				check.invalidAST(c.Pos(), "incorrect expression switch case")
-				continue
-			}
-			if x.mode != invalid {
-				check.caseValues(x, clause.List)
-			}
-			check.openScope(clause, "case")
-			inner := inner
-			if i+1 < len(s.Body.List) {
-				inner |= fallthroughOk
-			}
-			check.stmtList(inner, clause.Body)
-			check.closeScope()
-		}
-
-	case *ast.TypeSwitchStmt:
-		inner |= breakOk
-		check.openScope(s, "type switch")
-		defer check.closeScope()
-
-		check.simpleStmt(s.Init)
-
-		// A type switch guard must be of the form:
-		//
-		//     TypeSwitchGuard = [ identifier ":=" ] PrimaryExpr "." "(" "type" ")" .
-		//
-		// The parser is checking syntactic correctness;
-		// remaining syntactic errors are considered AST errors here.
-		// TODO(gri) better factoring of error handling (invalid ASTs)
-		//
-		var lhs *ast.Ident // lhs identifier or nil
-		var rhs ast.Expr
-		switch guard := s.Assign.(type) {
-		case *ast.ExprStmt:
-			rhs = guard.X
-		case *ast.AssignStmt:
-			if len(guard.Lhs) != 1 || guard.Tok != token.DEFINE || len(guard.Rhs) != 1 {
-				check.invalidAST(s.Pos(), "incorrect form of type switch guard")
-				return
-			}
-
-			lhs, _ = guard.Lhs[0].(*ast.Ident)
-			if lhs == nil {
-				check.invalidAST(s.Pos(), "incorrect form of type switch guard")
-				return
-			}
-
-			if lhs.Name == "_" {
-				// _ := x.(type) is an invalid short variable declaration
-				check.softErrorf(lhs.Pos(), "no new variable on left side of :=")
-				lhs = nil // avoid declared but not used error below
-			} else {
-				check.recordDef(lhs, nil) // lhs variable is implicitly declared in each cause clause
-			}
-
-			rhs = guard.Rhs[0]
-
-		default:
-			check.invalidAST(s.Pos(), "incorrect form of type switch guard")
-			return
-		}
-
-		// rhs must be of the form: expr.(type) and expr must be an interface
-		expr, _ := rhs.(*ast.TypeAssertExpr)
-		if expr == nil || expr.Type != nil {
-			check.invalidAST(s.Pos(), "incorrect form of type switch guard")
-			return
-		}
-		var x operand
-		check.expr(&x, expr.X)
-		if x.mode == invalid {
-			return
-		}
-		xtyp, _ := x.typ.Underlying().(*Interface)
-		if xtyp == nil {
-			check.errorf(x.pos(), "%s is not an interface", &x)
-			return
-		}
-
-		check.multipleDefaults(s.Body.List)
-
-		var lhsVars []*Var               // list of implicitly declared lhs variables
-		seen := make(map[Type]token.Pos) // map of seen types to positions
-		for _, s := range s.Body.List {
-			clause, _ := s.(*ast.CaseClause)
-			if clause == nil {
-				check.invalidAST(s.Pos(), "incorrect type switch case")
-				continue
-			}
-			// Check each type in this type switch case.
-			T := check.caseTypes(&x, xtyp, clause.List, seen)
-			check.openScope(clause, "case")
-			// If lhs exists, declare a corresponding variable in the case-local scope.
-			if lhs != nil {
-				// spec: "The TypeSwitchGuard may include a short variable declaration.
-				// When that form is used, the variable is declared at the beginning of
-				// the implicit block in each clause. In clauses with a case listing
-				// exactly one type, the variable has that type; otherwise, the variable
-				// has the type of the expression in the TypeSwitchGuard."
-				if len(clause.List) != 1 || T == nil {
-					T = x.typ
-				}
-				obj := NewVar(lhs.Pos(), check.pkg, lhs.Name, T)
-				scopePos := clause.End()
-				if len(clause.Body) > 0 {
-					scopePos = clause.Body[0].Pos()
-				}
-				check.declare(check.scope, nil, obj, scopePos)
-				check.recordImplicit(clause, obj)
-				// For the "declared but not used" error, all lhs variables act as
-				// one; i.e., if any one of them is 'used', all of them are 'used'.
-				// Collect them for later analysis.
-				lhsVars = append(lhsVars, obj)
-			}
-			check.stmtList(inner, clause.Body)
-			check.closeScope()
-		}
-
-		// If lhs exists, we must have at least one lhs variable that was used.
-		if lhs != nil {
-			var used bool
-			for _, v := range lhsVars {
-				if v.used {
-					used = true
-				}
-				v.used = true // avoid usage error when checking entire function
-			}
-			if !used {
-				check.softErrorf(lhs.Pos(), "%s declared but not used", lhs.Name)
-			}
-		}
-
-	case *ast.SelectStmt:
-		inner |= breakOk
-
-		check.multipleDefaults(s.Body.List)
-
-		for _, s := range s.Body.List {
-			clause, _ := s.(*ast.CommClause)
-			if clause == nil {
-				continue // error reported before
-			}
-
-			// clause.Comm must be a SendStmt, RecvStmt, or default case
-			valid := false
-			var rhs ast.Expr // rhs of RecvStmt, or nil
-			switch s := clause.Comm.(type) {
-			case nil, *ast.SendStmt:
-				valid = true
-			case *ast.AssignStmt:
-				if len(s.Rhs) == 1 {
-					rhs = s.Rhs[0]
-				}
-			case *ast.ExprStmt:
-				rhs = s.X
-			}
-
-			// if present, rhs must be a receive operation
-			if rhs != nil {
-				if x, _ := unparen(rhs).(*ast.UnaryExpr); x != nil && x.Op == token.ARROW {
-					valid = true
-				}
-			}
-
-			if !valid {
-				check.error(clause.Comm.Pos(), "select case must be send or receive (possibly with assignment)")
-				continue
-			}
-
-			check.openScope(s, "case")
-			if clause.Comm != nil {
-				check.stmt(inner, clause.Comm)
-			}
-			check.stmtList(inner, clause.Body)
-			check.closeScope()
-		}
-
-	case *ast.ForStmt:
-		inner |= breakOk | continueOk
-		check.openScope(s, "for")
-		defer check.closeScope()
-
-		check.simpleStmt(s.Init)
-		if s.Cond != nil {
-			var x operand
-			check.expr(&x, s.Cond)
-			if x.mode != invalid && !isBoolean(x.typ) {
-				check.error(s.Cond.Pos(), "non-boolean condition in for statement")
-			}
-		}
-		check.simpleStmt(s.Post)
-		// spec: "The init statement may be a short variable
-		// declaration, but the post statement must not."
-		if s, _ := s.Post.(*ast.AssignStmt); s != nil && s.Tok == token.DEFINE {
-			check.softErrorf(s.Pos(), "cannot declare in post statement")
-			check.use(s.Lhs...) // avoid follow-up errors
-		}
-		check.stmt(inner, s.Body)
-
-	case *ast.RangeStmt:
-		inner |= breakOk | continueOk
-		check.openScope(s, "for")
-		defer check.closeScope()
-
-		// check expression to iterate over
-		var x operand
-		check.expr(&x, s.X)
-
-		// determine key/value types
-		var key, val Type
-		if x.mode != invalid {
-			switch typ := x.typ.Underlying().(type) {
-			case *Basic:
-				if isString(typ) {
-					key = Typ[Int]
-					val = universeRune // use 'rune' name
-				}
-			case *Array:
-				key = Typ[Int]
-				val = typ.elem
-			case *Slice:
-				key = Typ[Int]
-				val = typ.elem
-			case *Pointer:
-				if typ, _ := typ.base.Underlying().(*Array); typ != nil {
-					key = Typ[Int]
-					val = typ.elem
-				}
-			case *Map:
-				key = typ.key
-				val = typ.elem
-			case *Chan:
-				key = typ.elem
-				val = Typ[Invalid]
-				if typ.dir == SendOnly {
-					check.errorf(x.pos(), "cannot range over send-only channel %s", &x)
-					// ok to continue
-				}
-				if s.Value != nil {
-					check.errorf(s.Value.Pos(), "iteration over %s permits only one iteration variable", &x)
-					// ok to continue
-				}
-			}
-		}
-
-		if key == nil {
-			check.errorf(x.pos(), "cannot range over %s", &x)
-			// ok to continue
-		}
-
-		// check assignment to/declaration of iteration variables
-		// (irregular assignment, cannot easily map to existing assignment checks)
-
-		// lhs expressions and initialization value (rhs) types
-		lhs := [2]ast.Expr{s.Key, s.Value}
-		rhs := [2]Type{key, val} // key, val may be nil
-
-		if s.Tok == token.DEFINE {
-			// short variable declaration; variable scope starts after the range clause
-			// (the for loop opens a new scope, so variables on the lhs never redeclare
-			// previously declared variables)
-			var vars []*Var
-			for i, lhs := range lhs {
-				if lhs == nil {
-					continue
-				}
-
-				// determine lhs variable
-				var obj *Var
-				if ident, _ := lhs.(*ast.Ident); ident != nil {
-					// declare new variable
-					name := ident.Name
-					obj = NewVar(ident.Pos(), check.pkg, name, nil)
-					check.recordDef(ident, obj)
-					// _ variables don't count as new variables
-					if name != "_" {
-						vars = append(vars, obj)
-					}
-				} else {
-					check.errorf(lhs.Pos(), "cannot declare %s", lhs)
-					obj = NewVar(lhs.Pos(), check.pkg, "_", nil) // dummy variable
-				}
-
-				// initialize lhs variable
-				if typ := rhs[i]; typ != nil {
-					x.mode = value
-					x.expr = lhs // we don't have a better rhs expression to use here
-					x.typ = typ
-					check.initVar(obj, &x, false)
-				} else {
-					obj.typ = Typ[Invalid]
-					obj.used = true // don't complain about unused variable
-				}
-			}
-
-			// declare variables
-			if len(vars) > 0 {
-				for _, obj := range vars {
-					// spec: "The scope of a constant or variable identifier declared inside
-					// a function begins at the end of the ConstSpec or VarSpec (ShortVarDecl
-					// for short variable declarations) and ends at the end of the innermost
-					// containing block."
-					scopePos := s.End()
-					check.declare(check.scope, nil /* recordDef already called */, obj, scopePos)
-				}
-			} else {
-				check.error(s.TokPos, "no new variables on left side of :=")
-			}
-		} else {
-			// ordinary assignment
-			for i, lhs := range lhs {
-				if lhs == nil {
-					continue
-				}
-				if typ := rhs[i]; typ != nil {
-					x.mode = value
-					x.expr = lhs // we don't have a better rhs expression to use here
-					x.typ = typ
-					check.assignVar(lhs, &x)
-				}
-			}
-		}
-
-		check.stmt(inner, s.Body)
-
-	default:
-		check.error(s.Pos(), "invalid statement")
-	}
-}
diff --git a/third_party/golang/go/types/type.go b/third_party/golang/go/types/type.go
deleted file mode 100644
index 1df8b45b28553..0000000000000
--- a/third_party/golang/go/types/type.go
+++ /dev/null
@@ -1,454 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package types
-
-import "sort"
-
-// TODO(gri) Revisit factory functions - make sure they have all relevant parameters.
-
-// A Type represents a type of Go.
-// All types implement the Type interface.
-type Type interface {
-	// Underlying returns the underlying type of a type.
-	Underlying() Type
-
-	// String returns a string representation of a type.
-	String() string
-}
-
-// BasicKind describes the kind of basic type.
-type BasicKind int
-
-const (
-	Invalid BasicKind = iota // type is invalid
-
-	// predeclared types
-	Bool
-	Int
-	Int8
-	Int16
-	Int32
-	Int64
-	Uint
-	Uint8
-	Uint16
-	Uint32
-	Uint64
-	Uintptr
-	Float32
-	Float64
-	Complex64
-	Complex128
-	String
-	UnsafePointer
-
-	// types for untyped values
-	UntypedBool
-	UntypedInt
-	UntypedRune
-	UntypedFloat
-	UntypedComplex
-	UntypedString
-	UntypedNil
-
-	// aliases
-	Byte = Uint8
-	Rune = Int32
-)
-
-// BasicInfo is a set of flags describing properties of a basic type.
-type BasicInfo int
-
-// Properties of basic types.
-const (
-	IsBoolean BasicInfo = 1 << iota
-	IsInteger
-	IsUnsigned
-	IsFloat
-	IsComplex
-	IsString
-	IsUntyped
-
-	IsOrdered   = IsInteger | IsFloat | IsString
-	IsNumeric   = IsInteger | IsFloat | IsComplex
-	IsConstType = IsBoolean | IsNumeric | IsString
-)
-
-// A Basic represents a basic type.
-type Basic struct {
-	kind BasicKind
-	info BasicInfo
-	name string
-}
-
-// Kind returns the kind of basic type b.
-func (b *Basic) Kind() BasicKind { return b.kind }
-
-// Info returns information about properties of basic type b.
-func (b *Basic) Info() BasicInfo { return b.info }
-
-// Name returns the name of basic type b.
-func (b *Basic) Name() string { return b.name }
-
-// An Array represents an array type.
-type Array struct {
-	len  int64
-	elem Type
-}
-
-// NewArray returns a new array type for the given element type and length.
-func NewArray(elem Type, len int64) *Array { return &Array{len, elem} }
-
-// Len returns the length of array a.
-func (a *Array) Len() int64 { return a.len }
-
-// Elem returns element type of array a.
-func (a *Array) Elem() Type { return a.elem }
-
-// A Slice represents a slice type.
-type Slice struct {
-	elem Type
-}
-
-// NewSlice returns a new slice type for the given element type.
-func NewSlice(elem Type) *Slice { return &Slice{elem} }
-
-// Elem returns the element type of slice s.
-func (s *Slice) Elem() Type { return s.elem }
-
-// A Struct represents a struct type.
-type Struct struct {
-	fields []*Var
-	tags   []string // field tags; nil if there are no tags
-	// TODO(gri) access to offsets is not threadsafe - fix this
-	offsets []int64 // field offsets in bytes, lazily initialized
-}
-
-// NewStruct returns a new struct with the given fields and corresponding field tags.
-// If a field with index i has a tag, tags[i] must be that tag, but len(tags) may be
-// only as long as required to hold the tag with the largest index i. Consequently,
-// if no field has a tag, tags may be nil.
-func NewStruct(fields []*Var, tags []string) *Struct {
-	var fset objset
-	for _, f := range fields {
-		if f.name != "_" && fset.insert(f) != nil {
-			panic("multiple fields with the same name")
-		}
-	}
-	if len(tags) > len(fields) {
-		panic("more tags than fields")
-	}
-	return &Struct{fields: fields, tags: tags}
-}
-
-// NumFields returns the number of fields in the struct (including blank and anonymous fields).
-func (s *Struct) NumFields() int { return len(s.fields) }
-
-// Field returns the i'th field for 0 <= i < NumFields().
-func (s *Struct) Field(i int) *Var { return s.fields[i] }
-
-// Tag returns the i'th field tag for 0 <= i < NumFields().
-func (s *Struct) Tag(i int) string {
-	if i < len(s.tags) {
-		return s.tags[i]
-	}
-	return ""
-}
-
-// A Pointer represents a pointer type.
-type Pointer struct {
-	base Type // element type
-}
-
-// NewPointer returns a new pointer type for the given element (base) type.
-func NewPointer(elem Type) *Pointer { return &Pointer{base: elem} }
-
-// Elem returns the element type for the given pointer p.
-func (p *Pointer) Elem() Type { return p.base }
-
-// A Tuple represents an ordered list of variables; a nil *Tuple is a valid (empty) tuple.
-// Tuples are used as components of signatures and to represent the type of multiple
-// assignments; they are not first class types of Go.
-type Tuple struct {
-	vars []*Var
-}
-
-// NewTuple returns a new tuple for the given variables.
-func NewTuple(x ...*Var) *Tuple {
-	if len(x) > 0 {
-		return &Tuple{x}
-	}
-	return nil
-}
-
-// Len returns the number variables of tuple t.
-func (t *Tuple) Len() int {
-	if t != nil {
-		return len(t.vars)
-	}
-	return 0
-}
-
-// At returns the i'th variable of tuple t.
-func (t *Tuple) At(i int) *Var { return t.vars[i] }
-
-// A Signature represents a (non-builtin) function or method type.
-type Signature struct {
-	// We need to keep the scope in Signature (rather than passing it around
-	// and store it in the Func Object) because when type-checking a function
-	// literal we call the general type checker which returns a general Type.
-	// We then unpack the *Signature and use the scope for the literal body.
-	scope    *Scope // function scope, present for package-local signatures
-	recv     *Var   // nil if not a method
-	params   *Tuple // (incoming) parameters from left to right; or nil
-	results  *Tuple // (outgoing) results from left to right; or nil
-	variadic bool   // true if the last parameter's type is of the form ...T (or string, for append built-in only)
-}
-
-// NewSignature returns a new function type for the given receiver, parameters,
-// and results, either of which may be nil. If variadic is set, the function
-// is variadic, it must have at least one parameter, and the last parameter
-// must be of unnamed slice type.
-func NewSignature(recv *Var, params, results *Tuple, variadic bool) *Signature {
-	if variadic {
-		n := params.Len()
-		if n == 0 {
-			panic("types.NewSignature: variadic function must have at least one parameter")
-		}
-		if _, ok := params.At(n - 1).typ.(*Slice); !ok {
-			panic("types.NewSignature: variadic parameter must be of unnamed slice type")
-		}
-	}
-	return &Signature{nil, recv, params, results, variadic}
-}
-
-// Recv returns the receiver of signature s (if a method), or nil if a
-// function.
-//
-// For an abstract method, Recv returns the enclosing interface either
-// as a *Named or an *Interface.  Due to embedding, an interface may
-// contain methods whose receiver type is a different interface.
-func (s *Signature) Recv() *Var { return s.recv }
-
-// Params returns the parameters of signature s, or nil.
-func (s *Signature) Params() *Tuple { return s.params }
-
-// Results returns the results of signature s, or nil.
-func (s *Signature) Results() *Tuple { return s.results }
-
-// Variadic reports whether the signature s is variadic.
-func (s *Signature) Variadic() bool { return s.variadic }
-
-// An Interface represents an interface type.
-type Interface struct {
-	methods   []*Func  // ordered list of explicitly declared methods
-	embeddeds []*Named // ordered list of explicitly embedded types
-
-	allMethods []*Func // ordered list of methods declared with or embedded in this interface (TODO(gri): replace with mset)
-}
-
-// NewInterface returns a new interface for the given methods and embedded types.
-func NewInterface(methods []*Func, embeddeds []*Named) *Interface {
-	typ := new(Interface)
-
-	var mset objset
-	for _, m := range methods {
-		if mset.insert(m) != nil {
-			panic("multiple methods with the same name")
-		}
-		// set receiver
-		// TODO(gri) Ideally, we should use a named type here instead of
-		// typ, for less verbose printing of interface method signatures.
-		m.typ.(*Signature).recv = NewVar(m.pos, m.pkg, "", typ)
-	}
-	sort.Sort(byUniqueMethodName(methods))
-
-	if embeddeds == nil {
-		sort.Sort(byUniqueTypeName(embeddeds))
-	}
-
-	typ.methods = methods
-	typ.embeddeds = embeddeds
-	return typ
-}
-
-// NumExplicitMethods returns the number of explicitly declared methods of interface t.
-func (t *Interface) NumExplicitMethods() int { return len(t.methods) }
-
-// ExplicitMethod returns the i'th explicitly declared method of interface t for 0 <= i < t.NumExplicitMethods().
-// The methods are ordered by their unique Id.
-func (t *Interface) ExplicitMethod(i int) *Func { return t.methods[i] }
-
-// NumEmbeddeds returns the number of embedded types in interface t.
-func (t *Interface) NumEmbeddeds() int { return len(t.embeddeds) }
-
-// Embedded returns the i'th embedded type of interface t for 0 <= i < t.NumEmbeddeds().
-// The types are ordered by the corresponding TypeName's unique Id.
-func (t *Interface) Embedded(i int) *Named { return t.embeddeds[i] }
-
-// NumMethods returns the total number of methods of interface t.
-func (t *Interface) NumMethods() int { return len(t.allMethods) }
-
-// Method returns the i'th method of interface t for 0 <= i < t.NumMethods().
-// The methods are ordered by their unique Id.
-func (t *Interface) Method(i int) *Func { return t.allMethods[i] }
-
-// Empty returns true if t is the empty interface.
-func (t *Interface) Empty() bool { return len(t.allMethods) == 0 }
-
-// Complete computes the interface's method set. It must be called by users of
-// NewInterface after the interface's embedded types are fully defined and
-// before using the interface type in any way other than to form other types.
-// Complete returns the receiver.
-func (t *Interface) Complete() *Interface {
-	if t.allMethods != nil {
-		return t
-	}
-
-	var allMethods []*Func
-	if t.embeddeds == nil {
-		if t.methods == nil {
-			allMethods = make([]*Func, 0, 1)
-		} else {
-			allMethods = t.methods
-		}
-	} else {
-		allMethods = append(allMethods, t.methods...)
-		for _, et := range t.embeddeds {
-			it := et.Underlying().(*Interface)
-			it.Complete()
-			for _, tm := range it.allMethods {
-				// Make a copy of the method and adjust its receiver type.
-				newm := *tm
-				newmtyp := *tm.typ.(*Signature)
-				newm.typ = &newmtyp
-				newmtyp.recv = NewVar(newm.pos, newm.pkg, "", t)
-				allMethods = append(allMethods, &newm)
-			}
-		}
-		sort.Sort(byUniqueMethodName(allMethods))
-	}
-	t.allMethods = allMethods
-
-	return t
-}
-
-// A Map represents a map type.
-type Map struct {
-	key, elem Type
-}
-
-// NewMap returns a new map for the given key and element types.
-func NewMap(key, elem Type) *Map {
-	return &Map{key, elem}
-}
-
-// Key returns the key type of map m.
-func (m *Map) Key() Type { return m.key }
-
-// Elem returns the element type of map m.
-func (m *Map) Elem() Type { return m.elem }
-
-// A Chan represents a channel type.
-type Chan struct {
-	dir  ChanDir
-	elem Type
-}
-
-// A ChanDir value indicates a channel direction.
-type ChanDir int
-
-// The direction of a channel is indicated by one of the following constants.
-const (
-	SendRecv ChanDir = iota
-	SendOnly
-	RecvOnly
-)
-
-// NewChan returns a new channel type for the given direction and element type.
-func NewChan(dir ChanDir, elem Type) *Chan {
-	return &Chan{dir, elem}
-}
-
-// Dir returns the direction of channel c.
-func (c *Chan) Dir() ChanDir { return c.dir }
-
-// Elem returns the element type of channel c.
-func (c *Chan) Elem() Type { return c.elem }
-
-// A Named represents a named type.
-type Named struct {
-	obj        *TypeName // corresponding declared object
-	underlying Type      // possibly a *Named during setup; never a *Named once set up completely
-	methods    []*Func   // methods declared for this type (not the method set of this type)
-}
-
-// NewNamed returns a new named type for the given type name, underlying type, and associated methods.
-// The underlying type must not be a *Named.
-func NewNamed(obj *TypeName, underlying Type, methods []*Func) *Named {
-	if _, ok := underlying.(*Named); ok {
-		panic("types.NewNamed: underlying type must not be *Named")
-	}
-	typ := &Named{obj: obj, underlying: underlying, methods: methods}
-	if obj.typ == nil {
-		obj.typ = typ
-	}
-	return typ
-}
-
-// TypeName returns the type name for the named type t.
-func (t *Named) Obj() *TypeName { return t.obj }
-
-// NumMethods returns the number of explicit methods whose receiver is named type t.
-func (t *Named) NumMethods() int { return len(t.methods) }
-
-// Method returns the i'th method of named type t for 0 <= i < t.NumMethods().
-func (t *Named) Method(i int) *Func { return t.methods[i] }
-
-// SetUnderlying sets the underlying type and marks t as complete.
-// TODO(gri) determine if there's a better solution rather than providing this function
-func (t *Named) SetUnderlying(underlying Type) {
-	if underlying == nil {
-		panic("types.Named.SetUnderlying: underlying type must not be nil")
-	}
-	if _, ok := underlying.(*Named); ok {
-		panic("types.Named.SetUnderlying: underlying type must not be *Named")
-	}
-	t.underlying = underlying
-}
-
-// AddMethod adds method m unless it is already in the method list.
-// TODO(gri) find a better solution instead of providing this function
-func (t *Named) AddMethod(m *Func) {
-	if i, _ := lookupMethod(t.methods, m.pkg, m.name); i < 0 {
-		t.methods = append(t.methods, m)
-	}
-}
-
-// Implementations for Type methods.
-
-func (t *Basic) Underlying() Type     { return t }
-func (t *Array) Underlying() Type     { return t }
-func (t *Slice) Underlying() Type     { return t }
-func (t *Struct) Underlying() Type    { return t }
-func (t *Pointer) Underlying() Type   { return t }
-func (t *Tuple) Underlying() Type     { return t }
-func (t *Signature) Underlying() Type { return t }
-func (t *Interface) Underlying() Type { return t }
-func (t *Map) Underlying() Type       { return t }
-func (t *Chan) Underlying() Type      { return t }
-func (t *Named) Underlying() Type     { return t.underlying }
-
-func (t *Basic) String() string     { return TypeString(t, nil) }
-func (t *Array) String() string     { return TypeString(t, nil) }
-func (t *Slice) String() string     { return TypeString(t, nil) }
-func (t *Struct) String() string    { return TypeString(t, nil) }
-func (t *Pointer) String() string   { return TypeString(t, nil) }
-func (t *Tuple) String() string     { return TypeString(t, nil) }
-func (t *Signature) String() string { return TypeString(t, nil) }
-func (t *Interface) String() string { return TypeString(t, nil) }
-func (t *Map) String() string       { return TypeString(t, nil) }
-func (t *Chan) String() string      { return TypeString(t, nil) }
-func (t *Named) String() string     { return TypeString(t, nil) }
diff --git a/third_party/golang/go/types/typestring.go b/third_party/golang/go/types/typestring.go
deleted file mode 100644
index bd62f4dc229e8..0000000000000
--- a/third_party/golang/go/types/typestring.go
+++ /dev/null
@@ -1,296 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements printing of types.
-
-package types
-
-import (
-	"bytes"
-	"fmt"
-)
-
-// A Qualifier controls how named package-level objects are printed in
-// calls to TypeString, ObjectString, and SelectionString.
-//
-// These three formatting routines call the Qualifier for each
-// package-level object O, and if the Qualifier returns a non-empty
-// string p, the object is printed in the form p.O.
-// If it returns an empty string, only the object name O is printed.
-//
-// Using a nil Qualifier is equivalent to using (*Package).Path: the
-// object is qualified by the import path, e.g., "encoding/json.Marshal".
-//
-type Qualifier func(*Package) string
-
-// RelativeTo(pkg) returns a Qualifier that fully qualifies members of
-// all packages other than pkg.
-func RelativeTo(pkg *Package) Qualifier {
-	if pkg == nil {
-		return nil
-	}
-	return func(other *Package) string {
-		if pkg == other {
-			return "" // same package; unqualified
-		}
-		return other.Path()
-	}
-}
-
-// If gcCompatibilityMode is set, printing of types is modified
-// to match the representation of some types in the gc compiler:
-//
-//	- byte and rune lose their alias name and simply stand for
-//	  uint8 and int32 respectively
-//	- embedded interfaces get flattened (the embedding info is lost,
-//	  and certain recursive interface types cannot be printed anymore)
-//
-// This makes it easier to compare packages computed with the type-
-// checker vs packages imported from gc export data.
-//
-// Caution: This flag affects all uses of WriteType, globally.
-// It is only provided for testing in conjunction with
-// gc-generated data.
-//
-// This flag is exported in the x/tools/go/types package. We don't
-// need it at the moment in the std repo and so we don't export it
-// anymore. We should eventually try to remove it altogether.
-var gcCompatibilityMode bool
-
-// TypeString returns the string representation of typ.
-// The Qualifier controls the printing of
-// package-level objects, and may be nil.
-func TypeString(typ Type, qf Qualifier) string {
-	var buf bytes.Buffer
-	WriteType(&buf, typ, qf)
-	return buf.String()
-}
-
-// WriteType writes the string representation of typ to buf.
-// The Qualifier controls the printing of
-// package-level objects, and may be nil.
-func WriteType(buf *bytes.Buffer, typ Type, qf Qualifier) {
-	writeType(buf, typ, qf, make([]Type, 8))
-}
-
-func writeType(buf *bytes.Buffer, typ Type, qf Qualifier, visited []Type) {
-	// Theoretically, this is a quadratic lookup algorithm, but in
-	// practice deeply nested composite types with unnamed component
-	// types are uncommon. This code is likely more efficient than
-	// using a map.
-	for _, t := range visited {
-		if t == typ {
-			fmt.Fprintf(buf, "○%T", typ) // cycle to typ
-			return
-		}
-	}
-	visited = append(visited, typ)
-
-	switch t := typ.(type) {
-	case nil:
-		buf.WriteString("")
-
-	case *Basic:
-		if t.kind == UnsafePointer {
-			buf.WriteString("unsafe.")
-		}
-		if gcCompatibilityMode {
-			// forget the alias names
-			switch t.kind {
-			case Byte:
-				t = Typ[Uint8]
-			case Rune:
-				t = Typ[Int32]
-			}
-		}
-		buf.WriteString(t.name)
-
-	case *Array:
-		fmt.Fprintf(buf, "[%d]", t.len)
-		writeType(buf, t.elem, qf, visited)
-
-	case *Slice:
-		buf.WriteString("[]")
-		writeType(buf, t.elem, qf, visited)
-
-	case *Struct:
-		buf.WriteString("struct{")
-		for i, f := range t.fields {
-			if i > 0 {
-				buf.WriteString("; ")
-			}
-			if !f.anonymous {
-				buf.WriteString(f.name)
-				buf.WriteByte(' ')
-			}
-			writeType(buf, f.typ, qf, visited)
-			if tag := t.Tag(i); tag != "" {
-				fmt.Fprintf(buf, " %q", tag)
-			}
-		}
-		buf.WriteByte('}')
-
-	case *Pointer:
-		buf.WriteByte('*')
-		writeType(buf, t.base, qf, visited)
-
-	case *Tuple:
-		writeTuple(buf, t, false, qf, visited)
-
-	case *Signature:
-		buf.WriteString("func")
-		writeSignature(buf, t, qf, visited)
-
-	case *Interface:
-		// We write the source-level methods and embedded types rather
-		// than the actual method set since resolved method signatures
-		// may have non-printable cycles if parameters have anonymous
-		// interface types that (directly or indirectly) embed the
-		// current interface. For instance, consider the result type
-		// of m:
-		//
-		//     type T interface{
-		//         m() interface{ T }
-		//     }
-		//
-		buf.WriteString("interface{")
-		if gcCompatibilityMode {
-			// print flattened interface
-			// (useful to compare against gc-generated interfaces)
-			for i, m := range t.allMethods {
-				if i > 0 {
-					buf.WriteString("; ")
-				}
-				buf.WriteString(m.name)
-				writeSignature(buf, m.typ.(*Signature), qf, visited)
-			}
-		} else {
-			// print explicit interface methods and embedded types
-			for i, m := range t.methods {
-				if i > 0 {
-					buf.WriteString("; ")
-				}
-				buf.WriteString(m.name)
-				writeSignature(buf, m.typ.(*Signature), qf, visited)
-			}
-			for i, typ := range t.embeddeds {
-				if i > 0 || len(t.methods) > 0 {
-					buf.WriteString("; ")
-				}
-				writeType(buf, typ, qf, visited)
-			}
-		}
-		buf.WriteByte('}')
-
-	case *Map:
-		buf.WriteString("map[")
-		writeType(buf, t.key, qf, visited)
-		buf.WriteByte(']')
-		writeType(buf, t.elem, qf, visited)
-
-	case *Chan:
-		var s string
-		var parens bool
-		switch t.dir {
-		case SendRecv:
-			s = "chan "
-			// chan (<-chan T) requires parentheses
-			if c, _ := t.elem.(*Chan); c != nil && c.dir == RecvOnly {
-				parens = true
-			}
-		case SendOnly:
-			s = "chan<- "
-		case RecvOnly:
-			s = "<-chan "
-		default:
-			panic("unreachable")
-		}
-		buf.WriteString(s)
-		if parens {
-			buf.WriteByte('(')
-		}
-		writeType(buf, t.elem, qf, visited)
-		if parens {
-			buf.WriteByte(')')
-		}
-
-	case *Named:
-		s := ""
-		if obj := t.obj; obj != nil {
-			if obj.pkg != nil {
-				writePackage(buf, obj.pkg, qf)
-			}
-			// TODO(gri): function-local named types should be displayed
-			// differently from named types at package level to avoid
-			// ambiguity.
-			s = obj.name
-		}
-		buf.WriteString(s)
-
-	default:
-		// For externally defined implementations of Type.
-		buf.WriteString(t.String())
-	}
-}
-
-func writeTuple(buf *bytes.Buffer, tup *Tuple, variadic bool, qf Qualifier, visited []Type) {
-	buf.WriteByte('(')
-	if tup != nil {
-		for i, v := range tup.vars {
-			if i > 0 {
-				buf.WriteString(", ")
-			}
-			if v.name != "" {
-				buf.WriteString(v.name)
-				buf.WriteByte(' ')
-			}
-			typ := v.typ
-			if variadic && i == len(tup.vars)-1 {
-				if s, ok := typ.(*Slice); ok {
-					buf.WriteString("...")
-					typ = s.elem
-				} else {
-					// special case:
-					// append(s, "foo"...) leads to signature func([]byte, string...)
-					if t, ok := typ.Underlying().(*Basic); !ok || t.kind != String {
-						panic("internal error: string type expected")
-					}
-					writeType(buf, typ, qf, visited)
-					buf.WriteString("...")
-					continue
-				}
-			}
-			writeType(buf, typ, qf, visited)
-		}
-	}
-	buf.WriteByte(')')
-}
-
-// WriteSignature writes the representation of the signature sig to buf,
-// without a leading "func" keyword.
-// The Qualifier controls the printing of
-// package-level objects, and may be nil.
-func WriteSignature(buf *bytes.Buffer, sig *Signature, qf Qualifier) {
-	writeSignature(buf, sig, qf, make([]Type, 8))
-}
-
-func writeSignature(buf *bytes.Buffer, sig *Signature, qf Qualifier, visited []Type) {
-	writeTuple(buf, sig.params, sig.variadic, qf, visited)
-
-	n := sig.results.Len()
-	if n == 0 {
-		// no result
-		return
-	}
-
-	buf.WriteByte(' ')
-	if n == 1 && sig.results.vars[0].name == "" {
-		// single unnamed result
-		writeType(buf, sig.results.vars[0].typ, qf, visited)
-		return
-	}
-
-	// multiple or named result(s)
-	writeTuple(buf, sig.results, false, qf, visited)
-}
diff --git a/third_party/golang/go/types/typexpr.go b/third_party/golang/go/types/typexpr.go
deleted file mode 100644
index 7d4456cd530eb..0000000000000
--- a/third_party/golang/go/types/typexpr.go
+++ /dev/null
@@ -1,712 +0,0 @@
-// Copyright 2013 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file implements type-checking of identifiers and type expressions.
-
-package types
-
-import (
-	"k8s.io/kubernetes/third_party/golang/go/ast"
-	"k8s.io/kubernetes/third_party/golang/go/constant"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-	"sort"
-	"strconv"
-)
-
-// ident type-checks identifier e and initializes x with the value or type of e.
-// If an error occurred, x.mode is set to invalid.
-// For the meaning of def and path, see check.typ, below.
-//
-func (check *Checker) ident(x *operand, e *ast.Ident, def *Named, path []*TypeName) {
-	x.mode = invalid
-	x.expr = e
-
-	scope, obj := check.scope.LookupParent(e.Name, check.pos)
-	if obj == nil {
-		if e.Name == "_" {
-			check.errorf(e.Pos(), "cannot use _ as value or type")
-		} else {
-			check.errorf(e.Pos(), "undeclared name: %s", e.Name)
-		}
-		return
-	}
-	check.recordUse(e, obj)
-
-	check.objDecl(obj, def, path)
-	typ := obj.Type()
-	assert(typ != nil)
-
-	// The object may be dot-imported: If so, remove its package from
-	// the map of unused dot imports for the respective file scope.
-	// (This code is only needed for dot-imports. Without them,
-	// we only have to mark variables, see *Var case below).
-	if pkg := obj.Pkg(); pkg != check.pkg && pkg != nil {
-		delete(check.unusedDotImports[scope], pkg)
-	}
-
-	switch obj := obj.(type) {
-	case *PkgName:
-		check.errorf(e.Pos(), "use of package %s not in selector", obj.name)
-		return
-
-	case *Const:
-		check.addDeclDep(obj)
-		if typ == Typ[Invalid] {
-			return
-		}
-		if obj == universeIota {
-			if check.iota == nil {
-				check.errorf(e.Pos(), "cannot use iota outside constant declaration")
-				return
-			}
-			x.val = check.iota
-		} else {
-			x.val = obj.val
-		}
-		assert(x.val != nil)
-		x.mode = constant_
-
-	case *TypeName:
-		x.mode = typexpr
-		// check for cycle
-		// (it's ok to iterate forward because each named type appears at most once in path)
-		for i, prev := range path {
-			if prev == obj {
-				check.errorf(obj.pos, "illegal cycle in declaration of %s", obj.name)
-				// print cycle
-				for _, obj := range path[i:] {
-					check.errorf(obj.Pos(), "\t%s refers to", obj.Name()) // secondary error, \t indented
-				}
-				check.errorf(obj.Pos(), "\t%s", obj.Name())
-				// maintain x.mode == typexpr despite error
-				typ = Typ[Invalid]
-				break
-			}
-		}
-
-	case *Var:
-		if obj.pkg == check.pkg {
-			obj.used = true
-		}
-		check.addDeclDep(obj)
-		if typ == Typ[Invalid] {
-			return
-		}
-		x.mode = variable
-
-	case *Func:
-		check.addDeclDep(obj)
-		x.mode = value
-
-	case *Builtin:
-		x.id = obj.id
-		x.mode = builtin
-
-	case *Nil:
-		x.mode = value
-
-	default:
-		unreachable()
-	}
-
-	x.typ = typ
-}
-
-// typExpr type-checks the type expression e and returns its type, or Typ[Invalid].
-// If def != nil, e is the type specification for the named type def, declared
-// in a type declaration, and def.underlying will be set to the type of e before
-// any components of e are type-checked. Path contains the path of named types
-// referring to this type.
-//
-func (check *Checker) typExpr(e ast.Expr, def *Named, path []*TypeName) (T Type) {
-	if trace {
-		check.trace(e.Pos(), "%s", e)
-		check.indent++
-		defer func() {
-			check.indent--
-			check.trace(e.Pos(), "=> %s", T)
-		}()
-	}
-
-	T = check.typExprInternal(e, def, path)
-	assert(isTyped(T))
-	check.recordTypeAndValue(e, typexpr, T, nil)
-
-	return
-}
-
-func (check *Checker) typ(e ast.Expr) Type {
-	return check.typExpr(e, nil, nil)
-}
-
-// funcType type-checks a function or method type.
-func (check *Checker) funcType(sig *Signature, recvPar *ast.FieldList, ftyp *ast.FuncType) {
-	scope := NewScope(check.scope, token.NoPos, token.NoPos, "function")
-	check.recordScope(ftyp, scope)
-
-	recvList, _ := check.collectParams(scope, recvPar, false)
-	params, variadic := check.collectParams(scope, ftyp.Params, true)
-	results, _ := check.collectParams(scope, ftyp.Results, false)
-
-	if recvPar != nil {
-		// recv parameter list present (may be empty)
-		// spec: "The receiver is specified via an extra parameter section preceding the
-		// method name. That parameter section must declare a single parameter, the receiver."
-		var recv *Var
-		switch len(recvList) {
-		case 0:
-			check.error(recvPar.Pos(), "method is missing receiver")
-			recv = NewParam(0, nil, "", Typ[Invalid]) // ignore recv below
-		default:
-			// more than one receiver
-			check.error(recvList[len(recvList)-1].Pos(), "method must have exactly one receiver")
-			fallthrough // continue with first receiver
-		case 1:
-			recv = recvList[0]
-		}
-		// spec: "The receiver type must be of the form T or *T where T is a type name."
-		// (ignore invalid types - error was reported before)
-		if t, _ := deref(recv.typ); t != Typ[Invalid] {
-			var err string
-			if T, _ := t.(*Named); T != nil {
-				// spec: "The type denoted by T is called the receiver base type; it must not
-				// be a pointer or interface type and it must be declared in the same package
-				// as the method."
-				if T.obj.pkg != check.pkg {
-					err = "type not defined in this package"
-				} else {
-					// TODO(gri) This is not correct if the underlying type is unknown yet.
-					switch u := T.underlying.(type) {
-					case *Basic:
-						// unsafe.Pointer is treated like a regular pointer
-						if u.kind == UnsafePointer {
-							err = "unsafe.Pointer"
-						}
-					case *Pointer, *Interface:
-						err = "pointer or interface type"
-					}
-				}
-			} else {
-				err = "basic or unnamed type"
-			}
-			if err != "" {
-				check.errorf(recv.pos, "invalid receiver %s (%s)", recv.typ, err)
-				// ok to continue
-			}
-		}
-		sig.recv = recv
-	}
-
-	sig.scope = scope
-	sig.params = NewTuple(params...)
-	sig.results = NewTuple(results...)
-	sig.variadic = variadic
-}
-
-// typExprInternal drives type checking of types.
-// Must only be called by typExpr.
-//
-func (check *Checker) typExprInternal(e ast.Expr, def *Named, path []*TypeName) Type {
-	switch e := e.(type) {
-	case *ast.BadExpr:
-		// ignore - error reported before
-
-	case *ast.Ident:
-		var x operand
-		check.ident(&x, e, def, path)
-
-		switch x.mode {
-		case typexpr:
-			typ := x.typ
-			def.setUnderlying(typ)
-			return typ
-		case invalid:
-			// ignore - error reported before
-		case novalue:
-			check.errorf(x.pos(), "%s used as type", &x)
-		default:
-			check.errorf(x.pos(), "%s is not a type", &x)
-		}
-
-	case *ast.SelectorExpr:
-		var x operand
-		check.selector(&x, e)
-
-		switch x.mode {
-		case typexpr:
-			typ := x.typ
-			def.setUnderlying(typ)
-			return typ
-		case invalid:
-			// ignore - error reported before
-		case novalue:
-			check.errorf(x.pos(), "%s used as type", &x)
-		default:
-			check.errorf(x.pos(), "%s is not a type", &x)
-		}
-
-	case *ast.ParenExpr:
-		return check.typExpr(e.X, def, path)
-
-	case *ast.ArrayType:
-		if e.Len != nil {
-			typ := new(Array)
-			def.setUnderlying(typ)
-			typ.len = check.arrayLength(e.Len)
-			typ.elem = check.typExpr(e.Elt, nil, path)
-			return typ
-
-		} else {
-			typ := new(Slice)
-			def.setUnderlying(typ)
-			typ.elem = check.typ(e.Elt)
-			return typ
-		}
-
-	case *ast.StructType:
-		typ := new(Struct)
-		def.setUnderlying(typ)
-		check.structType(typ, e, path)
-		return typ
-
-	case *ast.StarExpr:
-		typ := new(Pointer)
-		def.setUnderlying(typ)
-		typ.base = check.typ(e.X)
-		return typ
-
-	case *ast.FuncType:
-		typ := new(Signature)
-		def.setUnderlying(typ)
-		check.funcType(typ, nil, e)
-		return typ
-
-	case *ast.InterfaceType:
-		typ := new(Interface)
-		def.setUnderlying(typ)
-		check.interfaceType(typ, e, def, path)
-		return typ
-
-	case *ast.MapType:
-		typ := new(Map)
-		def.setUnderlying(typ)
-
-		typ.key = check.typ(e.Key)
-		typ.elem = check.typ(e.Value)
-
-		// spec: "The comparison operators == and != must be fully defined
-		// for operands of the key type; thus the key type must not be a
-		// function, map, or slice."
-		//
-		// Delay this check because it requires fully setup types;
-		// it is safe to continue in any case (was issue 6667).
-		check.delay(func() {
-			if !Comparable(typ.key) {
-				check.errorf(e.Key.Pos(), "invalid map key type %s", typ.key)
-			}
-		})
-
-		return typ
-
-	case *ast.ChanType:
-		typ := new(Chan)
-		def.setUnderlying(typ)
-
-		dir := SendRecv
-		switch e.Dir {
-		case ast.SEND | ast.RECV:
-			// nothing to do
-		case ast.SEND:
-			dir = SendOnly
-		case ast.RECV:
-			dir = RecvOnly
-		default:
-			check.invalidAST(e.Pos(), "unknown channel direction %d", e.Dir)
-			// ok to continue
-		}
-
-		typ.dir = dir
-		typ.elem = check.typ(e.Value)
-		return typ
-
-	default:
-		check.errorf(e.Pos(), "%s is not a type", e)
-	}
-
-	typ := Typ[Invalid]
-	def.setUnderlying(typ)
-	return typ
-}
-
-// typeOrNil type-checks the type expression (or nil value) e
-// and returns the typ of e, or nil.
-// If e is neither a type nor nil, typOrNil returns Typ[Invalid].
-//
-func (check *Checker) typOrNil(e ast.Expr) Type {
-	var x operand
-	check.rawExpr(&x, e, nil)
-	switch x.mode {
-	case invalid:
-		// ignore - error reported before
-	case novalue:
-		check.errorf(x.pos(), "%s used as type", &x)
-	case typexpr:
-		return x.typ
-	case value:
-		if x.isNil() {
-			return nil
-		}
-		fallthrough
-	default:
-		check.errorf(x.pos(), "%s is not a type", &x)
-	}
-	return Typ[Invalid]
-}
-
-func (check *Checker) arrayLength(e ast.Expr) int64 {
-	var x operand
-	check.expr(&x, e)
-	if x.mode != constant_ {
-		if x.mode != invalid {
-			check.errorf(x.pos(), "array length %s must be constant", &x)
-		}
-		return 0
-	}
-	if !x.isInteger() {
-		check.errorf(x.pos(), "array length %s must be integer", &x)
-		return 0
-	}
-	n, ok := constant.Int64Val(x.val)
-	if !ok || n < 0 {
-		check.errorf(x.pos(), "invalid array length %s", &x)
-		return 0
-	}
-	return n
-}
-
-func (check *Checker) collectParams(scope *Scope, list *ast.FieldList, variadicOk bool) (params []*Var, variadic bool) {
-	if list == nil {
-		return
-	}
-
-	var named, anonymous bool
-	for i, field := range list.List {
-		ftype := field.Type
-		if t, _ := ftype.(*ast.Ellipsis); t != nil {
-			ftype = t.Elt
-			if variadicOk && i == len(list.List)-1 {
-				variadic = true
-			} else {
-				check.invalidAST(field.Pos(), "... not permitted")
-				// ignore ... and continue
-			}
-		}
-		typ := check.typ(ftype)
-		// The parser ensures that f.Tag is nil and we don't
-		// care if a constructed AST contains a non-nil tag.
-		if len(field.Names) > 0 {
-			// named parameter
-			for _, name := range field.Names {
-				if name.Name == "" {
-					check.invalidAST(name.Pos(), "anonymous parameter")
-					// ok to continue
-				}
-				par := NewParam(name.Pos(), check.pkg, name.Name, typ)
-				check.declare(scope, name, par, scope.pos)
-				params = append(params, par)
-			}
-			named = true
-		} else {
-			// anonymous parameter
-			par := NewParam(ftype.Pos(), check.pkg, "", typ)
-			check.recordImplicit(field, par)
-			params = append(params, par)
-			anonymous = true
-		}
-	}
-
-	if named && anonymous {
-		check.invalidAST(list.Pos(), "list contains both named and anonymous parameters")
-		// ok to continue
-	}
-
-	// For a variadic function, change the last parameter's type from T to []T.
-	if variadic && len(params) > 0 {
-		last := params[len(params)-1]
-		last.typ = &Slice{elem: last.typ}
-	}
-
-	return
-}
-
-func (check *Checker) declareInSet(oset *objset, pos token.Pos, obj Object) bool {
-	if alt := oset.insert(obj); alt != nil {
-		check.errorf(pos, "%s redeclared", obj.Name())
-		check.reportAltDecl(alt)
-		return false
-	}
-	return true
-}
-
-func (check *Checker) interfaceType(iface *Interface, ityp *ast.InterfaceType, def *Named, path []*TypeName) {
-	// empty interface: common case
-	if ityp.Methods == nil {
-		return
-	}
-
-	// The parser ensures that field tags are nil and we don't
-	// care if a constructed AST contains non-nil tags.
-
-	// use named receiver type if available (for better error messages)
-	var recvTyp Type = iface
-	if def != nil {
-		recvTyp = def
-	}
-
-	// Phase 1: Collect explicitly declared methods, the corresponding
-	//          signature (AST) expressions, and the list of embedded
-	//          type (AST) expressions. Do not resolve signatures or
-	//          embedded types yet to avoid cycles referring to this
-	//          interface.
-
-	var (
-		mset       objset
-		signatures []ast.Expr // list of corresponding method signatures
-		embedded   []ast.Expr // list of embedded types
-	)
-	for _, f := range ityp.Methods.List {
-		if len(f.Names) > 0 {
-			// The parser ensures that there's only one method
-			// and we don't care if a constructed AST has more.
-			name := f.Names[0]
-			pos := name.Pos()
-			// spec: "As with all method sets, in an interface type,
-			// each method must have a unique non-blank name."
-			if name.Name == "_" {
-				check.errorf(pos, "invalid method name _")
-				continue
-			}
-			// Don't type-check signature yet - use an
-			// empty signature now and update it later.
-			// Since we know the receiver, set it up now
-			// (required to avoid crash in ptrRecv; see
-			// e.g. test case for issue 6638).
-			// TODO(gri) Consider marking methods signatures
-			// as incomplete, for better error messages. See
-			// also the T4 and T5 tests in testdata/cycles2.src.
-			sig := new(Signature)
-			sig.recv = NewVar(pos, check.pkg, "", recvTyp)
-			m := NewFunc(pos, check.pkg, name.Name, sig)
-			if check.declareInSet(&mset, pos, m) {
-				iface.methods = append(iface.methods, m)
-				iface.allMethods = append(iface.allMethods, m)
-				signatures = append(signatures, f.Type)
-				check.recordDef(name, m)
-			}
-		} else {
-			// embedded type
-			embedded = append(embedded, f.Type)
-		}
-	}
-
-	// Phase 2: Resolve embedded interfaces. Because an interface must not
-	//          embed itself (directly or indirectly), each embedded interface
-	//          can be fully resolved without depending on any method of this
-	//          interface (if there is a cycle or another error, the embedded
-	//          type resolves to an invalid type and is ignored).
-	//          In particular, the list of methods for each embedded interface
-	//          must be complete (it cannot depend on this interface), and so
-	//          those methods can be added to the list of all methods of this
-	//          interface.
-
-	for _, e := range embedded {
-		pos := e.Pos()
-		typ := check.typExpr(e, nil, path)
-		// Determine underlying embedded (possibly incomplete) type
-		// by following its forward chain.
-		named, _ := typ.(*Named)
-		under := underlying(named)
-		embed, _ := under.(*Interface)
-		if embed == nil {
-			if typ != Typ[Invalid] {
-				check.errorf(pos, "%s is not an interface", typ)
-			}
-			continue
-		}
-		iface.embeddeds = append(iface.embeddeds, named)
-		// collect embedded methods
-		for _, m := range embed.allMethods {
-			if check.declareInSet(&mset, pos, m) {
-				iface.allMethods = append(iface.allMethods, m)
-			}
-		}
-	}
-
-	// Phase 3: At this point all methods have been collected for this interface.
-	//          It is now safe to type-check the signatures of all explicitly
-	//          declared methods, even if they refer to this interface via a cycle
-	//          and embed the methods of this interface in a parameter of interface
-	//          type.
-
-	for i, m := range iface.methods {
-		expr := signatures[i]
-		typ := check.typ(expr)
-		sig, _ := typ.(*Signature)
-		if sig == nil {
-			if typ != Typ[Invalid] {
-				check.invalidAST(expr.Pos(), "%s is not a method signature", typ)
-			}
-			continue // keep method with empty method signature
-		}
-		// update signature, but keep recv that was set up before
-		old := m.typ.(*Signature)
-		sig.recv = old.recv
-		*old = *sig // update signature (don't replace it!)
-	}
-
-	// TODO(gri) The list of explicit methods is only sorted for now to
-	// produce the same Interface as NewInterface. We may be able to
-	// claim source order in the future. Revisit.
-	sort.Sort(byUniqueMethodName(iface.methods))
-
-	// TODO(gri) The list of embedded types is only sorted for now to
-	// produce the same Interface as NewInterface. We may be able to
-	// claim source order in the future. Revisit.
-	sort.Sort(byUniqueTypeName(iface.embeddeds))
-
-	sort.Sort(byUniqueMethodName(iface.allMethods))
-}
-
-// byUniqueTypeName named type lists can be sorted by their unique type names.
-type byUniqueTypeName []*Named
-
-func (a byUniqueTypeName) Len() int           { return len(a) }
-func (a byUniqueTypeName) Less(i, j int) bool { return a[i].obj.Id() < a[j].obj.Id() }
-func (a byUniqueTypeName) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
-
-// byUniqueMethodName method lists can be sorted by their unique method names.
-type byUniqueMethodName []*Func
-
-func (a byUniqueMethodName) Len() int           { return len(a) }
-func (a byUniqueMethodName) Less(i, j int) bool { return a[i].Id() < a[j].Id() }
-func (a byUniqueMethodName) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
-
-func (check *Checker) tag(t *ast.BasicLit) string {
-	if t != nil {
-		if t.Kind == token.STRING {
-			if val, err := strconv.Unquote(t.Value); err == nil {
-				return val
-			}
-		}
-		check.invalidAST(t.Pos(), "incorrect tag syntax: %q", t.Value)
-	}
-	return ""
-}
-
-func (check *Checker) structType(styp *Struct, e *ast.StructType, path []*TypeName) {
-	list := e.Fields
-	if list == nil {
-		return
-	}
-
-	// struct fields and tags
-	var fields []*Var
-	var tags []string
-
-	// for double-declaration checks
-	var fset objset
-
-	// current field typ and tag
-	var typ Type
-	var tag string
-	// anonymous != nil indicates an anonymous field.
-	add := func(field *ast.Field, ident *ast.Ident, anonymous *TypeName, pos token.Pos) {
-		if tag != "" && tags == nil {
-			tags = make([]string, len(fields))
-		}
-		if tags != nil {
-			tags = append(tags, tag)
-		}
-
-		name := ident.Name
-		fld := NewField(pos, check.pkg, name, typ, anonymous != nil)
-		// spec: "Within a struct, non-blank field names must be unique."
-		if name == "_" || check.declareInSet(&fset, pos, fld) {
-			fields = append(fields, fld)
-			check.recordDef(ident, fld)
-		}
-		if anonymous != nil {
-			check.recordUse(ident, anonymous)
-		}
-	}
-
-	for _, f := range list.List {
-		typ = check.typExpr(f.Type, nil, path)
-		tag = check.tag(f.Tag)
-		if len(f.Names) > 0 {
-			// named fields
-			for _, name := range f.Names {
-				add(f, name, nil, name.Pos())
-			}
-		} else {
-			// anonymous field
-			name := anonymousFieldIdent(f.Type)
-			pos := f.Type.Pos()
-			t, isPtr := deref(typ)
-			switch t := t.(type) {
-			case *Basic:
-				if t == Typ[Invalid] {
-					// error was reported before
-					continue
-				}
-				// unsafe.Pointer is treated like a regular pointer
-				if t.kind == UnsafePointer {
-					check.errorf(pos, "anonymous field type cannot be unsafe.Pointer")
-					continue
-				}
-				add(f, name, Universe.Lookup(t.name).(*TypeName), pos)
-
-			case *Named:
-				// spec: "An embedded type must be specified as a type name
-				// T or as a pointer to a non-interface type name *T, and T
-				// itself may not be a pointer type."
-				switch u := t.underlying.(type) {
-				case *Basic:
-					// unsafe.Pointer is treated like a regular pointer
-					if u.kind == UnsafePointer {
-						check.errorf(pos, "anonymous field type cannot be unsafe.Pointer")
-						continue
-					}
-				case *Pointer:
-					check.errorf(pos, "anonymous field type cannot be a pointer")
-					continue
-				case *Interface:
-					if isPtr {
-						check.errorf(pos, "anonymous field type cannot be a pointer to an interface")
-						continue
-					}
-				}
-				add(f, name, t.obj, pos)
-
-			default:
-				check.invalidAST(pos, "anonymous field type %s must be named", typ)
-			}
-		}
-	}
-
-	styp.fields = fields
-	styp.tags = tags
-}
-
-func anonymousFieldIdent(e ast.Expr) *ast.Ident {
-	switch e := e.(type) {
-	case *ast.Ident:
-		return e
-	case *ast.StarExpr:
-		return anonymousFieldIdent(e.X)
-	case *ast.SelectorExpr:
-		return e.Sel
-	}
-	return nil // invalid anonymous field
-}
diff --git a/third_party/golang/go/types/universe.go b/third_party/golang/go/types/universe.go
deleted file mode 100644
index 1b08d400ced9f..0000000000000
--- a/third_party/golang/go/types/universe.go
+++ /dev/null
@@ -1,223 +0,0 @@
-// Copyright 2011 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// This file sets up the universe scope and the unsafe package.
-
-package types
-
-import (
-	"k8s.io/kubernetes/third_party/golang/go/constant"
-	"k8s.io/kubernetes/third_party/golang/go/token"
-	"strings"
-)
-
-var (
-	Universe     *Scope
-	Unsafe       *Package
-	universeIota *Const
-	universeByte *Basic // uint8 alias, but has name "byte"
-	universeRune *Basic // int32 alias, but has name "rune"
-)
-
-var Typ = []*Basic{
-	Invalid: {Invalid, 0, "invalid type"},
-
-	Bool:          {Bool, IsBoolean, "bool"},
-	Int:           {Int, IsInteger, "int"},
-	Int8:          {Int8, IsInteger, "int8"},
-	Int16:         {Int16, IsInteger, "int16"},
-	Int32:         {Int32, IsInteger, "int32"},
-	Int64:         {Int64, IsInteger, "int64"},
-	Uint:          {Uint, IsInteger | IsUnsigned, "uint"},
-	Uint8:         {Uint8, IsInteger | IsUnsigned, "uint8"},
-	Uint16:        {Uint16, IsInteger | IsUnsigned, "uint16"},
-	Uint32:        {Uint32, IsInteger | IsUnsigned, "uint32"},
-	Uint64:        {Uint64, IsInteger | IsUnsigned, "uint64"},
-	Uintptr:       {Uintptr, IsInteger | IsUnsigned, "uintptr"},
-	Float32:       {Float32, IsFloat, "float32"},
-	Float64:       {Float64, IsFloat, "float64"},
-	Complex64:     {Complex64, IsComplex, "complex64"},
-	Complex128:    {Complex128, IsComplex, "complex128"},
-	String:        {String, IsString, "string"},
-	UnsafePointer: {UnsafePointer, 0, "Pointer"},
-
-	UntypedBool:    {UntypedBool, IsBoolean | IsUntyped, "untyped bool"},
-	UntypedInt:     {UntypedInt, IsInteger | IsUntyped, "untyped int"},
-	UntypedRune:    {UntypedRune, IsInteger | IsUntyped, "untyped rune"},
-	UntypedFloat:   {UntypedFloat, IsFloat | IsUntyped, "untyped float"},
-	UntypedComplex: {UntypedComplex, IsComplex | IsUntyped, "untyped complex"},
-	UntypedString:  {UntypedString, IsString | IsUntyped, "untyped string"},
-	UntypedNil:     {UntypedNil, IsUntyped, "untyped nil"},
-}
-
-var aliases = [...]*Basic{
-	{Byte, IsInteger | IsUnsigned, "byte"},
-	{Rune, IsInteger, "rune"},
-}
-
-func defPredeclaredTypes() {
-	for _, t := range Typ {
-		def(NewTypeName(token.NoPos, nil, t.name, t))
-	}
-	for _, t := range aliases {
-		def(NewTypeName(token.NoPos, nil, t.name, t))
-	}
-
-	// Error has a nil package in its qualified name since it is in no package
-	res := NewVar(token.NoPos, nil, "", Typ[String])
-	sig := &Signature{results: NewTuple(res)}
-	err := NewFunc(token.NoPos, nil, "Error", sig)
-	typ := &Named{underlying: NewInterface([]*Func{err}, nil).Complete()}
-	sig.recv = NewVar(token.NoPos, nil, "", typ)
-	def(NewTypeName(token.NoPos, nil, "error", typ))
-}
-
-var predeclaredConsts = [...]struct {
-	name string
-	kind BasicKind
-	val  constant.Value
-}{
-	{"true", UntypedBool, constant.MakeBool(true)},
-	{"false", UntypedBool, constant.MakeBool(false)},
-	{"iota", UntypedInt, constant.MakeInt64(0)},
-}
-
-func defPredeclaredConsts() {
-	for _, c := range predeclaredConsts {
-		def(NewConst(token.NoPos, nil, c.name, Typ[c.kind], c.val))
-	}
-}
-
-func defPredeclaredNil() {
-	def(&Nil{object{name: "nil", typ: Typ[UntypedNil]}})
-}
-
-// A builtinId is the id of a builtin function.
-type builtinId int
-
-const (
-	// universe scope
-	_Append builtinId = iota
-	_Cap
-	_Close
-	_Complex
-	_Copy
-	_Delete
-	_Imag
-	_Len
-	_Make
-	_New
-	_Panic
-	_Print
-	_Println
-	_Real
-	_Recover
-
-	// package unsafe
-	_Alignof
-	_Offsetof
-	_Sizeof
-
-	// testing support
-	_Assert
-	_Trace
-)
-
-var predeclaredFuncs = [...]struct {
-	name     string
-	nargs    int
-	variadic bool
-	kind     exprKind
-}{
-	_Append:  {"append", 1, true, expression},
-	_Cap:     {"cap", 1, false, expression},
-	_Close:   {"close", 1, false, statement},
-	_Complex: {"complex", 2, false, expression},
-	_Copy:    {"copy", 2, false, statement},
-	_Delete:  {"delete", 2, false, statement},
-	_Imag:    {"imag", 1, false, expression},
-	_Len:     {"len", 1, false, expression},
-	_Make:    {"make", 1, true, expression},
-	_New:     {"new", 1, false, expression},
-	_Panic:   {"panic", 1, false, statement},
-	_Print:   {"print", 0, true, statement},
-	_Println: {"println", 0, true, statement},
-	_Real:    {"real", 1, false, expression},
-	_Recover: {"recover", 0, false, statement},
-
-	_Alignof:  {"Alignof", 1, false, expression},
-	_Offsetof: {"Offsetof", 1, false, expression},
-	_Sizeof:   {"Sizeof", 1, false, expression},
-
-	_Assert: {"assert", 1, false, statement},
-	_Trace:  {"trace", 0, true, statement},
-}
-
-func defPredeclaredFuncs() {
-	for i := range predeclaredFuncs {
-		id := builtinId(i)
-		if id == _Assert || id == _Trace {
-			continue // only define these in testing environment
-		}
-		def(newBuiltin(id))
-	}
-}
-
-// DefPredeclaredTestFuncs defines the assert and trace built-ins.
-// These built-ins are intended for debugging and testing of this
-// package only.
-func DefPredeclaredTestFuncs() {
-	if Universe.Lookup("assert") != nil {
-		return // already defined
-	}
-	def(newBuiltin(_Assert))
-	def(newBuiltin(_Trace))
-}
-
-func init() {
-	Universe = NewScope(nil, token.NoPos, token.NoPos, "universe")
-	Unsafe = NewPackage("unsafe", "unsafe")
-	Unsafe.complete = true
-
-	defPredeclaredTypes()
-	defPredeclaredConsts()
-	defPredeclaredNil()
-	defPredeclaredFuncs()
-
-	universeIota = Universe.Lookup("iota").(*Const)
-	universeByte = Universe.Lookup("byte").(*TypeName).typ.(*Basic)
-	universeRune = Universe.Lookup("rune").(*TypeName).typ.(*Basic)
-}
-
-// Objects with names containing blanks are internal and not entered into
-// a scope. Objects with exported names are inserted in the unsafe package
-// scope; other objects are inserted in the universe scope.
-//
-func def(obj Object) {
-	name := obj.Name()
-	if strings.Index(name, " ") >= 0 {
-		return // nothing to do
-	}
-	// fix Obj link for named types
-	if typ, ok := obj.Type().(*Named); ok {
-		typ.obj = obj.(*TypeName)
-	}
-	// exported identifiers go into package unsafe
-	scope := Universe
-	if obj.Exported() {
-		scope = Unsafe.scope
-		// set Pkg field
-		switch obj := obj.(type) {
-		case *TypeName:
-			obj.pkg = Unsafe
-		case *Builtin:
-			obj.pkg = Unsafe
-		default:
-			unreachable()
-		}
-	}
-	if scope.Insert(obj) != nil {
-		panic("internal error: double declaration")
-	}
-}