Special-case Pattern Binding Decls Created by LLDB

When LLDB wraps a user-defined expression in the REPL, it takes something like this
```
<expr>
```

and turns it into (very very abstractly)

```
var result
do {
  result = <expr>
}
print(result)
```

In the process, it creates an implicit pattern binding and an implicit do block. Of these, only the implicit do is considered by ASTScope lookup to be relevant. This presents a problem when <expr> is or contains a closure, as the parameters of that closure are defined within a scope that will never be expanded. Thus,

```
> [42].map { x in x } // <- cannot find 'x' in scope
```

This patch provides the Swift half of the fix wherein we privilege pattern bindings created by the debugger and look through them to the underlying user expression when performing ASTScope expansion.

rdar://78256873

Author: CodaFi

include/swift/AST/ASTScope.h

@@ -957,7 +957,9 @@ class PatternEntryInitializerScope final : public AbstractPatternEntryScope {
 public:
   PatternEntryInitializerScope(PatternBindingDecl *pbDecl, unsigned entryIndex)
       : AbstractPatternEntryScope(pbDecl, entryIndex),
-        initAsWrittenWhenCreated(pbDecl->getOriginalInit(entryIndex)) {}
+        initAsWrittenWhenCreated(pbDecl->isDebuggerBinding() ?
+                                 pbDecl->getInit(entryIndex) :
+                                 pbDecl->getOriginalInit(entryIndex)) {}
   virtual ~PatternEntryInitializerScope() {}
 
 protected:

include/swift/AST/Decl.h

@@ -318,10 +318,13 @@ class alignas(1 << DeclAlignInBits) Decl {
     Hoisted : 1
   );
 
-  SWIFT_INLINE_BITFIELD_FULL(PatternBindingDecl, Decl, 1+2+16,
+  SWIFT_INLINE_BITFIELD_FULL(PatternBindingDecl, Decl, 1+1+2+16,
     /// Whether this pattern binding declares static variables.
     IsStatic : 1,
 
+    /// Whether this pattern binding is synthesized by the debugger.
+    IsDebugger : 1,
+
     /// Whether 'static' or 'class' was used.
     StaticSpelling : 2,
 
@@ -1474,9 +1477,10 @@ class PatternBindingEntry {
   enum class PatternFlags {
     IsText = 1 << 0,
     IsFullyValidated = 1 << 1,
+    IsFromDebugger = 1 << 2,
   };
   /// The initializer context used for this pattern binding entry.
-  llvm::PointerIntPair<DeclContext *, 2, OptionSet<PatternFlags>>
+  llvm::PointerIntPair<DeclContext *, 3, OptionSet<PatternFlags>>
       InitContextAndFlags;
 
   /// Values captured by this initializer.
@@ -1504,6 +1508,14 @@ class PatternBindingEntry {
                                PatternFlags::IsFullyValidated);
   }
 
+  /// Set if this pattern binding came from the debugger.
+  ///
+  /// Stay away unless you are \c PatternBindingDecl::createForDebugger
+  void setFromDebugger() {
+    InitContextAndFlags.setInt(InitContextAndFlags.getInt() |
+                               PatternFlags::IsFromDebugger);
+  }
+
 public:
   /// \p E is the initializer as parsed.
   PatternBindingEntry(Pattern *P, SourceLoc EqualLoc, Expr *E,
@@ -1586,6 +1598,11 @@ class PatternBindingEntry {
     PatternAndFlags.setInt(PatternAndFlags.getInt() | Flags::Subsumed);
   }
 
+  /// Returns \c true if the debugger created this pattern binding entry.
+  bool isFromDebugger() const {
+    return InitContextAndFlags.getInt().contains(PatternFlags::IsFromDebugger);
+  }
+
   // Return the first variable initialized by this pattern.
   VarDecl *getAnchoringVarDecl() const;
 
@@ -1671,6 +1688,13 @@ class PatternBindingDecl final : public Decl,
                                unsigned NumPatternEntries,
                                DeclContext *Parent);
 
+  // A dedicated entrypoint that allows LLDB to create pattern bindings
+  // that look implicit to the compiler but contain user code.
+  static PatternBindingDecl *createForDebugger(ASTContext &Ctx,
+                                               StaticSpellingKind Spelling,
+                                               Pattern *Pat, Expr *E,
+                                               DeclContext *Parent);
+
   SourceLoc getStartLoc() const {
     return StaticLoc.isValid() ? StaticLoc : VarLoc;
   }
@@ -1872,6 +1896,9 @@ class PatternBindingDecl final : public Decl,
     return getPatternList()[i].getInitStringRepresentation(scratch);
   }
 
+  /// Returns \c true if this pattern binding was created by the debugger.
+  bool isDebuggerBinding() const { return Bits.PatternBindingDecl.IsDebugger; }
+
   static bool classof(const Decl *D) {
     return D->getKind() == DeclKind::PatternBinding;
   }

lib/AST/ASTScopeCreation.cpp

@@ -480,9 +480,15 @@ ScopeCreator::addToScopeTreeAndReturnInsertionPoint(ASTNode n,
   if (!n)
     return parent;
 
+  // HACK: LLDB creates implicit pattern bindings that... contain user
+  // expressions. We need to actually honor lookups through those bindings
+  // in case they contain closures that bind additional variables in further
+  // scopes.
   if (auto *d = n.dyn_cast<Decl *>())
     if (d->isImplicit())
-      return parent;
+      if (!isa<PatternBindingDecl>(d)
+          || !cast<PatternBindingDecl>(d)->isDebuggerBinding())
+        return parent;
 
   NodeAdder adder(endLoc);
   if (auto *p = n.dyn_cast<Decl *>())
@@ -733,6 +739,23 @@ PatternEntryDeclScope::expandAScopeThatCreatesANewInsertionPoint(
             this, decl, patternEntryIndex);
   }
 
+  // If this pattern binding entry was created by the debugger, it will always
+  // have a synthesized init that is created from user code. We special-case
+  // lookups into these scopes to look through the debugger's chicanery to the
+  // underlying user-defined scopes, if any.
+  if (patternEntry.isFromDebugger() && patternEntry.getInit()) {
+    ASTScopeAssert(
+        patternEntry.getInit()->getSourceRange().isValid(),
+        "pattern initializer has invalid source range");
+    ASTScopeAssert(
+        !getSourceManager().isBeforeInBuffer(
+            patternEntry.getInit()->getStartLoc(), decl->getStartLoc()),
+        "inits are always after the '='");
+    scopeCreator
+        .constructExpandAndInsert<PatternEntryInitializerScope>(
+            this, decl, patternEntryIndex);
+  }
+
   // Add accessors for the variables in this pattern.
   patternEntry.getPattern()->forEachVariable([&](VarDecl *var) {
     scopeCreator.addChildrenForParsedAccessors(var, this);
@@ -751,8 +774,7 @@ void
 PatternEntryInitializerScope::expandAScopeThatDoesNotCreateANewInsertionPoint(
     ScopeCreator &scopeCreator) {
   // Create a child for the initializer expression.
-  scopeCreator.addToScopeTree(ASTNode(getPatternEntry().getOriginalInit()),
-                              this);
+  scopeCreator.addToScopeTree(ASTNode(initAsWrittenWhenCreated), this);
 }
 
 

lib/AST/ASTScopeSourceRange.cpp

@@ -40,6 +40,13 @@ static SourceLoc getLocAfterExtendedNominal(const ExtensionDecl *);
 
 void ASTScopeImpl::checkSourceRangeBeforeAddingChild(ASTScopeImpl *child,
                                                      const ASTContext &ctx) const {
+  // Ignore debugger bindings - they're a special mix of user code and implicit
+  // wrapper code that is too difficult to check for consistency.
+  if (auto d = getDeclIfAny().getPtrOrNull())
+    if (auto *PBD = dyn_cast<PatternBindingDecl>(d))
+      if (PBD->isDebuggerBinding())
+        return;
+  
   auto &sourceMgr = ctx.SourceMgr;
 
   auto range = getCharSourceRangeOfScope(sourceMgr);

lib/AST/Decl.cpp

@@ -1341,6 +1341,17 @@ PatternBindingDecl *PatternBindingDecl::createImplicit(
   return Result;
 }
 
+PatternBindingDecl *PatternBindingDecl::createForDebugger(
+    ASTContext &Ctx, StaticSpellingKind StaticSpelling, Pattern *Pat, Expr *E,
+    DeclContext *Parent) {
+  auto *Result = createImplicit(Ctx, StaticSpelling, Pat, E, Parent);
+  Result->Bits.PatternBindingDecl.IsDebugger = true;
+  for (auto &entry : Result->getMutablePatternList()) {
+    entry.setFromDebugger();
+  }
+  return Result;
+}
+
 PatternBindingDecl *
 PatternBindingDecl::create(ASTContext &Ctx, SourceLoc StaticLoc,
                            StaticSpellingKind StaticSpelling,