Merge pull request #66681 from xedin/enable-inits-on-props-with-init-accessors

[Sema/SILGen] InitAccessors: Synthesize default arguments for init accessor properties

Author: xedin

include/swift/AST/Decl.h

@@ -5317,6 +5317,16 @@ class AbstractStorageDecl : public ValueDecl {
   /// it.
   bool hasStorage() const;
 
+  /// Return true if this is a VarDecl that has init accessor associated
+  /// with it.
+  bool hasInitAccessor() const;
+
+  /// Return true if this is a property that either has storage
+  /// or init accessor associated with it.
+  bool supportsInitialization() const {
+    return hasStorage() || hasInitAccessor();
+  }
+
   /// Return true if this storage has the basic accessors/capability
   /// to be mutated.  This is generally constant after the accessors are
   /// installed by the parser/importer/whatever.

include/swift/AST/TypeCheckRequests.h

@@ -4312,6 +4312,22 @@ class IsNonUserModuleRequest
   bool isCached() const { return true; }
 };
 
+class HasInitAccessorRequest
+    : public SimpleRequest<HasInitAccessorRequest, bool(AbstractStorageDecl *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  bool evaluate(Evaluator &evaluator, AbstractStorageDecl *decl) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
 class InitAccessorReferencedVariablesRequest
     : public SimpleRequest<InitAccessorReferencedVariablesRequest,
                            ArrayRef<VarDecl *>(DeclAttribute *, AccessorDecl *,

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -487,6 +487,9 @@ SWIFT_REQUEST(TypeChecker, IsNonUserModuleRequest,
 SWIFT_REQUEST(TypeChecker, TypeCheckObjCImplementationRequest,
               unsigned(ExtensionDecl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, HasInitAccessorRequest,
+              bool(AbstractStorageDecl *), Cached,
+              NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, InitAccessorReferencedVariablesRequest,
               ArrayRef<VarDecl *>(DeclAttribute *, AccessorDecl *,
                                   ArrayRef<Identifier>),

lib/AST/Decl.cpp

@@ -6720,6 +6720,12 @@ Type AbstractStorageDecl::getValueInterfaceType() const {
   return cast<SubscriptDecl>(this)->getElementInterfaceType();
 }
 
+bool AbstractStorageDecl::hasInitAccessor() const {
+  return evaluateOrDefault(
+      getASTContext().evaluator,
+      HasInitAccessorRequest{const_cast<AbstractStorageDecl *>(this)}, false);
+}
+
 VarDecl::VarDecl(DeclKind kind, bool isStatic, VarDecl::Introducer introducer,
                  SourceLoc nameLoc, Identifier name,
                  DeclContext *dc, StorageIsMutable_t supportsMutation)

lib/Parse/ParseExpr.cpp

@@ -1059,14 +1059,14 @@ bool Parser::isStartOfGetSetAccessor() {
   // The only case this can happen is if the accessor label is immediately after
   // a brace (possibly preceded by attributes).  "get" is implicit, so it can't
   // be checked for.  Conveniently however, get/set properties are not allowed
-  // to have initializers, so we don't have an ambiguity, we just have to check
-  // for observing accessors.
+  // to have initializers unless they have `init` accessor, so we don't have an
+  // ambiguity, we just have to check for observing accessors and init accessor.
   //
   // If we have a 'didSet' or a 'willSet' label, disambiguate immediately as
   // an accessor block.
   Token NextToken = peekToken();
   if (NextToken.isContextualKeyword("didSet") ||
-      NextToken.isContextualKeyword("willSet"))
+      NextToken.isContextualKeyword("willSet") || NextToken.is(tok::kw_init))
     return true;
 
   // If we don't have attributes, then it cannot be an accessor block.
@@ -1087,9 +1087,9 @@ bool Parser::isStartOfGetSetAccessor() {
       skipSingle();
   }
 
-  // Check if we have 'didSet'/'willSet' after attributes.
+  // Check if we have 'didSet'/'willSet' or 'init' after attributes.
   return Tok.isContextualKeyword("didSet") ||
-         Tok.isContextualKeyword("willSet");
+         Tok.isContextualKeyword("willSet") || Tok.is(tok::kw_init);
 }
 
 /// Recover invalid uses of trailing closures in a situation

lib/SILGen/SILGenConstructor.cpp

@@ -1474,6 +1474,13 @@ void SILGenFunction::emitMemberInitializers(DeclContext *dc,
     if (auto pbd = dyn_cast<PatternBindingDecl>(member)) {
       if (pbd->isStatic()) continue;
 
+      // Skip properties with init accessors, they could only be used
+      // explicitly and in memberwise initializers.
+      if (auto *var = pbd->getSingleVar()) {
+        if (var->hasInitAccessor())
+          continue;
+      }
+
       for (auto i : range(pbd->getNumPatternEntries())) {
         auto init = pbd->getExecutableInit(i);
         if (!init) continue;

lib/Sema/CodeSynthesis.cpp

@@ -144,12 +144,6 @@ static void maybeAddMemberwiseDefaultArg(ParamDecl *arg, VarDecl *var,
   if (!var->getParentPattern()->getSingleVar())
     return;
 
-  // FIXME: Don't attempt to synthesize default arguments for init
-  //        accessor properties because there could be multiple properties
-  //        with default values they are going to initialize.
-  if (var->getAccessor(AccessorKind::Init))
-    return;
-
   // Whether we have explicit initialization.
   bool isExplicitlyInitialized = false;
   if (auto pbd = var->getParentPatternBinding()) {

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -2289,7 +2289,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
         if (PBD->isInitialized(i)) {
           // Add the attribute that preserves the "has an initializer" value
           // across module generation, as required for TBDGen.
-          if (var->hasStorage() &&
+          if (var->supportsInitialization() &&
               !var->getAttrs().hasAttribute<HasInitialValueAttr>()) {
             var->getAttrs().add(new (Ctx)
                                     HasInitialValueAttr(/*IsImplicit=*/true));

lib/Sema/TypeCheckMacros.cpp

@@ -1302,9 +1302,11 @@ Optional<unsigned> swift::expandAccessors(
     !accessorMacroOnlyIntroducesObservers(macro, roleAttr);
   if (foundNonObservingAccessor) {
     // If any non-observing accessor was added, mark the initializer as
-    // subsumed.
+    // subsumed unless it has init accessor, because the initializer in
+    // such cases could be used for memberwise initialization.
     if (auto var = dyn_cast<VarDecl>(storage)) {
-      if (auto binding = var->getParentPatternBinding()) {
+      if (auto binding = var->getParentPatternBinding();
+          !var->getAccessor(AccessorKind::Init)) {
         unsigned index = binding->getPatternEntryIndexForVarDecl(var);
         binding->setInitializerSubsumed(index);
       }

lib/Sema/TypeCheckStorage.cpp

@@ -301,8 +301,12 @@ StoredPropertiesAndMissingMembersRequest::evaluate(Evaluator &evaluator,
   return decl->getASTContext().AllocateCopy(results);
 }
 
-/// Determine whether the given variable has an init accessor.
-static bool hasInitAccessor(VarDecl *var) {
+bool HasInitAccessorRequest::evaluate(Evaluator &evaluator,
+                                      AbstractStorageDecl *decl) const {
+  auto *var = dyn_cast<VarDecl>(decl);
+  if (!var)
+    return false;
+
   if (var->getAccessor(AccessorKind::Init))
     return true;
 
@@ -340,7 +344,7 @@ InitAccessorPropertiesRequest::evaluate(Evaluator &evaluator,
   SmallVector<VarDecl *, 4> results;
   for (auto *member : decl->getMembers()) {
     auto *var = dyn_cast<VarDecl>(member);
-    if (!var || var->isStatic() || !hasInitAccessor(var)) {
+    if (!var || var->isStatic() || !var->hasInitAccessor()) {
       continue;
     }
 
@@ -3362,7 +3366,7 @@ static void finishStorageImplInfo(AbstractStorageDecl *storage,
   auto dc = storage->getDeclContext();
 
   if (auto var = dyn_cast<VarDecl>(storage)) {
-    if (!info.hasStorage()) {
+    if (!info.hasStorage() && !var->hasInitAccessor()) {
       if (auto *init = var->getParentExecutableInitializer()) {
         auto &Diags = var->getASTContext().Diags;
         Diags.diagnose(init->getLoc(), diag::getset_init)