Merge pull request #36226 from DougGregor/implicit-concurrent-value

Infer ConcurrentValue conformances for structs and enums.

Author: DougGregor

include/swift/AST/DeclContext.h

@@ -159,6 +159,9 @@ enum class ConformanceLookupKind : unsigned {
   OnlyExplicit,
   /// All conformances except for inherited ones.
   NonInherited,
+  /// All conformances except structurally-derived conformances, of which
+  /// ConcurrentValue is the only one.
+  NonStructural,
 };
 
 /// Describes a diagnostic for a conflict between two protocol

include/swift/AST/TypeCheckRequests.h

@@ -2895,6 +2895,26 @@ class SynthesizeMainFunctionRequest
   bool isCached() const { return true; }
 };
 
+/// Retrieve the implicit conformance for the given nominal type to
+/// the ConcurrentValue protocol.
+class GetImplicitConcurrentValueRequest :
+    public SimpleRequest<GetImplicitConcurrentValueRequest,
+                         NormalProtocolConformance *(NominalTypeDecl *),
+                         RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  NormalProtocolConformance *evaluate(
+      Evaluator &evaluator, NominalTypeDecl *nominal) const;
+
+public:
+  // Caching
+  bool isCached() const { return true; }
+};
+
 void simple_display(llvm::raw_ostream &out, Type value);
 void simple_display(llvm::raw_ostream &out, const TypeRepr *TyR);
 void simple_display(llvm::raw_ostream &out, ImplicitMemberAction action);

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -316,3 +316,6 @@ SWIFT_REQUEST(TypeChecker, SimpleDidSetRequest,
               bool(AccessorDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, SynthesizeMainFunctionRequest,
               FuncDecl *(Decl *), Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, GetImplicitConcurrentValueRequest,
+              NormalProtocolConformance *(NominalTypeDecl *),
+              Cached, NoLocationInfo)

include/swift/Basic/LangOptions.h

@@ -247,6 +247,9 @@ namespace swift {
     /// Enable experimental flow-sensitive concurrent captures.
     bool EnableExperimentalFlowSensitiveConcurrentCaptures = false;
 
+    /// Enable inference of ConcurrentValue conformances for public types.
+    bool EnableInferPublicConcurrentValue = false;
+
     /// Enable experimental derivation of `Codable` for enums.
     bool EnableExperimentalEnumCodableDerivation = false;
 

include/swift/Option/FrontendOptions.td

@@ -188,6 +188,12 @@ def batch_scan_input_file
 def import_prescan : Flag<["-"], "import-prescan">,
    HelpText<"When performing a dependency scan, only dentify all imports of the main Swift module sources">;
 
+def enable_infer_public_concurrent_value : Flag<["-"], "enable-infer-public-concurrent-value">,
+    HelpText<"Enable inference of ConcurrentValue conformances for public structs and enums">;
+
+def disable_infer_public_concurrent_value : Flag<["-"], "disable-infer-public-concurrent-value">,
+    HelpText<"Disable inference of ConcurrentValue conformances for public structs and enums">;
+
 } // end let Flags = [FrontendOption, NoDriverOption]
 
 def debug_crash_Group : OptionGroup<"<automatic crashing options>">;

lib/AST/Module.cpp

@@ -967,10 +967,21 @@ ModuleDecl::lookupExistentialConformance(Type type, ProtocolDecl *protocol) {
 
 ProtocolConformanceRef ModuleDecl::lookupConformance(Type type,
                                                      ProtocolDecl *protocol) {
+  // If we are recursively checking for implicit conformance of a nominal
+  // type to ConcurrentValue, fail without evaluating this request. This
+  // squashes cycles.
+  LookupConformanceInModuleRequest request{{this, type, protocol}};
+  if (protocol->isSpecificProtocol(KnownProtocolKind::ConcurrentValue)) {
+    if (auto nominal = type->getAnyNominal()) {
+      GetImplicitConcurrentValueRequest icvRequest{nominal};
+      if (getASTContext().evaluator.hasActiveRequest(icvRequest) ||
+          getASTContext().evaluator.hasActiveRequest(request))
+        return ProtocolConformanceRef::forInvalid();
+    }
+  }
+
   return evaluateOrDefault(
-      getASTContext().evaluator,
-      LookupConformanceInModuleRequest{{this, type, protocol}},
-      ProtocolConformanceRef::forInvalid());
+      getASTContext().evaluator, request, ProtocolConformanceRef::forInvalid());
 }
 
 ProtocolConformanceRef
@@ -1035,8 +1046,20 @@ LookupConformanceInModuleRequest::evaluate(
 
   // Find the (unspecialized) conformance.
   SmallVector<ProtocolConformance *, 2> conformances;
-  if (!nominal->lookupConformance(mod, protocol, conformances))
-    return ProtocolConformanceRef::forInvalid();
+  if (!nominal->lookupConformance(mod, protocol, conformances)) {
+    if (!protocol->isSpecificProtocol(KnownProtocolKind::ConcurrentValue))
+      return ProtocolConformanceRef::forInvalid();
+
+    // Try to infer ConcurrentValue conformance.
+    GetImplicitConcurrentValueRequest cvRequest{nominal};
+    if (auto conformance = evaluateOrDefault(
+            ctx.evaluator, cvRequest, nullptr)) {
+      conformances.clear();
+      conformances.push_back(conformance);
+    } else {
+      return ProtocolConformanceRef::forInvalid();
+    }
+  }
 
   // FIXME: Ambiguity resolution.
   auto conformance = conformances.front();

lib/AST/ProtocolConformance.cpp

@@ -1326,6 +1326,41 @@ IterableDeclContext::getLocalProtocols(ConformanceLookupKind lookupKind) const {
   return result;
 }
 
+/// Find a synthesized ConcurrentValue conformance in this declaration context,
+/// if there is one.
+static ProtocolConformance *findSynthesizedConcurrentValueConformance(
+    const DeclContext *dc) {
+  auto nominal = dc->getSelfNominalTypeDecl();
+  if (!nominal)
+    return nullptr;
+
+  if (isa<ProtocolDecl>(nominal))
+    return nullptr;
+
+  if (dc->getParentModule() != nominal->getParentModule())
+    return nullptr;
+
+  auto cvProto = nominal->getASTContext().getProtocol(
+      KnownProtocolKind::ConcurrentValue);
+  if (!cvProto)
+    return nullptr;
+
+  auto conformance = dc->getParentModule()->lookupConformance(
+      nominal->getDeclaredInterfaceType(), cvProto);
+  if (!conformance || !conformance.isConcrete())
+    return nullptr;
+
+  auto concrete = conformance.getConcrete();
+  if (concrete->getDeclContext() != dc)
+    return nullptr;
+
+  auto normal = concrete->getRootNormalConformance();
+  if (!normal || normal->getSourceKind() != ConformanceEntryKind::Synthesized)
+    return nullptr;
+
+  return normal;
+}
+
 std::vector<ProtocolConformance *>
 LookupAllConformancesInContextRequest::evaluate(
     Evaluator &eval, const IterableDeclContext *IDC) const {
@@ -1394,10 +1429,28 @@ IterableDeclContext::getLocalConformances(ConformanceLookupKind lookupKind)
            }
 
          case ConformanceLookupKind::All:
+         case ConformanceLookupKind::NonStructural:
            return true;
          }
       });
 
