Stop supporting default conversions

staging/src/k8s.io/apimachinery/pkg/conversion/converter.go

@@ -442,20 +442,20 @@ func (c *Converter) doConversion(src, dest interface{}, flags FieldMatchingFlags
 	if fn, ok := c.generatedConversionFuncs.untyped[pair]; ok {
 		return fn(src, dest, scope)
 	}
-	// TODO: consider everything past this point deprecated - we want to support only point to point top level
-	// conversions
 
 	dv, err := EnforcePtr(dest)
 	if err != nil {
 		return err
 	}
-	if !dv.CanAddr() && !dv.CanSet() {
-		return fmt.Errorf("can't write to dest")
-	}
 	sv, err := EnforcePtr(src)
 	if err != nil {
 		return err
 	}
+	return fmt.Errorf("converting (%s) to (%s): unknown conversion", sv.Type(), dv.Type())
+
+	// TODO: Everything past this point is deprecated.
+	//  Remove in 1.20 once we're sure it didn't break anything.
+
 	// Leave something on the stack, so that calls to struct tag getters never fail.
 	scope.srcStack.push(scopeStackElem{})
 	scope.destStack.push(scopeStackElem{})

staging/src/k8s.io/apimachinery/pkg/runtime/scheme.go

@@ -211,6 +211,19 @@ func (s *Scheme) AddKnownTypeWithName(gvk schema.GroupVersionKind, obj Object) {
 		}
 	}
 	s.typeToGVK[t] = append(s.typeToGVK[t], gvk)
+
+	// if the type implements DeepCopyInto(<obj>), register a self-conversion
+	if m := reflect.ValueOf(obj).MethodByName("DeepCopyInto"); m.IsValid() && m.Type().NumIn() == 1 && m.Type().NumOut() == 0 && m.Type().In(0) == reflect.TypeOf(obj) {
+		if err := s.AddGeneratedConversionFunc(obj, obj, func(a, b interface{}, scope conversion.Scope) error {
+			// copy a to b
+			reflect.ValueOf(a).MethodByName("DeepCopyInto").Call([]reflect.Value{reflect.ValueOf(b)})
+			// clear TypeMeta to match legacy reflective conversion
+			b.(Object).GetObjectKind().SetGroupVersionKind(schema.GroupVersionKind{})
+			return nil
+		}); err != nil {
+			panic(err)
+		}
+	}
 }
 
 // KnownTypes returns the types known for the given version.