[AST/Sema] TypeWrappers/NFC: Rename type wrapper storage property to $storage

Author: xedin

include/swift/AST/KnownIdentifiers.def

@@ -311,7 +311,7 @@ IDENTIFIER_WITH_NAME(builderSelf, "$builderSelf")
 
 // Type wrappers
 IDENTIFIER_WITH_NAME(TypeWrapperStorage, "$Storage")
-IDENTIFIER_WITH_NAME(TypeWrapperProperty, "$_storage")
+IDENTIFIER_WITH_NAME(TypeWrapperProperty, "$storage")
 IDENTIFIER(storageKeyPath)
 IDENTIFIER_WITH_NAME(localStorageVar, "_storage")
 

include/swift/AST/TypeCheckRequests.h

@@ -3588,7 +3588,7 @@ class GetTypeWrapperStorage
   bool isCached() const { return true; }
 };
 
-/// Inject or get `$_storage` property which is used to route accesses through
+/// Inject or get `$storage` property which is used to route accesses through
 /// to all stored properties of a type that has a type wrapper.
 class GetTypeWrapperProperty
     : public SimpleRequest<GetTypeWrapperProperty, VarDecl *(NominalTypeDecl *),

lib/Sema/CodeSynthesis.cpp

@@ -1249,7 +1249,7 @@ void TypeChecker::addImplicitConstructors(NominalTypeDecl *decl) {
       auto &ctx = decl->getASTContext();
       // If declaration is type wrapped and there are no
       // designated initializers, synthesize a special
-      // memberwise initializer that would instantiate `$_storage`.
+      // memberwise initializer that would instantiate `$storage`.
       if (!hasUserDefinedDesignatedInit(ctx.evaluator, decl))
         (void)decl->getTypeWrappedTypeMemberwiseInitializer();
     }

lib/Sema/TypeCheckStorage.cpp

