Fix AutoDiff tests. (#24564)

* Fix AutoDiff tests.

- Fix `createAutoDiffThunk` to pass ownership verification.
  - The `@differentiable` function operand must be copied if non-trivial.
- Fix `AutoDiff/builtin_differential_operators.swift` so that it actually runs.

* Revert changes to `emitBuiltinAutoDiffApplyAssociatedFunction`.

Re-add `createDestroyAddr`.
Fix indentation.

Author: dan-zheng

lib/SILGen/SILGenBuiltin.cpp

@@ -1078,12 +1078,11 @@ static ManagedValue emitBuiltinAutoDiffApplyAssociatedFunction(
         continue;
 
       if (argumentValue->getType().isObject()) {
-        SGF.B.createDestroyValue(loc, argumentValue);
+        SGF.B.emitDestroyValueOperation(loc, argumentValue);
         continue;
       }
 
-      if (false)
-        SGF.B.createDestroyAddr(loc, argumentValue);
+      SGF.B.createDestroyAddr(loc, argumentValue);
     }
   };
 
@@ -1096,7 +1095,8 @@ static ManagedValue emitBuiltinAutoDiffApplyAssociatedFunction(
     auto curryLevelArgVals = ArrayRef<SILValue>(origFnArgVals).slice(
         currentParameter, curryLevel->getNumParameters());
     auto applyResult = SGF.B.createApply(
-        loc, assocFn, SubstitutionMap(), curryLevelArgVals, /*isNonThrowing*/ false);
+        loc, assocFn, SubstitutionMap(), curryLevelArgVals,
+        /*isNonThrowing*/ false);
     currentParameter += curryLevel->getNumParameters();
 
     if (assocFnNeedsDestroy)
@@ -1125,8 +1125,8 @@ static ManagedValue emitBuiltinAutoDiffApplyAssociatedFunction(
         currentParameter);
     for (auto origFnArgVal : curryLevelArgVals)
       applyArgs.push_back(origFnArgVal);
-    auto differential = SGF.B.createApply(loc, assocFn, SubstitutionMap(), applyArgs,
-                                          /*isNonThrowing*/ false);
+    auto differential = SGF.B.createApply(
+        loc, assocFn, SubstitutionMap(), applyArgs, /*isNonThrowing*/ false);
 
     if (assocFnNeedsDestroy)
       SGF.B.createDestroyValue(loc, assocFn);
@@ -1143,8 +1143,9 @@ static ManagedValue emitBuiltinAutoDiffApplyAssociatedFunction(
   // Apply the last curry level, in the case where it only has direct results.
   auto curryLevelArgVals = ArrayRef<SILValue>(origFnArgVals).slice(
       currentParameter);
-  auto resultTuple = SGF.B.createApply(loc, assocFn, SubstitutionMap(), curryLevelArgVals,
-                                       /*isNonThrowing*/ false);
+  auto resultTuple = SGF.B.createApply(
+      loc, assocFn, SubstitutionMap(), curryLevelArgVals,
+      /*isNonThrowing*/ false);
 
   if (assocFnNeedsDestroy)
     SGF.B.createDestroyValue(loc, assocFn);

lib/SILGen/SILGenPoly.cpp

@@ -3245,13 +3245,8 @@ static ManagedValue createAutoDiffThunk(SILGenFunction &SGF,
                                         CanAnyFunctionType outputSubstType) {
   // Applies a thunk to all the components by extracting them, applying thunks
   // to all of them, and then putting them back together.
-
   auto sourceType = fn.getType().castTo<SILFunctionType>();
 
-  // We're never going to pass `fn` into anything that consumes it, so get its
-  // value without disabling cleanup.
-  auto fnValue = fn.getValue();
-
   auto withoutDifferentiablePattern = [](AbstractionPattern pattern)
       -> AbstractionPattern {
     auto patternType = cast<AnyFunctionType>(pattern.getType());
@@ -3269,10 +3264,13 @@ static ManagedValue createAutoDiffThunk(SILGenFunction &SGF,
   auto outputOrigTypeNotDiff = withoutDifferentiablePattern(outputOrigType);
   auto &expectedTLNotDiff = SGF.getTypeLowering(outputOrigTypeNotDiff,
                                                 outputSubstTypeNotDiff);
-  SILValue original = SGF.B.createAutoDiffFunctionExtractOriginal(loc, fnValue);
-  auto managedOriginal = original->getType().isTrivial(SGF.F)
-                             ? ManagedValue::forTrivialObjectRValue(original)
-                             : ManagedValue::forBorrowedObjectRValue(original);
+  // `autodiff_function_extract` is consuming; copy `fn` before passing as
+  // operand.
+  auto copiedFnValue = fn.copy(SGF, loc);
+  auto *original = SGF.B.createAutoDiffFunctionExtractOriginal(
+      loc, copiedFnValue.forward(SGF));
+  auto managedOriginal = SGF.emitManagedRValueWithCleanup(original);
+
   ManagedValue originalThunk = createThunk(
       SGF, loc, managedOriginal, inputOrigTypeNotDiff, inputSubstTypeNotDiff,
       outputOrigTypeNotDiff, outputSubstTypeNotDiff, expectedTLNotDiff);
@@ -3309,12 +3307,12 @@ static ManagedValue createAutoDiffThunk(SILGenFunction &SGF,
                                                    kind);
     auto &assocFnExpectedTL = SGF.getTypeLowering(assocFnOutputOrigType,
                                                   assocFnOutputSubstType);
-    auto assocFn = SGF.B.createAutoDiffFunctionExtract(
-        loc, kind,
-        /*differentiationOrder*/ 1, fnValue);
-    auto managedAssocFn = assocFn->getType().isTrivial(SGF.F)
-                              ? ManagedValue::forTrivialObjectRValue(assocFn)
-                              : ManagedValue::forBorrowedObjectRValue(assocFn);
+    // `autodiff_function_extract` is consuming; copy `fn` before passing as
+    // operand.
+    auto copiedFnValue = fn.copy(SGF, loc);
+    auto *assocFn = SGF.B.createAutoDiffFunctionExtract(
+        loc, kind, /*differentiationOrder*/ 1, copiedFnValue.forward(SGF));
+    auto managedAssocFn = SGF.emitManagedRValueWithCleanup(assocFn);
     return createThunk(SGF, loc, managedAssocFn, assocFnInputOrigType,
                        assocFnInputSubstType, assocFnOutputOrigType,
                        assocFnOutputSubstType, assocFnExpectedTL);

test/AutoDiff/builtin_differential_operators.swift

@@ -1,4 +1,7 @@
-// RUN: %target-run
+// RUN: %empty-directory(%t)
+// RUN: %target-build-swift %s -parse-stdlib -o %t/Builtins
+// RUN: %target-codesign %t/Builtins
+// RUN: %target-run %t/Builtins
 // REQUIRES: executable_test
 
 import Swift