Merge pull request #40220 from DougGregor/predates-concurrency

Author: swift-ci

include/swift/AST/Attr.def

@@ -635,15 +635,8 @@ CONTEXTUAL_SIMPLE_DECL_ATTR(nonisolated, Nonisolated,
   APIBreakingToAdd | APIStableToRemove,
   112)
 
-CONTEXTUAL_SIMPLE_DECL_ATTR(_unsafeSendable, UnsafeSendable,
-  OnParam | UserInaccessible |
-  ABIStableToAdd | ABIStableToRemove | APIBreakingToAdd | APIStableToRemove,
-  113)
-
-CONTEXTUAL_SIMPLE_DECL_ATTR(_unsafeMainActor, UnsafeMainActor,
-  OnParam | UserInaccessible |
-  ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIBreakingToRemove,
-  114)
+// 113 was experimental _unsafeSendable and is now unused
+// 114 was experimental _unsafeMainActor and is now unused
 
 SIMPLE_DECL_ATTR(_implicitSelfCapture, ImplicitSelfCapture,
   OnParam | UserInaccessible |
@@ -695,6 +688,12 @@ SIMPLE_DECL_ATTR(_noAllocation, NoAllocation,
   ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,
   124)
 
+SIMPLE_DECL_ATTR(_predatesConcurrency, PredatesConcurrency,
+  OnFunc | OnConstructor | OnProtocol | OnGenericType | OnVar | OnSubscript |
+  OnEnumElement | UserInaccessible |
+  ABIBreakingToAdd | ABIBreakingToRemove | APIBreakingToAdd | APIBreakingToRemove,
+  125)
+
 // If you're adding a new underscored attribute here, please document it in
 // docs/ReferenceGuides/UnderscoredAttributes.md.
 

include/swift/AST/Decl.h

@@ -883,6 +883,9 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
   /// but should behave like a top-level declaration. This is used by lldb.
   void setHoisted(bool hoisted = true) { Bits.Decl.Hoisted = hoisted; }
 
+  /// Whether this declaration predates the introduction of concurrency.
+  bool predatesConcurrency() const;
+
 public:
   bool escapedFromIfConfig() const {
     return Bits.Decl.EscapedFromIfConfig;

include/swift/AST/DiagnosticsParse.def

@@ -1719,6 +1719,10 @@ ERROR(sil_inst_autodiff_invalid_witness_generic_signature,PointsToFirstBadToken,
       "parameters as original function generic signature '%1'",
       (StringRef, StringRef))
 
+WARNING(warn_attr_unsafe_removed,none,
+        "'%0' attribute has been removed in favor of @_predatesConcurrency",
+        (StringRef))
+
 //------------------------------------------------------------------------------
 // MARK: Generics parsing diagnostics
 //------------------------------------------------------------------------------

lib/AST/Decl.cpp

@@ -718,6 +718,11 @@ Optional<CustomAttrNominalPair> Decl::getGlobalActorAttr() const {
                            None);
 }
 
+bool Decl::predatesConcurrency() const {
+  return getAttrs().hasAttribute<PredatesConcurrencyAttr>();
+}
+
+
 Expr *AbstractFunctionDecl::getSingleExpressionBody() const {
   assert(hasSingleExpressionBody() && "Not a single-expression body");
   auto braceStmt = getBody();

lib/ClangImporter/ImportType.cpp

@@ -1707,8 +1707,7 @@ static Type applyToFunctionType(
 }
 
 Type ClangImporter::Implementation::applyParamAttributes(
-    const clang::ParmVarDecl *param, Type type, bool &isUnsafeSendable,
-    bool &isUnsafeMainActor) {
+    const clang::ParmVarDecl *param, Type type) {
   if (!param->hasAttrs())
     return type;
 
@@ -1745,18 +1744,6 @@ Type ClangImporter::Implementation::applyParamAttributes(
 
       continue;
     }
-
-    // Map @_unsafeSendable.
-    if (swiftAttr->getAttribute() == "@_unsafeSendable") {
-      isUnsafeSendable = true;
-      continue;
-    }
-
-    // Map @_unsafeMainActor.
-    if (swiftAttr->getAttribute() == "@_unsafeMainActor") {
-      isUnsafeMainActor = true;
-      continue;
-    }
   }
 
   return type;
@@ -1953,10 +1940,8 @@ ParameterList *ClangImporter::Implementation::importFunctionParameterList(
     }
 
     // Apply attributes to the type.
-    bool isUnsafeSendable = false;
-    bool isUnsafeMainActor = false;
     swiftParamTy = applyParamAttributes(
-        param, swiftParamTy, isUnsafeSendable, isUnsafeMainActor);
+        param, swiftParamTy);
 
     // Figure out the name for this parameter.
     Identifier bodyName = importFullName(param, CurrentVersion)
@@ -1978,8 +1963,6 @@ ParameterList *ClangImporter::Implementation::importFunctionParameterList(
                                     : ParamSpecifier::Default);
     paramInfo->setInterfaceType(swiftParamTy);
     recordImplicitUnwrapForDecl(paramInfo, isParamTypeImplicitlyUnwrapped);
-    recordUnsafeConcurrencyForDecl(
-        paramInfo, isUnsafeSendable, isUnsafeMainActor);
     parameters.push_back(paramInfo);
     ++index;
   }
