Merge pull request swiftlang#34104 from slavapestov/more-astscope-fixes

More ASTScope fixes in preparation for turning off parse-time lookup

Author: slavapestov

include/swift/AST/Expr.h

@@ -1332,6 +1332,7 @@ class SuperRefExpr : public Expr {
     : Expr(ExprKind::SuperRef, Implicit, SuperTy), Self(Self), Loc(Loc) {}
 
   VarDecl *getSelf() const { return Self; }
+  void setSelf(VarDecl *self) { Self = self; }
 
   SourceLoc getSuperLoc() const { return Loc; }
   SourceRange getSourceRange() const { return Loc; }

lib/AST/UnqualifiedLookup.cpp

@@ -144,9 +144,6 @@ namespace {
     static const unsigned targetLookup;
 #endif
 
-  public: // for exp debugging
-    unsigned resultsSizeBeforeLocalsPass = ~0;
-
   public:
     // clang-format off
     UnqualifiedLookupFactory(DeclNameRef Name,
@@ -708,16 +705,10 @@ void UnqualifiedLookupFactory::printScopes(raw_ostream &out) const {
 
 void UnqualifiedLookupFactory::printResults(raw_ostream &out) const {
   for (auto i : indices(Results)) {
-    if (i == resultsSizeBeforeLocalsPass)
-      out << "============== next pass ============\n";
     out << i << ": ";
     Results[i].print(out);
     out << "\n";
   }
-  if (resultsSizeBeforeLocalsPass == Results.size())
-    out << "============== next pass ============\n";
-  if (resultsSizeBeforeLocalsPass == ~0u)
-    out << "never tried locals\n\n";
 }
 
 void UnqualifiedLookupFactory::print(raw_ostream &OS) const {

lib/Parse/ParseExpr.cpp

@@ -853,29 +853,6 @@ UnresolvedDeclRefExpr *Parser::parseExprOperator() {
   return new (Context) UnresolvedDeclRefExpr(name, refKind, DeclNameLoc(loc));
 }
 
-static VarDecl *getImplicitSelfDeclForSuperContext(Parser &P,
-                                                   DeclContext *DC,
-                                                   SourceLoc Loc) {
-  auto *methodContext = DC->getInnermostMethodContext();
-  if (!methodContext) {
-    P.diagnose(Loc, diag::super_not_in_class_method);
-    return nullptr;
-  }
-
-  // Do an actual lookup for 'self' in case it shows up in a capture list.
-  auto *methodSelf = methodContext->getImplicitSelfDecl();
-  auto *lookupSelf = P.lookupInScope(DeclNameRef(P.Context.Id_self));
-  if (lookupSelf && lookupSelf != methodSelf) {
-    // FIXME: This is the wrong diagnostic for if someone manually declares a
-    // variable named 'self' using backticks.
-    P.diagnose(Loc, diag::super_in_closure_with_capture);
-    P.diagnose(lookupSelf->getLoc(), diag::super_in_closure_with_capture_here);
-    return nullptr;
-  }
-
-  return methodSelf;
-}
-
 /// parseExprSuper
 ///
 ///   expr-super:
@@ -903,12 +880,8 @@ ParserResult<Expr> Parser::parseExprSuper() {
     return nullptr;
   }
 
-  VarDecl *selfDecl =
-      getImplicitSelfDeclForSuperContext(*this, CurDeclContext, superLoc);
-  if (!selfDecl)
-    return makeParserResult(new (Context) ErrorExpr(superLoc));
-
-  return makeParserResult(new (Context) SuperRefExpr(selfDecl, superLoc,
+  return makeParserResult(new (Context) SuperRefExpr(/*selfDecl=*/nullptr,
+                                                     superLoc,
                                                      /*Implicit=*/false));
 }
 

lib/Sema/MiscDiagnostics.cpp

@@ -2282,6 +2282,8 @@ bool swift::computeFixitsForOverridenDeclaration(
 namespace {
 
 class VarDeclUsageChecker : public ASTWalker {
+  DeclContext *DC;
+
   DiagnosticEngine &Diags;
   // Keep track of some information about a variable.
   enum {
@@ -2318,7 +2320,8 @@ class VarDeclUsageChecker : public ASTWalker {
   void operator=(const VarDeclUsageChecker &) = delete;
 
 public:
-  VarDeclUsageChecker(DiagnosticEngine &Diags) : Diags(Diags) {}
+  VarDeclUsageChecker(DeclContext *DC,
+                      DiagnosticEngine &Diags) : DC(DC), Diags(Diags) {}
 
   // After we have scanned the entire region, diagnose variables that could be
   // declared with a narrower usage kind.
@@ -3140,14 +3143,27 @@ std::pair<bool, Expr *> VarDeclUsageChecker::walkToExprPre(Expr *E) {
 void VarDeclUsageChecker::handleIfConfig(IfConfigDecl *ICD) {
   struct ConservativeDeclMarker : public ASTWalker {
     VarDeclUsageChecker &VDUC;
-    ConservativeDeclMarker(VarDeclUsageChecker &VDUC) : VDUC(VDUC) {}
+    SourceFile *SF;
+
+    ConservativeDeclMarker(VarDeclUsageChecker &VDUC)
+      : VDUC(VDUC), SF(VDUC.DC->getParentSourceFile()) {}
 
     Expr *walkToExprPost(Expr *E) override {
       // If we see a bound reference to a decl in an inactive #if block, then
       // conservatively mark it read and written.  This will silence "variable
       // unused" and "could be marked let" warnings for it.
       if (auto *DRE = dyn_cast<DeclRefExpr>(E))
         VDUC.addMark(DRE->getDecl(), RK_Read|RK_Written);
+      else if (auto *declRef = dyn_cast<UnresolvedDeclRefExpr>(E)) {
+        auto name = declRef->getName();
+        auto loc = declRef->getLoc();
+        if (name.isSimpleName() && loc.isValid()) {
+          auto *varDecl = dyn_cast_or_null<VarDecl>(
+            ASTScope::lookupSingleLocalDecl(SF, name.getFullName(), loc));
+          if (varDecl)
+            VDUC.addMark(varDecl, RK_Read|RK_Written);
+        }
+      }
       return E;
     }
   };
@@ -3166,7 +3182,7 @@ void VarDeclUsageChecker::handleIfConfig(IfConfigDecl *ICD) {
 void swift::
 performTopLevelDeclDiagnostics(TopLevelCodeDecl *TLCD) {
   auto &ctx = TLCD->getDeclContext()->getASTContext();
-  VarDeclUsageChecker checker(ctx.Diags);
+  VarDeclUsageChecker checker(TLCD, ctx.Diags);
   TLCD->walk(checker);
 }
 
@@ -3181,7 +3197,7 @@ void swift::performAbstractFuncDeclDiagnostics(AbstractFunctionDecl *AFD) {
   // be checked as part of their parent function or TopLevelCodeDecl.
   if (!AFD->getDeclContext()->isLocalContext()) {
     auto &ctx = AFD->getDeclContext()->getASTContext();
-    VarDeclUsageChecker checker(ctx.Diags);
+    VarDeclUsageChecker checker(AFD, ctx.Diags);
     AFD->walk(checker);
   }
 

lib/Sema/TypeCheckCaptures.cpp

@@ -572,8 +572,10 @@ class FindCapturedVars : public ASTWalker {
 
     // When we see a reference to the 'super' expression, capture 'self' decl.
     if (auto *superE = dyn_cast<SuperRefExpr>(E)) {
-      if (CurDC->isChildContextOf(superE->getSelf()->getDeclContext()))
-        addCapture(CapturedValue(superE->getSelf(), 0, superE->getLoc()));
+      if (auto *selfDecl = superE->getSelf()) {
+        if (CurDC->isChildContextOf(selfDecl->getDeclContext()))
+          addCapture(CapturedValue(selfDecl, 0, superE->getLoc()));
+      }
       return { false, superE };
     }
 

lib/Sema/TypeCheckConstraints.cpp

@@ -1114,6 +1114,29 @@ namespace {
 
     bool shouldWalkCaptureInitializerExpressions() override { return true; }
 
+    VarDecl *getImplicitSelfDeclForSuperContext(SourceLoc Loc) {
+      auto *methodContext = DC->getInnermostMethodContext();
+      if (!methodContext) {
+        Ctx.Diags.diagnose(Loc, diag::super_not_in_class_method);
+        return nullptr;
+      }
+
+      // Do an actual lookup for 'self' in case it shows up in a capture list.
+      auto *methodSelf = methodContext->getImplicitSelfDecl();
+      auto *lookupSelf = ASTScope::lookupSingleLocalDecl(DC->getParentSourceFile(),
+                                                         Ctx.Id_self, Loc);
+      if (lookupSelf && lookupSelf != methodSelf) {
+        // FIXME: This is the wrong diagnostic for if someone manually declares a
+        // variable named 'self' using backticks.
+        Ctx.Diags.diagnose(Loc, diag::super_in_closure_with_capture);
+        Ctx.Diags.diagnose(lookupSelf->getLoc(),
+                           diag::super_in_closure_with_capture_here);
+        return nullptr;
+      }
+
+      return methodSelf;
+    }
+
     std::pair<bool, Expr *> walkToExprPre(Expr *expr) override {
       // If this is a call, record the argument expression.
       if (auto call = dyn_cast<ApplyExpr>(expr)) {
@@ -1156,6 +1179,17 @@ namespace {
         return std::make_pair(recursive, expr);
       };
 
+      // Resolve 'super' references.
+      if (auto *superRef = dyn_cast<SuperRefExpr>(expr)) {
+        auto loc = superRef->getLoc();
+        auto *selfDecl = getImplicitSelfDeclForSuperContext(loc);
+        if (selfDecl == nullptr)
+          return finish(true, new (Ctx) ErrorExpr(loc));
+
+        superRef->setSelf(selfDecl);
+        return finish(true, superRef);
+      }
+
       // For closures, type-check the patterns and result type as written,
       // but do not walk into the body. That will be type-checked after
       // we've determine the complete function type.