bump(k8s.io/gengo): dcbe4570f0cf6efbc583a5321c8f9390f71a544d

Godeps/Godeps.json

@@ -1723,42 +1723,34 @@
 		},
 		{
 			"ImportPath": "github.com/google/certificate-transparency-go",
-			"Comment": "v1.0.10",
 			"Rev": "1bec4527572c443752ad4f2830bef88be0533236"
 		},
 		{
 			"ImportPath": "github.com/google/certificate-transparency-go/asn1",
-			"Comment": "v1.0.10",
 			"Rev": "1bec4527572c443752ad4f2830bef88be0533236"
 		},
 		{
 			"ImportPath": "github.com/google/certificate-transparency-go/client",
-			"Comment": "v1.0.10",
 			"Rev": "1bec4527572c443752ad4f2830bef88be0533236"
 		},
 		{
 			"ImportPath": "github.com/google/certificate-transparency-go/client/configpb",
-			"Comment": "v1.0.10",
 			"Rev": "1bec4527572c443752ad4f2830bef88be0533236"
 		},
 		{
 			"ImportPath": "github.com/google/certificate-transparency-go/jsonclient",
-			"Comment": "v1.0.10",
 			"Rev": "1bec4527572c443752ad4f2830bef88be0533236"
 		},
 		{
 			"ImportPath": "github.com/google/certificate-transparency-go/tls",
-			"Comment": "v1.0.10",
 			"Rev": "1bec4527572c443752ad4f2830bef88be0533236"
 		},
 		{
 			"ImportPath": "github.com/google/certificate-transparency-go/x509",
-			"Comment": "v1.0.10",
 			"Rev": "1bec4527572c443752ad4f2830bef88be0533236"
 		},
 		{
 			"ImportPath": "github.com/google/certificate-transparency-go/x509/pkix",
-			"Comment": "v1.0.10",
 			"Rev": "1bec4527572c443752ad4f2830bef88be0533236"
 		},
 		{
@@ -2000,7 +1992,6 @@
 		},
 		{
 			"ImportPath": "github.com/inconshreveable/mousetrap",
-			"Comment": "v1.0",
 			"Rev": "76626ae9c91c4f2a10f34cad8ce83ea42c93bb75"
 		},
 		{
@@ -2870,7 +2861,6 @@
 		},
 		{
 			"ImportPath": "github.com/xiang90/probing",
-			"Comment": "0.0.1",
 			"Rev": "07dd2e8dfe18522e9c447ba95f2fe95262f63bb2"
 		},
 		{
@@ -3312,43 +3302,43 @@
 		},
 		{
 			"ImportPath": "k8s.io/gengo/args",
-			"Rev": "01a732e01d00cb9a81bb0ca050d3e6d2b947927b"
+			"Rev": "dcbe4570f0cf6efbc583a5321c8f9390f71a544d"
 		},
 		{
 			"ImportPath": "k8s.io/gengo/examples/deepcopy-gen/generators",
-			"Rev": "01a732e01d00cb9a81bb0ca050d3e6d2b947927b"
+			"Rev": "dcbe4570f0cf6efbc583a5321c8f9390f71a544d"
 		},
 		{
 			"ImportPath": "k8s.io/gengo/examples/defaulter-gen/generators",
-			"Rev": "01a732e01d00cb9a81bb0ca050d3e6d2b947927b"
+			"Rev": "dcbe4570f0cf6efbc583a5321c8f9390f71a544d"
 		},
 		{
 			"ImportPath": "k8s.io/gengo/examples/import-boss/generators",
-			"Rev": "01a732e01d00cb9a81bb0ca050d3e6d2b947927b"
+			"Rev": "dcbe4570f0cf6efbc583a5321c8f9390f71a544d"
 		},
 		{
 			"ImportPath": "k8s.io/gengo/examples/set-gen/generators",
-			"Rev": "01a732e01d00cb9a81bb0ca050d3e6d2b947927b"
+			"Rev": "dcbe4570f0cf6efbc583a5321c8f9390f71a544d"
 		},
 		{
 			"ImportPath": "k8s.io/gengo/examples/set-gen/sets",
-			"Rev": "01a732e01d00cb9a81bb0ca050d3e6d2b947927b"
+			"Rev": "dcbe4570f0cf6efbc583a5321c8f9390f71a544d"
 		},
 		{
 			"ImportPath": "k8s.io/gengo/generator",
-			"Rev": "01a732e01d00cb9a81bb0ca050d3e6d2b947927b"
+			"Rev": "dcbe4570f0cf6efbc583a5321c8f9390f71a544d"
 		},
 		{
 			"ImportPath": "k8s.io/gengo/namer",
-			"Rev": "01a732e01d00cb9a81bb0ca050d3e6d2b947927b"
+			"Rev": "dcbe4570f0cf6efbc583a5321c8f9390f71a544d"
 		},
 		{
 			"ImportPath": "k8s.io/gengo/parser",
-			"Rev": "01a732e01d00cb9a81bb0ca050d3e6d2b947927b"
+			"Rev": "dcbe4570f0cf6efbc583a5321c8f9390f71a544d"
 		},
 		{
 			"ImportPath": "k8s.io/gengo/types",
-			"Rev": "01a732e01d00cb9a81bb0ca050d3e6d2b947927b"
+			"Rev": "dcbe4570f0cf6efbc583a5321c8f9390f71a544d"
 		},
 		{
 			"ImportPath": "k8s.io/heapster/metrics/api/v1/types",

staging/src/k8s.io/code-generator/Godeps/Godeps.json

@@ -220,43 +220,43 @@
 		},
 		{
 			"ImportPath": "k8s.io/gengo/args",
-			"Rev": "01a732e01d00cb9a81bb0ca050d3e6d2b947927b"
+			"Rev": "dcbe4570f0cf6efbc583a5321c8f9390f71a544d"
 		},
 		{
 			"ImportPath": "k8s.io/gengo/examples/deepcopy-gen/generators",
-			"Rev": "01a732e01d00cb9a81bb0ca050d3e6d2b947927b"
+			"Rev": "dcbe4570f0cf6efbc583a5321c8f9390f71a544d"
 		},
 		{
 			"ImportPath": "k8s.io/gengo/examples/defaulter-gen/generators",
-			"Rev": "01a732e01d00cb9a81bb0ca050d3e6d2b947927b"
+			"Rev": "dcbe4570f0cf6efbc583a5321c8f9390f71a544d"
 		},
 		{
 			"ImportPath": "k8s.io/gengo/examples/import-boss/generators",
-			"Rev": "01a732e01d00cb9a81bb0ca050d3e6d2b947927b"
+			"Rev": "dcbe4570f0cf6efbc583a5321c8f9390f71a544d"
 		},
 		{
 			"ImportPath": "k8s.io/gengo/examples/set-gen/generators",
-			"Rev": "01a732e01d00cb9a81bb0ca050d3e6d2b947927b"
+			"Rev": "dcbe4570f0cf6efbc583a5321c8f9390f71a544d"
 		},
 		{
 			"ImportPath": "k8s.io/gengo/examples/set-gen/sets",
-			"Rev": "01a732e01d00cb9a81bb0ca050d3e6d2b947927b"
+			"Rev": "dcbe4570f0cf6efbc583a5321c8f9390f71a544d"
 		},
 		{
 			"ImportPath": "k8s.io/gengo/generator",
-			"Rev": "01a732e01d00cb9a81bb0ca050d3e6d2b947927b"
+			"Rev": "dcbe4570f0cf6efbc583a5321c8f9390f71a544d"
 		},
 		{
 			"ImportPath": "k8s.io/gengo/namer",
-			"Rev": "01a732e01d00cb9a81bb0ca050d3e6d2b947927b"
+			"Rev": "dcbe4570f0cf6efbc583a5321c8f9390f71a544d"
 		},
 		{
 			"ImportPath": "k8s.io/gengo/parser",
-			"Rev": "01a732e01d00cb9a81bb0ca050d3e6d2b947927b"
+			"Rev": "dcbe4570f0cf6efbc583a5321c8f9390f71a544d"
 		},
 		{
 			"ImportPath": "k8s.io/gengo/types",
-			"Rev": "01a732e01d00cb9a81bb0ca050d3e6d2b947927b"
+			"Rev": "dcbe4570f0cf6efbc583a5321c8f9390f71a544d"
 		},
 		{
 			"ImportPath": "k8s.io/kube-openapi/pkg/common",

vendor/k8s.io/gengo/examples/deepcopy-gen/generators/deepcopy.go

@@ -683,7 +683,7 @@ func (g *genDeepCopy) generateFor(t *types.Type, sw *generator.SnippetWriter) {
 		// can never happen because we branch on the underlying type which is never an alias
 		glog.Fatalf("Hit an alias type %v. This should never happen.", t)
 	default:
-		f = g.doUnknown
+		glog.Fatalf("Hit an unsupported type %v.", t)
 	}
 	f(t, sw)
 }
