---

yaml
---
r: 326303
b: refs/heads/master-next
c: 7f834cd
h: refs/heads/master
i:
  326301: 328097c
  326299: 97ddb6f
  326295: 2fd8e11
  326287: ee45234
  326271: a721ae0

Author: David Ungar

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: e052da7d8886fa0439677852e8f7830b20c2e1da
-refs/heads/master-next: 10583f89c6c014537baefb1f772df096a71a0c5c
+refs/heads/master-next: 7f834cdb54a7f9b1bb04eba3f9a6688a6b058d20
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-b: 66d897bfcf64a82cb9a87f5e663d889189d06d07

branches/master-next/include/swift/AST/ASTScope.h

@@ -193,12 +193,14 @@ class ASTScopeImpl {
 
 public: // for addReusedBodyScopes
   void addChild(ASTScopeImpl *child, ASTContext &);
-  std::vector<ASTScopeImpl *> rescueYoungestChildren(unsigned count);
+  std::vector<ASTScopeImpl *>
+  rescueASTAncestorScopesForReuseFromMe(unsigned count);
 
   /// When reexpanding, do we always create a new body?
-  virtual NullablePtr<ASTScopeImpl> getParentOfRescuedScopes();
-  std::vector<ASTScopeImpl *> rescueScopesToReuse();
-  void addReusedScopes(ArrayRef<ASTScopeImpl *>);
+  virtual NullablePtr<ASTScopeImpl> getParentOfASTAncestorScopesToBeRescued();
+  std::vector<ASTScopeImpl *>
+  rescueASTAncestorScopesForReuseFromMeOrDescendants();
+  void replaceASTAncestorScopes(ArrayRef<ASTScopeImpl *>);
 
 private:
   void removeChildren();
@@ -1073,7 +1075,7 @@ class AbstractFunctionBodyScope : public ASTScopeImpl {
   Decl *getDecl() const { return decl; }
   static bool isAMethod(const AbstractFunctionDecl *);
 
-  NullablePtr<ASTScopeImpl> getParentOfRescuedScopes() override;
+  NullablePtr<ASTScopeImpl> getParentOfASTAncestorScopesToBeRescued() override;
 
 protected:
   bool lookupLocalsOrMembers(ArrayRef<const ASTScopeImpl *>,
@@ -1496,7 +1498,7 @@ class TopLevelCodeScope final : public ASTScopeImpl {
   Decl *getDecl() const { return decl; }
   NullablePtr<const void> getReferrent() const override;
 
-  NullablePtr<ASTScopeImpl> getParentOfRescuedScopes() override;
+  NullablePtr<ASTScopeImpl> getParentOfASTAncestorScopesToBeRescued() override;
 };
 
 /// The \c _@specialize attribute.

branches/master-next/lib/AST/ASTScopeCreation.cpp

@@ -1739,10 +1739,10 @@ bool ASTScopeImpl::reexpandIfObsolete(ScopeCreator &scopeCreator) {
 }
 
 void ASTScopeImpl::reexpand(ScopeCreator &scopeCreator) {
-  auto scopesToReuse = rescueScopesToReuse();
+  auto astAncestorScopes = rescueASTAncestorScopesForReuseFromMeOrDescendants();
   disownDescendants(scopeCreator);
   expandAndBeCurrent(scopeCreator);
-  addReusedScopes(scopesToReuse);
+  replaceASTAncestorScopes(astAncestorScopes);
 }
 
 #pragma mark getScopeCreator
@@ -1911,34 +1911,43 @@ bool WholeClosureScope::isCurrentIfWasExpanded() const {
   return bodyWhenLastExpanded == closureExpr->getBody();
 }
 
-#pragma mark getParentOfRescuedScopes
-NullablePtr<ASTScopeImpl> ASTScopeImpl::getParentOfRescuedScopes() {
+#pragma mark getParentOfASTAncestorScopesToBeRescued
+NullablePtr<ASTScopeImpl>
+ASTScopeImpl::getParentOfASTAncestorScopesToBeRescued() {
   return this;
 }
 NullablePtr<ASTScopeImpl>
-AbstractFunctionBodyScope::getParentOfRescuedScopes() {
+AbstractFunctionBodyScope::getParentOfASTAncestorScopesToBeRescued() {
   // Reexpansion always creates a new body as the first child
+  // That body contains the scopes to be rescued.
   return getChildren().empty() ? nullptr : getChildren().front();
 }
-NullablePtr<ASTScopeImpl> TopLevelCodeScope::getParentOfRescuedScopes() {
+NullablePtr<ASTScopeImpl>
+TopLevelCodeScope::getParentOfASTAncestorScopesToBeRescued() {
   // Reexpansion always creates a new body as the first child
+  // That body contains the scopes to be rescued.
   return getChildren().empty() ? nullptr : getChildren().front();
 }
 
 #pragma mark rescuing & reusing
-std::vector<ASTScopeImpl *> ASTScopeImpl::rescueScopesToReuse() {
-  // If I was never expanded, then there won't be any rescuable scopes.
-  if (!wasEverExpanded())
+std::vector<ASTScopeImpl *>
+ASTScopeImpl::rescueASTAncestorScopesForReuseFromMeOrDescendants() {
+// If I was never expanded, then there won't be any rescuable scopes.
+  if (!getWasExpanded())
     return {};
-  if (auto *p = getParentOfRescuedScopes().getPtrOrNull()) {
-    return p->rescueYoungestChildren(p->getChildren().size() -
-                                     p->getChildrenCountWhenLastExpanded());
+  if (auto *p = getParentOfASTAncestorScopesToBeRescued().getPtrOrNull()) {
+    return p->rescueASTAncestorScopesForReuseFromMe(
+        p->getChildren().size() - p->getChildrenCountWhenLastExpanded());
   }
+  ASTScopeAssert(
+      scopesFromASTAncestors == 0,
+      "If receives ASTAncestor scopes, must know where to find parent");
   return {};
 }
 
-void ASTScopeImpl::addReusedScopes(ArrayRef<ASTScopeImpl *> scopesToAdd) {
-  auto *p = getParentOfRescuedScopes().getPtrOrNull();
+void ASTScopeImpl::replaceASTAncestorScopes(
+    ArrayRef<ASTScopeImpl *> scopesToAdd) {
+  auto *p = getParentOfASTAncestorScopesToBeRescued().getPtrOrNull();
   if (!p) {
     ASTScopeAssert(scopesToAdd.empty(), "Non-empty body disappeared?!");
     return;
@@ -1952,16 +1961,17 @@ void ASTScopeImpl::addReusedScopes(ArrayRef<ASTScopeImpl *> scopesToAdd) {
 }
 
 std::vector<ASTScopeImpl *>
-ASTScopeImpl::rescueYoungestChildren(const unsigned int count) {
-  std::vector<ASTScopeImpl *> youngestChildren;
+ASTScopeImpl::rescueASTAncestorScopesForReuseFromMe(const unsigned int count) {
+  std::vector<ASTScopeImpl *> astAncestorScopes;
   for (unsigned i = getChildren().size() - count; i < getChildren().size(); ++i)
-    youngestChildren.push_back(getChildren()[i]);
+    astAncestorScopes.push_back(getChildren()[i]);
   // So they don't get disowned and children cleared.
   for (unsigned i = 0; i < count; ++i) {
     storedChildren.back()->emancipate();
     storedChildren.pop_back();
+    --scopesFromASTAncestors;
   }
-  return youngestChildren;
+  return astAncestorScopes;
 }
 
 unsigned ASTScopeImpl::getChildrenCountWhenLastExpanded() const {