Check ConcurrentValue on @Concurrent functions and function types

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -4315,6 +4315,10 @@ WARNING(non_concurrent_property_type,none,
         "cannot use %0 %1 with a non-concurrent-value type %2 "
         "%select{across actors|from concurrently-executed code}3",
         (DescriptiveDeclKind, DeclName, Type, bool))
+WARNING(non_concurrent_function_type,none,
+        "`@concurrent` %select{function type|closure}0 has "
+        "non-concurrent-value %select{parameter|result}1 type %2",
+        (bool, bool, Type))
 
 ERROR(actorindependent_let,none,
       "'@actorIndependent' is meaningless on 'let' declarations because "

lib/Sema/TypeCheckAttr.cpp

@@ -128,7 +128,6 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
   IGNORED_ATTR(OriginallyDefinedIn)
   IGNORED_ATTR(NoDerivative)
   IGNORED_ATTR(SpecializeExtension)
-  IGNORED_ATTR(Concurrent)
 #undef IGNORED_ATTR
 
   void visitAlignmentAttr(AlignmentAttr *attr) {
@@ -420,6 +419,22 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
       }
     }
   }
+
+  void visitConcurrentAttr(ConcurrentAttr *attr) {
+    auto VD = dyn_cast<ValueDecl>(D);
+    if (!VD)
+      return;
+
+    auto innermostDC = VD->getInnermostDeclContext();
+    SubstitutionMap subs;
+    if (auto genericEnv = innermostDC->getGenericEnvironmentOfContext()) {
+      subs = genericEnv->getForwardingSubstitutionMap();
+    }
+
+    (void)diagnoseNonConcurrentTypesInReference(
+        ConcreteDeclRef(VD, subs), innermostDC, VD->getLoc(),
+        ConcurrentReferenceKind::ConcurrentFunction);
+  }
 };
 } // end anonymous namespace
 

lib/Sema/TypeCheckConcurrency.cpp

@@ -938,6 +938,35 @@ bool swift::diagnoseNonConcurrentTypesInReference(
   return false;
 }
 