@@ -710,70 +710,53 @@ func (g *genDeepCopy) doMap(t *types.Type, sw *generator.SnippetWriter) {
 		return
 	}
 
-	sw.Do("*out = make($.|raw$, len(*in))\n", t)
-	if ut.Key.IsAssignable() {
-		dc, dci := deepCopyMethodOrDie(ut.Elem), deepCopyIntoMethodOrDie(ut.Elem)
-		switch {
-		case dc != nil || dci != nil:
-			sw.Do("for key, val := range *in {\n", nil)
-			// Note: a DeepCopy exists because it is added if DeepCopyInto is manually defined
-			leftPointer := ut.Elem.Kind == types.Pointer
-			rightPointer := !isReference(ut.Elem)
-			if dc != nil {
-				rightPointer = dc.Results[0].Kind == types.Pointer
-			}
-			if leftPointer == rightPointer {
-				sw.Do("(*out)[key] = val.DeepCopy()\n", nil)
-			} else if leftPointer {
-				sw.Do("x := val.DeepCopy()\n", nil)
-				sw.Do("(*out)[key] = &x\n", nil)
-			} else {
-				sw.Do("(*out)[key] = *val.DeepCopy()\n", nil)
-			}
-			sw.Do("}\n", nil)
-		case ut.Elem.IsAnonymousStruct(): // not uet here because it needs type cast
-			sw.Do("for key := range *in {\n", nil)
-			sw.Do("(*out)[key] = struct{}{}\n", nil)
-			sw.Do("}\n", nil)
-		case uet.IsAssignable():
-			sw.Do("for key, val := range *in {\n", nil)
-			sw.Do("(*out)[key] = val\n", nil)
-			sw.Do("}\n", nil)
-		case uet.Kind == types.Interface:
-			sw.Do("for key, val := range *in {\n", nil)
-			sw.Do("if val == nil {(*out)[key]=nil} else {\n", nil)
-			// Note: if t.Elem has been an alias "J" of an interface "I" in Go, we will see it
-			// as kind Interface of name "J" here, i.e. generate val.DeepCopyJ(). The golang
-			// parser does not give us the underlying interface name. So we cannot do any better.
-			sw.Do(fmt.Sprintf("(*out)[key] = val.DeepCopy%s()\n", uet.Name.Name), nil)
-			sw.Do("}}\n", nil)
-		default:
-			sw.Do("for key, val := range *in {\n", nil)
-			if g.copyableAndInBounds(uet) {
-				sw.Do("newVal := new($.|raw$)\n", ut.Elem)
-				sw.Do("val.DeepCopyInto(newVal)\n", nil)
-				sw.Do("(*out)[key] = *newVal\n", nil)
-			} else if uet.Kind == types.Slice && underlyingType(uet.Elem).Kind == types.Builtin {
-				sw.Do("if val==nil { (*out)[key]=nil } else {\n", nil)
-				sw.Do("(*out)[key] = make($.|raw$, len(val))\n", uet)
-				sw.Do("copy((*out)[key], val)\n", nil)
-				sw.Do("}\n", nil)
-			} else if uet.Kind == types.Pointer {
-				sw.Do("if val==nil { (*out)[key]=nil } else {\n", nil)
-				sw.Do("(*out)[key] = new($.Elem|raw$)\n", uet)
-				sw.Do("val.DeepCopyInto((*out)[key])\n", nil)
-				sw.Do("}\n", nil)
-			} else {
-				sw.Do("(*out)[key] = *val.DeepCopy()\n", uet)
-			}
-			sw.Do("}\n", nil)
-		}
-	} else {
-		// TODO: Implement it when necessary.
-		sw.Do("for range *in {\n", nil)
-		sw.Do("// FIXME: Copying unassignable keys unsupported $.|raw$\n", ut.Key)
-		sw.Do("}\n", nil)
+	if !ut.Key.IsAssignable() {
+		glog.Fatalf("Hit an unsupported type %v.", uet)
 	}
+
+	sw.Do("*out = make($.|raw$, len(*in))\n", t)
+	sw.Do("for key, val := range *in {\n", nil)
+	dc, dci := deepCopyMethodOrDie(ut.Elem), deepCopyIntoMethodOrDie(ut.Elem)
+	switch {
+	case dc != nil || dci != nil:
+		// Note: a DeepCopy exists because it is added if DeepCopyInto is manually defined
+		leftPointer := ut.Elem.Kind == types.Pointer
+		rightPointer := !isReference(ut.Elem)
+		if dc != nil {
+			rightPointer = dc.Results[0].Kind == types.Pointer
+		}
+		if leftPointer == rightPointer {
+			sw.Do("(*out)[key] = val.DeepCopy()\n", nil)
+		} else if leftPointer {
+			sw.Do("x := val.DeepCopy()\n", nil)
+			sw.Do("(*out)[key] = &x\n", nil)
+		} else {
+			sw.Do("(*out)[key] = *val.DeepCopy()\n", nil)
+		}
+	case ut.Elem.IsAnonymousStruct(): // not uet here because it needs type cast
+		sw.Do("(*out)[key] = val\n", nil)
+	case uet.IsAssignable():
+		sw.Do("(*out)[key] = val\n", nil)
+	case uet.Kind == types.Interface:
+		sw.Do("if val == nil {(*out)[key]=nil} else {\n", nil)
+		// Note: if t.Elem has been an alias "J" of an interface "I" in Go, we will see it
+		// as kind Interface of name "J" here, i.e. generate val.DeepCopyJ(). The golang
+		// parser does not give us the underlying interface name. So we cannot do any better.
+		sw.Do(fmt.Sprintf("(*out)[key] = val.DeepCopy%s()\n", uet.Name.Name), nil)
+		sw.Do("}\n", nil)
+	case uet.Kind == types.Slice || uet.Kind == types.Map || uet.Kind == types.Pointer:
+		sw.Do("var outVal $.|raw$\n", uet)
+		sw.Do("if val == nil { (*out)[key] = nil } else {\n", nil)
+		sw.Do("in, out := &val, &outVal\n", uet)
+		g.generateFor(ut.Elem, sw)
+		sw.Do("}\n", nil)
+		sw.Do("(*out)[key] = outVal\n", nil)
+	case uet.Kind == types.Struct:
+		sw.Do("(*out)[key] = *val.DeepCopy()\n", uet)
+	default:
+		glog.Fatalf("Hit an unsupported type %v.", uet)
+	}
+	sw.Do("}\n", nil)
 }
 
 // doSlice generates code for a slice or an alias to a slice. The generated code is
