[AutoDiff] Unoptimized code generation for simple derivatives when called from conditional control-flow contexts

[jkshtj]

Description

The compiler is not optimizing the code as well as it could when simple derivatives are called from code that contains control-flow.

Reproduction

import _Differentiation

@differentiable(reverse)
func oneOperation(a: Float) -> Float {
    return a * 2
}

func f() {
  var obj: Float = 0

  for i in 1...1000 {
       obj += gradient(at: Float(i), of: oneOperation)
  }
}

// As compared to `f()` derivative of `oneOperation`
// is fully inlined into `g()`.
func g() {
  // Simple function composition.
  var obj: Float = 0
  obj += gradient(at: Float(i), of: oneOperation)
}
f()

Expected behavior

More optimized code should be generated. Specifically, the derivative of the simple function, called from a conditional control-flow context, should ideally have the same performance (minus the overhead of control-flow itself) as when called from a non-conditional control-flow context.

Environment

Present in 5.9 and likely all higher and lower versioned toolchains.

Additional information

No response