Move unqualified init diagnosis from Parse to Sema

Author: AnthonyLatsis

include/swift/AST/DiagnosticsParse.def

@@ -413,8 +413,6 @@ ERROR(subscript_without_get,none,
       "subscript declarations must have a getter", ())
 
 // initializer
-ERROR(invalid_nested_init,none,
-      "missing '%select{super.|self.}0' at initializer invocation", (bool))
 ERROR(initializer_decl_wrong_scope,none,
       "initializers may only be declared within a type", ())
 ERROR(expected_lparen_initializer,PointsToFirstBadToken,

include/swift/AST/DiagnosticsSema.def

@@ -4293,6 +4293,11 @@ ERROR(no_member_of_module,none,
 
 ERROR(super_with_no_base_class,none,
       "'super' members cannot be referenced in a root class", ())
+ERROR(unqualified_init,none,
+      "initializer expression requires explicit access"
+      "%select{|; did you mean to prepend it with|; did you mean to prepend "
+      "it with}0%select{| 'self.'?| 'super.'?}0",
+      (unsigned))
 
 ERROR(bad_init_ref_base, none,
       "'init' can only refer to the initializers of "

include/swift/Parse/Parser.h

@@ -1798,7 +1798,7 @@ class Parser {
       SourceLoc &rightAngleLoc, ArgumentList *&argList, bool isExprBasic,
       const Diagnostic &diag);
 
-  ParserResult<Expr> parseExprIdentifier();
+  ParserResult<Expr> parseExprIdentifier(bool allowKeyword);
   Expr *parseExprEditorPlaceholder(Token PlaceholderTok,
                                    Identifier PlaceholderId);
 

lib/Parse/ParseExpr.cpp

@@ -1755,8 +1755,9 @@ ParserResult<Expr> Parser::parseExprPrimary(Diag<> ID, bool isExprBasic) {
 
     LLVM_FALLTHROUGH;
   }
+  case tok::kw_init:
   case tok::kw_Self:     // Self
-    return parseExprIdentifier();
+    return parseExprIdentifier(/*allowKeyword=*/true);
 
   case tok::kw_Any: { // Any
     auto TyR = parseAnyType();
@@ -2390,17 +2391,20 @@ ParserStatus Parser::parseFreestandingMacroExpansion(
 
 ///   expr-identifier:
 ///     unqualified-decl-name generic-args?
-ParserResult<Expr> Parser::parseExprIdentifier() {
+ParserResult<Expr> Parser::parseExprIdentifier(bool allowKeyword) {
   ParserStatus status;
-  assert(Tok.isAny(tok::identifier, tok::kw_self, tok::kw_Self));
+  assert(Tok.isAny(tok::identifier, tok::kw_self, tok::kw_Self) ||
+         (allowKeyword && Tok.isKeyword()));
   Token IdentTok = Tok;
 
+  auto declNameFlags = DeclNameFlag::AllowCompoundNames |
+                       DeclNameFlag::AllowLowercaseAndUppercaseSelf;
+  if (allowKeyword) {
+    declNameFlags |= DeclNameFlag::AllowKeywords;
+  }
   // Parse the unqualified-decl-name.
   DeclNameLoc loc;
-  DeclNameRef name =
-      parseDeclNameRef(loc, diag::expected_expr,
-                       DeclNameFlag::AllowCompoundNames |
-                           DeclNameFlag::AllowLowercaseAndUppercaseSelf);
+  DeclNameRef name = parseDeclNameRef(loc, diag::expected_expr, declNameFlags);
 
   SmallVector<TypeRepr*, 8> args;
   SourceLoc LAngleLoc, RAngleLoc;
@@ -2701,7 +2705,7 @@ ParserStatus Parser::parseClosureSignatureIfPresent(
         // the expression to capture.
         if (!Tok.is(tok::code_complete)) {
           name = Context.getIdentifier(Tok.getText());
-          auto initializerResult = parseExprIdentifier();
+          auto initializerResult = parseExprIdentifier(/*allowKeyword=*/false);
           status |= initializerResult;
           initializer = initializerResult.get();
         } else {

lib/Parse/ParseStmt.cpp

@@ -480,16 +480,6 @@ ParserStatus Parser::parseBraceItems(SmallVectorImpl<ASTNode> &Entries,
           if (isa<GuardStmt>(stmt))
             IsFollowingGuard = true;
       }
-    } else if (Tok.is(tok::kw_init) && isa<ConstructorDecl>(CurDeclContext)) {
-      SourceLoc StartLoc = Tok.getLoc();
-      auto CD = cast<ConstructorDecl>(CurDeclContext);
-      // Hint at missing 'self.' or 'super.' then skip this statement.
-      bool isSelf = CD->getAttrs().hasAttribute<ConvenienceAttr>() ||
-                    !isa<ClassDecl>(CD->getParent());
-      diagnose(StartLoc, diag::invalid_nested_init, isSelf)
-        .fixItInsert(StartLoc, isSelf ? "self." : "super.");
-      NeedParseErrorRecovery = true;
-      BraceItemsStatus.setIsParseError();
     } else {
       ParserStatus ExprOrStmtStatus = parseExprOrStmt(Result);
       BraceItemsStatus |= ExprOrStmtStatus;

lib/Sema/PreCheckExpr.cpp

@@ -847,6 +847,83 @@ TypeChecker::getSelfForInitDelegationInConstructor(DeclContext *DC,
   return nullptr;
 }
 
+/// Diagnoses an unqualified `init` expression.
+///
+/// \param initExpr The \c init expression.
+/// \param dc The declaration context of \p initExpr.
+///
+/// \returns An expression matching `self.init` or `super.init` that can be used
+/// to recover, or `nullptr` if cannot recover.
+static UnresolvedDotExpr *
+diagnoseUnqualifiedInit(UnresolvedDeclRefExpr *initExpr, DeclContext *dc,
+                        ASTContext &ctx) {
+  const auto loc = initExpr->getLoc();
+
+  enum class Suggestion : unsigned {
+    None = 0,
+    Self = 1,
+    Super = 2,
+  };
+
+  Suggestion suggestion = [dc]() {
+    NominalTypeDecl *nominal = nullptr;
+    {
+      auto *typeDC = dc->getInnermostTypeContext();
+      if (!typeDC) {
+        // No type context--no suggestion.
+        return Suggestion::None;
+      }
+
+      nominal = typeDC->getSelfNominalTypeDecl();
+    }
+
+    auto *classDecl = dyn_cast<ClassDecl>(nominal);
+    if (!classDecl || !classDecl->hasSuperclass()) {
+      // No class or no superclass--suggest 'self.'.
+      return Suggestion::Self;
+    }
+
+    if (auto *initDecl = dyn_cast<ConstructorDecl>(dc)) {
+      if (initDecl->getAttrs().hasAttribute<ConvenienceAttr>()) {
+        // Innermost context is a convenience initializer--suggest 'self.'.
+        return Suggestion::Self;
+      } else {
+        // Innermost context is a designated initializer--suggest 'super.'.
+        return Suggestion::Super;
+      }
+    }
+
+    // Class context but innermost context is not an initializer--suggest
+    // 'self.'. 'super.' might be possible too, but is far lesss likely to be
+    // the right answer.
+    return Suggestion::Self;
+  }();
+
+  auto diag =
+      ctx.Diags.diagnose(loc, diag::unqualified_init, (unsigned)suggestion);
+
+  Expr *base = nullptr;
+  switch (suggestion) {
+  case Suggestion::None:
+    return nullptr;
+  case Suggestion::Self:
+    diag.fixItInsert(loc, "self.");
+    base = new (ctx)
+        UnresolvedDeclRefExpr(DeclNameRef(ctx.Id_self), DeclRefKind::Ordinary,
+                              initExpr->getNameLoc());
+    base->setImplicit(true);
+    break;
+  case Suggestion::Super:
+    diag.fixItInsert(loc, "super.");
+    base = new (ctx) SuperRefExpr(/*Self=*/nullptr, loc, /*Implicit=*/true);
+    break;
+  }
+
+  return new (ctx)
+      UnresolvedDotExpr(base, /*dotloc=*/SourceLoc(), initExpr->getName(),
+                        initExpr->getNameLoc(), /*implicit=*/true);
+}
+
 namespace {
   /// Update the function reference kind based on adding a direct call to a
   /// callee with this kind.
@@ -1090,6 +1167,17 @@ namespace {
       if (auto unresolved = dyn_cast<UnresolvedDeclRefExpr>(expr)) {
         TypeChecker::checkForForbiddenPrefix(
             getASTContext(), unresolved->getName().getBaseName());
+
+        if (unresolved->getName().getBaseName().isConstructor()) {
+          if (auto *recoveryExpr =
+                  diagnoseUnqualifiedInit(unresolved, DC, Ctx)) {
+            return finish(true, recoveryExpr);
+          }
+
+          return finish(false,
+                        new (Ctx) ErrorExpr(unresolved->getSourceRange()));
+        }
+
         auto *refExpr =
             TypeChecker::resolveDeclRefExpr(unresolved, DC, UseErrorExprs);
 

test/Parse/init_deinit.swift

@@ -121,22 +121,133 @@ func barFunc() {
 // https://github.com/apple/swift/issues/43464
 
 class Aaron {
-  init(x: Int) {}
-  convenience init() { init(x: 1) } // expected-error {{missing 'self.' at initializer invocation}} {{24-24=self.}}
+  init(x: Int) {
+    func foo() {
+      // Make sure we recover and assume 'self.init'.
+      // expected-error@+2 {{initializer expression requires explicit access; did you mean to prepend it with 'self.'?}} {{11-11=self.}}
+      // expected-error@+1 {{type of expression is ambiguous without a type annotation}}
+      _ = init
+    }
+  }
+  convenience init() {
+    // Make sure we recover and assume 'self.init'.
+    // expected-error@+2 {{initializer expression requires explicit access; did you mean to prepend it with 'self.'?}} {{5-5=self.}}
+    // expected-error@+1 {{cannot convert value of type 'Bool' to expected argument type 'Int'}}
+    init(x: true)
+
+    // FIXME: self.init considered initializer delegation in nested function?
+    // expected-error@+2 {{initializer delegation ('self.init') cannot be nested in another expression}}
+    // expected-error@+1 {{initializer expression requires explicit access; did you mean to prepend it with 'self.'?}} {{22-22=self.}}
+    func foo() { _ = init() }
+  }
+
+  required init(y: Int) {}
+
+  static func aaronFn() {
+    // Make sure we recover and assume 'self.init'.
+    // expected-error@+2 {{initializer expression requires explicit access; did you mean to prepend it with 'self.'?}} {{9-9=self.}}
+    // expected-error@+1 {{incorrect argument label in call (have 'z:', expected 'y:')}}
+    _ = init(z: 0)
+  }
+
+  // Make sure we recover and assume 'self.init'.
+  // expected-error@+3 {{initializer expression requires explicit access; did you mean to prepend it with 'self.'?}} {{45-45=self.}}
+  // expected-error@+2 {{cannot convert value of type 'Aaron' to specified type 'Int'}}
+  // expected-error@+1 {{incorrect argument label in call (have 'z:', expected 'y:')}}
+  static var aaronVar: Aaron { let _: Int = init(z: 0) }
 }
 
 class Theodosia: Aaron {
   init() {
-    init(x: 2) // expected-error {{missing 'super.' at initializer invocation}} {{5-5=super.}}
+    // Make sure we recover and assume 'super.init'.
+    // expected-error@+2 {{initializer expression requires explicit access; did you mean to prepend it with 'super.'?}} {{5-5=super.}}
+    // expected-error@+1 {{cannot convert value of type 'Bool' to expected argument type 'Int'}}
+    init(x: true)
+
+    // Make sure we recover and assume 'self.init'.
+    // expected-error@+2 {{initializer expression requires explicit access; did you mean to prepend it with 'self.'?}} {{22-22=self.}}
+    // expected-error@+1 {{type of expression is ambiguous without a type annotation}}
+    func foo() { _ = init }
+  }
+
+  required init(y: Int) {}
+
+  static func theodosiaFn() {
+    // Make sure we recover and assume 'self.init'.
+    // expected-error@+2 {{initializer expression requires explicit access; did you mean to prepend it with 'self.'?}} {{9-9=self.}}
+    // expected-error@+1 {{incorrect argument label in call (have 'z:', expected 'y:')}}
+    _ = init(z: 0)
+
+    // FIXME: We could optimistically parse this as an expression instead
+    // expected-error@+2 {{initializers may only be declared within a type}}
+    // expected-error@+1 {{expected parameter type following ':'}}
+    init(z: 0)
+  }
+
+  static var theodosiaVar: Aaron {
+    // Make sure we recover and assume 'self.init'.
+    // expected-error@+2 {{initializer expression requires explicit access; did you mean to prepend it with 'self.'?}} {{9-9=self.}}
+    // expected-error@+1 {{incorrect argument label in call (have 'z:', expected 'y:')}}
+    _ = init(z: 0)
   }
 }
 
 struct AaronStruct {
   init(x: Int) {}
-  init() { init(x: 1) } // expected-error {{missing 'self.' at initializer invocation}} {{12-12=self.}}
+  init() {
+    // Make sure we recover and assume 'self.init'.
+    // expected-error@+2 {{initializer expression requires explicit access; did you mean to prepend it with 'self.'?}} {{5-5=self.}}
+    // expected-error@+1 {{incorrect argument label in call (have 'y:', expected 'x:')}}
+    init(y: 1)
+
+    func foo() {
+      // Make sure we recover and assume 'self.init'.
+      // expected-error@+2 {{initializer expression requires explicit access; did you mean to prepend it with 'self.'?}} {{11-11=self.}}
+      // expected-error@+1 {{incorrect argument label in call (have 'y:', expected 'x:')}}
+      _ = init(y: 1)
+    }
+  }
+
+  static func aaronFn() {
+    // Make sure we recover and assume 'self.init'.
+    // expected-error@+2 {{initializer expression requires explicit access; did you mean to prepend it with 'self.'?}} {{9-9=self.}}
+    // expected-error@+1 {{incorrect argument label in call (have 'y:', expected 'x:')}}
+    _ = init(y: 1)
+
+    // FIXME: We could optimistically parse this as an expression instead
+    // expected-error@+2 {{initializers may only be declared within a type}}
+    // expected-error@+1 {{expected parameter type following ':'}}
+    init(y: 1)
+  }
+
+  static var aaronVar: Aaron {
+    // Make sure we recover and assume 'self.init'.
+    // expected-error@+2 {{initializer expression requires explicit access; did you mean to prepend it with 'self.'?}} {{9-9=self.}}
+    // expected-error@+1 {{incorrect argument label in call (have 'y:', expected 'x:')}}
+    _ = init(y: 1)
+
+    // FIXME: We could optimistically parse this as an expression instead
+    // expected-error@+3 {{initializers may only be declared within a type}}
+    // expected-error@+2 {{consecutive statements on a line must be separated by ';'}}
+    // expected-error@+1 {{non-void function should return a value}}
+    return init()
+  }
 }
 
 enum AaronEnum: Int {
   case A = 1
-  init(x: Int) { init(rawValue: x)! } // expected-error {{missing 'self.' at initializer invocation}} {{18-18=self.}}
+
+  init(x: Int) {
+    // Make sure we recover and assume 'self.init'.
+    // expected-error@+2 {{initializer expression requires explicit access; did you mean to prepend it with 'self.'?}} {{5-5=self.}}
+    // expected-error@+1 {{cannot convert value of type 'String' to expected argument type 'Int'}}
+    init(rawValue: "")!
+  }
+}
+
+do {
+  func foo() {
+    // expected-error@+1 {{initializer expression requires explicit access}} {none}}
+    _ = init()
+  }
 }