[AST] TypeWrappers: A request to synthesize _storage variable for an initializer

User-defined initializer would populate `_storage` incrementally
so it could be passed to `<TypeWrapper>.init(memberwise:)` call
to initialize the type wrapper.

Author: xedin

include/swift/AST/Decl.h

@@ -7649,6 +7649,12 @@ class ConstructorDecl : public AbstractFunctionDecl {
   /// \endcode
   bool isObjCZeroParameterWithLongSelector() const;
 
+  /// If this is a user-defined constructor that belongs to
+  /// a type wrapped type return a local `_storage` variable
+  /// injected by the compiler for aid with type wrapper
+  /// initialization.
+  VarDecl *getLocalTypeWrapperStorageVar() const;
+
   static bool classof(const Decl *D) {
     return D->getKind() == DeclKind::Constructor;
   }

include/swift/AST/KnownIdentifiers.def

@@ -314,6 +314,7 @@ IDENTIFIER_WITH_NAME(TypeWrapperStorage, "$Storage")
 IDENTIFIER_WITH_NAME(TypeWrapperProperty, "$_storage")
 IDENTIFIER(storageKeyPath)
 IDENTIFIER(memberwise)
+IDENTIFIER_WITH_NAME(localStorageVar, "_storage")
 
 // The singleton instance of TupleTypeDecl in the Builtin module
 IDENTIFIER(TheTupleType)

include/swift/AST/TypeCheckRequests.h

@@ -3705,6 +3705,21 @@ class SynthesizeTypeWrapperInitializerBody
   bool isCached() const { return true; }
 };
 
+class SynthesizeLocalVariableForTypeWrapperStorage
+    : public SimpleRequest<SynthesizeLocalVariableForTypeWrapperStorage,
+                           VarDecl *(ConstructorDecl *), RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  VarDecl *evaluate(Evaluator &evaluator, ConstructorDecl *) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
 void simple_display(llvm::raw_ostream &out, ASTNode node);
 void simple_display(llvm::raw_ostream &out, Type value);
 void simple_display(llvm::raw_ostream &out, const TypeRepr *TyR);

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -434,3 +434,6 @@ SWIFT_REQUEST(TypeChecker, SynthesizeTypeWrapperInitializer,
 SWIFT_REQUEST(TypeChecker, SynthesizeTypeWrapperInitializerBody,
               BraceStmt *(ConstructorDecl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, SynthesizeLocalVariableForTypeWrapperStorage,
+              VarDecl *(ConstructorDecl *),
+              Cached, NoLocationInfo)

lib/AST/Decl.cpp

@@ -8789,6 +8789,13 @@ bool ConstructorDecl::isObjCZeroParameterWithLongSelector() const {
   return params->get(0)->getInterfaceType()->isVoid();
 }
 
+VarDecl *ConstructorDecl::getLocalTypeWrapperStorageVar() const {
+  auto &ctx = getASTContext();
+  auto *mutableSelf = const_cast<ConstructorDecl *>(this);
+  return evaluateOrDefault(
+      ctx.evaluator, SynthesizeLocalVariableForTypeWrapperStorage{mutableSelf},
+      nullptr);
+}
 
 DestructorDecl::DestructorDecl(SourceLoc DestructorLoc, DeclContext *Parent)
   : AbstractFunctionDecl(DeclKind::Destructor, Parent,

lib/Sema/TypeCheckTypeWrapper.cpp

@@ -25,28 +25,37 @@
 
 using namespace swift;
 
-/// Create a property declaration and inject it into the given type.
-static VarDecl *injectProperty(NominalTypeDecl *parent, Identifier name,
-                               Type type, VarDecl::Introducer introducer,
-                               AccessLevel accessLevel,
-                               Expr *initializer = nullptr) {
-  auto &ctx = parent->getASTContext();
+static PatternBindingDecl *injectVariable(DeclContext *DC, Identifier name,
+                                          Type type,
+                                          VarDecl::Introducer introducer,
+                                          Expr *initializer = nullptr) {
+  auto &ctx = DC->getASTContext();
 
   auto *var = new (ctx) VarDecl(/*isStatic=*/false, introducer,
-                                /*nameLoc=*/SourceLoc(), name, parent);
+                                /*nameLoc=*/SourceLoc(), name, DC);
 
   var->setImplicit();
   var->setSynthesized();
-  var->setAccess(accessLevel);
   var->setInterfaceType(type);
 
   Pattern *pattern = NamedPattern::createImplicit(ctx, var);
   pattern->setType(type);
 
   pattern = TypedPattern::createImplicit(ctx, pattern, type);
 
-  auto *PBD = PatternBindingDecl::createImplicit(ctx, StaticSpellingKind::None,
-                                                 pattern, initializer, parent);
+  return PatternBindingDecl::createImplicit(ctx, StaticSpellingKind::None,
+                                            pattern, initializer, DC);
+}
+
+/// Create a property declaration and inject it into the given type.
+static VarDecl *injectProperty(NominalTypeDecl *parent, Identifier name,
+                               Type type, VarDecl::Introducer introducer,
+                               AccessLevel accessLevel,
+                               Expr *initializer = nullptr) {
+  auto *PBD = injectVariable(parent, name, type, introducer, initializer);
+  auto *var = PBD->getSingleVar();
+
+  var->setAccess(accessLevel);
 
   parent->addMember(PBD);
   parent->addMember(var);
@@ -472,3 +481,33 @@ SynthesizeTypeWrapperInitializerBody::evaluate(Evaluator &evaluator,
   return BraceStmt::create(ctx, /*lbloc=*/ctor->getLoc(), body,
                            /*rbloc=*/ctor->getLoc(), /*implicit=*/true);
 }
+
+VarDecl *SynthesizeLocalVariableForTypeWrapperStorage::evaluate(
+    Evaluator &evaluator, ConstructorDecl *ctor) const {
+  auto &ctx = ctor->getASTContext();
+
+  if (ctor->isImplicit() || !ctor->isDesignatedInit())
+    return nullptr;
+
+  auto *DC = ctor->getDeclContext()->getSelfNominalTypeDecl();
+  if (!(DC && DC->hasTypeWrapper()))
+    return nullptr;
+
+  auto *storageDecl =
+      evaluateOrDefault(evaluator, GetTypeWrapperStorage{DC}, nullptr);
+  assert(storageDecl);
+
+  SmallVector<TupleTypeElt, 4> members;
+  for (auto *member : storageDecl->getMembers()) {
+    if (auto *var = dyn_cast<VarDecl>(member)) {
+      assert(var->hasStorage() &&
+             "$Storage should have stored properties only");
+      members.push_back({var->getValueInterfaceType(), var->getName()});
+    }
+  }
+
+  auto *PBD =
+      injectVariable(ctor, ctx.Id_localStorageVar, TupleType::get(members, ctx),
+                     VarDecl::Introducer::Var);
+  return PBD->getSingleVar();
+}