Merge pull request #67183 from xedin/convert-effects-into-storageRestrictions

[AST/Sema] Implement @storageRestrictions attribute

Author: xedin

include/swift/AST/Attr.h

@@ -1617,6 +1617,48 @@ class AccessesAttr final
   }
 };
 
+class StorageRestrictionsAttr final
+    : public DeclAttribute,
+      private llvm::TrailingObjects<StorageRestrictionsAttr, Identifier> {
+  friend TrailingObjects;
+
+  size_t NumInitializes;
+  size_t NumAccesses;
+
+  size_t numTrailingObjects(OverloadToken<Identifier>) const {
+    return NumInitializes + NumAccesses;
+  }
+
+public:
+  StorageRestrictionsAttr(SourceLoc AtLoc, SourceRange Range,
+                          ArrayRef<Identifier> initializes,
+                          ArrayRef<Identifier> accesses, bool Implicit);
+
+  unsigned getNumInitializesProperties() const { return NumInitializes; }
+
+  unsigned getNumAccessesProperties() const { return NumAccesses; }
+
+  ArrayRef<Identifier> getInitializesNames() const {
+    return {getTrailingObjects<Identifier>(), NumInitializes};
+  }
+
+  ArrayRef<Identifier> getAccessesNames() const {
+    return {getTrailingObjects<Identifier>() + NumInitializes, NumAccesses};
+  }
+
+  ArrayRef<VarDecl *> getInitializesProperties(AccessorDecl *attachedTo) const;
+  ArrayRef<VarDecl *> getAccessesProperties(AccessorDecl *attachedTo) const;
+
+  static StorageRestrictionsAttr *create(ASTContext &ctx, SourceLoc atLoc,
+                                         SourceRange range,
+                                         ArrayRef<Identifier> initializes,
+                                         ArrayRef<Identifier> accesses);
+
+  static bool classof(const DeclAttribute *DA) {
+    return DA->getKind() == DAK_StorageRestrictions;
+  }
+};
+
 /// The @_implements attribute, which treats a decl as the implementation for
 /// some named protocol requirement (but otherwise not-visible by that name).
 class ImplementsAttr : public DeclAttribute {

include/swift/AST/Decl.h

@@ -7650,6 +7650,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;
   }

include/swift/AST/DiagnosticsParse.def

@@ -2128,5 +2128,17 @@ ERROR(init_accessor_is_not_on_property,none,
       "init accessors could only be associated with properties",
       ())
 
+ERROR(missing_storage_restrictions_attr_label,none,
+      "missing label in @storageRestrictions attribute", ())
+
+ERROR(invalid_storage_restrictions_attr_label,none,
+      "unexpected label %0 in @storageRestrictions attribute", (Identifier))
+
+ERROR(duplicate_storage_restrictions_attr_label,none,
+      "duplicate label %0 in @storageRestrictions attribute", (Identifier))
+
+ERROR(storage_restrictions_attr_expected_name,none,
+      "expected property name in @storageRestrictions list", ())
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/DiagnosticsSema.def

