Merge pull request #83886 from janbaig/temp-branch

[SILGen] Remove and replace ad-hoc `assign_by_wrapper` instruction

Author: xedin

SwiftCompilerSources/Sources/Optimizer/Utilities/AddressUtils.swift

@@ -125,7 +125,7 @@ extension AddressUseVisitor {
     case is SwitchEnumAddrInst, is CheckedCastAddrBranchInst,
          is SelectEnumAddrInst, is InjectEnumAddrInst,
          is StoreInst, is StoreUnownedInst, is StoreWeakInst,
-         is AssignInst, is AssignByWrapperInst, is AssignOrInitInst,
+         is AssignInst, is AssignOrInitInst,
          is TupleAddrConstructorInst, is InitBlockStorageHeaderInst,
          is RetainValueAddrInst, is ReleaseValueAddrInst,
          is DestroyAddrInst, is DeallocStackInst, 

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -347,8 +347,6 @@ final public class AssignInst : Instruction, StoringInstruction {
   }
 }
 
-final public class AssignByWrapperInst : Instruction, StoringInstruction {}
-
 final public class AssignOrInitInst : Instruction, StoringInstruction {}
 
 /// Instruction that copy or move from a source to destination address.

SwiftCompilerSources/Sources/SIL/Registration.swift

@@ -43,7 +43,6 @@ private func registerSILClasses() {
   register(StoreUnownedInst.self)
   register(StoreBorrowInst.self)
   register(AssignInst.self)
-  register(AssignByWrapperInst.self)
   register(AssignOrInitInst.self)
   register(CopyAddrInst.self)
   register(ExplicitCopyAddrInst.self)

docs/ABI/Mangling.rst

@@ -368,6 +368,7 @@ Entities
   entity-spec ::= entity 'fa'                // runtime discoverable attribute generator
   entity-spec ::= 'fi'                       // non-local variable initializer
   entity-spec ::= 'fP'                       // property wrapper backing initializer
+  entity-spec ::= 'fF'                       // property wrapped field init accessor
   entity-spec ::= 'fW'                       // property wrapper init from projected value
   entity-spec ::= 'fD'                       // deallocating destructor; untyped
   entity-spec ::= 'fZ'                       // isolated deallocating destructor; untyped

docs/SIL/Instructions.md

@@ -1064,43 +1064,49 @@ a sequence that also correctly destroys the current value.
 This instruction is only valid in Raw SIL and is rewritten as
 appropriate by the definitive initialization pass.
 
-### assign_by_wrapper
-
-```
-sil-instruction ::= 'assign_by_wrapper' sil-operand 'to' mode? sil-operand ',' 'init' sil-operand ',' 'set' sil-operand
-
-mode ::= '[init]' | '[assign]' | '[assign_wrapped_value]'
-
-assign_by_wrapper %0 : $S to %1 : $*T, init %2 : $F, set %3 : $G
-// $S can be a value or address type
-// $T must be the type of a property wrapper.
-// $F must be a function type, taking $S as a single argument (or multiple arguments in case of a tuple) and returning $T
-// $G must be a function type, taking $S as a single argument (or multiple arguments in case of a tuple) and without a return value
-```
-
-Similar to the [assign](#assign) instruction, but the assignment is done
-via a delegate.
-
-Initially the instruction is created with no mode. Once the mode is
-decided (by the definitive initialization pass), the instruction is
-lowered as follows:
-
-If the mode is `initialization`, the function `%2` is called with `%0`
-as argument. The result is stored to `%1`. In case of an address type,
-`%1` is simply passed as a first out-argument to `%2`.
-
-The `assign` mode works similar to `initialization`, except that the
-destination is "assigned" rather than "initialized". This means that
-the existing value in the destination is destroyed before the new value
-is stored.
-
-If the mode is `assign_wrapped_value`, the function `%3` is called with
-`%0` as argument. As `%3` is a setter (e.g. for the property in the
-containing nominal type), the destination address `%1` is not used in
-this case.
-
-This instruction is only valid in Raw SIL and is rewritten as
-appropriate by the definitive initialization pass.
+### assign_or_init 
+
+```
+sil-instruction ::= 'assign_or_init' mode? attached-property ',' self-or-local ',' sil-operand ',' 'value' ',' sil-operand ',' 'init' sil-operand ',' 'set' sil-operand
+
+mode ::= '[init]' | '[assign]'
+attached-property ::= '#' sil-decl-ref
+self-or-local ::= 'self' | 'local'
+
+// Nominal Context:
+assign_or_init #MyStruct.x, self %A, value %V, init %I, set %S
+// Local Context (only emitted with compiler synthesized thunks currently):   
+assign_or_init #x, local %L, value %V, init %I, set %S
+```
+
+Assigns or initializes a computed property with an attached init accessor. 
+This instruction is emitted during SILGen without an explicit mode. 
+The definitive initialization (DI) pass resolves the mode and rewrites
+the instruction accordingly:
+
+- `[init]`: In this mode, the init accessor `%I` is called with `%V` 
+as an argument. 
+- `[assign]`: In this mode, the setter function `%S` is called with `%V`
+as an argument.
+
+This instruction is only valid in Raw SIL and is rewritten as appropriate by
+the DI pass.
+
+Operand Roles:
+- `attached-property`: The property being written to. For nominal contexts, this 
+refers to a property with an attached init accessor (e.g. `#MyStruct.x`). For local 
+contexts, it refers to a local variable name (e.g. `#x`).
+- `self-or-local`: 
+  - `self %A`: Refers to the instance of the type that owns the property with the 
+  attached init accessor.
+  - `local %L`: Indicates the assignment is to a local variable (`%L`) rather than 
+  a property of a nominal type. While init accessors are not currently available to be 
+  used in local contexts in user-authored code, the compiler can synthesize an `assign_or_init`
+  in local contexts using an init accessor thunk in special cases.
+- `value %V`: The input value passed to either the `init` or `set` function, depending on 
+the selected DI mode.
+- `init %I`: A partially applied function implementing the property's init accessor.
+- `set %S`: A partially applied function implementing the property's setter.
 
 ### mark_uninitialized
 

include/swift/AST/ASTMangler.h

@@ -246,6 +246,8 @@ class ASTMangler : public Mangler {
   std::string mangleInitializerEntity(const VarDecl *var, SymbolKind SKind);
   std::string mangleBackingInitializerEntity(const VarDecl *var,
                                              SymbolKind SKind = SymbolKind::Default);
+  std::string manglePropertyWrappedFieldInitAccessorEntity(
+      const VarDecl *var, SymbolKind SKind = SymbolKind::Default);
   std::string mangleInitFromProjectedValueEntity(const VarDecl *var,
                                                  SymbolKind SKind = SymbolKind::Default);
 
@@ -722,6 +724,7 @@ class ASTMangler : public Mangler {
 
   void appendInitializerEntity(const VarDecl *var);
   void appendBackingInitializerEntity(const VarDecl *var);
+  void appendPropertyWrappedFieldInitAccessorEntity(const VarDecl *var);
   void appendInitFromProjectedValueEntity(const VarDecl *var);
 
   CanType getDeclTypeForMangling(const ValueDecl *decl,

include/swift/Demangling/DemangleNodes.def

@@ -213,6 +213,7 @@ NODE(PrefixOperator)
 NODE(PrivateDeclName)
 NODE(PropertyDescriptor)
 CONTEXT_NODE(PropertyWrapperBackingInitializer)
+CONTEXT_NODE(PropertyWrappedFieldInitAccessor)
 CONTEXT_NODE(PropertyWrapperInitFromProjectedValue)
 CONTEXT_NODE(Protocol)
 CONTEXT_NODE(ProtocolSymbolicReference)

include/swift/SIL/AddressWalker.h

@@ -214,8 +214,7 @@ TransitiveAddressWalker<Impl>::walk(SILValue projectedAddress) {
         isa<AssignInst>(user) || isa<LoadUnownedInst>(user) ||
         isa<StoreUnownedInst>(user) || isa<EndApplyInst>(user) ||
         isa<LoadWeakInst>(user) || isa<StoreWeakInst>(user) ||
-        isa<AssignByWrapperInst>(user) || isa<AssignOrInitInst>(user) ||
-        isa<BeginUnpairedAccessInst>(user) ||
+        isa<AssignOrInitInst>(user) || isa<BeginUnpairedAccessInst>(user) ||
         isa<EndUnpairedAccessInst>(user) || isa<WitnessMethodInst>(user) ||
         isa<SelectEnumAddrInst>(user) || isa<InjectEnumAddrInst>(user) ||
         isa<IsUniqueInst>(user) || isa<ValueMetatypeInst>(user) ||
@@ -229,7 +228,8 @@ TransitiveAddressWalker<Impl>::walk(SILValue projectedAddress) {
         isa<PackElementSetInst>(user) || isa<PackElementGetInst>(user) ||
         isa<DeinitExistentialAddrInst>(user) || isa<LoadBorrowInst>(user) ||
         isa<TupleAddrConstructorInst>(user) || isa<DeallocPackInst>(user) ||
-        isa<MergeIsolationRegionInst>(user) || isa<EndCOWMutationAddrInst>(user)) {
+        isa<MergeIsolationRegionInst>(user) ||
+        isa<EndCOWMutationAddrInst>(user)) {
       callVisitUse(op);
       continue;
     }

include/swift/SIL/InstructionUtils.h

@@ -158,10 +158,6 @@ bool isInstrumentation(SILInstruction *Instruction);
 /// argument of the partial apply if it is.
 SILValue isPartialApplyOfReabstractionThunk(PartialApplyInst *PAI);
 
-/// Returns true if \p PAI is only used by an assign_by_wrapper instruction as
-/// init or set function.
-bool onlyUsedByAssignByWrapper(PartialApplyInst *PAI);
-
 /// Returns true if \p PAI is only used by an \c assign_or_init
 /// instruction as init or set function.
 bool onlyUsedByAssignOrInit(PartialApplyInst *PAI);

include/swift/SIL/SILBuilder.h

@@ -972,25 +972,13 @@ class SILBuilder {
                                  Qualifier));
   }
 
-  AssignByWrapperInst *createAssignByWrapper(SILLocation Loc, SILValue Src,
-                                             SILValue Dest,
-                                             SILValue Initializer,
-                                             SILValue Setter,
-                                             AssignByWrapperInst::Mode mode) {
-    return insert(new (getModule()) AssignByWrapperInst(
-        getSILDebugLocation(Loc), Src, Dest, Initializer, Setter, mode));
-  }
-
-  AssignOrInitInst *createAssignOrInit(SILLocation Loc,
-                                       VarDecl *Property,
-                                       SILValue Self,
-                                       SILValue Src,
-                                       SILValue Initializer,
-                                       SILValue Setter,
+  AssignOrInitInst *createAssignOrInit(SILLocation Loc, VarDecl *Property,
+                                       SILValue SelfOrLocal, SILValue Src,
+                                       SILValue Initializer, SILValue Setter,
                                        AssignOrInitInst::Mode Mode) {
-    return insert(new (getModule())
-                      AssignOrInitInst(getSILDebugLocation(Loc), Property, Self,
-                                       Src, Initializer, Setter, Mode));
+    return insert(new (getModule()) AssignOrInitInst(
+        getSILDebugLocation(Loc), Property, SelfOrLocal, Src, Initializer,
+        Setter, Mode));
   }
 
   StoreBorrowInst *createStoreBorrow(SILLocation Loc, SILValue Src,