[AutoDiff] Fix derivative generic signature same-type requirements.

[dan-zheng]

Fix derivative generic signature calculation when same-type requirements bind
all generic parameters to concrete types, i.e. when all generic parameters are
concrete.

Declarations whose generic signature have all concrete generic parameters are
lowered as SIL functions with no generic signature: they are specialized with
the concrete types from the same-type requirements.

For @differentiable attributes: when the original generic signature and the
derivative generic signature are equal and all generic parameters are concrete,
do not set the attribute's derivative generic signature.

Update SIL infrastructure to handle derivative generic signatures with all
concrete generic parameters. In such cases:

• SIL derivative function types are specialized with concrete types and have
  no generic signature.
• SIL differentiability witnesses have a derivative generic signature iff it
  differs from the original generic signature. Witness generic signatures should
  be used for remapping types during the differentiation transform.

Resolves TF-1059 and TF-1062.
Exposes SR-11950: SIL parser crash for SILGen round-trip.

---

Examples

TF-1059

struct Tensor<Scalar> {}
extension Tensor: Differentiable where Scalar == Float {}

extension Tensor where Scalar == Float {
  @differentiable(vjp: _vjpAdd)
  static func + (_ lhs: Tensor, _ rhs: Tensor) -> Tensor {
    return lhs
  }

  static func _vjpAdd(lhs: Tensor, rhs: Tensor)
    -> (Tensor, (TangentVector) -> (TangentVector, TangentVector)) {
    return (lhs + rhs, { v in (v, v) })
  }
}

let _: @differentiable (Tensor<Float>, Tensor<Float>) -> Tensor<Float> = { $0 + $1 }

Before:

$ swift tf-1059.swift
tf-1059.swift:16:79: error: expression is not differentiable
let _: @differentiable (Tensor<Float>, Tensor<Float>) -> Tensor<Float> = { $0 + $1 }
                                                                              ^
tf-1059.swift:16:79: note: function call is not differentiable because generic requirements are not met: 'Scalar == Float'
let _: @differentiable (Tensor<Float>, Tensor<Float>) -> Tensor<Float> = { $0 + $1 }
                                                                              ^

After: runs successfully.

TF-1062

struct Tensor<T>: Differentiable {}
extension Tensor: Equatable where T: Equatable {}
extension Tensor where T: AdditiveArithmetic {
  static func + (_ lhs: Self, _ rhs: Self) -> Self {
    lhs
  }
}
extension Tensor where T == Float {
  @derivative(of: +)
  static func vjpAdd(_ lhs: Self, _ rhs: Self) -> (
    value: Self, pullback: (TangentVector) -> (TangentVector, TangentVector)
  ) {
    return (lhs + rhs, { v in (v, v) })
  }
}

Before:

$ swift tf-1062.swift
tf-1062.swift:9:19: error: could not find function '+' with expected type '<T where T == Float> (Tensor<T>.Type) -> (Tensor<T>, Tensor<T>) -> Tensor<T>'
  @derivative(of: +)
                  ^

After: runs successfully.

[dan-zheng]

Note: this code is copied from #28762 - it's needed to fix TF-1062. #28762 should be merged first!

[dan-zheng]

Note: this helper is removed because the witness derivative generic signature can be used directly, now that derivative generic signatures are propagated correctly. There's no need to fallback to the original generic signature.

[rxwei]

Will this fix @differentiable(where T == Float)?

[dan-zheng]

Will this fix @differentiable(where T == Float)?

Yes, that's exactly what's tested.

[dan-zheng]

@swift-ci Please test tensorflow