Merge pull request #37909 from CodaFi/closure-to-the-edge

[5.5] Special-case Pattern Binding Decls Created by LLDB

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

@@ -1350,6 +1350,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,