@@ -7457,6 +7457,9 @@ ERROR(init_accessor_initializes_attribute_on_other_declaration,none,
 ERROR(init_accessor_accesses_attribute_on_other_declaration,none,
       "accesses(...) attribute could only be used with init accessors",
       ())
+ERROR(storage_restrictions_attribute_not_on_init_accessor,none,
+      "@storageRestrictions attribute could only be used with init accessors",
+      ())
 ERROR(init_accessor_property_both_init_and_accessed,none,
       "property %0 cannot be both initialized and accessed",
       (DeclName))

include/swift/Parse/Parser.h

@@ -1073,6 +1073,11 @@ class Parser {
       llvm::function_ref<bool(Parser &)> parseSILTargetName,
       llvm::function_ref<bool(Parser &)> parseSILSIPModule);
 
+  /// Parse the @storageRestrictions(initializes:accesses:) attribute.
+  /// \p Attr is where to store the parsed attribute
+  ParserResult<StorageRestrictionsAttr>
+  parseStorageRestrictionsAttribute(SourceLoc AtLoc, SourceLoc Loc);
+
   /// Parse the @_implements attribute.
   /// \p Attr is where to store the parsed attribute
   ParserResult<ImplementsAttr> parseImplementsAttribute(SourceLoc AtLoc,

lib/AST/Attr.cpp

@@ -1600,6 +1600,8 @@ StringRef DeclAttribute::getAttrName() const {
     return "initializes";
   case DAK_Accesses:
     return "accesses";
+  case DAK_StorageRestrictions:
+    return "storageRestrictions";
   case DAK_Implements:
     return "_implements";
   case DAK_ClangImporterSynthesizedType:
@@ -2405,6 +2407,29 @@ AccessesAttr::create(ASTContext &ctx, SourceLoc atLoc, SourceRange range,
   return new (mem) AccessesAttr(atLoc, range, properties);
 }
 
+StorageRestrictionsAttr::StorageRestrictionsAttr(
+    SourceLoc AtLoc, SourceRange Range, ArrayRef<Identifier> initializes,
+    ArrayRef<Identifier> accesses, bool Implicit)
+    : DeclAttribute(DAK_StorageRestrictions, AtLoc, Range, Implicit),
+      NumInitializes(initializes.size()),
+      NumAccesses(accesses.size()) {
+  std::uninitialized_copy(initializes.begin(), initializes.end(),
+                          getTrailingObjects<Identifier>());
+  std::uninitialized_copy(accesses.begin(), accesses.end(),
+                          getTrailingObjects<Identifier>() + NumInitializes);
+}
+
+StorageRestrictionsAttr *
+StorageRestrictionsAttr::create(
+    ASTContext &ctx, SourceLoc atLoc, SourceRange range,
+    ArrayRef<Identifier> initializes, ArrayRef<Identifier> accesses) {
+  unsigned size =
+      totalSizeToAlloc<Identifier>(initializes.size() + accesses.size());
+  void *mem = ctx.Allocate(size, alignof(StorageRestrictionsAttr));
+  return new (mem) StorageRestrictionsAttr(atLoc, range, initializes, accesses,
+                                           /*implicit=*/false);
+}
+
 ImplementsAttr::ImplementsAttr(SourceLoc atLoc, SourceRange range,
                                TypeRepr *TyR,
                                DeclName MemberName,
@@ -2583,6 +2608,26 @@ AccessesAttr::getPropertyDecls(AccessorDecl *attachedTo) const {
       {});
 }
 
+ArrayRef<VarDecl *> StorageRestrictionsAttr::getInitializesProperties(
+    AccessorDecl *attachedTo) const {
+  auto &ctx = attachedTo->getASTContext();
+  return evaluateOrDefault(ctx.evaluator,
+                           InitAccessorReferencedVariablesRequest{
+                               const_cast<StorageRestrictionsAttr *>(this),
+                               attachedTo, getInitializesNames()},
+                           {});
+}
+
+ArrayRef<VarDecl *>
+StorageRestrictionsAttr::getAccessesProperties(AccessorDecl *attachedTo) const {
+  auto &ctx = attachedTo->getASTContext();
+  return evaluateOrDefault(ctx.evaluator,
+                           InitAccessorReferencedVariablesRequest{
+                               const_cast<StorageRestrictionsAttr *>(this),
+                               attachedTo, getAccessesNames()},
+                           {});
+}
+
 void swift::simple_display(llvm::raw_ostream &out, const DeclAttribute *attr) {
   if (attr)
     attr->print(out);

lib/AST/Decl.cpp

@@ -4948,11 +4948,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});
   }
 }
 
@@ -6868,21 +6865,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);
@@ -9548,6 +9539,32 @@ void AccessorDecl::printUserFacingName(raw_ostream &out) const {
   out << ")";
 }
 
