[Sema] DebuggerTestingTransform: avoid re-using AST nodes in generated code

While building a closure to inject `checkExpect` code, clone member
references associated with assignment. Re-using AST nodes is generally
invalid. This is visible with multi-statement closure inference enabled,
because the body is type-checked together with enclosing context
and both elements end up sharing `DeclRefExpr` and `MemberRefExpr`s.

Author: xedin

Diff for: lib/Sema/DebuggerTestingTransform.cpp

@@ -208,6 +208,49 @@ class DebuggerTestingTransform : public ASTWalker {
     auto *PODeclRef = new (Ctx)
         UnresolvedDeclRefExpr(StringForPrintObjectName,
                               DeclRefKind::Ordinary, DeclNameLoc());
+
+    std::function<DeclRefExpr *(DeclRefExpr *)> cloneDeclRef =
+        [&](DeclRefExpr *DRE) {
+          auto *ref = new (Ctx) DeclRefExpr(
+              DRE->getDeclRef(),
+              /*Loc=*/DeclNameLoc(),
+              /*Implicit=*/true, DRE->getAccessSemantics(), DRE->getType());
+
+          if (auto hopTarget = DRE->isImplicitlyAsync())
+            ref->setImplicitlyAsync(*hopTarget);
+
+          ref->setImplicitlyThrows(DRE->isImplicitlyThrows());
+
+          return ref;
+        };
+
+    std::function<MemberRefExpr *(MemberRefExpr *)> cloneMemberRef =
+        [&](MemberRefExpr *M) {
+          auto *base = M->getBase();
+
+          if (auto *DRE = dyn_cast<DeclRefExpr>(base))
+            base = cloneDeclRef(DRE);
+          else if (auto *M = dyn_cast<MemberRefExpr>(base))
+            base = cloneMemberRef(M);
+
+          auto *ref = new (Ctx)
+              MemberRefExpr(base, /*dotLoc=*/SourceLoc(), M->getDecl(),
+                            /*loc=*/DeclNameLoc(),
+                            /*Implicit=*/true, M->getAccessSemantics());
+          ref->setType(M->getType());
+
+          return ref;
+        };
+
+    // Let's make a copy of either decl or member ref without source
+    // information. It's invalid to have decl reference expressions
+    // reused, each reference should get a fresh expression.
+    if (auto *DRE = dyn_cast<DeclRefExpr>(DstRef)) {
+      DstRef = cloneDeclRef(DRE);
+    } else {
+      DstRef = cloneMemberRef(cast<MemberRefExpr>(DstRef));
+    }
+
     auto *POArgList = ArgumentList::forImplicitUnlabeled(Ctx, {DstRef});
     auto *POCall = CallExpr::createImplicit(Ctx, PODeclRef, POArgList);
     POCall->setThrows(false);