Clarify interface to swift::checkConcurrentValueConformance

Author: DougGregor

lib/Sema/TypeCheckConcurrency.cpp

@@ -2356,30 +2356,33 @@ static bool shouldDiagnoseExistingDataRaces(const DeclContext *dc) {
   return false;
 }
 
-void swift::checkConcurrentValueConformance(
-    ProtocolConformance *conformance, bool asWarning) {
+bool swift::checkConcurrentValueConformance(
+    ProtocolConformance *conformance, ConcurrentValueCheck check) {
   auto conformanceDC = conformance->getDeclContext();
   auto nominal = conformance->getType()->getAnyNominal();
   if (!nominal)
-    return;
+    return false;
 
   auto classDecl = dyn_cast<ClassDecl>(nominal);
   if (classDecl) {
     // Actors implicitly conform to ConcurrentValue and protect their state.
     if (classDecl->isActor())
-      return;
+      return false;
   }
 
   // ConcurrentValue can only be used in the same source file.
   auto conformanceDecl = conformanceDC->getAsDecl();
+  bool asWarning = (check == ConcurrentValueCheck::ImpliedByStandardProtocol);
   if (!conformanceDC->getParentSourceFile() ||
       conformanceDC->getParentSourceFile() != nominal->getParentSourceFile()) {
     conformanceDecl->diagnose(
         asWarning
           ? diag::concurrent_value_outside_source_file_warn
           : diag::concurrent_value_outside_source_file,
         nominal->getDescriptiveKind(), nominal->getName());
-    return;
+
+    if (!asWarning)
+      return true;
   }
 
   if (classDecl) {
@@ -2389,8 +2392,9 @@ void swift::checkConcurrentValueConformance(
           asWarning ? diag::concurrent_value_open_class_warn
                     : diag::concurrent_value_open_class,
           classDecl->getName());
+
       if (!asWarning)
-        return;
+        return true;
     }
 
     // A 'ConcurrentValue' class cannot inherit from another class, although
@@ -2403,15 +2407,17 @@ void swift::checkConcurrentValueConformance(
                         : diag::concurrent_value_inherit,
               nominal->getASTContext().LangOpts.EnableObjCInterop,
               classDecl->getName());
+
           if (!asWarning)
-            return;
+            return true;
         }
       }
     }
   }
 
   // Stored properties of structs and classes must have
   // ConcurrentValue-conforming types.
+  bool invalid = false;
   if (isa<StructDecl>(nominal) || classDecl) {
     for (auto property : nominal->getStoredProperties()) {
       if (classDecl && property->supportsMutation()) {
@@ -2420,6 +2426,7 @@ void swift::checkConcurrentValueConformance(
                       : diag::concurrent_value_class_mutable_property,
             property->getName(), nominal->getDescriptiveKind(),
             nominal->getName());
+        invalid = true;
         continue;
       }
 
@@ -2431,11 +2438,12 @@ void swift::checkConcurrentValueConformance(
                       : diag::non_concurrent_type_member,
             false, property->getName(),
             nominal->getDescriptiveKind(), nominal->getName(), propertyType);
+        invalid = true;
         continue;
       }
     }
 
-    return;
+    return invalid;
   }
 
   // Associated values of enum cases must have ConcurrentValue-conforming
@@ -2454,9 +2462,12 @@ void swift::checkConcurrentValueConformance(
                         : diag::non_concurrent_type_member,
               true, element->getName(),
               nominal->getDescriptiveKind(), nominal->getName(), elementType);
+          invalid = true;
           continue;
         }
       }
     }
   }
+
+  return invalid;
 }

lib/Sema/TypeCheckConcurrency.h

@@ -190,9 +190,22 @@ bool diagnoseNonConcurrentTypesInReference(
     ConcreteDeclRef declRef, const DeclContext *dc, SourceLoc loc,
     ConcurrentReferenceKind refKind);
 
+/// How the concurrent value check should be performed.
+enum class ConcurrentValueCheck {
+  /// ConcurrentValue conformance was explicitly stated and should be
+  /// fully checked.
+  Explicit,
+
+  /// ConcurrentValue conformance was implied by one of the standard library
+  /// protocols that added ConcurrentValue after-the-fact.
+  ImpliedByStandardProtocol,
+};
+
 /// Check the correctness of the given ConcurrentValue conformance.
-void checkConcurrentValueConformance(
-    ProtocolConformance *conformance, bool asWarning);
+///
+/// \returns true if an error occurred.
+bool checkConcurrentValueConformance(
+    ProtocolConformance *conformance, ConcurrentValueCheck check);
 
 } // end namespace swift
 

lib/Sema/TypeCheckProtocol.cpp

@@ -5715,8 +5715,10 @@ void TypeChecker::checkConformancesInContext(IterableDeclContext *idc) {
 
   // Check constraints of ConcurrentValue.
   if (concurrentValueConformance && !unsafeConcurrentValueConformance) {
-    bool asWarning = errorConformance || codingKeyConformance;
-    checkConcurrentValueConformance(concurrentValueConformance, asWarning);
+    ConcurrentValueCheck check = ConcurrentValueCheck::Explicit;
+    if (errorConformance || codingKeyConformance)
+      check = ConcurrentValueCheck::ImpliedByStandardProtocol;
+    checkConcurrentValueConformance(concurrentValueConformance, check);
   }
 
   // Check all conformances.