Fix interpolated string effect placement

This fixes the placement of the await fix-it inside of interpolated
strings. We were putting the effect between the `\` and `(`, which
doesn't exactly work out very well. I'm intentionally being relatively
gentle with the casting when grabbing the body of the interpolated
string.

I can't think of a valid expression that doesn't result in that
structure, so it's probably safe to do a straight cast, and probably
should switch it over eventually. In the current state-of-affairs, it
will put the fix-it placement in the wrong place if my assumptions are
broken about the structure of the code.

Author: etcwilde

Diff for: lib/Sema/TypeCheckEffects.cpp

@@ -1436,6 +1436,11 @@ class Context {
     DiagnoseErrorOnTry = b;
   }
 
+  /// Return true when the current context is under an interpolated string
+  bool isWithinInterpolatedString() const {
+    return InterpolatedString != nullptr;
+  }
+
   /// Stores the location of the innermost await
   SourceLoc awaitLoc = SourceLoc();
 
@@ -2084,15 +2089,38 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
   }
 
   /// Find the top location where we should put the await
-  static Expr* walkToAnchor(Expr *e,
-                            llvm::DenseMap<Expr *, Expr*> &parentMap) {
+  static Expr *walkToAnchor(Expr *e, llvm::DenseMap<Expr *, Expr *> &parentMap,
+                            bool isInterpolatedString) {
     Expr *parent = e;
     Expr *lastParent = e;
     while (parent && !isEffectAnchor(parent)) {
       lastParent = parent;
       parent = parentMap[parent];
     }
-    return parent && !isAnchorTooEarly(parent) ? parent : lastParent;
+
+    if (parent && !isAnchorTooEarly(parent)) {
+      return parent;
+    }
+
+    if (isInterpolatedString) {
+      // TODO: I'm being gentle with the casts to avoid breaking things
+      //       If we see incorrect fix-it locations in string interpolations
+      //       we need to change how this behaves
+      //       Assert builds will crash giving us a bug to fix, non-asserts will
+      //       quietly "just work".
+      assert(parent == nullptr && "Expected to be at top of expression");
+      assert(isa<CallExpr>(lastParent) &&
+             "Expected top of string interpolation to be CalExpr");
+      assert(isa<ParenExpr>(dyn_cast<CallExpr>(lastParent)->getArg()) &&
+             "Expected paren expr in string interpolation call");
+      if (CallExpr *callExpr = dyn_cast<CallExpr>(lastParent)) {
+        if (ParenExpr *body = dyn_cast<ParenExpr>(callExpr->getArg())) {
+          return body->getSubExpr();
+        }
+      }
+    }
+
+    return lastParent;
   }
 
   void flagInvalidCode() {
@@ -2620,7 +2648,8 @@ class CheckEffectsCoverage : public EffectsHandlingWalker<CheckEffectsCoverage>
       // Diagnose async calls that are outside of an await context.
       else if (!Flags.has(ContextFlags::IsAsyncCovered)) {
         Expr *expr = E.dyn_cast<Expr*>();
-        Expr *anchor = walkToAnchor(expr, parentMap);
+        Expr *anchor = walkToAnchor(expr, parentMap,
+                                    CurContext.isWithinInterpolatedString());
 
         auto key = uncoveredAsync.find(anchor);
         if (key == uncoveredAsync.end()) {