handle any in default case to avoid more possible panics

Author: brekelj1

pkg/crd/gen_integration_test.go

@@ -194,7 +194,7 @@ var _ = Describe("CRD Generation proper defaulting", func() {
 				posRel, err := filepath.Rel(filepath.Join(wd, genDir), pkgError.Pos)
 				Expect(err).NotTo(HaveOccurred())
 				Expect(posRel).To(Equal("iface/iface_types.go:32:6"))
-				Expect(pkgError.Msg).To(Equal("cannot generate schema for interface type any"))
+				Expect(pkgError.Msg).To(Equal("cannot generate schema for any"))
 				matches++
 			}
 		}

pkg/crd/schema.go

@@ -270,8 +270,9 @@ func localNamedToSchema(ctx *schemaContext, ident *ast.Ident) *apiext.JSONSchema
 	if aliasInfo, isAlias := typeInfo.(*types.Alias); isAlias {
 		typeInfo = aliasInfo.Rhs()
 	}
-	if basicInfo, isBasic := typeInfo.(*types.Basic); isBasic {
-		typ, fmt, err := builtinToType(basicInfo, ctx.allowDangerousTypes)
+	switch typeInfo := typeInfo.(type) {
+	case *types.Basic:
+		typ, fmt, err := builtinToType(typeInfo, ctx.allowDangerousTypes)
 		if err != nil {
 			ctx.pkg.AddError(loader.ErrFromNode(err, ident))
 		}
@@ -280,7 +281,7 @@ func localNamedToSchema(ctx *schemaContext, ident *ast.Ident) *apiext.JSONSchema
 		// > For gotypesalias=1, alias declarations produce an Alias type.
 		// > Otherwise, the alias information is only in the type name, which
 		// > points directly to the actual (aliased) type.
-		if basicInfo.Name() != ident.Name {
+		if typeInfo.Name() != ident.Name {
 			ctx.requestSchema("", ident.Name)
 			link := TypeRefLink("", ident.Name)
 			return &apiext.JSONSchemaProps{
@@ -293,24 +294,25 @@ func localNamedToSchema(ctx *schemaContext, ident *ast.Ident) *apiext.JSONSchema
 			Type:   typ,
 			Format: fmt,
 		}
-	}
-	if _, isInterface := typeInfo.(*types.Interface); isInterface {
-		ctx.pkg.AddError(loader.ErrFromNode(fmt.Errorf("cannot generate schema for interface type %s", ident.Name), ident))
+	case interface{ Obj() *types.TypeName }:
+		// NB(directxman12): if there are dot imports, this might be an external reference,
+		// so use typechecking info to get the actual object
+		typeNameInfo := typeInfo.Obj()
+		pkg := typeNameInfo.Pkg()
+		pkgPath := loader.NonVendorPath(pkg.Path())
+		if pkg == ctx.pkg.Types {
+			pkgPath = ""
+		}
+		ctx.requestSchema(pkgPath, typeNameInfo.Name())
+		link := TypeRefLink(pkgPath, typeNameInfo.Name())
+		return &apiext.JSONSchemaProps{
+			Ref: &link,
+		}
+	default:
+		// This happens for type any, and other scenarios.
+		ctx.pkg.AddError(loader.ErrFromNode(fmt.Errorf("cannot generate schema for %s", ident.Name), ident))
 		return &apiext.JSONSchemaProps{}
 	}
-	// NB(directxman12): if there are dot imports, this might be an external reference,
-	// so use typechecking info to get the actual object
-	typeNameInfo := typeInfo.(interface{ Obj() *types.TypeName }).Obj()
-	pkg := typeNameInfo.Pkg()
-	pkgPath := loader.NonVendorPath(pkg.Path())
-	if pkg == ctx.pkg.Types {
-		pkgPath = ""
-	}
-	ctx.requestSchema(pkgPath, typeNameInfo.Name())
-	link := TypeRefLink(pkgPath, typeNameInfo.Name())
-	return &apiext.JSONSchemaProps{
-		Ref: &link,
-	}
 }
 
 // namedSchema creates a schema (ref) for an explicitly external type reference.