Infer ConcurrentValue conformances for structs and enums.

When a struct or enum has only ConcurrentValue-conforming instance
data, infer conformance to ConcurrentValue.

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)

lib/AST/Module.cpp

@@ -967,6 +967,17 @@ 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.
+  if (protocol->isSpecificProtocol(KnownProtocolKind::ConcurrentValue)) {
+    if (auto nominal = type->getAnyNominal()) {
+      GetImplicitConcurrentValueRequest request{nominal};
+      if (getASTContext().evaluator.hasActiveRequest(request))
+        return ProtocolConformanceRef::forInvalid();
+    }
+  }
+
   return evaluateOrDefault(
       getASTContext().evaluator,
       LookupConformanceInModuleRequest{{this, type, protocol}},
@@ -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/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;
     }

lib/Sema/TypeCheckConcurrency.cpp

@@ -178,7 +178,8 @@ bool IsAsyncHandlerRequest::evaluate(
   // implies @asyncHandler.
   {
     auto idc = cast<IterableDeclContext>(dc->getAsDecl());
-    auto conformances = idc->getLocalConformances();
+    auto conformances = idc->getLocalConformances(
+        ConformanceLookupKind::NonStructural);
 
     for (auto conformance : conformances) {
       auto protocol = conformance->getProtocol();
@@ -2048,7 +2049,8 @@ static Optional<ActorIsolation> getIsolationFromWitnessedRequirements(
 
   // Walk through each of the conformances in this context, collecting any
   // requirements that have actor isolation.
-  auto conformances = idc->getLocalConformances();
+  auto conformances = idc->getLocalConformances(
+      ConformanceLookupKind::NonStructural);
   using IsolatedRequirement =
       std::tuple<ProtocolConformance *, ActorIsolation, ValueDecl *>;
   SmallVector<IsolatedRequirement, 2> isolatedRequirements;
@@ -2356,6 +2358,17 @@ static bool shouldDiagnoseExistingDataRaces(const DeclContext *dc) {
   return false;
 }
 
+static bool shouldDiagnoseConcurrentValue(ConcurrentValueCheck check) {
+  switch (check) {
+  case ConcurrentValueCheck::ImpliedByStandardProtocol:
+  case ConcurrentValueCheck::Explicit:
+    return true;
+
+  case ConcurrentValueCheck::Implicit:
+    return false;
+  }
+}
+
 /// Check the instance storage of the given nominal type to verify whether
 /// it is comprised only of ConcurrentValue instance storage.
 static bool checkConcurrentValueInstanceStorage(
@@ -2368,6 +2381,9 @@ static bool checkConcurrentValueInstanceStorage(
     auto classDecl = dyn_cast<ClassDecl>(nominal);
     for (auto property : nominal->getStoredProperties()) {
       if (classDecl && property->supportsMutation()) {
+        if (!shouldDiagnoseConcurrentValue(check))
+          return true;
+
         property->diagnose(
             asWarning ? diag::concurrent_value_class_mutable_property_warn
                       : diag::concurrent_value_class_mutable_property,
@@ -2379,6 +2395,9 @@ static bool checkConcurrentValueInstanceStorage(
 
       auto propertyType = dc->mapTypeIntoContext(property->getInterfaceType());
       if (!isConcurrentValueType(dc, propertyType)) {
+        if (!shouldDiagnoseConcurrentValue(check))
+          return true;
+
         property->diagnose(
             asWarning ? diag::non_concurrent_type_member_warn
                       : diag::non_concurrent_type_member,
@@ -2403,6 +2422,9 @@ static bool checkConcurrentValueInstanceStorage(
         auto elementType = dc->mapTypeIntoContext(
             element->getArgumentInterfaceType());
         if (!isConcurrentValueType(dc, elementType)) {
+          if (!shouldDiagnoseConcurrentValue(check))
+            return true;
+
           element->diagnose(
               asWarning ? diag::non_concurrent_type_member_warn
                         : diag::non_concurrent_type_member,
@@ -2479,3 +2501,62 @@ bool swift::checkConcurrentValueConformance(
 
   return checkConcurrentValueInstanceStorage(nominal, conformanceDC, check);
 }
+
+NormalProtocolConformance *GetImplicitConcurrentValueRequest::evaluate(
+    Evaluator &evaluator, NominalTypeDecl *nominal) const {
+  // Only structs and enums get implicit ConcurrentValue conformances.
+  if (!isa<StructDecl>(nominal) && !isa<EnumDecl>(nominal))
+    return nullptr;
+
+  // Check the context in which the conformance occurs.
+  if (auto *file = dyn_cast<FileUnit>(nominal->getModuleScopeContext())) {
+    switch (file->getKind()) {
+    case FileUnitKind::Source:
+      // Check what kind of source file we have.
+      if (auto sourceFile = nominal->getParentSourceFile()) {
+        switch (sourceFile->Kind) {
+        case SourceFileKind::Interface:
+          // Interfaces have explicitly called-out ConcurrentValue conformances.
+          return nullptr;
+
+        case SourceFileKind::Library:
+        case SourceFileKind::Main:
+        case SourceFileKind::SIL:
+          break;
+        }
+      }
+      break;
+
+    case FileUnitKind::Builtin:
+    case FileUnitKind::SerializedAST:
+    case FileUnitKind::Synthesized:
+      // Explicitly-handled modules don't infer ConcurrentValue conformances.
+      return nullptr;
+
+    case FileUnitKind::ClangModule:
+    case FileUnitKind::DWARFModule:
+      // Infer conformances for imported modules.
+      break;
+    }
+  } else {
+    return nullptr;
+  }
+
+  // Check the instance storage for ConcurrentValue conformance.
+  if (checkConcurrentValueInstanceStorage(
+          nominal, nominal, ConcurrentValueCheck::Implicit))
+    return nullptr;
+
+  ASTContext &ctx = nominal->getASTContext();
+  auto proto = ctx.getProtocol(KnownProtocolKind::ConcurrentValue);
+  if (!proto)
+    return nullptr;
+
+  auto conformance = ctx.getConformance(
+      nominal->getDeclaredInterfaceType(), proto, nominal->getLoc(),
+      nominal, ProtocolConformanceState::Complete);
+  conformance->setSourceKindAndImplyingConformance(
+      ConformanceEntryKind::Synthesized, nullptr);
+
+  return conformance;
+}

lib/Sema/TypeCheckConcurrency.h

@@ -199,6 +199,9 @@ enum class ConcurrentValueCheck {
   /// ConcurrentValue conformance was implied by one of the standard library
   /// protocols that added ConcurrentValue after-the-fact.
   ImpliedByStandardProtocol,
+
+  /// Implicit conformance to ConcurrentValue for structs and enums.
+  Implicit,
 };
 
 /// Check the correctness of the given ConcurrentValue conformance.

lib/Sema/TypeCheckRequestFunctions.cpp

@@ -274,7 +274,8 @@ static Type inferResultBuilderType(ValueDecl *decl)  {
   auto addConformanceMatches = [&matches](ValueDecl *lookupDecl) {
     DeclContext *dc = lookupDecl->getDeclContext();
     auto idc = cast<IterableDeclContext>(dc->getAsDecl());
-    auto conformances = idc->getLocalConformances();
+    auto conformances = idc->getLocalConformances(
+        ConformanceLookupKind::NonStructural);
 
     for (auto conformance : conformances) {
       auto protocol = conformance->getProtocol();

test/Concurrency/concurrent_value_inference.swift

@@ -0,0 +1,41 @@
+// RUN: %target-typecheck-verify-swift
+
+class C1 { }
+final class C2: ConcurrentValue { }
+
+struct S1 {
+  var x: Int
+  var s: String
+  var c: C2
+}
+
+enum E1 {
+  case base
+  indirect case nested(E1)
+}
+
+enum E2 {
+  case s1(S1)
+  case c2(C2)
+}
+
+struct GS1<T> { }
+
+struct GS2<T> {
+  var storage: T
+}
+
+func acceptCV<T: ConcurrentValue>(_: T) { }
+// expected-note@-1 3{{where 'T' =}}
+
+func testCV(
+  c1: C1, c2: C2, s1: S1, e1: E1, e2: E2, gs1: GS1<Int>, gs2: GS2<Int>
+) {
+  acceptCV(c1) // expected-error{{'C1' conform to 'ConcurrentValue'}}
+  acceptCV(c2)
+  acceptCV(s1)
+  acceptCV(e1) // expected-error{{'E1' conform to 'ConcurrentValue'}}
+  acceptCV(e2)
+  acceptCV(gs1)
+  acceptCV(gs2) // expected-error{{'GS2<Int>' conform to 'ConcurrentValue'}}
+}

test/Incremental/Verifier/multi-file-private/Inputs/Inner.swift

@@ -12,3 +12,4 @@ public func blah(foo: Foo) {}
 public var defaultFoo: Foo = {
   return Inner()
 }
+// expected-superclass{{main.Inner}}