[AutoDiff upstream] Fix stdlib differentiation tests.

Temporarily disable not-yet-supported differentiation tests:

- Forward-mode differentiation.
  - TF-1237: to be upstreamed.
- `Differentiable.zeroTangentVector`.
  - TF-1238: to be upstreamed.
- `SIMD.sum` differentiation.
  - TF-1103: `@_alwaysEmitIntoClient` derivative registration.

Author: dan-zheng

stdlib/public/Differentiation/ArrayDifferentiation.swift

@@ -164,14 +164,6 @@ extension Array: Differentiable where Element: Differentiable {
     view.move(along: direction)
     self = view.base
   }
-
-  /// A closure that produces a `TangentVector` of zeros with the same
-  /// `count` as `self`.
-  public var zeroTangentVectorInitializer: () -> TangentVector {
-    { [count = self.count] in
-      TangentVector(.init(repeating: .zero, count: count))
-    }
-  }
 }
 
 //===----------------------------------------------------------------------===//

test/AutoDiff/stdlib/array.swift

@@ -368,10 +368,10 @@ ArrayAutoDiffTests.test("Array.init(repeating:count:)") {
     Array(repeating: x, count: 10)
   }
   expectEqual(Float(10), gradient(at: .zero) { x in
-    repeating(x).differentiableReduce(0, {$0 + $1}).value
+    repeating(x).differentiableReduce(0, {$0 + $1})
   })
   expectEqual(Float(20), pullback(at: .zero, in: { x in
-    repeating(x).differentiableReduce(0, {$0 + $1}).value
+    repeating(x).differentiableReduce(0, {$0 + $1})
   })(2))
 }
 
@@ -401,22 +401,13 @@ ArrayAutoDiffTests.test("Array.DifferentiableView.base") {
     backprop(FloatArrayTan([1, 2, 3, 4])))
 }
 