+  // If we want to add structural conformances, do so now.
+  switch (lookupKind) {
+    case ConformanceLookupKind::All:
+    case ConformanceLookupKind::NonInherited: {
+      // Look for a ConcurrentValue conformance globally. If it is synthesized
+      // and matches this declaration context, use it.
+      auto dc = getAsGenericContext();
+      if (auto conformance = findSynthesizedConcurrentValueConformance(dc))
+        result.push_back(conformance);
+      break;
+    }
+
+    case ConformanceLookupKind::NonStructural:
+    case ConformanceLookupKind::OnlyExplicit:
+      break;
+  }
+
   return result;
 }
 

lib/Frontend/CompilerInvocation.cpp

@@ -385,6 +385,10 @@ static bool ParseLangArgs(LangOptions &Opts, ArgList &Args,
 
   Opts.EnableExperimentalConcurrency |=
     Args.hasArg(OPT_enable_experimental_concurrency);
+  Opts.EnableInferPublicConcurrentValue |=
+    Args.hasFlag(OPT_enable_infer_public_concurrent_value,
+                 OPT_disable_infer_public_concurrent_value,
+                 false);
   Opts.EnableExperimentalFlowSensitiveConcurrentCaptures |=
     Args.hasArg(OPT_enable_experimental_flow_sensitive_concurrent_captures);
 

lib/Frontend/ModuleInterfaceSupport.cpp

@@ -590,7 +590,10 @@ class InheritedProtocolCollector {
       DeclAttributes::print(printer, printOptions, attrs);
 
       printer << "extension ";
-      nominal->getDeclaredType().print(printer, printOptions);
+      PrintOptions typePrintOptions = printOptions;
+      typePrintOptions.FullyQualifiedTypes = false;
+      typePrintOptions.FullyQualifiedTypesIfAmbiguous = false;
+      nominal->getDeclaredType().print(printer, typePrintOptions);
       printer << " : ";
 
       proto->getDeclaredInterfaceType()->print(printer, printOptions);

lib/Sema/DerivedConformanceEquatableHashable.cpp

@@ -942,7 +942,8 @@ getHashableConformance(const Decl *parentDecl) {
   ASTContext &C = parentDecl->getASTContext();
   const auto IDC = cast<IterableDeclContext>(parentDecl);
   auto hashableProto = C.getProtocol(KnownProtocolKind::Hashable);
-  for (auto conformance: IDC->getLocalConformances()) {
+  for (auto conformance: IDC->getLocalConformances(
+           ConformanceLookupKind::NonStructural)) {
     if (conformance->getProtocol() == hashableProto) {
       return conformance;
     }