Bumping k8s version to 1.13.0-beta.1

vendor/golang.org/x/tools/go/analysis/internal/analysisflags/help.go

@@ -18,7 +18,7 @@ string. It uses heuristics that do not guarantee all reports are
 genuine problems, but it can find errors not caught by the compilers.
 `
 
-// Help implements the help subcommand for a multichecker or vet-lite
+// Help implements the help subcommand for a multichecker or unitchecker
 // style command. The optional args specify the analyzers to describe.
 // Help calls log.Fatal if no such analyzer exists.
 func Help(progname string, analyzers []*analysis.Analyzer, args []string) {

vendor/golang.org/x/tools/go/analysis/passes/composite/composite.go

@@ -16,7 +16,7 @@ import (
 	"golang.org/x/tools/go/ast/inspector"
 )
 
-const Doc = `checked for unkeyed composite literals
+const Doc = `check for unkeyed composite literals
 
 This analyzer reports a diagnostic for composite literals of struct
 types imported from another package that do not use the field-keyed

vendor/golang.org/x/tools/go/analysis/passes/lostcancel/lostcancel.go

@@ -93,32 +93,32 @@ func runFunc(pass *analysis.Pass, node ast.Node) {
 		//   ctx, cancel     = context.WithCancel(...)
 		//   var ctx, cancel = context.WithCancel(...)
 		//
-		if isContextWithCancel(pass.TypesInfo, n) && isCall(stack[len(stack)-2]) {
-			var id *ast.Ident // id of cancel var
-			stmt := stack[len(stack)-3]
-			switch stmt := stmt.(type) {
-			case *ast.ValueSpec:
-				if len(stmt.Names) > 1 {
-					id = stmt.Names[1]
-				}
-			case *ast.AssignStmt:
-				if len(stmt.Lhs) > 1 {
-					id, _ = stmt.Lhs[1].(*ast.Ident)
-				}
+		if !isContextWithCancel(pass.TypesInfo, n) || !isCall(stack[len(stack)-2]) {
+			return true
+		}
+		var id *ast.Ident // id of cancel var
+		stmt := stack[len(stack)-3]
+		switch stmt := stmt.(type) {
+		case *ast.ValueSpec:
+			if len(stmt.Names) > 1 {
+				id = stmt.Names[1]
 			}
-			if id != nil {
-				if id.Name == "_" {
-					pass.Reportf(id.Pos(),
-						"the cancel function returned by context.%s should be called, not discarded, to avoid a context leak",
-						n.(*ast.SelectorExpr).Sel.Name)
-				} else if v, ok := pass.TypesInfo.Uses[id].(*types.Var); ok {
-					cancelvars[v] = stmt
-				} else if v, ok := pass.TypesInfo.Defs[id].(*types.Var); ok {
-					cancelvars[v] = stmt
-				}
+		case *ast.AssignStmt:
+			if len(stmt.Lhs) > 1 {
+				id, _ = stmt.Lhs[1].(*ast.Ident)
+			}
+		}
+		if id != nil {
+			if id.Name == "_" {
+				pass.Reportf(id.Pos(),
+					"the cancel function returned by context.%s should be called, not discarded, to avoid a context leak",
+					n.(*ast.SelectorExpr).Sel.Name)
+			} else if v, ok := pass.TypesInfo.Uses[id].(*types.Var); ok {
+				cancelvars[v] = stmt
+			} else if v, ok := pass.TypesInfo.Defs[id].(*types.Var); ok {
+				cancelvars[v] = stmt
 			}
 		}
-
 		return true
 	})
 
@@ -179,18 +179,22 @@ func hasImport(pkg *types.Package, path string) bool {
 // isContextWithCancel reports whether n is one of the qualified identifiers
 // context.With{Cancel,Timeout,Deadline}.
 func isContextWithCancel(info *types.Info, n ast.Node) bool {
-	if sel, ok := n.(*ast.SelectorExpr); ok {
-		switch sel.Sel.Name {
-		case "WithCancel", "WithTimeout", "WithDeadline":
-			if x, ok := sel.X.(*ast.Ident); ok {
-				if pkgname, ok := info.Uses[x].(*types.PkgName); ok {
-					return pkgname.Imported().Path() == contextPackage
-				}
-				// Import failed, so we can't check package path.
-				// Just check the local package name (heuristic).
-				return x.Name == "context"
-			}
+	sel, ok := n.(*ast.SelectorExpr)
+	if !ok {
+		return false
+	}
+	switch sel.Sel.Name {
+	case "WithCancel", "WithTimeout", "WithDeadline":
+	default:
+		return false
+	}
+	if x, ok := sel.X.(*ast.Ident); ok {
+		if pkgname, ok := info.Uses[x].(*types.PkgName); ok {
+			return pkgname.Imported().Path() == contextPackage
 		}
+		// Import failed, so we can't check package path.
+		// Just check the local package name (heuristic).
+		return x.Name == "context"
 	}
 	return false
 }
@@ -270,29 +274,30 @@ outer:
 	var search func(blocks []*cfg.Block) *ast.ReturnStmt
 	search = func(blocks []*cfg.Block) *ast.ReturnStmt {
 		for _, b := range blocks {
-			if !seen[b] {
-				seen[b] = true
+			if seen[b] {
+				continue
+			}
+			seen[b] = true
 
-				// Prune the search if the block uses v.
-				if blockUses(pass, v, b) {
-					continue
-				}
+			// Prune the search if the block uses v.
+			if blockUses(pass, v, b) {
+				continue
+			}
 
-				// Found path to return statement?
-				if ret := b.Return(); ret != nil {
-					if debug {
-						fmt.Printf("found path to return in block %s\n", b)
-					}
-					return ret // found
+			// Found path to return statement?
+			if ret := b.Return(); ret != nil {
+				if debug {
+					fmt.Printf("found path to return in block %s\n", b)
 				}
+				return ret // found
+			}
 
-				// Recur
-				if ret := search(b.Succs); ret != nil {
-					if debug {
-						fmt.Printf(" from block %s\n", b)
-					}
-					return ret
+			// Recur
+			if ret := search(b.Succs); ret != nil {
+				if debug {
+					fmt.Printf(" from block %s\n", b)
 				}
+				return ret
 			}
 		}
 		return nil

vendor/golang.org/x/tools/go/analysis/passes/stdmethods/stdmethods.go

@@ -131,7 +131,7 @@ func canonicalMethod(pass *analysis.Pass, id *ast.Ident) {
 			expectFmt += " (" + argjoin(expect.results) + ")"
 		}
 
-		actual := types.TypeString(sign, (*types.Package).Name)
+		actual := typeString(sign)
 		actual = strings.TrimPrefix(actual, "func")
 		actual = id.Name + actual
 
@@ -139,6 +139,10 @@ func canonicalMethod(pass *analysis.Pass, id *ast.Ident) {
 	}
 }
 
+func typeString(typ types.Type) string {
+	return types.TypeString(typ, (*types.Package).Name)
+}
+
 func argjoin(x []string) string {
 	y := make([]string, len(x))
 	for i, s := range x {
@@ -178,5 +182,5 @@ func matchParamType(fset *token.FileSet, pkg *types.Package, expect string, actu
 	}
 
 	// Overkill but easy.
-	return actual.String() == expect
+	return typeString(actual) == expect
 }

vendor/golang.org/x/tools/go/analysis/passes/stdmethods/testdata/src/a/a.go

@@ -24,6 +24,10 @@ func (U) GobDecode() {} // want `should have signature GobDecode\(\[\]byte\) err
 // Test rendering of type names such as xml.Encoder in diagnostic.
 func (U) MarshalXML(*xml.Encoder) {} // want `method MarshalXML\(\*xml.Encoder\) should...`
 
