adding the @_compilerInitialized attribute

This attribute is designed for let-bound variables whose initializing
assignment is synthesized by the compiler. This assignment is
expected to happen at some point before DefiniteInitialization has
run, which is the pass that verifies whether the compiler truly
initialized the variable.

I generally expect that this will never be a user-facing feature, and
that the synthesized assignment happens in SILGen.

Author: kavon

include/swift/AST/Attr.def

@@ -265,6 +265,10 @@ SIMPLE_DECL_ATTR(objcMembers, ObjCMembers,
   OnClass |
   ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,
   34)
+CONTEXTUAL_SIMPLE_DECL_ATTR(_compilerInitialized, CompilerInitialized,
+  OnVar |
+  ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,
+  35)
 CONTEXTUAL_SIMPLE_DECL_ATTR(__consuming, Consuming,
   OnFunc | OnAccessor |
   DeclModifier |

include/swift/AST/DiagnosticsSIL.def

@@ -211,6 +211,8 @@ ERROR(return_from_init_without_initing_stored_properties,none,
       "return from initializer without initializing all"
       " stored properties", ())
 
+ERROR(explicit_store_of_compilerinitialized,none,
+      "illegal assignment to '@_compilerInitialized' storage", ())
 ERROR(variable_function_use_uninit,none,
       "%select{variable|constant}1 '%0' used by function definition before"
       " being initialized",

include/swift/AST/DiagnosticsSema.def

@@ -3203,6 +3203,17 @@ ERROR(escaping_non_function_parameter,none,
 ERROR(escaping_optional_type_argument, none,
       "closure is already escaping in optional type argument", ())
 
+// @_compilerInitialized attribute
+ERROR(incompatible_compilerinitialized_var,none,
+      "'@_compilerInitialized' attribute only applies to "
+      "let-bound stored properties without a default value", ())
+ERROR(protocol_compilerinitialized,none,
+      "'@_compilerInitialized' is not currently supported in protocols", ())
+ERROR(optional_compilerinitialized,none,
+      "'@_compilerInitialized' cannot be applied to an Optional let", ())
+ERROR(instancemember_compilerinitialized,none,
+      "'@_compilerInitialized' can only be applied to a non-static class or actor member", ())
+
 // @_nonEphemeral attribute
 ERROR(non_ephemeral_non_pointer_type,none,
       "@_nonEphemeral attribute only applies to pointer types", ())

lib/SILOptimizer/Mandatory/DIMemoryUseCollector.cpp

@@ -524,6 +524,10 @@ class ElementUseCollector {
   /// of this.
   bool InEnumSubElement = false;
 
+  /// If true, then encountered uses correspond to a VarDecl marked
+  /// as \p @_compilerInitialized
+  bool InCompilerInitializedField = false;
+
 public:
   ElementUseCollector(const DIMemoryObjectInfo &TheMemory,
                       DIElementUseInfo &UseInfo,
@@ -665,6 +669,16 @@ static SILValue getAccessedPointer(SILValue Pointer) {
   return Pointer;
 }
 
+static DIUseKind verifyCompilerInitialized(SILValue pointer,
+                                           SILInstruction *write,
+                                           DIUseKind origKind) {
+  // if the write is _not_ auto-generated, it's a bad store.
+  if (!write->getLoc().isAutoGenerated())
+    return DIUseKind::BadExplicitStore;
+
+  return origKind;
+}
+
 void ElementUseCollector::collectUses(SILValue Pointer, unsigned BaseEltNo) {
   assert(Pointer->getType().isAddress() &&
          "Walked through the pointer to the value?");
@@ -733,6 +747,11 @@ void ElementUseCollector::collectUses(SILValue Pointer, unsigned BaseEltNo) {
       else
         Kind = DIUseKind::Initialization;
 
+      // If it's a non-synthesized write to a @_compilerInitialized field,
+      // indicate that in the Kind.
+      if (LLVM_UNLIKELY(InCompilerInitializedField))
+        Kind = verifyCompilerInitialized(Pointer, User, Kind);
+
       addElementUses(BaseEltNo, PointeeType, User, Kind);
       continue;
     }
@@ -1403,9 +1422,15 @@ void ElementUseCollector::collectClassSelfUses(
       if (EltNumbering.count(REAI->getField()) != 0) {
         assert(EltNumbering.count(REAI->getField()) &&
                "ref_element_addr not a local field?");
+
+        // Remember whether the field is marked '@_compilerInitialized'
+        const bool hasCompInit =
+          REAI->getField()->getAttrs().hasAttribute<CompilerInitializedAttr>();
+        llvm::SaveAndRestore<bool> X1(InCompilerInitializedField, hasCompInit);
+
         // Recursively collect uses of the fields.  Note that fields of the class
         // could be tuples, so they may be tracked as independent elements.
-        llvm::SaveAndRestore<bool> X(IsSelfOfNonDelegatingInitializer, false);
+        llvm::SaveAndRestore<bool> X2(IsSelfOfNonDelegatingInitializer, false);
         collectUses(REAI, EltNumbering[REAI->getField()]);
         continue;
       }

lib/SILOptimizer/Mandatory/DIMemoryUseCollector.h

@@ -274,6 +274,10 @@ enum DIUseKind {
   /// The instruction is a store to a member of a larger struct value.
   PartialStore,
 
+  /// This instruction is an init, assignment, or store to a
+  /// @_compilerInitialized field that was _not_ automatically generated
+  BadExplicitStore,
+
   /// An 'inout' argument of a function application.
   InOutArgument,
 

lib/SILOptimizer/Mandatory/DefiniteInitialization.cpp

@@ -537,6 +537,7 @@ namespace {
     void diagnoseRefElementAddr(RefElementAddrInst *REI);
     bool diagnoseMethodCall(const DIMemoryUse &Use,
                             bool SuperInitDone);
+    void diagnoseBadExplicitStore(SILInstruction *Inst);
 
     bool isBlockIsReachableFromEntry(const SILBasicBlock *BB);
   };
@@ -574,6 +575,7 @@ LifetimeChecker::LifetimeChecker(const DIMemoryObjectInfo &TheMemory,
     case DIUseKind::InOutSelfArgument:
     case DIUseKind::PartialStore:
     case DIUseKind::SelfInit:
+    case DIUseKind::BadExplicitStore:
       break;
     }
 
@@ -777,6 +779,13 @@ void LifetimeChecker::diagnoseInitError(const DIMemoryUse &Use,
     diagnose(Module, TheMemory.getLoc(), diag::variable_defined_here, isLet);
 }
 
+void LifetimeChecker::diagnoseBadExplicitStore(SILInstruction *Inst) {
+  if (!shouldEmitError(Inst))
+    return;
+
+  diagnose(Module, Inst->getLoc(), diag::explicit_store_of_compilerinitialized);
+}
+
 /// Determines whether the given function is a constructor that belogs to a
 /// distributed actor declaration.
 static bool isDistributedActorCtor(SILFunction &F) {
@@ -1138,6 +1147,10 @@ void LifetimeChecker::doIt() {
     case DIUseKind::TypeOfSelf:
       handleTypeOfSelfUse(Use);
       break;
+
+    case DIUseKind::BadExplicitStore:
+      diagnoseBadExplicitStore(Inst);
+      break;
     }
   }
 

lib/Sema/TypeCheckAttr.cpp

@@ -316,6 +316,8 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
 
   void visitUnsafeInheritExecutorAttr(UnsafeInheritExecutorAttr *attr);
 
+  void visitCompilerInitializedAttr(CompilerInitializedAttr *attr);
+
   void checkBackDeployAttrs(ArrayRef<BackDeployAttr *> Attrs);
 
   void visitKnownToBeLocalAttr(KnownToBeLocalAttr *attr);
@@ -5959,6 +5961,48 @@ void AttributeChecker::visitUnsafeInheritExecutorAttr(
   }
 }
 
+void AttributeChecker::visitCompilerInitializedAttr(
+    CompilerInitializedAttr *attr) {
+  auto var = cast<VarDecl>(D);
+
+  // For now, ban its use within protocols. I could imagine supporting it
+  // by saying that witnesses must also be compiler-initialized, but I can't
+  // think of a use case for that right now.
+  if (auto ctx = var->getDeclContext()) {
+    if (isa<ProtocolDecl>(ctx) && var->isProtocolRequirement()) {
+      diagnose(attr->getLocation(), diag::protocol_compilerinitialized);
+      return;
+    }
+  }
+
+  // Must be a let-bound stored property without an initial value.
+  // The fact that it's let-bound generally simplifies the implementation
+  // of this attribute in definite initialization, since we don't need to
+  // reason about whether the compiler made the first assignment to the var,
+  // etc.
+  if (var->hasInitialValue()
+      || !var->isOrdinaryStoredProperty()
+      || !var->isLet()) {
+    diagnose(attr->getLocation(), diag::incompatible_compilerinitialized_var);
+    return;
+  }
+
+  // Because optionals are implicitly initialized to nil according to the
+  // language, this attribute doesn't make sense on optionals.
+  if (var->getType()->isOptional()) {
+    diagnose(attr->getLocation(), diag::optional_compilerinitialized);
+    return;
+  }
+
+  // To keep things even more simple in definite initialization, restrict
+  // the attribute to class/actor instance members only. This means we can
+  // focus just on the initialization in the init.
+  if (!(var->getDeclContext()->getSelfClassDecl() && var->isInstanceMember())) {
+    diagnose(attr->getLocation(), diag::instancemember_compilerinitialized);
+    return;
+  }
+}
+
 namespace {
 
 class ClosureAttributeChecker

lib/Sema/TypeCheckDeclOverride.cpp

@@ -1576,6 +1576,7 @@ namespace  {
     UNINTERESTING_ATTR(KnownToBeLocal)
 
     UNINTERESTING_ATTR(UnsafeInheritExecutor)
+    UNINTERESTING_ATTR(CompilerInitialized)
 
 #undef UNINTERESTING_ATTR
 

lib/Serialization/ModuleFormat.h

@@ -56,7 +56,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 680; // Ignore export_as in XRef
+const uint16_t SWIFTMODULE_VERSION_MINOR = 681; // Add @_compilerInitialized attr
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///

test/SILOptimizer/definite_init.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend -emit-sil %s -o /dev/null
+// RUN: %target-swift-frontend -emit-sil -verify %s -o /dev/null
 
 class SomeClass {}
 
@@ -53,3 +53,10 @@ func tuple_test() -> Int {
 
   return t.1+t.0  // No diagnostic, everything is fully initialized.
 }
+
+class CheckCompilerInitAttr {
+  @_compilerInitialized let poster: Int
+  init() {
+    poster = 10 // expected-error {{illegal assignment to '@_compilerInitialized' storage}}
+  }
+}