Clean up AutoClosureExpr::getUnwrappedCurryThunkExpr().

Replace a hand-rolled variant of the subject function used for actor
isolation checking with a call to it. This exposed some limitations of
the function, which would assert() when dealing with partial
applications that involved optionals. Fix those as well.

Author: DougGregor

lib/AST/Expr.cpp

@@ -2007,17 +2007,37 @@ Expr *AutoClosureExpr::getSingleExpressionBody() const {
 }
 
 Expr *AutoClosureExpr::getUnwrappedCurryThunkExpr() const {
+  auto maybeUnwrapOpenExistential = [](Expr *expr) {
+    if (auto *openExistential = dyn_cast<OpenExistentialExpr>(expr)) {
+      expr = openExistential->getSubExpr()->getSemanticsProvidingExpr();
+      if (auto *ICE = dyn_cast<ImplicitConversionExpr>(expr))
+        expr = ICE->getSyntacticSubExpr();
+    }
+
+    return expr;
+  };
+
+  auto maybeUnwrapOptionalEval = [](Expr *expr) {
+    if (auto optEval = dyn_cast<OptionalEvaluationExpr>(expr))
+      expr = optEval->getSubExpr();
+    if (auto inject = dyn_cast<InjectIntoOptionalExpr>(expr))
+      expr = inject->getSubExpr();
+    if (auto erasure = dyn_cast<ErasureExpr>(expr))
+      expr = erasure->getSubExpr();
+    if (auto bind = dyn_cast<BindOptionalExpr>(expr))
+      expr = bind->getSubExpr();
+    return expr;
+  };
+
   switch (getThunkKind()) {
   case AutoClosureExpr::Kind::None:
     break;
 
   case AutoClosureExpr::Kind::SingleCurryThunk: {
     auto *body = getSingleExpressionBody();
     body = body->getSemanticsProvidingExpr();
-
-    if (auto *openExistential = dyn_cast<OpenExistentialExpr>(body)) {
-      body = openExistential->getSubExpr()->getSemanticsProvidingExpr();
-    }
+    body = maybeUnwrapOpenExistential(body);
+    body = maybeUnwrapOptionalEval(body);
 
     if (auto *outerCall = dyn_cast<ApplyExpr>(body)) {
       return outerCall->getFn();
@@ -2034,18 +2054,12 @@ Expr *AutoClosureExpr::getUnwrappedCurryThunkExpr() const {
                AutoClosureExpr::Kind::SingleCurryThunk);
       auto *innerBody = innerClosure->getSingleExpressionBody();
       innerBody = innerBody->getSemanticsProvidingExpr();
-
-      if (auto *openExistential = dyn_cast<OpenExistentialExpr>(innerBody)) {
-        innerBody = openExistential->getSubExpr()->getSemanticsProvidingExpr();
-        if (auto *ICE = dyn_cast<ImplicitConversionExpr>(innerBody))
-          innerBody = ICE->getSyntacticSubExpr();
-      }
+      innerBody = maybeUnwrapOpenExistential(innerBody);
+      innerBody = maybeUnwrapOptionalEval(innerBody);
 
       if (auto *outerCall = dyn_cast<ApplyExpr>(innerBody)) {
         if (auto *innerCall = dyn_cast<ApplyExpr>(outerCall->getFn())) {
-          if (auto *declRef = dyn_cast<DeclRefExpr>(innerCall->getFn())) {
-            return declRef;
-          }
+          return innerCall->getFn();
         }
       }
     }

lib/Sema/TypeCheckConcurrency.cpp

@@ -358,21 +358,8 @@ static Optional<PartialApplyThunkInfo> decomposePartialApplyThunk(
         != AutoClosureExpr::Kind::DoubleCurryThunk)
     return None;
 
-  // Check for the inner closure in the thunk.
-  auto innerAutoclosure = dyn_cast<AutoClosureExpr>(
-      outerAutoclosure->getSingleExpressionBody());
-  if (!innerAutoclosure ||
-      innerAutoclosure->getThunkKind()
-          != AutoClosureExpr::Kind::SingleCurryThunk)
-    return None;
-
-  auto innerCall = dyn_cast<CallExpr>(
-      innerAutoclosure->getSingleExpressionBody());
-  if (!innerCall)
-    return None;
-
-  auto memberCall = dyn_cast<DotSyntaxCallExpr>(innerCall->getFn());
-  if (!memberCall)
+  auto memberFn = outerAutoclosure->getUnwrappedCurryThunkExpr();
+  if (!memberFn)
     return None;
 
   // Determine whether the partial apply thunk was immediately converted to
@@ -383,8 +370,7 @@ static Optional<PartialApplyThunkInfo> decomposePartialApplyThunk(
     isEscaping = fnType && !fnType->isNoEscape();
   }
 
-  return PartialApplyThunkInfo{
-      apply->getArg(), memberCall->getFn(), isEscaping};
+  return PartialApplyThunkInfo{apply->getArg(), memberFn, isEscaping};
 }
 
 /// Find the immediate member reference in the given expression.