+func (U) UnmarshalXML(*xml.Decoder, xml.StartElement) error { // no error: signature matches xml.Unmarshaler
+	return nil
+}
+
 type I interface {
 	ReadByte() byte // want `should have signature ReadByte\(\) \(byte, error\)`
 }

vendor/golang.org/x/tools/go/analysis/passes/unsafeptr/unsafeptr.go

@@ -62,28 +62,28 @@ func isSafeUintptr(info *types.Info, x ast.Expr) bool {
 		return isSafeUintptr(info, x.X)
 
 	case *ast.SelectorExpr:
-		switch x.Sel.Name {
-		case "Data":
-			// reflect.SliceHeader and reflect.StringHeader are okay,
-			// but only if they are pointing at a real slice or string.
-			// It's not okay to do:
-			//	var x SliceHeader
-			//	x.Data = uintptr(unsafe.Pointer(...))
-			//	... use x ...
-			//	p := unsafe.Pointer(x.Data)
-			// because in the middle the garbage collector doesn't
-			// see x.Data as a pointer and so x.Data may be dangling
-			// by the time we get to the conversion at the end.
-			// For now approximate by saying that *Header is okay
-			// but Header is not.
-			pt, ok := info.Types[x.X].Type.(*types.Pointer)
-			if ok {
-				t, ok := pt.Elem().(*types.Named)
-				if ok && t.Obj().Pkg().Path() == "reflect" {
-					switch t.Obj().Name() {
-					case "StringHeader", "SliceHeader":
-						return true
-					}
+		if x.Sel.Name != "Data" {
+			break
+		}
+		// reflect.SliceHeader and reflect.StringHeader are okay,
+		// but only if they are pointing at a real slice or string.
+		// It's not okay to do:
+		//	var x SliceHeader
+		//	x.Data = uintptr(unsafe.Pointer(...))
+		//	... use x ...
+		//	p := unsafe.Pointer(x.Data)
+		// because in the middle the garbage collector doesn't
+		// see x.Data as a pointer and so x.Data may be dangling
+		// by the time we get to the conversion at the end.
+		// For now approximate by saying that *Header is okay
+		// but Header is not.
+		pt, ok := info.Types[x.X].Type.(*types.Pointer)
+		if ok {
+			t, ok := pt.Elem().(*types.Named)
+			if ok && t.Obj().Pkg().Path() == "reflect" {
+				switch t.Obj().Name() {
+				case "StringHeader", "SliceHeader":
+					return true
 				}
 			}
 		}

vendor/golang.org/x/tools/go/analysis/unitchecker/main.go

@@ -1,7 +1,12 @@
-// The vet-lite command is a driver for static checkers conforming to
-// the golang.org/x/tools/go/analysis API. It must be run by go vet:
+// +build ignore
+
+// This file provides an example command for static checkers
+// conforming to the golang.org/x/tools/go/analysis API.
+// It serves as a model for the behavior of the cmd/vet tool in $GOROOT.
+// Being based on the unitchecker driver, it must be run by go vet:
 //
-//   $ go vet -vettool=$(which vet-lite)
+//   $ go build -o unitchecker main.go
+//   $ go vet -vettool=unitchecker my/project/...
 //
 // For a checker also capable of running standalone, use multichecker.
 package main
@@ -32,21 +37,6 @@ import (
 	"golang.org/x/tools/go/analysis/passes/unusedresult"
 )
 
-// Legacy vet had the concept of "experimental" checkers. There
-// was exactly one, shadow, and it had to be explicitly enabled
-// by the -shadow flag, which would of course disable all the
-// other tristate flags, requiring the -all flag to reenable them.
-// (By itself, -all did not enable all checkers.)
-// The -all flag is no longer needed, so it is a no-op.
-//
-// The shadow analyzer has been removed from the suite,
-// but can be run using these additional commands:
-//   $ go install golang.org/x/tools/go/analysis/passes/shadow/cmd/shadow
-//   $ go vet -vettool=$(which shadow)
-// Alternatively, one could build a multichecker containing all
-// the desired checks (vet's suite + shadow) and run it in a
-// single "go vet" command.
-
 func main() {
 	unitchecker.Main(
 		asmdecl.Analyzer,

vendor/golang.org/x/tools/go/analysis/unitchecker/unitchecker.go

@@ -95,7 +95,7 @@ func Main(analyzers ...*analysis.Analyzer) {
 
 Usage of %[1]s:
 	%.16[1]s unit.cfg	# execute analysis specified by config file
-	%.16[1]s help		# general help
+	%.16[1]s help    	# general help
 	%.16[1]s help name	# help on specific analyzer and its flags
 `, progname)
 		os.Exit(1)