+ArrayRef<VarDecl *> AccessorDecl::getInitializedProperties() const {
+  assert(isInitAccessor());
+
+  if (auto *SR = getAttrs().getAttribute<StorageRestrictionsAttr>())
+    return SR->getInitializesProperties(const_cast<AccessorDecl *>(this));
+
+  // Fallback to old effect style declaration.
+  if (auto *initAttr = getAttrs().getAttribute<InitializesAttr>())
+    return initAttr->getPropertyDecls(const_cast<AccessorDecl *>(this));
+
+  return {};
+}
+
+ArrayRef<VarDecl *> AccessorDecl::getAccessedProperties() const {
+  assert(isInitAccessor());
+
+  if (auto *SR = getAttrs().getAttribute<StorageRestrictionsAttr>())
+    return SR->getAccessesProperties(const_cast<AccessorDecl *>(this));
+
+  // Fallback to old effect style declaration.
+  if (auto *accessAttr = getAttrs().getAttribute<AccessesAttr>())
+    return accessAttr->getPropertyDecls(const_cast<AccessorDecl *>(this));
+
+  return {};
+}
+
 StaticSpellingKind FuncDecl::getCorrectStaticSpelling() const {
   assert(getDeclContext()->isTypeContext());
   if (!isStatic())

lib/Macros/Sources/ObservationMacros/ObservableMacro.swift

@@ -312,7 +312,8 @@ public struct ObservationTrackedMacro: AccessorMacro {
 
     let initAccessor: AccessorDeclSyntax =
       """
-      init(initialValue) initializes(_\(identifier)) {
+      @storageRestrictions(initializes: _\(identifier))
+      init(initialValue) {
         _\(identifier) = initialValue
       }
       """

lib/Parse/ParseDecl.cpp

@@ -1165,6 +1165,111 @@ bool Parser::parseSpecializeAttribute(
   return true;
 }
 
+ParserResult<StorageRestrictionsAttr>
+Parser::parseStorageRestrictionsAttribute(SourceLoc AtLoc, SourceLoc Loc) {
+  StringRef AttrName = "storageRestrictions";
+  ParserStatus Status;
+
+  if (Tok.isNot(tok::l_paren)) {
+    diagnose(Loc, diag::attr_expected_lparen, AttrName,
+             /*DeclModifier=*/false);
+    Status.setIsParseError();
+    return Status;
+  }
+
+  // Consume '('
+  SourceLoc lParenLoc = consumeToken();
+
+  SmallVector<Identifier> initializesProperties;
+  SmallVector<Identifier> accessesProperties;
+
+  auto parseProperties = [&](SourceLoc loc, Identifier label,
+                             SmallVectorImpl<Identifier> &properties) {
+    if (!properties.empty()) {
+      diagnose(loc, diag::duplicate_storage_restrictions_attr_label, label);
+      return true;
+    }
+
+    bool hasNextProperty = false;
+    do {
+      // Next is not a property name but a label followed by ':'
+      if (peekToken().is(tok::colon))
+        break;
+
+      Identifier propertyName;
+      SourceLoc propertyNameLoc;
+      if (parseIdentifier(propertyName, propertyNameLoc,
+                          diag::storage_restrictions_attr_expected_name,
+                          /*diagnoseDollarPrefix=*/true)) {
+        return true;
+      }
+
+      properties.push_back(propertyName);
+
+      // Parse the comma, if the list continues.
+      hasNextProperty = consumeIf(tok::comma);
+    } while (hasNextProperty);
+
+    return false;
+  };
+
+  auto parseArgument = [&](bool isOptional = false) -> bool {
+    if (Tok.is(tok::r_paren) && isOptional)
+      return false;
+
+    Identifier accessLabel;
+    SourceLoc loc;
+    parseOptionalArgumentLabel(accessLabel, loc);
+
+    if (accessLabel.empty()) {
+      diagnose(Loc, diag::missing_storage_restrictions_attr_label);
+      return true;
+    }
+
+    enum class AccessKind { Initialization, Access, Invalid };
+
+    auto access = llvm::StringSwitch<AccessKind>(accessLabel.str())
+                      .Case("initializes", AccessKind::Initialization)
+                      .Case("accesses", AccessKind::Access)
+                      .Default(AccessKind::Invalid);
+
+    switch (access) {
+    case AccessKind::Initialization:
+      return parseProperties(loc, accessLabel, initializesProperties);
+
+    case AccessKind::Access:
+      return parseProperties(loc, accessLabel, accessesProperties);
+
+    case AccessKind::Invalid:
+      diagnose(loc, diag::invalid_storage_restrictions_attr_label, accessLabel);
+      return true;
+    }
+  };
+
+  // Attribute should have at least one argument.
+  if (parseArgument() || parseArgument(/*isOptional=*/true)) {
+    Status.setIsParseError();
+    // Let's skip ahead to `)` to recover.
+    skipUntil(tok::r_paren);
+  }
+
+  // Consume ')'
+  SourceLoc rParenLoc;
+  if (!consumeIf(tok::r_paren, rParenLoc)) {
+    diagnose(lParenLoc, diag::attr_expected_rparen, AttrName,
+             /*DeclModifier=*/false);
+    Status.setIsParseError();
+  }
+
+  if (Status.isErrorOrHasCompletion()) {
+    return Status;
+  }
+
+  return ParserResult<StorageRestrictionsAttr>(StorageRestrictionsAttr::create(
+      Context, AtLoc, SourceRange(Loc, rParenLoc), initializesProperties,
+      accessesProperties));
+}
+
 ParserResult<ImplementsAttr>
 Parser::parseImplementsAttribute(SourceLoc AtLoc, SourceLoc Loc) {
   StringRef AttrName = "_implements";
@@ -3424,6 +3529,15 @@ ParserStatus Parser::parseNewDeclAttribute(DeclAttributes &Attributes,
     llvm_unreachable("AccessesAttr not yet implemented");
   }
 
+  case DAK_StorageRestrictions: {
+    ParserResult<StorageRestrictionsAttr> Attr =
+        parseStorageRestrictionsAttribute(AtLoc, Loc);
+    if (Attr.isNonNull()) {
+      Attributes.add(Attr.get());
+    }
+    break;
+  }
+
   case DAK_Implements: {
     ParserResult<ImplementsAttr> Attr = parseImplementsAttribute(AtLoc, Loc);
     if (Attr.isNonNull()) {