@@ -797,8 +780,8 @@ func (g *genDeepCopy) doSlice(t *types.Type, sw *generator.SnippetWriter) {
 		sw.Do("copy(*out, *in)\n", nil)
 	} else {
 		sw.Do("for i := range *in {\n", nil)
-		if uet.Kind == types.Slice || uet.Kind == types.Map || deepCopyMethodOrDie(ut.Elem) != nil || deepCopyIntoMethodOrDie(ut.Elem) != nil {
-			sw.Do("if (*in)[i] != nil {\n", nil)
+		if uet.Kind == types.Slice || uet.Kind == types.Map || uet.Kind == types.Pointer || deepCopyMethodOrDie(ut.Elem) != nil || deepCopyIntoMethodOrDie(ut.Elem) != nil {
+			sw.Do("if (*in)[i] == nil { (*out)[i] = nil } else {\n", nil)
 			sw.Do("in, out := &(*in)[i], &(*out)[i]\n", nil)
 			g.generateFor(ut.Elem, sw)
 			sw.Do("}\n", nil)
@@ -809,15 +792,10 @@ func (g *genDeepCopy) doSlice(t *types.Type, sw *generator.SnippetWriter) {
 			// parser does not give us the underlying interface name. So we cannot do any better.
 			sw.Do(fmt.Sprintf("(*out)[i] = (*in)[i].DeepCopy%s()\n", uet.Name.Name), nil)
 			sw.Do("}\n", nil)
-		} else if uet.Kind == types.Pointer {
-			sw.Do("if (*in)[i]==nil { (*out)[i]=nil } else {\n", nil)
-			sw.Do("(*out)[i] = new($.Elem|raw$)\n", uet)
-			sw.Do("(*in)[i].DeepCopyInto((*out)[i])\n", nil)
-			sw.Do("}\n", nil)
 		} else if uet.Kind == types.Struct {
 			sw.Do("(*in)[i].DeepCopyInto(&(*out)[i])\n", nil)
 		} else {
-			sw.Do("(*out)[i] = (*in)[i].DeepCopy()\n", nil)
+			glog.Fatalf("Hit an unsupported type %v.", uet)
 		}
 		sw.Do("}\n", nil)
 	}
@@ -885,7 +863,7 @@ func (g *genDeepCopy) doStruct(t *types.Type, sw *generator.SnippetWriter) {
 			sw.Do(fmt.Sprintf("out.$.name$ = in.$.name$.DeepCopy%s()\n", uft.Name.Name), args)
 			sw.Do("}\n", nil)
 		default:
-			sw.Do("out.$.name$ = in.$.name$.DeepCopy()\n", args)
+			glog.Fatalf("Hit an unsupported type %v.", uft)
 		}
 	}
 }