@@ -107,7 +107,7 @@ static bool hasStoredProperties(NominalTypeDecl *decl,
 static void computeLoweredStoredProperties(NominalTypeDecl *decl,
                                            IterableDeclContext *implDecl) {
   // If declaration has a type wrapper, make sure that
-  // `$_storage` property is synthesized.
+  // `$storage` property is synthesized.
   if (decl->hasTypeWrapper())
     (void)decl->getTypeWrapperProperty();
 

lib/Sema/TypeCheckTypeWrapper.cpp

@@ -205,7 +205,7 @@ GetTypeWrapperProperty::evaluate(Evaluator &evaluator,
           ->castTo<AnyGenericType>();
   assert(typeWrapperType);
 
-  // $_storage: Wrapper<$Storage>
+  // $storage: Wrapper<$Storage>
   auto propertyTy = BoundGenericType::get(
       typeWrapper, /*Parent=*/typeWrapperType->getParent(),
       /*genericArgs=*/{storage->getInterfaceType()->getMetatypeInstanceType()});
@@ -240,7 +240,7 @@ VarDecl *GetTypeWrapperStorageForProperty::evaluate(Evaluator &evaluator,
 }
 
 /// Given the property create a subscript to reach its type wrapper storage:
-/// `$_storage[storageKeyPath: \$Storage.<property>]`.
+/// `$storage[storageKeyPath: \$Storage.<property>]`.
 static SubscriptExpr *subscriptTypeWrappedProperty(VarDecl *var,
                                                    AccessorDecl *useDC) {
   auto &ctx = useDC->getASTContext();
@@ -270,7 +270,7 @@ static SubscriptExpr *subscriptTypeWrappedProperty(VarDecl *var,
                             /*Loc=*/DeclNameLoc(), /*Implicit=*/true),
       typeWrapperVar->getName());
 
-  // $_storage[storageKeyPath: \$Storage.<property-name>]
+  // $storage[storageKeyPath: \$Storage.<property-name>]
   return SubscriptExpr::create(
       ctx, subscriptBaseExpr,
       ArgumentList::forImplicitSingle(ctx, ctx.Id_storageKeyPath, argExpr),
@@ -403,7 +403,7 @@ BraceStmt *SynthesizeTypeWrappedTypeMemberwiseInitializerBody::evaluate(
   auto &ctx = ctor->getASTContext();
   auto *parent = ctor->getDeclContext()->getSelfNominalTypeDecl();
 
-  // self.$_storage = .init(storage: $Storage(...))
+  // self.$storage = .init(storage: $Storage(...))
   auto *storageType = parent->getTypeWrapperStorageDecl();
   assert(storageType);
 

test/SILOptimizer/type_wrapper_definite_init_diagnostics.swift

@@ -43,7 +43,7 @@ do {
     }
   }
 
-  // FIXME: Diagnostics should mention `self.b` or `self.a` and not `self.$_storage`
+  // FIXME: Diagnostics should mention `self.b` or `self.a` and not `self.$storage`
 
   @Wrapper
   struct ImmutableTest3 {
@@ -57,7 +57,7 @@ do {
 
     init(a: Int = 42) {
       self.a = a
-      print(self.a) // expected-error {{'self' used before all stored properties are initialized}} expected-note {{'self.$_storage' not initialized}}
+      print(self.a) // expected-error {{'self' used before all stored properties are initialized}} expected-note {{'self.$storage' not initialized}}
       self.b = ""
     }
 
@@ -74,15 +74,15 @@ do {
       if let b = otherB {
         self.b = b
       }
-    } // expected-error {{return from initializer without initializing all stored properties}} expected-note {{'self.$_storage' not initialized}}
+    } // expected-error {{return from initializer without initializing all stored properties}} expected-note {{'self.$storage' not initialized}}
 
     init(optB: String? = nil) {
       if let optB {
         self.b = optB
-        print(self.b) // expected-error {{'self' used before all stored properties are initialized}} expected-note {{'self.$_storage' not initialized}}
+        print(self.b) // expected-error {{'self' used before all stored properties are initialized}} expected-note {{'self.$storage' not initialized}}
       } else {
         self.b = ""
-        print(self.b) // expected-error {{'self' used before all stored properties are initialized}} expected-note {{'self.$_storage' not initialized}}
+        print(self.b) // expected-error {{'self' used before all stored properties are initialized}} expected-note {{'self.$storage' not initialized}}
       }
 
       self.a = 0

test/SILOptimizer/type_wrapper_init_transform.swift

@@ -34,7 +34,7 @@ struct TrivialStruct {
   // CHECK: store [[STORAGE_INIT_RES]] to [trivial] [[STORAGE_INST]] : $*TrivialStruct.$Storage
   // CHECK: [[WRAPPER_INIT_REF:%.*]] = function_ref @$s4test7WrapperV7storageACyxGx_tcfC : $@convention(method) <τ_0_0> (@in τ_0_0, @thin Wrapper<τ_0_0>.Type) -> @out Wrapper<τ_0_0>
   // CHECK: [[SELF_ACCESS:%.*]] = begin_access [modify] [static] %1 : $*TrivialStruct
-  // CHECK: [[STORAGE_VAR_REF:%.*]] = struct_element_addr [[SELF_ACCESS]] : $*TrivialStruct, #TrivialStruct.$_storage
+  // CHECK: [[STORAGE_VAR_REF:%.*]] = struct_element_addr [[SELF_ACCESS]] : $*TrivialStruct, #TrivialStruct.$storage
   // CHECK: [[WRAPPER_METATYPE:%.*]] = metatype $@thin Wrapper<TrivialStruct.$Storage>.Type
   // CHECK: [[WRAPPER_INST:%.*]] = alloc_stack $Wrapper<TrivialStruct.$Storage>
   // CHECK: {{.*}} = apply [[WRAPPER_INIT_REF]]<TrivialStruct.$Storage>([[WRAPPER_INST]], [[STORAGE_INST]], [[WRAPPER_METATYPE]]) : $@convention(method) <τ_0_0> (@in τ_0_0, @thin Wrapper<τ_0_0>.Type) -> @out Wrapper<τ_0_0>
@@ -68,7 +68,7 @@ struct GenericStruct<T: Collection> {
   // CHECK: {{.*}} = apply [[STORAGE_INIT_REF]]<T>([[STORAGE_INST]], [[T_VAL]], [[STORAGE_METATYPE]]) : $@convention(method) <τ_0_0 where τ_0_0 : Collection> (@in τ_0_0, @thin GenericStruct<τ_0_0>.$Storage.Type) -> @out GenericStruct<τ_0_0>.$Storage
   // CHECK: [[WRAPPER_INIT_REF:%.*]] = function_ref @$s4test7WrapperV7storageACyxGx_tcfC : $@convention(method) <τ_0_0> (@in τ_0_0, @thin Wrapper<τ_0_0>.Type) -> @out Wrapper<τ_0_0>
   // CHECK: [[SELF_ACCESS:%.*]] = begin_access [modify] [static] [[SELF]] : $*GenericStruct<T>
-  // CHECK: [[STORAGE_VAR:%.*]] = struct_element_addr [[SELF_ACCESS]] : $*GenericStruct<T>, #GenericStruct.$_storage
+  // CHECK: [[STORAGE_VAR:%.*]] = struct_element_addr [[SELF_ACCESS]] : $*GenericStruct<T>, #GenericStruct.$storage
   // CHECK: [[WRAPPER_METATYPE:%.*]] = metatype $@thin Wrapper<GenericStruct<T>.$Storage>.Type
   // CHECK: [[WRAPPER_INST:%.*]] = alloc_stack $Wrapper<GenericStruct<T>.$Storage>
   // CHECK: {{.*}} = apply [[WRAPPER_INIT_REF]]<GenericStruct<T>.$Storage>([[WRAPPER_INST]], [[STORAGE_INST]], [[WRAPPER_METATYPE]]) : $@convention(method) <τ_0_0> (@in τ_0_0, @thin Wrapper<τ_0_0>.Type) -> @out Wrapper<τ_0_0>
@@ -90,7 +90,7 @@ class GenericClass<T: Collection> {
   // CHECK: [[TEST_PROP:%.*]] = tuple_element_addr [[LOCAL_STORAGE]] : $*(test: T), 0
   // CHECK: assign_by_wrapper origin type_wrapper, [[TEST_VAL:%.*]] : $*T to [initialization] [[TEST_PROP]] : $*T, set {{.*}}
   // CHECK: [[SELF_ACCESS:%.*]] = begin_borrow [[SELF:%.*]] : $GenericClass<T>
-  // CHECK-NEXT: [[STORAGE_VAR_REF:%.*]] = ref_element_addr [[SELF_ACCESS]] : $GenericClass<T>, #GenericClass.$_storage
+  // CHECK-NEXT: [[STORAGE_VAR_REF:%.*]] = ref_element_addr [[SELF_ACCESS]] : $GenericClass<T>, #GenericClass.$storage
   // CHECK: {{.*}} = apply [[WRAPPER_INIT_REF:%.*]]<GenericClass<T>.$Storage>([[WRAPPER_INST:%.*]], [[STORAGE_INST:%.*]], {{.*}}) : $@convention(method) <τ_0_0> (@in τ_0_0, @thin Wrapper<τ_0_0>.Type) -> @out Wrapper<τ_0_0>
   // CHECK: [[STORAGE_VAR_ACCESS:%.*]] = begin_access [modify] [dynamic] [[STORAGE_VAR_REF]] : $*Wrapper<GenericClass<T>.$Storage>
   // CHECK-NEXT: copy_addr [take] [[WRAPPER_INST]] to [initialization] [[STORAGE_VAR_ACCESS]] : $*Wrapper<GenericClass<T>.$Storage>
@@ -192,7 +192,7 @@ class TestConditionalInjection<T> {
   // CHECK: end_access [[LOCAL_STORAGE_ACCESS]] : $*(b: Optional<T>)
   // CHECK: {{.*}} = apply [[STORAGE_INIT_REF]]<T>([[STORAGE_INST:%.*]], [[B_VAL]], {{.*}}) : $@convention(method) <τ_0_0> (@in Optional<τ_0_0>, @thin TestConditionalInjection<τ_0_0>.$Storage.Type) -> @out TestConditionalInjection<τ_0_0>.$Storage
   // CHECK: [[SELF_ACCESS:%.*]] = begin_borrow [[SELF:%.*]] : $TestConditionalInjection<T>
-  // CHECK: [[STORAGE_PROP:%.*]] = ref_element_addr [[SELF_ACCESS]] : $TestConditionalInjection<T>, #TestConditionalInjection.$_storage
+  // CHECK: [[STORAGE_PROP:%.*]] = ref_element_addr [[SELF_ACCESS]] : $TestConditionalInjection<T>, #TestConditionalInjection.$storage
   // CHECK: [[WRAPPER_INST:%.*]] = alloc_stack $Wrapper<TestConditionalInjection<T>.$Storage>
   // CHECK: {{.*}} = apply [[WRAPPER_INIT_REF:%.*]]<TestConditionalInjection<T>.$Storage>([[WRAPPER_INST]], [[STORAGE_INST]], {{.*}}) : $@convention(method) <τ_0_0> (@in τ_0_0, @thin Wrapper<τ_0_0>.Type) -> @out Wrapper<τ_0_0>
   // CHECK: [[STORAGE_PROP_ACCESS:%.*]] = begin_access [modify] [dynamic] [[STORAGE_PROP]] : $*Wrapper<TestConditionalInjection<T>.$Storage>
@@ -213,7 +213,7 @@ class TestConditionalInjection<T> {
   // CHECK: end_access [[LOCAL_STORAGE_ACCESS]] : $*(b: Optional<T>)
   // CHECK: {{.*}} = apply [[STORAGE_INIT_REF]]<T>([[STORAGE_INST:%.*]], [[B_VAL]], {{.*}}) : $@convention(method) <τ_0_0> (@in Optional<τ_0_0>, @thin TestConditionalInjection<τ_0_0>.$Storage.Type) -> @out TestConditionalInjection<τ_0_0>.$Storage
   // CHECK: [[SELF_ACCESS:%.*]] = begin_borrow [[SELF:%.*]] : $TestConditionalInjection<T>
-  // CHECK: [[STORAGE_PROP:%.*]] = ref_element_addr [[SELF_ACCESS]] : $TestConditionalInjection<T>, #TestConditionalInjection.$_storage
+  // CHECK: [[STORAGE_PROP:%.*]] = ref_element_addr [[SELF_ACCESS]] : $TestConditionalInjection<T>, #TestConditionalInjection.$storage
   // CHECK: [[WRAPPER_INST:%.*]] = alloc_stack $Wrapper<TestConditionalInjection<T>.$Storage>
   // CHECK: {{.*}} = apply [[WRAPPER_INIT_REF:%.*]]<TestConditionalInjection<T>.$Storage>([[WRAPPER_INST]], [[STORAGE_INST]], {{.*}}) : $@convention(method) <τ_0_0> (@in τ_0_0, @thin Wrapper<τ_0_0>.Type) -> @out Wrapper<τ_0_0>
   // CHECK: [[STORAGE_PROP_ACCESS:%.*]] = begin_access [modify] [dynamic] [[STORAGE_PROP]] : $*Wrapper<TestConditionalInjection<T>.$Storage>
@@ -251,7 +251,7 @@ class TestConditionalInjection<T> {
   // CHECK: end_access [[LOCAL_STORAGE_ACCESS]] : $*(b: Optional<T>)
   // CHECK: {{.*}} = apply [[STORAGE_INIT_REF]]<T>([[STORAGE_INST:%.*]], [[B_VAL]], {{.*}}) : $@convention(method) <τ_0_0> (@in Optional<τ_0_0>, @thin TestConditionalInjection<τ_0_0>.$Storage.Type) -> @out TestConditionalInjection<τ_0_0>.$Storage
   // CHECK: [[SELF_ACCESS:%.*]] = begin_borrow [[SELF:%.*]] : $TestConditionalInjection<T>
-  // CHECK: [[STORAGE_PROP:%.*]] = ref_element_addr [[SELF_ACCESS]] : $TestConditionalInjection<T>, #TestConditionalInjection.$_storage
+  // CHECK: [[STORAGE_PROP:%.*]] = ref_element_addr [[SELF_ACCESS]] : $TestConditionalInjection<T>, #TestConditionalInjection.$storage
   // CHECK: [[WRAPPER_INST:%.*]] = alloc_stack $Wrapper<TestConditionalInjection<T>.$Storage>
   // CHECK: {{.*}} = apply [[WRAPPER_INIT_REF:%.*]]<TestConditionalInjection<T>.$Storage>([[WRAPPER_INST]], [[STORAGE_INST]], {{.*}}) : $@convention(method) <τ_0_0> (@in τ_0_0, @thin Wrapper<τ_0_0>.Type) -> @out Wrapper<τ_0_0>
   // CHECK: [[STORAGE_PROP_ACCESS:%.*]] = begin_access [modify] [dynamic] [[STORAGE_PROP]] : $*Wrapper<TestConditionalInjection<T>.$Storage>
@@ -272,7 +272,7 @@ class TestConditionalInjection<T> {
   // CHECK: end_access [[LOCAL_STORAGE_ACCESS]] : $*(b: Optional<T>)
   // CHECK: {{.*}} = apply [[STORAGE_INIT_REF]]<T>([[STORAGE_INST:%.*]], [[B_VAL]], {{.*}}) : $@convention(method) <τ_0_0> (@in Optional<τ_0_0>, @thin TestConditionalInjection<τ_0_0>.$Storage.Type) -> @out TestConditionalInjection<τ_0_0>.$Storage
   // CHECK: [[SELF_ACCESS:%.*]] = begin_borrow [[SELF:%.*]] : $TestConditionalInjection<T>
-  // CHECK: [[STORAGE_PROP:%.*]] = ref_element_addr [[SELF_ACCESS]] : $TestConditionalInjection<T>, #TestConditionalInjection.$_storage
+  // CHECK: [[STORAGE_PROP:%.*]] = ref_element_addr [[SELF_ACCESS]] : $TestConditionalInjection<T>, #TestConditionalInjection.$storage
   // CHECK: [[WRAPPER_INST:%.*]] = alloc_stack $Wrapper<TestConditionalInjection<T>.$Storage>
   // CHECK: {{.*}} = apply [[WRAPPER_INIT_REF:%.*]]<TestConditionalInjection<T>.$Storage>([[WRAPPER_INST]], [[STORAGE_INST]], {{.*}}) : $@convention(method) <τ_0_0> (@in τ_0_0, @thin Wrapper<τ_0_0>.Type) -> @out Wrapper<τ_0_0>
   // CHECK: [[STORAGE_PROP_ACCESS:%.*]] = begin_access [modify] [dynamic] [[STORAGE_PROP]] : $*Wrapper<TestConditionalInjection<T>.$Storage>
@@ -372,7 +372,7 @@ struct TypeWithLetProperties<T> {
       // CHECK-NEXT: {{.*}} = apply [[STORAGE_INIT_REF]]<T>([[STORAGE]], [[T]], [[B_VAL]], [[STORAGE_METATYPE]])
 
       // CHECK: [[WRAPPER_INIT_REF:%.*]] = function_ref @$s4test7WrapperV7storageACyxGx_tcfC
-      // CHECK: [[STORAGE_PROP:%.*]] = struct_element_addr [[SELF_ACCESS:%.*]] : $*TypeWithLetProperties<T>, #TypeWithLetProperties.$_storage
+      // CHECK: [[STORAGE_PROP:%.*]] = struct_element_addr [[SELF_ACCESS:%.*]] : $*TypeWithLetProperties<T>, #TypeWithLetProperties.$storage
       // CHECK: [[WRAPPER_INST:%.*]] = alloc_stack $Wrapper<TypeWithLetProperties<T>.$Storage>
       // CHECK-NEXT: {{.*}} = apply [[WRAPPER_INIT_REF]]<TypeWithLetProperties<T>.$Storage>([[WRAPPER_INST]], [[STORAGE]], [[WRAPPER_METATYPE:%.*]])
 
@@ -402,7 +402,7 @@ struct TypeWithLetProperties<T> {
       // CHECK-NEXT: {{.*}} = apply [[STORAGE_INIT_REF]]<T>([[STORAGE]], [[T]], [[B_VAL]], [[STORAGE_METATYPE]])
 
       // CHECK: [[WRAPPER_INIT_REF:%.*]] = function_ref @$s4test7WrapperV7storageACyxGx_tcfC
-      // CHECK: [[STORAGE_PROP:%.*]] = struct_element_addr [[SELF_ACCESS:%.*]] : $*TypeWithLetProperties<T>, #TypeWithLetProperties.$_storage
+      // CHECK: [[STORAGE_PROP:%.*]] = struct_element_addr [[SELF_ACCESS:%.*]] : $*TypeWithLetProperties<T>, #TypeWithLetProperties.$storage
       // CHECK: [[WRAPPER_INST:%.*]] = alloc_stack $Wrapper<TypeWithLetProperties<T>.$Storage>
       // CHECK-NEXT: {{.*}} = apply [[WRAPPER_INIT_REF]]<TypeWithLetProperties<T>.$Storage>([[WRAPPER_INST]], [[STORAGE]], [[WRAPPER_METATYPE:%.*]])