+bool swift::diagnoseNonConcurrentTypesInFunctionType(
+    const AnyFunctionType *fnType, const DeclContext *dc, SourceLoc loc,
+    bool isClosure) {
+  ASTContext &ctx = dc->getASTContext();
+  // Bail out immediately if we aren't supposed to do this checking.
+  if (!dc->getASTContext().LangOpts.EnableExperimentalConcurrentValueChecking)
+    return false;
+
+  // Check parameter types.
+  for (const auto &param : fnType->getParams()) {
+    Type paramType = param.getParameterType();
+    if (!isConcurrentValueType(dc, paramType)) {
+      ctx.Diags.diagnose(
+          loc, diag::non_concurrent_function_type, isClosure, false, paramType);
+      return true;
+    }
+  }
+
+  // Check result type.
+  if (!isConcurrentValueType(dc, fnType->getResult())) {
+    ctx.Diags.diagnose(
+        loc, diag::non_concurrent_function_type, isClosure, true,
+        fnType->getResult());
+    return true;
+  }
+
+  return false;
+}
+
 namespace {
   /// Check whether a particular context may execute concurrently within
   /// another context.
@@ -1079,6 +1108,18 @@ namespace {
       if (auto *closure = dyn_cast<AbstractClosureExpr>(expr)) {
         closure->setActorIsolation(determineClosureIsolation(closure));
         contextStack.push_back(closure);
+
+        
+        // Concurrent closures must be composed of concurrent-safe parameter
+        // and result types.
+        if (isConcurrentClosure(closure)) {
+          if (auto fnType = closure->getType()->getAs<FunctionType>()) {
+            (void)diagnoseNonConcurrentTypesInFunctionType(
+                 fnType, getDeclContext(), closure->getLoc(),
+                 /*isClosure=*/true);
+          }
+        }
+
         return { true, expr };
       }
 

lib/Sema/TypeCheckConcurrency.h

@@ -25,6 +25,7 @@ namespace swift {
 
 class AbstractFunctionDecl;
 class ActorIsolation;
+class AnyFunctionType;
 class ASTContext;
 class ClassDecl;
 class ConcreteDeclRef;
@@ -60,6 +61,8 @@ enum class ConcurrentReferenceKind {
   CrossActor,
   /// A local capture referenced from concurrent code.
   LocalCapture,
+  /// Concurrent function
+  ConcurrentFunction,
 };
 
 /// Describes why or where a particular entity has a non-concurrent-value type.
@@ -233,6 +236,12 @@ bool diagnoseNonConcurrentTypesInReference(
     ConcreteDeclRef declRef, const DeclContext *dc, SourceLoc loc,
     ConcurrentReferenceKind refKind);
 
+/// Diagnose the presence of any non-concurrent types within the given
+/// function type.
+bool diagnoseNonConcurrentTypesInFunctionType(
+    const AnyFunctionType *fnType, const DeclContext *dc, SourceLoc loc,
+    bool isClosure);
+
 } // end namespace swift
 
 #endif /* SWIFT_SEMA_TYPECHECKCONCURRENCY_H */

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -1906,6 +1906,8 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
     (void) TAD->getGenericSignature();
     (void) TAD->getUnderlyingType();
 
+    // Make sure to check the underlying type.
+    
     TypeChecker::checkDeclAttributes(TAD);
     checkAccessControl(TAD);
     checkGenericParams(TAD);

lib/Sema/TypeCheckType.cpp

@@ -17,6 +17,7 @@
 
 #include "TypeChecker.h"
 #include "TypeCheckAvailability.h"
+#include "TypeCheckConcurrency.h"
 #include "TypeCheckProtocol.h"
 #include "TypeCheckType.h"
 #include "TypoCorrection.h"
@@ -2824,6 +2825,14 @@ NeverNullType TypeResolver::resolveASTFunctionType(
   if (fnTy->hasError())
     return fnTy;
 
+  // Concurrent function types must be composed of concurrent-safe parameter
+  // and result types.
+  if (concurrent && resolution.getStage() > TypeResolutionStage::Structural) {
+    (void)diagnoseNonConcurrentTypesInFunctionType(
+         fnTy, resolution.getDeclContext(), repr->getLoc(),
+         /*isClosure=*/false);
+  }
+
   // If the type is a block or C function pointer, it must be representable in
   // ObjC.
   switch (representation) {

test/Concurrency/concurrent_value_checking.swift

@@ -118,3 +118,30 @@ class SomeClass: MainActorProto {
   @SomeGlobalActor
   func asyncMainMethod(_: NotConcurrent) async { } // expected-warning{{cannot pass argument of non-concurrent-value type 'NotConcurrent' across actors}}
 }
+
+// ----------------------------------------------------------------------
+// ConcurrentValue restriction on concurrent functions.
+// ----------------------------------------------------------------------
+
+// FIXME: poor diagnostic
+@concurrent func concurrentFunc() -> NotConcurrent? { nil } // expected-warning{{cannot call function returning non-concurrent-value type 'NotConcurrent?' across actors}}
+
+// ----------------------------------------------------------------------
+// ConcurrentValue restriction on @concurrent types.
+// ----------------------------------------------------------------------
+typealias CF = @concurrent () -> NotConcurrent? // expected-warning{{`@concurrent` function type has non-concurrent-value result type 'NotConcurrent?'}}
+typealias BadGenericCF<T> = @concurrent () -> T? // expected-warning{{`@concurrent` function type has non-concurrent-value result type 'T?'}}
+typealias GoodGenericCF<T: ConcurrentValue> = @concurrent () -> T? // okay
+
+var concurrentFuncVar: (@concurrent (NotConcurrent) -> Void)? = nil // expected-warning{{`@concurrent` function type has non-concurrent-value parameter type 'NotConcurrent'}}
+
+// ----------------------------------------------------------------------
+// ConcurrentValue restriction on @concurrent closures.
+// ----------------------------------------------------------------------
+func acceptConcurrentUnary<T>(_: @concurrent (T) -> T) { }
+
+func concurrentClosures<T>(_: T) {
+  acceptConcurrentUnary { (x: T) in // expected-warning{{`@concurrent` closure has non-concurrent-value parameter type 'T'}}
+    x
+  }
+}