Merge pull request swiftlang#27322 from DougGregor/property-wrapper-composition-di

[DI] Support definite initialization for composed property wrappers.

Author: DougGregor

docs/ABI/Mangling.rst

@@ -290,6 +290,7 @@ Entities
   entity-spec ::= type 'fu' INDEX            // implicit anonymous closure
   entity-spec ::= 'fA' INDEX                 // default argument N+1 generator
   entity-spec ::= 'fi'                       // non-local variable initializer
+  entity-spec ::= 'fP'                       // property wrapper backing initializer
   entity-spec ::= 'fD'                       // deallocating destructor; untyped
   entity-spec ::= 'fd'                       // non-deallocating destructor; untyped
   entity-spec ::= 'fE'                       // ivar destroyer; untyped

include/swift/AST/ASTMangler.h

@@ -124,6 +124,8 @@ class ASTMangler : public Mangler {
                                           SymbolKind SKind);
 
   std::string mangleInitializerEntity(const VarDecl *var, SymbolKind SKind);
+  std::string mangleBackingInitializerEntity(const VarDecl *var,
+                                             SymbolKind SKind);
 
   std::string mangleNominalType(const NominalTypeDecl *decl);
 
@@ -311,6 +313,7 @@ class ASTMangler : public Mangler {
   void appendDefaultArgumentEntity(const DeclContext *ctx, unsigned index);
 
   void appendInitializerEntity(const VarDecl *var);
+  void appendBackingInitializerEntity(const VarDecl *var);
 
   CanType getDeclTypeForMangling(const ValueDecl *decl,
                                  GenericSignature *&genericSig,

include/swift/AST/DiagnosticsSema.def

@@ -4528,8 +4528,6 @@ ERROR(property_wrapper_wrong_initial_value_init, none,
       (DeclName, Type, Type))
 ERROR(property_wrapper_failable_init, none,
       "%0 cannot be failable", (DeclName))
-ERROR(property_wrapper_ambiguous_initial_value_init, none,
-  "property wrapper type %0 has multiple initial-value initializers", (Type))
 ERROR(property_wrapper_ambiguous_default_value_init, none,
   "property wrapper type %0 has multiple default-value initializers", (Type))
 ERROR(property_wrapper_type_requirement_not_accessible,none,

include/swift/AST/PropertyWrappers.h

@@ -35,12 +35,13 @@ struct PropertyWrapperTypeInfo {
   /// directed.
   VarDecl *valueVar = nullptr;
 
-  /// The initializer init(wrappedValue:) that will be called when the
+  /// Whether there is an init(wrappedValue:) that will be called when the
   /// initializing the property wrapper type from a value of the property type.
-  ///
-  /// This initializer is optional, but if present will be used for the `=`
-  /// initialization syntax.
-  ConstructorDecl *wrappedValueInit = nullptr;
+  enum {
+    NoWrappedValueInit = 0,
+    HasWrappedValueInit,
+    HasInitialValueInit
+  } wrappedValueInit = NoWrappedValueInit;
 
   /// The initializer `init()` that will be called to default-initialize a
   /// value with an attached property wrapper.

include/swift/Demangling/DemangleNodes.def

@@ -157,6 +157,7 @@ NODE(PostfixOperator)
 NODE(PrefixOperator)
 NODE(PrivateDeclName)
 NODE(PropertyDescriptor)
+CONTEXT_NODE(PropertyWrapperBackingInitializer)
 CONTEXT_NODE(Protocol)
 CONTEXT_NODE(ProtocolSymbolicReference)
 NODE(ProtocolConformance)

include/swift/SIL/SILDeclRef.h

@@ -133,6 +133,10 @@ struct SILDeclRef {
     /// routines have an ivar destroyer, which is emitted as
     /// .cxx_destruct.
     IVarDestroyer,
+
+    /// References the wrapped value injection function used to initialize
+    /// the backing storage property from a wrapped value.
+    PropertyWrapperBackingInitializer,
   };
 
   /// The ValueDecl or AbstractClosureExpr represented by this SILDeclRef.

lib/AST/ASTMangler.cpp

@@ -155,6 +155,14 @@ std::string ASTMangler::mangleInitializerEntity(const VarDecl *var,
   return finalize();
 }
 
+std::string ASTMangler::mangleBackingInitializerEntity(const VarDecl *var,
+                                                       SymbolKind SKind) {
+  beginMangling();
+  appendBackingInitializerEntity(var);
+  appendSymbolKind(SKind);
+  return finalize();
+}
+
 std::string ASTMangler::mangleNominalType(const NominalTypeDecl *decl) {
   beginMangling();
   appendAnyGenericType(decl);
@@ -2334,6 +2342,11 @@ void ASTMangler::appendInitializerEntity(const VarDecl *var) {
   appendOperator("fi");
 }
 
+void ASTMangler::appendBackingInitializerEntity(const VarDecl *var) {
+  appendEntity(var, "vp", var->isStatic());
+  appendOperator("fP");
+}
+
 /// Is this declaration a method for mangling purposes? If so, we'll leave the
 /// Self type out of its mangling.
 static bool isMethodDecl(const Decl *decl) {

lib/AST/Decl.cpp

@@ -5482,7 +5482,8 @@ bool VarDecl::hasAttachedPropertyWrapper() const {
   return !getAttachedPropertyWrappers().empty();
 }
 
-/// Whether all of the attached property wrappers have an init(initialValue:) initializer.
+/// Whether all of the attached property wrappers have an init(wrappedValue:)
+/// initializer.
 bool VarDecl::allAttachedPropertyWrappersHaveInitialValueInit() const {
   for (unsigned i : indices(getAttachedPropertyWrappers())) {
     if (!getAttachedPropertyWrapperTypeInfo(i).wrappedValueInit)

lib/AST/TypeCheckRequests.cpp

@@ -564,11 +564,6 @@ void swift::simple_display(
     out << propertyWrapper.valueVar->printRef();
   else
     out << "null";
-  out << ", ";
-  if (propertyWrapper.wrappedValueInit)
-    out << propertyWrapper.wrappedValueInit->printRef();
-  else
-    out << "null";
   out << " }";
 }
 

lib/Demangling/Demangler.cpp

@@ -1577,6 +1577,7 @@ bool Demangle::nodeConsumesGenericArgs(Node *node) {
     case Node::Kind::ExplicitClosure:
     case Node::Kind::DefaultArgumentInitializer:
     case Node::Kind::Initializer:
+    case Node::Kind::PropertyWrapperBackingInitializer:
       return false;
     default:
       return true;
@@ -2934,6 +2935,10 @@ NodePointer Demangler::demangleFunctionEntity() {
     case 'u': Args = TypeAndIndex; Kind = Node::Kind::ImplicitClosure; break;
     case 'A': Args = Index; Kind = Node::Kind::DefaultArgumentInitializer; break;
     case 'p': return demangleEntity(Node::Kind::GenericTypeParamDecl);
+    case 'P':
+      Args = None;
+      Kind = Node::Kind::PropertyWrapperBackingInitializer;
+      break;
     default: return nullptr;
   }