[Sema] PreCheck: Diagnose standalone self within init accessors

'self' within init accessor could only be used to refer to
properties listed in `initializes` and `accesses` attributes.

Author: xedin

include/swift/AST/DeclContext.h

@@ -82,6 +82,7 @@ namespace swift {
   class SerializedDefaultArgumentInitializer;
   class SerializedTopLevelCodeDecl;
   class StructDecl;
+  class AccessorDecl;
 
 namespace serialization {
 using DeclID = llvm::PointerEmbeddedInt<unsigned, 31>;
@@ -457,6 +458,18 @@ class alignas(1 << DeclContextAlignInBits) DeclContext
     return const_cast<DeclContext*>(this)->getInnermostMethodContext();
   }
 
+  /// Returns the innermost accessor context that belongs to a property.
+  ///
+  /// This routine looks through closure, initializer, and local function
+  /// contexts to find the innermost accessor declaration.
+  ///
+  /// \returns the innermost accessor, or null if there is no such context.
+  LLVM_READONLY
+  AccessorDecl *getInnermostPropertyAccessorContext();
+  const AccessorDecl *getInnermostPropertyAccessorContext() const {
+    return const_cast<DeclContext*>(this)->getInnermostPropertyAccessorContext();
+  }
+
   /// Returns the innermost type context.
   ///
   /// This routine looks through closure, initializer, and local function

include/swift/AST/DiagnosticsSema.def

@@ -7342,6 +7342,10 @@ ERROR(init_accessor_accesses_attribute_on_other_declaration,none,
 ERROR(init_accessor_property_both_init_and_accessed,none,
       "property %0 cannot be both initialized and accessed",
       (DeclName))
+ERROR(invalid_use_of_self_in_init_accessor,none,
+      "'self' within init accessors can only be used to reference "
+      "properties listed in 'initializes' and 'accesses'; "
+      "init accessors are run before 'self' is fully available", ())
 
 
 #define UNDEFINE_DIAGNOSTIC_MACROS

lib/AST/DeclContext.cpp

@@ -211,6 +211,24 @@ AbstractFunctionDecl *DeclContext::getInnermostMethodContext() {
   return nullptr;
 }
 
+AccessorDecl *DeclContext::getInnermostPropertyAccessorContext() {
+  auto dc = this;
+  do {
+    if (auto decl = dc->getAsDecl()) {
+      auto accessor = dyn_cast<AccessorDecl>(decl);
+      // If we found a non-accessor decl, we're done.
+      if (accessor == nullptr)
+        return nullptr;
+
+      auto *storage = accessor->getStorage();
+      if (isa<VarDecl>(storage) && storage->getDeclContext()->isTypeContext())
+        return accessor;
+    }
+  } while ((dc = dc->getParent()));
+
+  return nullptr;
+}
+
 bool DeclContext::isTypeContext() const {
   if (auto decl = getAsDecl())
     return isa<NominalTypeDecl>(decl) || isa<ExtensionDecl>(decl);

lib/Sema/PreCheckExpr.cpp

@@ -1066,8 +1066,24 @@ namespace {
       if (auto unresolved = dyn_cast<UnresolvedDeclRefExpr>(expr)) {
         TypeChecker::checkForForbiddenPrefix(
             getASTContext(), unresolved->getName().getBaseName());
-        return finish(true, TypeChecker::resolveDeclRefExpr(unresolved, DC,
-                                                            UseErrorExprs));
+        auto *refExpr =
+            TypeChecker::resolveDeclRefExpr(unresolved, DC, UseErrorExprs);
+
+        // Check whether this is standalone `self` in init accessor, which
+        // is invalid.
+        if (auto *accessor = DC->getInnermostPropertyAccessorContext()) {
+          if (accessor->isInitAccessor() && isa<DeclRefExpr>(refExpr)) {
+            auto *DRE = cast<DeclRefExpr>(refExpr);
+            if (accessor->getImplicitSelfDecl() == DRE->getDecl() &&
+                !isa_and_nonnull<UnresolvedDotExpr>(Parent.getAsExpr())) {
+              Ctx.Diags.diagnose(unresolved->getLoc(),
+                                 diag::invalid_use_of_self_in_init_accessor);
+              refExpr = new (Ctx) ErrorExpr(unresolved->getSourceRange());
+            }
+          }
+        }
+
+        return finish(true, refExpr);
       }
 
       // Let's try to figure out if `InOutExpr` is out of place early

test/decl/var/init_accessors.swift

@@ -136,3 +136,40 @@ func test_duplicate_and_computed_lazy_properties() {
     lazy var c: Int = 42
   }
 }
+
+func test_invalid_self_uses() {
+  func capture<T>(_: T) -> Int? { nil }
+
+  struct Test {
+    var a: Int {
+      init(initialValue) {
+        let x = self
+        // expected-error@-1 {{'self' within init accessors can only be used to reference properties listed in 'initializes' and 'accesses'; init accessors are run before 'self' is fully available}}
+
+        _ = {
+          print(self)
+          // expected-error@-1 {{'self' within init accessors can only be used to reference properties listed in 'initializes' and 'accesses'; init accessors are run before 'self' is fully available}}
+        }
+
+        _ = { [weak self] in
+          // expected-error@-1 {{'self' within init accessors can only be used to reference properties listed in 'initializes' and 'accesses'; init accessors are run before 'self' is fully available}}
+        }
+
+        _ = {
+          guard let _ = capture(self) else {
+            // expected-error@-1 {{'self' within init accessors can only be used to reference properties listed in 'initializes' and 'accesses'; init accessors are run before 'self' is fully available}}
+            return
+          }
+        }
+
+        Test.test(self)
+        // expected-error@-1 {{'self' within init accessors can only be used to reference properties listed in 'initializes' and 'accesses'; init accessors are run before 'self' is fully available}}
+      }
+
+      get { 42 }
+      set { }
+    }
+
+    static func test<T>(_: T) {}
+  }
+}