[AST] Make it possible to access type wrapper storage of a var

This is important because we need to force existance of the
underlying storage at the right moment.

Author: xedin

Diff for: include/swift/AST/Decl.h

@@ -5564,6 +5564,13 @@ class VarDecl : public AbstractStorageDecl {
   /// all access to it routed through a type wrapper.
   bool isAccessedViaTypeWrapper() const;
 
+  /// For type wrapped properties (see \c isAccessedViaTypeWrapper)
+  /// all access is routed through a type wrapper.
+  ///
+  /// \returns an underlying type wrapper property which is a
+  /// storage endpoint for all access to this property.
+  VarDecl *getUnderlyingTypeWrapperStorage() const;
+
   /// Visit all auxiliary declarations to this VarDecl.
   ///
   /// An auxiliary declaration is a declaration synthesized by the compiler to support

Diff for: lib/Sema/TypeCheckStorage.cpp

@@ -104,7 +104,7 @@ static bool hasStoredProperties(NominalTypeDecl *decl) {
 
 static void computeLoweredStoredProperties(NominalTypeDecl *decl) {
   // Just walk over the members of the type, forcing backing storage
-  // for lazy properties and property wrappers to be synthesized.
+  // for lazy properties, property and type wrappers to be synthesized.
   for (auto *member : decl->getMembers()) {
     auto *var = dyn_cast<VarDecl>(member);
     if (!var || var->isStatic())
@@ -117,6 +117,10 @@ static void computeLoweredStoredProperties(NominalTypeDecl *decl) {
       (void) var->getPropertyWrapperAuxiliaryVariables();
       (void) var->getPropertyWrapperInitializerInfo();
     }
+
+    if (var->isAccessedViaTypeWrapper()) {
+      (void)var->getUnderlyingTypeWrapperStorage();
+    }
   }
 
   // If this is an actor, check conformance to the Actor protocol to

Diff for: lib/Sema/TypeCheckTypeWrapper.cpp

@@ -60,6 +60,13 @@ bool VarDecl::isAccessedViaTypeWrapper() const {
                            false);
 }
 
+VarDecl *VarDecl::getUnderlyingTypeWrapperStorage() const {
+  auto *mutableSelf = const_cast<VarDecl *>(this);
+  return evaluateOrDefault(getASTContext().evaluator,
+                           GetTypeWrapperStorageForProperty{mutableSelf},
+                           nullptr);
+}
+
 NominalTypeDecl *NominalTypeDecl::getTypeWrapper() const {
   auto *mutableSelf = const_cast<NominalTypeDecl *>(this);
   return evaluateOrDefault(getASTContext().evaluator,
@@ -217,8 +224,7 @@ static SubscriptExpr *subscriptTypeWrappedProperty(VarDecl *var,
 
   auto *typeWrapperVar =
       evaluateOrDefault(ctx.evaluator, GetTypeWrapperProperty{parent}, nullptr);
-  auto *storageVar = evaluateOrDefault(
-      ctx.evaluator, GetTypeWrapperStorageForProperty{var}, nullptr);
+  auto *storageVar = var->getUnderlyingTypeWrapperStorage();
 
   assert(typeWrapperVar);
   assert(storageVar);