[AutoDiff] Not differentiate through global closures flow-sensitively. (#25676)

Earlier we added a hack to differentiate global constants or
variables that are initialized with a closure whose body is
differentiable. However, function conversion should not be flow
sensitive. This patch removes the hack.

Author: rxwei

lib/SILOptimizer/Mandatory/Differentiation.cpp

@@ -2086,88 +2086,6 @@ emitAssociatedFunctionReference(
     return std::make_pair(convertedRef, minimalAttr->getIndices());
   }
 
-  // Find global `let` closure.
-  if (auto *load = peerThroughFunctionConversions<LoadInst>(original)) {
-    FunctionRefInst *initialFnRef = nullptr;
-    SILValue initVal;
-    if (auto *globalAddr = dyn_cast<GlobalAddrInst>(load->getOperand())) {
-      // Search for the original function used to initialize this `let`
-      // constant.
-      if (auto *global = globalAddr->getReferencedGlobal()) {
-        if (!global->isLet()) {
-          context.emitNondifferentiabilityError(original, invoker,
-              diag::autodiff_cannot_differentiate_global_var_closures);
-          return None;
-        }
-        // FIXME: In LLDB REPL, "main" will not be the function we should look
-        // for.
-        if (auto *mainFn = global->getModule().lookUpFunction("main")) {
-          if (mainFn->isDefinition())
-            for (auto &inst : mainFn->front())
-              if (auto *globalAddrInMain = dyn_cast<GlobalAddrInst>(&inst))
-                if (globalAddrInMain->getReferencedGlobal() == global)
-                  for (auto *use : globalAddrInMain->getUses())
-                    if (auto *store = dyn_cast<StoreInst>(use->getUser()))
-                      if (store->getDest() == globalAddrInMain)
-                        initialFnRef = peerThroughFunctionConversions
-                            <FunctionRefInst>((initVal = store->getSrc()));
-        }
-      }
-    }
-    if (initialFnRef) {
-      assert(initVal);
-      auto *initialFn = initialFnRef->getReferencedFunctionOrNull();
-      auto *minimalAttr =
-          context.lookUpMinimalDifferentiableAttr(initialFn, desiredIndices);
-      if (!minimalAttr) {
-        if (initialFn->isExternalDeclaration()) {
-          context.emitNondifferentiabilityError(
-              original, invoker,
-              diag::autodiff_global_let_closure_not_differentiable);
-          return None;
-        }
-        ArrayRef<Requirement> contextualRequirements;
-        if (invoker.getKind() ==
-            DifferentiationInvoker::Kind::IndirectDifferentiation)
-          contextualRequirements =
-              invoker.getIndirectDifferentiation().second->getRequirements();
-        auto *newAttr = context.getOrCreateDifferentiableAttr(
-            initialFn, desiredIndices, contextualRequirements);
-        bool error = context.processDifferentiableAttribute(
-            initialFn, newAttr, invoker);
-        if (error)
-          return None;
-        minimalAttr = newAttr;
-      }
-      if (context.processDifferentiableAttribute(
-              initialFn, minimalAttr, invoker))
-        return None;
-      SILFunction *assocFn = nullptr;
-      switch (kind) {
-      case AutoDiffAssociatedFunctionKind::JVP:
-        assert(!minimalAttr->getJVPName().empty() && "Expected JVP name");
-        assocFn = context.getModule().lookUpFunction(minimalAttr->getJVPName());
-        break;
-      case AutoDiffAssociatedFunctionKind::VJP:
-        assert(!minimalAttr->getVJPName().empty() && "Expected VJP name");
-        assocFn = context.getModule().lookUpFunction(minimalAttr->getVJPName());
-        break;
-      }
-      assert(assocFn && "Associated function must be resolved");
-      auto assocFnGenSig =
-          assocFn->getLoweredFunctionType()->getGenericSignature();
-      auto loc = original.getLoc();
-      auto *initialVJPRef = builder.createFunctionRef(loc, assocFn);
-      auto converted =
-          reapplyFunctionConversion(initialVJPRef, initialFnRef, initVal,
-                                    builder, loc, assocFnGenSig);
-      converted =
-          reapplyFunctionConversion(converted, load, original,
-                                    builder, loc, assocFnGenSig);
-      return std::make_pair(converted, minimalAttr->getIndices());
-    }
-  }
-
   // Find witness method retrieval.
   if (auto *witnessMethod =
           peerThroughFunctionConversions<WitnessMethodInst>(original)) {

test/AutoDiff/simple_math.swift

@@ -73,13 +73,6 @@ SimpleMathTests.test("CaptureGlobal") {
   expectEqual(30, gradient(at: 0, in: foo))
 }
 
-let foo: (Float) -> Float = { x in
-  return x * x
-}
-SimpleMathTests.test("GlobalLet") {
-  expectEqual(2, gradient(at: 1, in: foo))
-}
-
 var foo_diffable: @differentiable (Float) -> (Float)
   = differentiableFunction { x in (x * x, { v in 2 * x * v }) }
 SimpleMathTests.test("GlobalDiffableFunc") {