Merge pull request #68243 from xedin/thread-parent-module-through-astscope

[AST] ASTScope: Pass parent module to all search methods

Author: xedin

include/swift/AST/ASTScope.h

@@ -298,15 +298,18 @@ class ASTScopeImpl : public ASTAllocated<ASTScopeImpl> {
 
 protected:
   /// Not const because may reexpand some scopes.
-  ASTScopeImpl *findInnermostEnclosingScope(SourceLoc,
+  ASTScopeImpl *findInnermostEnclosingScope(ModuleDecl *,
+                                            SourceLoc,
                                             NullablePtr<raw_ostream>);
-  ASTScopeImpl *findInnermostEnclosingScopeImpl(SourceLoc,
+  ASTScopeImpl *findInnermostEnclosingScopeImpl(ModuleDecl *,
+                                                SourceLoc,
                                                 NullablePtr<raw_ostream>,
                                                 SourceManager &,
                                                 ScopeCreator &);
 
 private:
-  NullablePtr<ASTScopeImpl> findChildContaining(SourceLoc loc,
+  NullablePtr<ASTScopeImpl> findChildContaining(ModuleDecl *,
+                                                SourceLoc loc,
                                                 SourceManager &sourceMgr) const;
 
 #pragma mark - - lookup- per scope

lib/AST/ASTScopeCreation.cpp

@@ -251,7 +251,8 @@ void ASTSourceFileScope::expandFunctionBody(AbstractFunctionDecl *AFD) {
   auto sr = AFD->getOriginalBodySourceRange();
   if (sr.isInvalid())
     return;
-  ASTScopeImpl *bodyScope = findInnermostEnclosingScope(sr.Start, nullptr);
+  ASTScopeImpl *bodyScope =
+      findInnermostEnclosingScope(AFD->getParentModule(), sr.Start, nullptr);
   if (!bodyScope->getWasExpanded())
     bodyScope->expandAndBeCurrent(*scopeCreator);
 }

lib/AST/ASTScopeLookup.cpp

@@ -48,30 +48,32 @@ void ASTScopeImpl::unqualifiedLookup(
 const ASTScopeImpl *ASTScopeImpl::findStartingScopeForLookup(
     SourceFile *sourceFile, const SourceLoc loc) {
   auto *const fileScope = sourceFile->getScope().impl;
-  const auto *innermost = fileScope->findInnermostEnclosingScope(loc, nullptr);
+  const auto *innermost = fileScope->findInnermostEnclosingScope(
+      sourceFile->getParentModule(), loc, nullptr);
   ASTScopeAssert(innermost->getWasExpanded(),
                  "If looking in a scope, it must have been expanded.");
 
   return innermost;
 }
 
 ASTScopeImpl *
-ASTScopeImpl::findInnermostEnclosingScope(SourceLoc loc,
+ASTScopeImpl::findInnermostEnclosingScope(ModuleDecl *parentModule,
+                                          SourceLoc loc,
                                           NullablePtr<raw_ostream> os) {
-  return findInnermostEnclosingScopeImpl(loc, os, getSourceManager(),
-                                         getScopeCreator());
+  return findInnermostEnclosingScopeImpl(parentModule, loc, os,
+                                         getSourceManager(), getScopeCreator());
 }
 
 ASTScopeImpl *ASTScopeImpl::findInnermostEnclosingScopeImpl(
-    SourceLoc loc, NullablePtr<raw_ostream> os, SourceManager &sourceMgr,
-    ScopeCreator &scopeCreator) {
+    ModuleDecl *parentModule, SourceLoc loc, NullablePtr<raw_ostream> os,
+    SourceManager &sourceMgr, ScopeCreator &scopeCreator) {
   if (!getWasExpanded())
     expandAndBeCurrent(scopeCreator);
-  auto child = findChildContaining(loc, sourceMgr);
+  auto child = findChildContaining(parentModule, loc, sourceMgr);
   if (!child)
     return this;
-  return child.get()->findInnermostEnclosingScopeImpl(loc, os, sourceMgr,
-                                                      scopeCreator);
+  return child.get()->findInnermostEnclosingScopeImpl(parentModule, loc, os,
+                                                      sourceMgr, scopeCreator);
 }
 
 /// If the \p loc is in a new buffer but \p range is not, consider the location
@@ -89,10 +91,10 @@ static SourceLoc translateLocForReplacedRange(SourceManager &sourceMgr,
 }
 
 NullablePtr<ASTScopeImpl>
-ASTScopeImpl::findChildContaining(SourceLoc loc,
+ASTScopeImpl::findChildContaining(ModuleDecl *parentModule,
+                                  SourceLoc loc,
                                   SourceManager &sourceMgr) const {
-  auto *moduleDecl = this->getSourceFile()->getParentModule();
-  auto *locSourceFile = moduleDecl->getSourceFileContainingLocation(loc);
+  auto *locSourceFile = parentModule->getSourceFileContainingLocation(loc);
 
   // Use binary search to find the child that contains this location.
   auto *const *child = llvm::lower_bound(
@@ -109,7 +111,7 @@ ASTScopeImpl::findChildContaining(SourceLoc loc,
         // Note that `scope->getSourceFile()` returns the root of the source tree,
         // not the source file containing the location of the ASTScope.
         auto scopeStart = scope->getSourceRangeOfThisASTNode().Start;
-        auto *scopeSourceFile = moduleDecl->getSourceFileContainingLocation(scopeStart);
+        auto *scopeSourceFile = parentModule->getSourceFileContainingLocation(scopeStart);
 
         if (scopeSourceFile != locSourceFile) {
           // To compare a source location that is possibly inside a macro expansion
@@ -624,7 +626,8 @@ llvm::SmallVector<LabeledStmt *, 4>
 ASTScopeImpl::lookupLabeledStmts(SourceFile *sourceFile, SourceLoc loc) {
   // Find the innermost scope from which to start our search.
   auto *const fileScope = sourceFile->getScope().impl;
-  const auto *innermost = fileScope->findInnermostEnclosingScope(loc, nullptr);
+  const auto *innermost = fileScope->findInnermostEnclosingScope(
+      sourceFile->getParentModule(), loc, nullptr);
   ASTScopeAssert(innermost->getWasExpanded(),
                  "If looking in a scope, it must have been expanded.");
 
@@ -652,7 +655,8 @@ std::pair<CaseStmt *, CaseStmt *> ASTScopeImpl::lookupFallthroughSourceAndDest(
     SourceFile *sourceFile, SourceLoc loc) {
   // Find the innermost scope from which to start our search.
   auto *const fileScope = sourceFile->getScope().impl;
-  const auto *innermost = fileScope->findInnermostEnclosingScope(loc, nullptr);
+  const auto *innermost = fileScope->findInnermostEnclosingScope(
+      sourceFile->getParentModule(), loc, nullptr);
   ASTScopeAssert(innermost->getWasExpanded(),
                  "If looking in a scope, it must have been expanded.");
 
@@ -686,7 +690,8 @@ void ASTScopeImpl::lookupEnclosingMacroScope(
     return;
 
   auto *fileScope = sourceFile->getScope().impl;
-  auto *scope = fileScope->findInnermostEnclosingScope(loc, nullptr);
+  auto *scope = fileScope->findInnermostEnclosingScope(
+      sourceFile->getParentModule(), loc, nullptr);
   do {
     auto *freestanding = scope->getFreestandingMacro().getPtrOrNull();
     if (freestanding && consume(freestanding))

lib/AST/ASTScopePrinting.cpp

@@ -54,7 +54,8 @@ void ASTScopeImpl::dumpOneScopeMapLocation(
 
   llvm::errs() << "***Scope at " << lineColumn.first << ":" << lineColumn.second
                << "***\n";
-  auto *locScope = findInnermostEnclosingScope(loc, &llvm::errs());
+  auto *parentModule = getSourceFile()->getParentModule();
+  auto *locScope = findInnermostEnclosingScope(parentModule, loc, &llvm::errs());
   locScope->print(llvm::errs(), 0, false, false);
 
   namelookup::ASTScopeDeclGatherer gatherer;