[AST] NFC: Add a way to request initialized/accesses properties from init accessor

(cherry picked from commit 28a39d6)

Author: xedin

include/swift/AST/Decl.h

@@ -7652,6 +7652,13 @@ class AccessorDecl final : public FuncDecl {
   /// for anything other than a getter or setter.
   void printUserFacingName(llvm::raw_ostream &out) const;
 
+  /// If this is an init accessor, retrieve a list of instance properties
+  /// initialized by it.
+  ArrayRef<VarDecl *> getInitializedProperties() const;
+  /// If this is an init accessor, retrieve a list of instance properties
+  /// accessed by it.
+  ArrayRef<VarDecl *> getAccessedProperties() const;
+
   static bool classof(const Decl *D) {
     return D->getKind() == DeclKind::Accessor;
   }

lib/AST/Decl.cpp

@@ -4939,11 +4939,8 @@ void NominalTypeDecl::collectPropertiesInitializableByInitAccessors(
     std::multimap<VarDecl *, VarDecl *> &result) const {
   for (auto *property : getInitAccessorProperties()) {
     auto *initAccessor = property->getAccessor(AccessorKind::Init);
-    if (auto *initAttr =
-            initAccessor->getAttrs().getAttribute<InitializesAttr>()) {
-      for (auto *subsumed : initAttr->getPropertyDecls(initAccessor))
-        result.insert({subsumed, property});
-    }
+    for (auto *subsumed : initAccessor->getInitializedProperties())
+      result.insert({subsumed, property});
   }
 }
 
@@ -6859,21 +6856,15 @@ bool VarDecl::isSettable(const DeclContext *UseDC,
   // designated initializer(s) or by init accessors.
   if (isInstanceMember()) {
     // Init accessors allow assignments to `let` properties if a
-    // property is part of `initializes(...)` list.
+    // property is part of `initializes` list.
     if (auto *accessor =
             dyn_cast<AccessorDecl>(const_cast<DeclContext *>(UseDC))) {
-      // Check whether this property is part of `initializes(...)` list,
+      // Check whether this property is part of `initializes` list,
       // and allow assignment/mutation if so. DI would be responsible
       // for checking for re-assignment.
-      if (auto *initAttr =
-              accessor->getAttrs().getAttribute<InitializesAttr>()) {
-        return llvm::is_contained(initAttr->getPropertyDecls(accessor),
-                                  const_cast<VarDecl *>(this));
-      }
-
-      // If there is no `initializes` attribute, no referenced properties
-      // can be assignment to or mutated.
-      return false;
+      return accessor->isInitAccessor() &&
+             llvm::is_contained(accessor->getInitializedProperties(),
+                                const_cast<VarDecl *>(this));
     }
 
     auto *CD = dyn_cast<ConstructorDecl>(UseDC);
@@ -9536,6 +9527,20 @@ void AccessorDecl::printUserFacingName(raw_ostream &out) const {
   out << ")";
 }
 
+ArrayRef<VarDecl *> AccessorDecl::getInitializedProperties() const {
+  assert(isInitAccessor());
+  if (auto *initAttr = getAttrs().getAttribute<InitializesAttr>())
+    return initAttr->getPropertyDecls(const_cast<AccessorDecl *>(this));
+  return {};
+}
+
+ArrayRef<VarDecl *> AccessorDecl::getAccessedProperties() const {
+  assert(isInitAccessor());
+  if (auto *accessAttr = getAttrs().getAttribute<AccessesAttr>())
+    return accessAttr->getPropertyDecls(const_cast<AccessorDecl *>(this));
+  return {};
+}
+
 StaticSpellingKind FuncDecl::getCorrectStaticSpelling() const {
   assert(getDeclContext()->isTypeContext());
   if (!isStatic())

lib/SIL/IR/SILFunctionType.cpp

@@ -2381,26 +2381,22 @@ static CanSILFunctionType getSILFunctionTypeForInitAccessor(
   // Drop `self` parameter.
   inputs.pop_back();
 
-  // `accesses(...)` appear as `inout` parameters because they could be
+  // accessed properties appear as `inout` parameters because they could be
   // read from and modified.
-  if (auto *attr = accessor->getAttrs().getAttribute<AccessesAttr>()) {
-    for (auto *property : attr->getPropertyDecls(accessor)) {
-      inputs.push_back(
-          SILParameterInfo(property->getInterfaceType()->getCanonicalType(),
-                           ParameterConvention::Indirect_Inout));
-    }
+  for (auto *property : accessor->getAccessedProperties()) {
+    inputs.push_back(
+        SILParameterInfo(property->getInterfaceType()->getCanonicalType(),
+                         ParameterConvention::Indirect_Inout));
   }
 
   SmallVector<SILResultInfo, 8> results;
 
-  // `initializes(...)` appear as `@out` result because they are initialized
-  // by the accessor.
-  if (auto *attr = accessor->getAttrs().getAttribute<InitializesAttr>()) {
-    for (auto *property : attr->getPropertyDecls(accessor)) {
-      results.push_back(
-          SILResultInfo(property->getInterfaceType()->getCanonicalType(),
-                        ResultConvention::Indirect));
-    }
+  // initialized properties appear as `@out` results because they are
+  // initialized by the accessor.
+  for (auto *property : accessor->getInitializedProperties()) {
+    results.push_back(
+        SILResultInfo(property->getInterfaceType()->getCanonicalType(),
+                      ResultConvention::Indirect));
   }
 
   auto calleeConvention = ParameterConvention::Direct_Unowned;

lib/SIL/IR/SILInstructions.cpp

@@ -1304,26 +1304,18 @@ AccessorDecl *AssignOrInitInst::getReferencedInitAccessor() const {
 }
 
 unsigned AssignOrInitInst::getNumInitializedProperties() const {
-  if (auto *accessor = getReferencedInitAccessor()) {
-    auto *initAttr = accessor->getAttrs().getAttribute<InitializesAttr>();
-    return initAttr ? initAttr->getNumProperties() : 0;
-  }
-  return 0;
+  return getInitializedProperties().size();
 }
 
 ArrayRef<VarDecl *> AssignOrInitInst::getInitializedProperties() const {
-  if (auto *accessor = getReferencedInitAccessor()) {
-    if (auto *initAttr = accessor->getAttrs().getAttribute<InitializesAttr>())
-      return initAttr->getPropertyDecls(accessor);
-  }
+  if (auto *accessor = getReferencedInitAccessor())
+    return accessor->getInitializedProperties();
   return {};
 }
 
 ArrayRef<VarDecl *> AssignOrInitInst::getAccessedProperties() const {
-  if (auto *accessor = getReferencedInitAccessor()) {
-    if (auto *accessAttr = accessor->getAttrs().getAttribute<AccessesAttr>())
-      return accessAttr->getPropertyDecls(accessor);
-  }
+  if (auto *accessor = getReferencedInitAccessor())
+    return accessor->getAccessedProperties();
   return {};
 }
 

lib/SILGen/SILGenConstructor.cpp

@@ -284,21 +284,17 @@ emitApplyOfInitAccessor(SILGenFunction &SGF, SILLocation loc,
   };
 
   // First, let's emit all of the indirect results.
-  if (auto *initAttr = accessor->getAttrs().getAttribute<InitializesAttr>()) {
-    for (auto *property : initAttr->getPropertyDecls(accessor)) {
-      arguments.push_back(emitFieldReference(property, /*forInit=*/true));
-    }
+  for (auto *property : accessor->getInitializedProperties()) {
+    arguments.push_back(emitFieldReference(property, /*forInit=*/true));
   }
 
   // `initialValue`
   std::move(initialValue).forwardAll(SGF, arguments);
 
-  // And finally, all of the properties in `accesses(...)` list which are
+  // And finally, all of the properties in `accesses` list which are
   // `inout` arguments.
-  if (auto *accessAttr = accessor->getAttrs().getAttribute<AccessesAttr>()) {
-    for (auto *property : accessAttr->getPropertyDecls(accessor)) {
-      arguments.push_back(emitFieldReference(property));
-    }
+  for (auto *property : accessor->getAccessedProperties()) {
+    arguments.push_back(emitFieldReference(property));
   }
 
   SubstitutionMap subs;
@@ -1603,39 +1599,33 @@ void SILGenFunction::emitInitAccessor(AccessorDecl *accessor) {
     InitAccessorArgumentMappings[property] = arg;
   };
 
-  // First, emit results, this is our "initializes(...)" properties and
+  // First, emit results, this is our "initializes" properties and
   // require DI to check that each property is fully initialized.
-  if (auto *initAttr = accessor->getAttrs().getAttribute<InitializesAttr>()) {
-    auto initializedProperties = initAttr->getPropertyDecls(accessor);
-    for (unsigned i = 0, n = initializedProperties.size(); i != n; ++i) {
-      auto *property = initializedProperties[i];
-      auto propertyTy =
-          getSILTypeInContext(accessorTy->getResults()[i], accessorTy);
-      createArgument(property, propertyTy, /*markUninitialized=*/true);
-    }
+  auto initializedProperties = accessor->getInitializedProperties();
+  for (unsigned i = 0, n = initializedProperties.size(); i != n; ++i) {
+    auto *property = initializedProperties[i];
+    auto propertyTy =
+        getSILTypeInContext(accessorTy->getResults()[i], accessorTy);
+    createArgument(property, propertyTy, /*markUninitialized=*/true);
   }
 
   // Collect all of the parameters that represent properties listed by
   // "accesses" attribute. They have to be emitted in order of arguments which
   // means after the "newValue" which is emitted by \c emitBasicProlog.
-  llvm::Optional<ArrayRef<VarDecl *>> accessedProperties;
-  {
-    if (auto *accessAttr = accessor->getAttrs().getAttribute<AccessesAttr>())
-      accessedProperties = accessAttr->getPropertyDecls(accessor);
-  }
+  auto accessedProperties = accessor->getAccessedProperties();
 
   // Emit `newValue` argument.
   emitBasicProlog(accessor->getParameters(), /*selfParam=*/nullptr,
                   TupleType::getEmpty(F.getASTContext()), accessor,
                   /*throws=*/false, /*throwsLoc=*/SourceLoc(),
                   /*ignored parameters*/
-                  accessedProperties ? accessedProperties->size() : 0);
+                  accessedProperties.size());
 
-  // Emit arguments for all `accesses(...)` properties.
-  if (accessedProperties) {
-    auto propertyIter = accessedProperties->begin();
+  // Emit arguments for all `accesses` properties.
+  if (!accessedProperties.empty()) {
+    auto propertyIter = accessedProperties.begin();
     auto propertyArgs = accessorTy->getParameters().slice(
-        accessorTy->getNumParameters() - accessedProperties->size());
+        accessorTy->getNumParameters() - accessedProperties.size());
 
     for (const auto &argument : propertyArgs) {
       createArgument(*propertyIter, getSILTypeInContext(argument, accessorTy));

lib/SILOptimizer/Mandatory/RawSILInstLowering.cpp

@@ -314,7 +314,7 @@ lowerAssignOrInitInstruction(SILBuilderWithScope &b,
 
       SmallVector<SILValue> arguments;
 
-      // First, emit all of the properties listed in `initializes(...)`. They
+      // First, emit all of the properties listed in `initializes`. They
       // are passed as indirect results.
       {
         auto toInitialize = inst->getInitializedProperties();
@@ -330,7 +330,7 @@ lowerAssignOrInitInstruction(SILBuilderWithScope &b,
       emitInitAccessorInitialValueArgument(arguments, src, convention, b,
                                            forCleanup);
 
-      // And finally, emit all of the `accesses(...)` properties.
+      // And finally, emit all of the `accesses` properties.
       for (auto *property : inst->getAccessedProperties())
         arguments.push_back(emitFieldReference(property));
 

lib/Sema/CSSimplify.cpp

@@ -9648,21 +9648,15 @@ performMemberLookup(ConstraintKind constraintKind, DeclNameRef memberName,
             // If name doesn't appear in either `initializes` or `accesses`
             // then it's invalid instance member.
 
-            if (auto *initializesAttr =
-                    accessor->getAttrs().getAttribute<InitializesAttr>()) {
-              isValidReference |= llvm::any_of(
-                  initializesAttr->getProperties(), [&](Identifier name) {
-                    return DeclNameRef(name) == memberName;
-                  });
-            }
-
-            if (auto *accessesAttr =
-                    accessor->getAttrs().getAttribute<AccessesAttr>()) {
-              isValidReference |= llvm::any_of(
-                  accessesAttr->getProperties(), [&](Identifier name) {
-                    return DeclNameRef(name) == memberName;
-                  });
-            }
+            isValidReference |= llvm::any_of(
+                accessor->getInitializedProperties(), [&](VarDecl *prop) {
+                  return prop->createNameRef() == memberName;
+                });
+
+            isValidReference |= llvm::any_of(
+                accessor->getAccessedProperties(), [&](VarDecl *prop) {
+                  return prop->createNameRef() == memberName;
+                });
 
             if (!isValidReference) {
               result.addUnviable(

lib/Sema/CodeSynthesis.cpp

@@ -1304,22 +1304,14 @@ HasMemberwiseInitRequest::evaluate(Evaluator &evaluator,
       if (auto *initAccessor = var->getAccessor(AccessorKind::Init)) {
         // Make sure that all properties accessed by init accessor
         // are previously initialized.
-        if (auto accessAttr =
-            initAccessor->getAttrs().getAttribute<AccessesAttr>()) {
-          for (auto *property : accessAttr->getPropertyDecls(initAccessor)) {
-            if (!initializedProperties.count(property))
-              invalidOrderings.push_back(
-                {var, property->getName()});
-          }
+        for (auto *property : initAccessor->getAccessedProperties()) {
+          if (!initializedProperties.count(property))
+            invalidOrderings.push_back({var, property->getName()});
         }
 
         // Record all of the properties initialized by calling init accessor.
-        if (auto initAttr =
-            initAccessor->getAttrs().getAttribute<InitializesAttr>()) {
-          auto properties = initAttr->getPropertyDecls(initAccessor);
-          initializedProperties.insert(properties.begin(), properties.end());
-        }
-
+        auto properties = initAccessor->getInitializedProperties();
+        initializedProperties.insert(properties.begin(), properties.end());
         continue;
       }
 

lib/Sema/TypeCheckStorage.cpp

@@ -368,9 +368,8 @@ MemberwiseInitPropertiesRequest::evaluate(Evaluator &evaluator,
     // that the accessor initializes. Mark those stored properties as being subsumed; we'll
     // get back to them later.
     if (auto initAccessor = var->getAccessor(AccessorKind::Init)) {
-      if (auto initAttr = initAccessor->getAttrs().getAttribute<InitializesAttr>()) {
-        for (auto subsumed : initAttr->getPropertyDecls(initAccessor))
-          subsumedViaInitAccessor.insert(subsumed);
+      for (auto subsumed : initAccessor->getInitializedProperties()) {
+        subsumedViaInitAccessor.insert(subsumed);
       }
     }
   };