[Concurrency] Don't diagnose non-ConcurrentValue parameters/result type of @Concurrent functions.

Thanks to Jordan Rose and John McCall, who pointed out why this checking was unnecessary.
As a drive-by, ensure that we diagnose parameter references properly.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -4312,10 +4312,6 @@ 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(non_concurrent_type_member,none,
       "%select{stored property %1|associated value %1}0 of "
       "'ConcurrentValue'-conforming %2 %3 has non-concurrent-value type %4",

lib/Sema/TypeCheckConcurrency.cpp

@@ -905,7 +905,9 @@ bool swift::diagnoseNonConcurrentTypesInReference(
   }
 
   if (auto var = dyn_cast<VarDecl>(declRef.getDecl())) {
-    Type propertyType = var->getValueInterfaceType().subst(subs);
+    Type propertyType = var->isLocalCapture()
+        ? var->getType()
+        : var->getValueInterfaceType().subst(subs);
     if (!isConcurrentValueType(dc, propertyType)) {
       return diagnoseNonConcurrentProperty(loc, refKind, var, propertyType);
     }
@@ -932,35 +934,6 @@ 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 for adherence to the actor isolation rules, emitting errors
   /// when actor-isolated declarations are used in an unsafe manner.
@@ -1113,18 +1086,6 @@ 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

@@ -237,12 +237,6 @@ 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);
-
 /// Check the correctness of the given ConcurrentValue conformance.
 void checkConcurrentValueConformance(ProtocolConformance *conformance);
 

lib/Sema/TypeCheckType.cpp

@@ -2823,14 +2823,6 @@ 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

@@ -151,22 +151,23 @@ class SomeClass: MainActorProto {
 @concurrent func concurrentFunc() -> NotConcurrent? { nil } // expected-warning{{cannot call function returning non-concurrent-value type 'NotConcurrent?' across actors}}
 
 // ----------------------------------------------------------------------
-// ConcurrentValue restriction on @concurrent types.
+// No ConcurrentValue restriction on @concurrent function 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 CF = @concurrent () -> NotConcurrent?
+typealias BadGenericCF<T> = @concurrent () -> 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'}}
+var concurrentFuncVar: (@concurrent (NotConcurrent) -> Void)? = nil
 
 // ----------------------------------------------------------------------
 // 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
+  acceptConcurrentUnary { (x: T) in
+    _ = x // ok
+    acceptConcurrentUnary { _ in x } // expected-warning{{cannot use parameter 'x' with a non-concurrent-value type 'T' from concurrently-executed code}}
   }
 }