[AutoDiff] Emit a diagnostic for non-differentiable active values (swiftlang#67697)

For some values we cannot compute types for differentiation (for example,
tangent vector type), so it is better to diagnose them earlier. Otherwise we hit
assertions when generating code for such invalid values.

The LIT test is a reduced reproducer from the issue swiftlang#66996. Before the patch the
compiler crashed while trying to get a tangent vector type for the following
value (partial_apply):

    %54 = function_ref @$s4null1o2ffSdAA1FV_tFSdyKXEfu0_ :
      $@convention(thin) @Substituted <τ_0_0> (@inout_aliasable Double)
      -> (@out τ_0_0, @error any Error) for <Double>

    %55 = partial_apply [callee_guaranteed] %54(%2) :
      $@convention(thin) @Substituted <τ_0_0> (@inout_aliasable Double)
      -> (@out τ_0_0, @error any Error) for <Double>

Now we emit a diagnostic instead.

The patch resolves issues swiftlang#66996 and swiftlang#63331

Author: asavonic

lib/SILOptimizer/Differentiation/PullbackCloner.cpp

@@ -1864,6 +1864,16 @@ bool PullbackCloner::Implementation::run() {
       // become projections into their adjoint base buffer.
       if (Projection::isAddressProjection(v))
         return false;
+
+      // Check that active values are differentiable. Otherwise we may crash
+      // later when tangent space is required, but not available.
+      if (!getTangentSpace(remapType(type).getASTType())) {
+        getContext().emitNondifferentiabilityError(
+            v, getInvoker(), diag::autodiff_expression_not_differentiable_note);
+        errorOccurred = true;
+        return true;
+      }
+
       // Record active value.
       bbActiveValues.push_back(v);
       return false;

test/AutoDiff/SILOptimizer/optional_error.swift

@@ -0,0 +1,20 @@
+// RUN: %target-swift-frontend -emit-sil -verify %s
+
+import _Differentiation
+
+// expected-error @+1 {{function is not differentiable}}
+@differentiable(reverse)
+// expected-note @+1 {{when differentiating this function definition}}
+func o(ff: F) -> Double {
+    var y = ff.i?.first { $0 >= 0.0 } ?? 0.0
+    while 0.0 < y {
+        // expected-note @+1 {{expression is not differentiable}}
+	y = ff.g() ?? y
+    }
+    return y
+}
+
+public struct F: Differentiable {
+    @noDerivative var i: [Double]? {return nil}
+    func g() -> Double? {return nil}
+}