AST: Unconditionally synthesize Copyable/Escapable conformances

Author: slavapestov

lib/AST/ConformanceLookup.cpp

@@ -640,17 +640,6 @@ LookupConformanceInModuleRequest::evaluate(
       } else {
         return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
       }
-    } else if (protocol->isSpecificProtocol(KnownProtocolKind::Copyable)) {
-      if (!ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
-        // Return an abstract conformance to maintain legacy compatability.
-        // We only need to do this until we are properly dealing with or
-        // omitting Copyable conformances in modules/interfaces.
-
-        if (nominal->canBeCopyable())
-          return ProtocolConformanceRef(protocol);
-      }
-
-      return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
     } else if (protocol->isSpecificProtocol(
                    KnownProtocolKind::BitwiseCopyable)) {
       // Try to infer BitwiseCopyable conformance.

lib/AST/Decl.cpp

@@ -4920,20 +4920,13 @@ GenericParameterReferenceInfo ValueDecl::findExistentialSelfReferences(
 }
 
 static TypeDecl::CanBeInvertible::Result
-conformanceExists(TypeDecl const *decl, InvertibleProtocolKind ip) {
+conformanceExists(const NominalTypeDecl *decl, InvertibleProtocolKind ip) {
+  assert(isa<StructDecl>(decl) || isa<EnumDecl>(decl) || isa<ClassDecl>(decl));
+
   auto *proto = decl->getASTContext().getProtocol(getKnownProtocolKind(ip));
   assert(proto && "missing Copyable/Escapable from stdlib!");
 
-  // Handle protocols specially, without building a GenericSignature.
-  if (auto *protoDecl = dyn_cast<ProtocolDecl>(decl)) {
-    return protoDecl->inheritsFrom(proto)
-         ? TypeDecl::CanBeInvertible::Always
-         : TypeDecl::CanBeInvertible::Never;
-  }
-
   Type selfTy = decl->getDeclaredInterfaceType();
-  assert(selfTy);
-
   auto conformance = decl->getModuleContext()->lookupConformance(selfTy, proto,
       /*allowMissing=*/false);
 
@@ -4947,22 +4940,10 @@ conformanceExists(TypeDecl const *decl, InvertibleProtocolKind ip) {
 }
 
 TypeDecl::CanBeInvertible::Result NominalTypeDecl::canBeCopyable() const {
-  if (!getASTContext().LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
-    return !hasInverseMarking(InvertibleProtocolKind::Copyable)
-               ? CanBeInvertible::Always
-               : CanBeInvertible::Never;
-  }
-
   return conformanceExists(this, InvertibleProtocolKind::Copyable);
 }
 
 TypeDecl::CanBeInvertible::Result NominalTypeDecl::canBeEscapable() const {
-  if (!getASTContext().LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
-    return !hasInverseMarking(InvertibleProtocolKind::Escapable)
-               ? CanBeInvertible::Always
-               : CanBeInvertible::Never;
-  }
-
   return conformanceExists(this, InvertibleProtocolKind::Escapable);
 }
 

lib/AST/ProtocolConformance.cpp

@@ -1090,38 +1090,35 @@ void NominalTypeDecl::prepareConformanceTable() const {
   };
 
   // Synthesize the unconditional conformances to invertible protocols.
-  if (ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
-    // FIXME: We should be able to only resolve the inheritance clause once,
-    // but we also do it in ConformanceLookupTable::updateLookupTable().
-    InvertibleProtocolSet inverses;
-    bool anyObject = false;
-    (void) getDirectlyInheritedNominalTypeDecls(this, inverses, anyObject);
-
-    // Handle deprecated attributes.
-    if (getAttrs().hasAttribute<MoveOnlyAttr>())
-      inverses.insert(InvertibleProtocolKind::Copyable);
-    if (getAttrs().hasAttribute<NonEscapableAttr>())
-      inverses.insert(InvertibleProtocolKind::Escapable);
-
-    bool hasSuppressedConformances = false;
-    for (auto ip : InvertibleProtocolSet::full()) {
-      if (!inverses.contains(ip) ||
-          (isa<ClassDecl>(this) &&
-           !ctx.LangOpts.hasFeature(Feature::MoveOnlyClasses))) {
-        addSynthesized(ctx.getProtocol(getKnownProtocolKind(ip)));
-      } else {
-        hasSuppressedConformances = true;
-      }
-    }
 
-    // Non-copyable and non-escaping types do not implicitly conform to
-    // any other protocols.
-    if (hasSuppressedConformances)
-      return;
-  } else if (!canBeCopyable()) {
-    return; // No synthesized conformances for move-only nominals.
+  // FIXME: We should be able to only resolve the inheritance clause once,
+  // but we also do it in ConformanceLookupTable::updateLookupTable().
+  InvertibleProtocolSet inverses;
+  bool anyObject = false;
+  (void) getDirectlyInheritedNominalTypeDecls(this, inverses, anyObject);
+
+  // Handle deprecated attributes.
+  if (getAttrs().hasAttribute<MoveOnlyAttr>())
+    inverses.insert(InvertibleProtocolKind::Copyable);
+  if (getAttrs().hasAttribute<NonEscapableAttr>())
+    inverses.insert(InvertibleProtocolKind::Escapable);
+
+  bool hasSuppressedConformances = false;
+  for (auto ip : InvertibleProtocolSet::full()) {
+    if (!inverses.contains(ip) ||
+        (isa<ClassDecl>(this) &&
+         !ctx.LangOpts.hasFeature(Feature::MoveOnlyClasses))) {
+      addSynthesized(ctx.getProtocol(getKnownProtocolKind(ip)));
+    } else {
+      hasSuppressedConformances = true;
+    }
   }
 
+  // Non-copyable and non-escaping types do not implicitly conform to
+  // any other protocols.
+  if (hasSuppressedConformances)
+    return;
+
   // Don't do any more for synthesized FileUnits.
   if (file->getKind() == FileUnitKind::Synthesized)
     return;