@@ -896,9 +874,9 @@ func (g *genDeepCopy) doPointer(t *types.Type, sw *generator.SnippetWriter) {
 	ut := underlyingType(t)
 	uet := underlyingType(ut.Elem)
 
-	sw.Do("if *in == nil { *out = nil } else {\n", t)
 	dc, dci := deepCopyMethodOrDie(ut.Elem), deepCopyIntoMethodOrDie(ut.Elem)
-	if dc != nil || dci != nil {
+	switch {
+	case dc != nil || dci != nil:
 		rightPointer := !isReference(ut.Elem)
 		if dc != nil {
 			rightPointer = dc.Results[0].Kind == types.Pointer
@@ -909,25 +887,19 @@ func (g *genDeepCopy) doPointer(t *types.Type, sw *generator.SnippetWriter) {
 			sw.Do("x := (*in).DeepCopy()\n", nil)
 			sw.Do("*out = &x\n", nil)
 		}
-	} else if uet.IsAssignable() {
+	case uet.IsAssignable():
 		sw.Do("*out = new($.Elem|raw$)\n", ut)
 		sw.Do("**out = **in", nil)
-	} else {
-		switch uet.Kind {
-		case types.Map, types.Slice:
-			sw.Do("*out = new($.Elem|raw$)\n", ut)
-			sw.Do("if **in != nil {\n", nil)
-			sw.Do("in, out := *in, *out\n", nil)
-			g.generateFor(uet, sw)
-			sw.Do("}\n", nil)
-		default:
-			sw.Do("*out = new($.Elem|raw$)\n", ut)
-			sw.Do("(*in).DeepCopyInto(*out)\n", nil)
-		}
+	case uet.Kind == types.Map, uet.Kind == types.Slice, uet.Kind == types.Pointer:
+		sw.Do("*out = new($.Elem|raw$)\n", ut)
+		sw.Do("if **in != nil {\n", nil)
+		sw.Do("in, out := *in, *out\n", nil)
+		g.generateFor(uet, sw)
+		sw.Do("}\n", nil)
+	case uet.Kind == types.Struct:
+		sw.Do("*out = new($.Elem|raw$)\n", ut)
+		sw.Do("(*in).DeepCopyInto(*out)\n", nil)
+	default:
+		glog.Fatalf("Hit an unsupported type %v.", uet)
 	}
-	sw.Do("}", t)
-}
-
-func (g *genDeepCopy) doUnknown(t *types.Type, sw *generator.SnippetWriter) {
-	sw.Do("// FIXME: Type $.|raw$ is unsupported.\n", t)
 }

vendor/k8s.io/gengo/generator/import_tracker.go

@@ -17,9 +17,10 @@ limitations under the License.
 package generator
 
 import (
-	"path/filepath"
 	"strings"
 
+	"github.com/golang/glog"
+
 	"k8s.io/gengo/namer"
 	"k8s.io/gengo/types"
 )
@@ -37,7 +38,14 @@ func NewImportTracker(typesToAdd ...*types.Type) namer.ImportTracker {
 
 func golangTrackerLocalName(tracker namer.ImportTracker, t types.Name) string {
 	path := t.Package
-	dirs := strings.Split(path, string(filepath.Separator))
+
+	// Using backslashes in package names causes gengo to produce Go code which
+	// will not compile with the gc compiler. See the comment on GoSeperator.
+	if strings.ContainsRune(path, '\\') {
+		glog.Warningf("Warning: backslash used in import path '%v', this is unsupported.\n", path)
+	}
+
+	dirs := strings.Split(path, namer.GoSeperator)
 	for n := len(dirs) - 1; n >= 0; n-- {
 		// TODO: bikeshed about whether it's more readable to have an
 		// _, something else, or nothing between directory names.

vendor/k8s.io/gengo/namer/namer.go

@@ -23,6 +23,17 @@ import (
 	"k8s.io/gengo/types"
 )
 
+const (
+	// GoSeperator is used to split go import paths.
+	// Forward slash is used instead of filepath.Seperator because it is the
+	// only universally-accepted path delimiter and the only delimiter not
+	// potentially forbidden by Go compilers. (In particular gc does not allow
+	// the use of backslashes in import paths.)
+	// See https://golang.org/ref/spec#Import_declarations.
+	// See also https://github.com/kubernetes/gengo/issues/83#issuecomment-367040772.
+	GoSeperator = "/"
+)
+
 // Returns whether a name is a private Go name.
 func IsPrivateGoName(name string) bool {
 	return len(name) == 0 || strings.ToLower(name[:1]) == name[:1]
@@ -187,7 +198,7 @@ var (
 
 // filters out unwanted directory names and sanitizes remaining names.
 func (ns *NameStrategy) filterDirs(path string) []string {
-	allDirs := strings.Split(path, string(filepath.Separator))
+	allDirs := strings.Split(path, GoSeperator)
 	dirs := make([]string, 0, len(allDirs))
 	for _, p := range allDirs {
 		if ns.IgnoreWords == nil || !ns.IgnoreWords[p] {

vendor/k8s.io/gengo/parser/parse.go

@@ -26,6 +26,7 @@ import (
 	"io/ioutil"
 	"os"
 	"os/exec"
+	"path"
 	"path/filepath"
 	"sort"
 	"strings"
@@ -226,12 +227,12 @@ func (b *Builder) AddDirRecursive(dir string) error {
 	// filepath.Walk includes the root dir, but we already did that, so we'll
 	// remove that prefix and rebuild a package import path.
 	prefix := b.buildPackages[dir].Dir
-	fn := func(path string, info os.FileInfo, err error) error {
+	fn := func(filePath string, info os.FileInfo, err error) error {
 		if info != nil && info.IsDir() {
-			rel := strings.TrimPrefix(path, prefix)
+			rel := filepath.ToSlash(strings.TrimPrefix(filePath, prefix))
 			if rel != "" {
 				// Make a pkg path.
-				pkg := filepath.Join(string(canonicalizeImportPath(b.buildPackages[dir].ImportPath)), rel)
+				pkg := path.Join(string(canonicalizeImportPath(b.buildPackages[dir].ImportPath)), rel)
 
 				// Add it.
 				if _, err := b.importPackage(pkg, true); err != nil {
@@ -488,7 +489,7 @@ func (b *Builder) findTypesIn(pkgPath importPathString, u *types.Universe) error
 	u.Package(string(pkgPath)).SourcePath = b.absPaths[pkgPath]
 
 	for _, f := range b.parsed[pkgPath] {
-		if strings.HasSuffix(f.name, "/doc.go") {
+		if _, fileName := filepath.Split(f.name); fileName == "doc.go" {
 			tp := u.Package(string(pkgPath))
 			// findTypesIn might be called multiple times. Clean up tp.Comments
 			// to avoid repeatedly fill same comments to it.