@@ -2544,10 +2527,7 @@ ImportedType ClangImporter::Implementation::importMethodParamsAndReturnType(
     }
 
     // Apply Clang attributes to the parameter type.
-    bool isUnsafeSendable = false;
-    bool isUnsafeMainActor = false;
-    swiftParamTy = applyParamAttributes(
-        param, swiftParamTy, isUnsafeSendable, isUnsafeMainActor);
+    swiftParamTy = applyParamAttributes(param, swiftParamTy);
 
     // Figure out the name for this parameter.
     Identifier bodyName = importFullName(param, CurrentVersion)
@@ -2571,8 +2551,6 @@ ImportedType ClangImporter::Implementation::importMethodParamsAndReturnType(
     paramInfo->setSpecifier(ParamSpecifier::Default);
     paramInfo->setInterfaceType(swiftParamTy);
     recordImplicitUnwrapForDecl(paramInfo, paramIsIUO);
-    recordUnsafeConcurrencyForDecl(
-        paramInfo, isUnsafeSendable, isUnsafeMainActor);
 
     // Determine whether we have a default argument.
     if (kind == SpecialMethodKind::Regular ||

lib/ClangImporter/ImporterImpl.h

@@ -685,19 +685,6 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
     decl->setImplicitlyUnwrappedOptional(true);
   }
 
-  void recordUnsafeConcurrencyForDecl(
-      ValueDecl *decl, bool isUnsafeSendable, bool isUnsafeMainActor) {
-    if (isUnsafeSendable) {
-      decl->getAttrs().add(
-          new (SwiftContext) UnsafeSendableAttr(/*implicit=*/true));
-    }
-
-    if (isUnsafeMainActor) {
-      decl->getAttrs().add(
-          new (SwiftContext) UnsafeMainActorAttr(/*implicit=*/true));
-    }
-  }
-
   /// Retrieve the Clang AST context.
   clang::ASTContext &getClangASTContext() const {
     return Instance->getASTContext();
@@ -848,8 +835,7 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   void importAttributes(const clang::NamedDecl *ClangDecl, Decl *MappedDecl,
                         const clang::ObjCContainerDecl *NewContext = nullptr);
 
-  Type applyParamAttributes(const clang::ParmVarDecl *param, Type type,
-                            bool &isUnsafeSendable, bool &isUnsafeMainActor);
+  Type applyParamAttributes(const clang::ParmVarDecl *param, Type type);
 
   /// If we already imported a given decl, return the corresponding Swift decl.
   /// Otherwise, return nullptr.

lib/Parse/ParseDecl.cpp

@@ -3080,6 +3080,17 @@ ParserStatus Parser::parseDeclAttribute(
     return makeParserSuccess();
   }
 
+  // @_unsafeSendable and @_unsafeMainActor have been removed; warn about them.
+  if (DK == DAK_Count &&
+      (Tok.getText() == "_unsafeSendable" ||
+       Tok.getText() == "_unsafeMainActor")) {
+    StringRef attrName = Tok.getText();
+    SourceLoc attrLoc = consumeToken();
+    diagnose(AtLoc, diag::warn_attr_unsafe_removed, attrName)
+      .fixItRemove(SourceRange(AtLoc, attrLoc));
+    return makeParserSuccess();
+  }
+
   if (DK != DAK_Count && !DeclAttribute::shouldBeRejectedByParser(DK)) {
     parseNewDeclAttribute(Attributes, AtLoc, DK, isFromClangAttribute);
     return makeParserSuccess();

lib/Sema/ConstraintSystem.cpp

@@ -1107,6 +1107,9 @@ Type ConstraintSystem::getUnopenedTypeOfReference(
   Type requestedType =
       getType(value)->getWithoutSpecifierType()->getReferenceStorageReferent();
 
+  // Adjust the type for concurrency.
+  requestedType = adjustVarTypeForConcurrency(requestedType, value, UseDC);
+
   // If we're dealing with contextual types, and we referenced this type from
   // a different context, map the type.
   if (!wantInterfaceType && requestedType->hasArchetype()) {
@@ -1757,7 +1760,11 @@ ConstraintSystem::getTypeOfMemberReference(
                               ->castTo<AnyFunctionType>()->getParams();
       // FIXME: Verify ExtInfo state is correct, not working by accident.
       FunctionType::ExtInfo info;
-      refType = FunctionType::get(indices, elementTy, info);
+      auto *refFnType = FunctionType::get(indices, elementTy, info);
+
+      refType = adjustFunctionTypeForConcurrency(
+          refFnType, subscript, useDC, /*numApplies=*/1,
+          /*isMainDispatchQueue=*/false);
     } else {
       refType = getUnopenedTypeOfReference(cast<VarDecl>(value), baseTy, useDC,
                                            locator,
@@ -2051,14 +2058,17 @@ Type ConstraintSystem::getEffectiveOverloadType(ConstraintLocator *locator,
                        ->castTo<AnyFunctionType>()->getParams();
       // FIXME: Verify ExtInfo state is correct, not working by accident.
       FunctionType::ExtInfo info;
-      type = FunctionType::get(indices, elementTy, info);
+      type = adjustFunctionTypeForConcurrency(
+          FunctionType::get(indices, elementTy, info),
+          subscript, useDC, /*numApplies=*/1, /*isMainDispatchQueue=*/false);
     } else if (auto var = dyn_cast<VarDecl>(decl)) {
       type = var->getValueInterfaceType();
       if (doesStorageProduceLValue(var, overload.getBaseType(), useDC)) {
         type = LValueType::get(type);
       } else if (type->hasDynamicSelfType()) {
         type = withDynamicSelfResultReplaced(type, /*uncurryLevel=*/0);
       }
+      type = adjustVarTypeForConcurrency(type, var, useDC);
     } else if (isa<AbstractFunctionDecl>(decl) || isa<EnumElementDecl>(decl)) {
       if (decl->isInstanceMember() &&
           (!overload.getBaseType() ||
@@ -2087,7 +2097,10 @@ Type ConstraintSystem::getEffectiveOverloadType(ConstraintLocator *locator,
         }
       }
 
-      type = type->castTo<FunctionType>()->getResult();
+      type = adjustFunctionTypeForConcurrency(
+          type->castTo<FunctionType>(),
+          subscript, useDC, /*numApplies=*/2, /*isMainDispatchQueue=*/false)
+        ->getResult();
     }
   }
 

lib/Sema/TypeCheckAttr.cpp

@@ -114,11 +114,10 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
   IGNORED_ATTR(NonSendable)
   IGNORED_ATTR(AtRethrows)
   IGNORED_ATTR(AtReasync)
-  IGNORED_ATTR(UnsafeSendable)
-  IGNORED_ATTR(UnsafeMainActor)
   IGNORED_ATTR(ImplicitSelfCapture)
   IGNORED_ATTR(InheritActorContext)
   IGNORED_ATTR(Isolated)
+  IGNORED_ATTR(PredatesConcurrency)
 #undef IGNORED_ATTR
 
   void visitAlignmentAttr(AlignmentAttr *attr) {