Parse: Move the lookup of 'self' for a SuperRefExpr to preCheckExpression()

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/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/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.