[AutoDiff] Partial fix for @differentiable function thunking crash. (#25803)

Partial fix for `@differentiable` function thunk with output opaque
abstraction pattern. Avoid `AbstractionPattern` methods that crash for
opaque patterns.

Small step towards fixing TF-123.
Reproducers no longer crash, SIL verification fails instead.
Robust fix requires more work - see TF-123 for more details.

Author: dan-zheng

lib/SILGen/SILGenPoly.cpp

@@ -3257,19 +3257,23 @@ static ManagedValue createAutoDiffThunk(SILGenFunction &SGF,
 
   auto withoutDifferentiablePattern = [](AbstractionPattern pattern)
       -> AbstractionPattern {
-    auto patternType = cast<AnyFunctionType>(pattern.getType());
+    auto patternType = pattern.getAs<AnyFunctionType>();
+    // If pattern does not store an `AnyFunctionType`, return original pattern.
+    // This logic handles opaque abstraction patterns.
+    if (!patternType)
+      return pattern;
     pattern.rewriteType(
         pattern.getGenericSignature(),
         patternType->getWithoutDifferentiability()->getCanonicalType());
     return pattern;
   };
 
+  auto inputOrigTypeNotDiff = withoutDifferentiablePattern(inputOrigType);
   CanAnyFunctionType inputSubstTypeNotDiff(
       inputSubstType->getWithoutDifferentiability());
-  auto inputOrigTypeNotDiff = withoutDifferentiablePattern(inputOrigType);
+  auto outputOrigTypeNotDiff = withoutDifferentiablePattern(outputOrigType);
   CanAnyFunctionType outputSubstTypeNotDiff(
       outputSubstType->getWithoutDifferentiability());
-  auto outputOrigTypeNotDiff = withoutDifferentiablePattern(outputOrigType);
   auto &expectedTLNotDiff = SGF.getTypeLowering(outputOrigTypeNotDiff,
                                                 outputSubstTypeNotDiff);
   // `autodiff_function_extract` is consuming; copy `fn` before passing as
@@ -3301,18 +3305,21 @@ static ManagedValue createAutoDiffThunk(SILGenFunction &SGF,
   auto getAssocFnPattern =
       [&](AbstractionPattern pattern, AutoDiffAssociatedFunctionKind kind)
           -> AbstractionPattern {
+        // If pattern does not store an `AnyFunctionType`, return original
+        // pattern. This logic handles opaque abstraction patterns.
+        auto patternType = pattern.getAs<AnyFunctionType>();
+        if (!patternType)
+          return pattern;
         return AbstractionPattern(
-            pattern.getGenericSignature(),
-            getAssocFnTy(cast<AnyFunctionType>(pattern.getType()), kind));
+            pattern.getGenericSignature(), getAssocFnTy(patternType, kind));
       };
   auto createAssocFnThunk = [&](AutoDiffAssociatedFunctionKind kind)
       -> ManagedValue {
+    auto assocFnInputOrigType = getAssocFnPattern(inputOrigTypeNotDiff, kind);
     auto assocFnInputSubstType = getAssocFnTy(inputSubstTypeNotDiff, kind);
-    auto assocFnInputOrigType = getAssocFnPattern(inputOrigTypeNotDiff,
-                                                  kind);
-    auto assocFnOutputSubstType = getAssocFnTy(outputSubstTypeNotDiff, kind);
     auto assocFnOutputOrigType = getAssocFnPattern(outputOrigTypeNotDiff,
                                                    kind);
+    auto assocFnOutputSubstType = getAssocFnTy(outputSubstTypeNotDiff, kind);
     auto &assocFnExpectedTL = SGF.getTypeLowering(assocFnOutputOrigType,
                                                   assocFnOutputSubstType);
     // `autodiff_function_extract` is consuming; copy `fn` before passing as

test/AutoDiff/differentiable_func_sil.swift

@@ -0,0 +1,17 @@
+// RUN: not --crash %target-swift-frontend -emit-sil %s 2>&1
+// REQUIRES: asserts
+
+// NOTE: Remove `not --crash` from RUN line when TF-123 is fixed.
+
+// FIXME(TF-123): `@differentiable` function thunking with opaque
+// abstraction patterns.
+func blackHole(_ x: Any) {}
+let f: @differentiable (Float) -> Float = { $0 }
+blackHole(f)
+
+// FIXME(TF-123): `@differentiable` function thunking with opaque
+// abstraction patterns.
+struct TF_123 {
+  var f: @differentiable (Float) -> Float
+}
+_ = \TF_123.f