-ArrayAutoDiffTests.test("Array.DifferentiableView : KeyPathIterable") {
-  struct Container : KeyPathIterable {
-    let a: Array<Float>.DifferentiableView
-  }
-  let container = Container(a: Array<Float>.DifferentiableView([1, 2, 3]))
-  expectEqual(
-    [1, 2, 3],
-    container.recursivelyAllKeyPaths(to: Float.self).map {
-      container[keyPath: $0]
-    })
-}
-
-ArrayAutoDiffTests.test("Array.zeroTangentVectorInitializer") {
+// TODO: Upstream `Differentiable.zeroTangentVector` and implementations.
+/*
+ArrayAutoDiffTests.test("Array.zeroTangentVector") {
   let count = 10
   let array: [Float] = Array((0..<count).map(Float.init))
   expectEqual(array.zeroTangentVector.base, Array(repeating: 0, count: count))
 }
+*/
 
 runAllTests()

test/AutoDiff/stdlib/floating_point.swift.gyb

@@ -38,24 +38,33 @@ FloatingPointDerivativeTests.test("${Self}.+") {
   expectEqual((1, 1), gradient(at: ${Self}(4), ${Self}(5), in: +))
   expectEqual((10, 10), pullback(at: ${Self}(4), ${Self}(5), in: +)(${Self}(10)))
 
-  expectEqual(2, derivative(at: ${Self}(4), ${Self}(5), in: +))
-  expectEqual(20, differential(at: ${Self}(4), ${Self}(5), in: +)(${Self}(10), ${Self}(10)))
+  // TODO(TF-1237): Upstream forward-mode differentiation.
+  expectCrash {
+    expectEqual(2, derivative(at: ${Self}(4), ${Self}(5), in: +))
+    expectEqual(20, differential(at: ${Self}(4), ${Self}(5), in: +)(${Self}(10), ${Self}(10)))
+  }
 }
 
 FloatingPointDerivativeTests.test("${Self}.-") {
   expectEqual((1, -1), gradient(at: ${Self}(4), ${Self}(5), in: -))
   expectEqual((10, -10), pullback(at: ${Self}(4), ${Self}(5), in: -)(${Self}(10)))
 
-  expectEqual(0, derivative(at: ${Self}(4), ${Self}(5), in: -))
-  expectEqual(-5, differential(at: ${Self}(4), ${Self}(5), in: -)(${Self}(5), ${Self}(10)))
+  // TODO(TF-1237): Upstream forward-mode differentiation.
+  expectCrash {
+    expectEqual(0, derivative(at: ${Self}(4), ${Self}(5), in: -))
+    expectEqual(-5, differential(at: ${Self}(4), ${Self}(5), in: -)(${Self}(5), ${Self}(10)))
+  }
 }
 
 FloatingPointDerivativeTests.test("${Self}.*") {
   expectEqual((5, 4), gradient(at: ${Self}(4), ${Self}(5), in: *))
   expectEqual((50, 40), pullback(at: ${Self}(4), ${Self}(5), in: *)(${Self}(10)))
 
-  expectEqual(9, derivative(at: ${Self}(4), ${Self}(5), in: *))
-  expectEqual(90, differential(at: ${Self}(4), ${Self}(5), in: *)(${Self}(10), ${Self}(10)))
+  // TODO(TF-1237): Upstream forward-mode differentiation.
+  expectCrash {
+    expectEqual(9, derivative(at: ${Self}(4), ${Self}(5), in: *))
+    expectEqual(90, differential(at: ${Self}(4), ${Self}(5), in: *)(${Self}(10), ${Self}(10)))
+  }
 }
 
 FloatingPointDerivativeTests.test("${Self}./") {
@@ -70,8 +79,11 @@ FloatingPointDerivativeTests.test("${Self}./") {
     expectEqualWithTolerance(-1.6, dy)
   }
 
-  expectEqualWithTolerance(0.04, derivative(at: ${Self}(4), ${Self}(5), in: /))
-  expectEqual(90, differential(at: ${Self}(4), ${Self}(5), in: *)(${Self}(10), ${Self}(10)))
+  // TODO(TF-1237): Upstream forward-mode differentiation.
+  expectCrash {
+    expectEqualWithTolerance(0.04, derivative(at: ${Self}(4), ${Self}(5), in: /))
+    expectEqual(90, differential(at: ${Self}(4), ${Self}(5), in: *)(${Self}(10), ${Self}(10)))
+  }
 }
 
 FloatingPointDerivativeTests.test("${Self}.squareRoot") {

test/AutoDiff/stdlib/simd.swift

@@ -22,6 +22,9 @@ SIMDTests.test("init(repeating:)") {
   expectEqual(8, bp1(g))
 }
 
+// FIXME(TF-1103): Derivative registration does not yet support
+// `@_alwaysEmitIntoClient` original functions.
+/*
 SIMDTests.test("Sum") {
   let a = SIMD4<Float>(1, 2, 3, 4)
 
@@ -32,6 +35,7 @@ SIMDTests.test("Sum") {
   expectEqual(10, val1)
   expectEqual(SIMD4<Float>(3, 3, 3, 3), bp1(3))
 }
+*/
 
 SIMDTests.test("Identity") {
   let a = SIMD4<Float>(1, 2, 3, 4)
@@ -259,6 +263,8 @@ SIMDTests.test("Generics") {
   expectEqual(SIMD3<Double>(5, 10, 15), val4)
   expectEqual((SIMD3<Double>(5, 5, 5), 6), bp4(g))
 
+  // FIXME(TF-1103): Derivative registration does not yet support
+  /*
   func testSum<Scalar, SIMDType: SIMD>(x: SIMDType) -> Scalar
     where SIMDType.Scalar == Scalar,
           SIMDType : Differentiable,
@@ -271,6 +277,7 @@ SIMDTests.test("Generics") {
   let (val5, bp5) = valueWithPullback(at: a, in: simd3Sum)
   expectEqual(6, val5)
   expectEqual(SIMD3<Double>(7, 7, 7), bp5(7))
+  */
 }
 
 runAllTests()

test/AutoDiff/stdlib/tgmath_derivatives.swift.gyb

@@ -55,6 +55,10 @@ where T == T.TangentVector {
 %for T in ['Float', 'Float80']:
 
 DerivativeTests.test("${op}_${T}") {
+%if op == 'derivative':
+  // TODO(TF-1237): Upstream forward-mode differentiation and uncomment the next line.
+  expectCrash {
+%end
   expectEqualWithTolerance(7.3890560989306502274, ${op}(at: 2 as ${T}, in: exp))
   expectEqualWithTolerance(2.772588722239781145, ${op}(at: 2 as ${T}, in: exp2))
   expectEqualWithTolerance(7.3890560989306502274, ${op}(at: 2 as ${T}, in: expm1))
@@ -82,6 +86,10 @@ DerivativeTests.test("${op}_${T}") {
   expectEqualWithTolerance(0, ${op}(at: 2 as ${T}, in: { round($0) }))
   expectEqualWithTolerance(0, ${op}(at: 2 as ${T}, in: { trunc($0) }))
 
+%if op == 'derivative':
+  } // `expectCrash` for forward-mode differentiation
+%end
+
   // Differential operator specific tests.
 
   // fma
@@ -91,7 +99,10 @@ DerivativeTests.test("${op}_${T}") {
   expectEqualWithTolerance(4, dfma.1)
   expectEqualWithTolerance(1, dfma.2)
 %else: # if op == 'derivative'
-  expectEqualWithTolerance(10, dfma)
+  // TODO(TF-1237): Upstream forward-mode differentiation.
+  expectCrash {
+    expectEqualWithTolerance(10, dfma)
+  }
 %end
 
   // remainder, fmod