Merge pull request swiftlang#80159 from AnthonyLatsis/danaus-plexippus-5

Sema: Extend adoption mode for `AsyncCallerExecution` to storage declarations

Author: AnthonyLatsis

include/swift/AST/Decl.h

@@ -3197,6 +3197,11 @@ class ValueDecl : public Decl {
   /// Is this declaration marked with 'dynamic'?
   bool isDynamic() const;
 
+  /// Returns whether accesses to this declaration are asynchronous.
+  /// If the declaration is neither `AbstractFunctionDecl` nor
+  /// `AbstractStorageDecl`, returns `false`.
+  bool isAsync() const;
+
 private:
   bool isObjCDynamic() const {
     return isObjC() && isDynamic();
@@ -3320,6 +3325,14 @@ class ValueDecl : public Decl {
   /// parameter lists, for example an enum element without associated values.
   bool hasParameterList() const;
 
+  /// Returns the parameter list directly associated with this declaration,
+  /// or `nullptr` if there is none.
+  ///
+  /// Note that some declarations with function interface types do not have
+  /// parameter lists. For example, an enum element without associated values.
+  ParameterList *getParameterList();
+  const ParameterList *getParameterList() const;
+
   /// Returns the number of curry levels in the declaration's interface type.
   unsigned getNumCurryLevels() const;
 
@@ -9733,14 +9746,6 @@ inline bool ValueDecl::hasCurriedSelf() const {
   return false;
 }
 
-inline bool ValueDecl::hasParameterList() const {
-  if (auto *eed = dyn_cast<EnumElementDecl>(this))
-    return eed->hasAssociatedValues();
-  if (auto *macro = dyn_cast<MacroDecl>(this))
-    return macro->parameterList != nullptr;
-  return isa<AbstractFunctionDecl>(this) || isa<SubscriptDecl>(this);
-}
-
 inline unsigned ValueDecl::getNumCurryLevels() const {
   unsigned curryLevels = 0;
   if (hasParameterList())
@@ -9828,10 +9833,6 @@ inline EnumElementDecl *EnumDecl::getUniqueElement(bool hasValue) const {
   return result;
 }
 
-/// Retrieve the parameter list for a given declaration, or nullptr if there
-/// is none.
-ParameterList *getParameterList(ValueDecl *source);
-
 /// Retrieve the parameter list for a given declaration context, or nullptr if
 /// there is none.
 ParameterList *getParameterList(DeclContext *source);

include/swift/AST/DeclAttr.def

@@ -862,7 +862,7 @@ DECL_ATTR(abi, ABI,
 DECL_ATTR_FEATURE_REQUIREMENT(ABI, ABIAttribute)
 
 DECL_ATTR(execution, Execution,
-  OnAbstractFunction,
+  OnFunc | OnConstructor | OnSubscript | OnVar,
   ABIBreakingToAdd | ABIBreakingToRemove | APIBreakingToAdd | APIBreakingToRemove,
   166)
 DECL_ATTR_FEATURE_REQUIREMENT(Execution, ExecutionAttribute)

lib/AST/ASTMangler.cpp

@@ -1139,7 +1139,7 @@ static unsigned getUnnamedParamIndex(const ParamDecl *D) {
   if (isa<AbstractClosureExpr>(DC)) {
     ParamList = cast<AbstractClosureExpr>(DC)->getParameters();
   } else {
-    ParamList = getParameterList(cast<ValueDecl>(DC->getAsDecl()));
+    ParamList = cast<ValueDecl>(DC->getAsDecl())->getParameterList();
   }
 
   unsigned UnnamedIndex = 0;

lib/AST/Decl.cpp

@@ -1337,8 +1337,7 @@ bool Decl::hasUnderscoredNaming() const {
   // underscore, it's a private function or subscript.
   if (isa<AbstractFunctionDecl>(D) || isa<SubscriptDecl>(D)) {
     const auto VD = cast<ValueDecl>(D);
-    if (getParameterList(const_cast<ValueDecl *>(VD))
-            ->hasInternalParameter("_")) {
+    if (VD->getParameterList()->hasInternalParameter("_")) {
       return true;
     }
   }
@@ -4117,6 +4116,26 @@ ValueDecl::getCachedOpaqueResultTypeDecl() const {
       .getCachedResult();
 }
 
+ParameterList *ValueDecl::getParameterList() {
+  if (auto *function = dyn_cast<AbstractFunctionDecl>(this)) {
+    return function->getParameters();
+  } else if (auto *enumElement = dyn_cast<EnumElementDecl>(this)) {
+    return enumElement->getParameterList();
+  } else if (auto *subscript = dyn_cast<SubscriptDecl>(this)) {
+    return subscript->getIndices();
+  } else if (auto *macro = dyn_cast<MacroDecl>(this)) {
+    return macro->parameterList;
+  }
+
+  return nullptr;
+}
+
+const ParameterList *ValueDecl::getParameterList() const {
+  return const_cast<ValueDecl *>(this)->getParameterList();
+}
+
+bool ValueDecl::hasParameterList() const { return (bool)getParameterList(); }
+
 bool ValueDecl::isObjC() const {
   ASTContext &ctx = getASTContext();
   return evaluateOrDefault(ctx.evaluator,
@@ -4182,6 +4201,24 @@ bool ValueDecl::isDynamic() const {
     getAttrs().hasAttribute<DynamicAttr>());
 }
 
+bool ValueDecl::isAsync() const {
+  if (auto *function = dyn_cast<AbstractFunctionDecl>(this)) {
+    return function->hasAsync();
+  }
+
+  // Async storage declarations must be get-only. Don't consider it async
+  // otherwise, even if it has an async getter.
+  if (auto *storage = dyn_cast<AbstractStorageDecl>(this)) {
+    if (storage->getAllAccessors().size() == 1) {
+      if (auto *getter = storage->getAccessor(AccessorKind::Get)) {
+        return getter->hasAsync();
+      }
+    }
+  }
+
+  return false;
+}
+
 bool ValueDecl::isObjCDynamicInGenericClass() const {
   if (!isObjCDynamic())
     return false;
@@ -9599,24 +9636,10 @@ DeclName AbstractFunctionDecl::getEffectiveFullName() const {
   return DeclName();
 }
 
-ParameterList *swift::getParameterList(ValueDecl *source) {
-  if (auto *AFD = dyn_cast<AbstractFunctionDecl>(source)) {
-    return AFD->getParameters();
-  } else if (auto *EED = dyn_cast<EnumElementDecl>(source)) {
-    return EED->getParameterList();
-  } else if (auto *SD = dyn_cast<SubscriptDecl>(source)) {
-    return SD->getIndices();
-  } else if (auto *MD = dyn_cast<MacroDecl>(source)) {
-    return MD->parameterList;
-  }
-
-  return nullptr;
-}
-
 ParameterList *swift::getParameterList(DeclContext *source) {
   if (auto *D = source->getAsDecl()) {
     if (auto *VD = dyn_cast<ValueDecl>(D)) {
-      return getParameterList(VD);
+      return VD->getParameterList();
     }
   } else if (auto *CE = dyn_cast<AbstractClosureExpr>(source)) {
     return CE->getParameters();
@@ -9628,7 +9651,7 @@ ParameterList *swift::getParameterList(DeclContext *source) {
 const ParamDecl *swift::getParameterAt(ConcreteDeclRef declRef,
                                        unsigned index) {
   auto *source = declRef.getDecl();
-  if (auto *params = getParameterList(const_cast<ValueDecl *>(source))) {
+  if (auto *params = source->getParameterList()) {
     unsigned origIndex = params->getOrigParamIndex(declRef.getSubstitutions(),
                                                    index);
     return params->get(origIndex);
@@ -9638,7 +9661,7 @@ const ParamDecl *swift::getParameterAt(ConcreteDeclRef declRef,
 
 const ParamDecl *swift::getParameterAt(const ValueDecl *source,
                                        unsigned index) {
-  if (auto *params = getParameterList(const_cast<ValueDecl *>(source))) {
+  if (auto *params = source->getParameterList()) {
     return index < params->size() ? params->get(index) : nullptr;
   }
   return nullptr;

lib/AST/DeclContext.cpp

@@ -501,7 +501,7 @@ swift::FragileFunctionKindRequest::evaluate(Evaluator &evaluator,
       dc = dc->getParent();
 
       auto *VD = cast<ValueDecl>(dc->getAsDecl());
-      assert(VD->hasParameterList());
+      ASSERT(VD->hasParameterList());
 
       if (VD->getDeclContext()->isLocalContext()) {
         auto kind = VD->getDeclContext()->getFragileFunctionKind();
@@ -1615,15 +1615,10 @@ bool DeclContext::isAsyncContext() const {
     return getParent()->isAsyncContext();
   case DeclContextKind::AbstractClosureExpr:
     return cast<AbstractClosureExpr>(this)->isBodyAsync();
-  case DeclContextKind::AbstractFunctionDecl: {
-    const AbstractFunctionDecl *function = cast<AbstractFunctionDecl>(this);
-    return function->hasAsync();
-  }
-  case DeclContextKind::SubscriptDecl: {
-    AccessorDecl *getter =
-        cast<SubscriptDecl>(this)->getAccessor(AccessorKind::Get);
-    return getter != nullptr && getter->hasAsync();
-  }
+  case DeclContextKind::AbstractFunctionDecl:
+    return cast<AbstractFunctionDecl>(this)->hasAsync();
+  case DeclContextKind::SubscriptDecl:
+    return cast<SubscriptDecl>(this)->isAsync();
   }
   llvm_unreachable("Unhandled DeclContextKind switch");
 }

lib/AST/FeatureSet.cpp

@@ -478,19 +478,13 @@ static bool usesFeatureBuiltinEmplaceTypedThrows(Decl *decl) {
 }
 
 static bool usesFeatureExecutionAttribute(Decl *decl) {
-  if (auto *ASD = dyn_cast<AbstractStorageDecl>(decl)) {
-    if (auto *getter = ASD->getAccessor(AccessorKind::Get))
-      return usesFeatureExecutionAttribute(getter);
+  if (!DeclAttribute::canAttributeAppearOnDecl(DeclAttrKind::Execution, decl)) {
     return false;
   }
 
   if (decl->getAttrs().hasAttribute<ExecutionAttr>())
     return true;
 
-  auto VD = dyn_cast<ValueDecl>(decl);
-  if (!VD)
-    return false;
-
   auto hasExecutionAttr = [](TypeRepr *R) {
     if (!R)
       return false;
@@ -508,8 +502,10 @@ static bool usesFeatureExecutionAttribute(Decl *decl) {
     });
   };
 
+  auto *VD = cast<ValueDecl>(decl);
+
   // Check if any parameters that have `@execution` attribute.
-  if (auto *PL = getParameterList(VD)) {
+  if (auto *PL = VD->getParameterList()) {
     for (auto *P : *PL) {
       if (hasExecutionAttr(P->getTypeRepr()))
         return true;

lib/AST/NameLookup.cpp

@@ -3714,13 +3714,14 @@ createOpaqueParameterGenericParams(GenericContext *genericContext, GenericParamL
     return { };
 
   // Functions, initializers, and subscripts can contain opaque parameters.
-  ParameterList *params = nullptr;
-  if (auto func = dyn_cast<AbstractFunctionDecl>(value))
-    params = func->getParameters();
-  else if (auto subscript = dyn_cast<SubscriptDecl>(value))
-    params = subscript->getIndices();
-  else
+  // FIXME: What's wrong with allowing them in macro decls?
+  if (isa<MacroDecl>(value)) {
     return { };
+  }
+  auto *params = value->getParameterList();
+  if (!params) {
+    return {};
+  }
 
   // Look for parameters that have "some" types in them.
   unsigned index = parsedGenericParams ? parsedGenericParams->size() : 0;

lib/AST/RawComment.cpp

@@ -242,7 +242,7 @@ static bool hasDoubleUnderscore(const Decl *D) {
   // If it's a function or subscript with a parameter with leading
   // double underscore, it's a private function or subscript.
   if (isa<AbstractFunctionDecl>(D) || isa<SubscriptDecl>(D)) {
-    auto *params = getParameterList(cast<ValueDecl>(const_cast<Decl *>(D)));
+    auto *params = cast<ValueDecl>(D)->getParameterList();
     if (params->hasInternalParameter(Prefix))
       return true;
   }

lib/AST/Type.cpp

@@ -1359,13 +1359,11 @@ ParameterListInfo::ParameterListInfo(
     return;
 
   // Find the corresponding parameter list.
-  const ParameterList *paramList =
-      getParameterList(const_cast<ValueDecl *>(paramOwner));
+  auto *paramList = paramOwner->getParameterList();
 
   // No parameter list means no default arguments - hand back the zeroed
   // bitvector.
   if (!paramList) {
-    assert(!paramOwner->hasParameterList());
     return;
   }
 

lib/ClangImporter/ClangDerivedConformances.cpp

@@ -81,8 +81,6 @@ static FuncDecl *getInsertFunc(NominalTypeDecl *decl,
   FuncDecl *insert = nullptr;
   for (auto candidate : inserts) {
     if (auto candidateMethod = dyn_cast<FuncDecl>(candidate)) {
-      if (!candidateMethod->hasParameterList())
-        continue;
       auto params = candidateMethod->getParameters();
       if (params->size() != 1)
         continue;
@@ -158,7 +156,7 @@ static ValueDecl *lookupOperator(NominalTypeDecl *decl, Identifier id,
 static ValueDecl *getEqualEqualOperator(NominalTypeDecl *decl) {
   auto isValid = [&](ValueDecl *equalEqualOp) -> bool {
     auto equalEqual = dyn_cast<FuncDecl>(equalEqualOp);
-    if (!equalEqual || !equalEqual->hasParameterList())
+    if (!equalEqual)
       return false;
     auto params = equalEqual->getParameters();
     if (params->size() != 2)
@@ -187,7 +185,7 @@ static FuncDecl *getMinusOperator(NominalTypeDecl *decl) {
 
   auto isValid = [&](ValueDecl *minusOp) -> bool {
     auto minus = dyn_cast<FuncDecl>(minusOp);
-    if (!minus || !minus->hasParameterList())
+    if (!minus)
       return false;
     auto params = minus->getParameters();
     if (params->size() != 2)
@@ -218,7 +216,7 @@ static FuncDecl *getMinusOperator(NominalTypeDecl *decl) {
 static FuncDecl *getPlusEqualOperator(NominalTypeDecl *decl, Type distanceTy) {
   auto isValid = [&](ValueDecl *plusEqualOp) -> bool {
     auto plusEqual = dyn_cast<FuncDecl>(plusEqualOp);
-    if (!plusEqual || !plusEqual->hasParameterList())
+    if (!plusEqual)
       return false;
     auto params = plusEqual->getParameters();
     if (params->size() != 2)