Sema: Remove deriveConformanceForInvertible()

Author: slavapestov

lib/AST/ConformanceLookup.cpp

@@ -677,31 +677,17 @@ LookupConformanceInModuleRequest::evaluate(
       } else {
         return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
       }
-    } else if (protocol->isSpecificProtocol(KnownProtocolKind::Copyable)
-               || protocol->isSpecificProtocol(KnownProtocolKind::Escapable)) {
-      const auto kp = protocol->getKnownProtocolKind().value();
-
-      if (!ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics)
-          && kp == KnownProtocolKind::Copyable) {
+    } 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);
-        else
-          return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
       }
 
-      // Try to infer the conformance.
-      ImplicitKnownProtocolConformanceRequest cvRequest{nominal, kp};
-      if (auto conformance = evaluateOrDefault(
-          ctx.evaluator, cvRequest, nullptr)) {
-        conformances.clear();
-        conformances.push_back(conformance);
-      } else {
-        return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
-      }
+      return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
     } else if (protocol->isSpecificProtocol(
                    KnownProtocolKind::BitwiseCopyable)) {
       // Try to infer BitwiseCopyable conformance.

lib/AST/ProtocolConformance.cpp

@@ -1072,7 +1072,8 @@ void NominalTypeDecl::prepareConformanceTable() const {
   auto *file = cast<FileUnit>(getModuleScopeContext());
   if (file->getKind() != FileUnitKind::Source &&
       file->getKind() != FileUnitKind::ClangModule &&
-      file->getKind() != FileUnitKind::DWARFModule) {
+      file->getKind() != FileUnitKind::DWARFModule &&
+      file->getKind() != FileUnitKind::Synthesized) {
     return;
   }
 
@@ -1089,7 +1090,6 @@ void NominalTypeDecl::prepareConformanceTable() const {
   };
 
   // Synthesize the unconditional conformances to invertible protocols.
-  // For conditional ones, see findSynthesizedConformances .
   if (ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
     // Classes get their conformances during ModuleDecl::lookupConformance.
     if (!isa<ClassDecl>(this)) {
@@ -1101,14 +1101,19 @@ void NominalTypeDecl::prepareConformanceTable() const {
           missingOne = true;
       }
 
-      // FIXME: rdar://122289155 (NCGenerics: convert Equatable, Hashable, and RawRepresentable to ~Copyable.)
+      // Non-copyable and non-escaping types do not implicitly conform to
+      // any other protocols.
       if (missingOne)
         return;
     }
   } else if (!canBeCopyable()) {
     return; // No synthesized conformances for move-only nominals.
   }
 
+  // Don't do any more for synthesized FileUnits.
+  if (file->getKind() == FileUnitKind::Synthesized)
+    return;
+
   // Add protocols for any synthesized protocol attributes.
   for (auto attr : getAttrs().getAttributes<SynthesizedProtocolAttr>()) {
     addSynthesized(attr->getProtocol());

lib/Sema/TypeCheckDecl.cpp

@@ -3088,9 +3088,6 @@ ImplicitKnownProtocolConformanceRequest::evaluate(Evaluator &evaluator,
     return deriveImplicitSendableConformance(evaluator, nominal);
   case KnownProtocolKind::BitwiseCopyable:
     return deriveImplicitBitwiseCopyableConformance(nominal);
-  case KnownProtocolKind::Escapable:
-  case KnownProtocolKind::Copyable:
-    return deriveConformanceForInvertible(evaluator, nominal, kp);
   default:
     llvm_unreachable("non-implicitly derived KnownProtocol");
   }

lib/Sema/TypeCheckInvertible.cpp

@@ -22,7 +22,7 @@
 #include "swift/AST/InverseMarking.h"
 #include "TypeChecker.h"
 
-namespace swift {
+using namespace swift;
 
 /// MARK: diagnostic utilities
 
@@ -267,12 +267,12 @@ static bool checkInvertibleConformanceCommon(ProtocolConformance *conformance,
   return conforms;
 }
 
-bool checkEscapableConformance(ProtocolConformance *conformance) {
+bool swift::checkEscapableConformance(ProtocolConformance *conformance) {
   return checkInvertibleConformanceCommon(conformance,
                                           InvertibleProtocolKind::Escapable);
 }
 
-bool checkCopyableConformance(ProtocolConformance *conformance) {
+bool swift::checkCopyableConformance(ProtocolConformance *conformance) {
   return checkInvertibleConformanceCommon(conformance,
                                           InvertibleProtocolKind::Copyable);
 }
@@ -313,57 +313,3 @@ bool StorageVisitor::visit(NominalTypeDecl *nominal, DeclContext *dc) {
   assert(!isa<ProtocolDecl>(nominal) || !isa<BuiltinTupleDecl>(nominal));
   return false;
 }
-
-/// Produces implicit ProtocolConformances for known protocols. Does _not_ check
-/// whether the conformance is valid. Nor does it recursively check whether
-/// stored properties implicitly conform, so there is no risk of a
-/// request-evaluator cycle.
-///
-/// (the conformance is checked in `TypeChecker::checkConformancesInContext`).
-ProtocolConformance *deriveConformanceForInvertible(Evaluator &evaluator,
-                                                    NominalTypeDecl *nominal,
-                                                    KnownProtocolKind kp) {
-  auto &ctx = nominal->getASTContext();
-  auto *proto = ctx.getProtocol(kp);
-  auto ip = getInvertibleProtocolKind(kp);
-  if (!ip)
-    llvm_unreachable("not an invertible protocol");
-
-  assert(!isa<ClassDecl>(nominal) && "classes aren't handled here");
-
-  // Generates a conformance for the nominal to the protocol.
-  // The conformanceDC specifies THE decl context to use for the conformance.
-  auto generateConformance =
-      [&](DeclContext *conformanceDC) -> ProtocolConformance * {
-    // Form a conformance.
-    auto conformance = ctx.getNormalConformance(
-        nominal->getDeclaredInterfaceType(), proto, nominal->getLoc(),
-        conformanceDC, ProtocolConformanceState::Complete,
-        /*isUnchecked=*/false, /*isPreconcurrency=*/false);
-    conformance->setSourceKindAndImplyingConformance(
-        ConformanceEntryKind::Synthesized, nullptr);
-
-    nominal->registerProtocolConformance(conformance, /*synthesized=*/true);
-    return conformance;
-  };
-
-  // Check what kind of inverse-marking we have to determine whether to generate
-  // a conformance for IP.
-  switch (nominal->hasInverseMarking(*ip).getKind()) {
-  case InverseMarking::Kind::LegacyExplicit:
-  case InverseMarking::Kind::Explicit:
-    return nullptr; // No positive IP conformance will be inferred.
-
-  case InverseMarking::Kind::None:
-    // All types already start with conformances to the invertible protocols in
-    // this case, within `NominalTypeDecl::prepareConformanceTable`.
-    //
-    // There are various other kinds of SourceFiles, like SIL, which instead
-    // get their conformances here instead.
-    //
-    // If there's no inverse, we infer a positive IP conformance.
-    return generateConformance(nominal);
-  }
-}
-
-}

lib/Sema/TypeCheckInvertible.h

@@ -36,11 +36,6 @@ bool checkCopyableConformance(ProtocolConformance *conformance);
 
 /// \returns true if the conformance to Escapable was successfully validated.
 bool checkEscapableConformance(ProtocolConformance *conformance);
-
-/// You should be using `ImplicitKnownProtocolConformanceRequest` instead
-ProtocolConformance *deriveConformanceForInvertible(Evaluator &evaluator,
-                                                    NominalTypeDecl *nominal,
-                                                    KnownProtocolKind kp);
 }
 
 

test/decl/import/import.swift

@@ -1,5 +1,5 @@
 // RUN: %empty-directory(%t)
-// RUN: echo "public struct X {}; public var x = X()" | %target-swift-frontend -module-name import_builtin -parse-stdlib -emit-module -o %t -
+// RUN: echo "import Swift; public struct X {}; public var x = X()" | %target-swift-frontend -module-name import_builtin -parse-stdlib -emit-module -o %t -
 // RUN: echo "public func foo() -> Int { return false }" > %t/import_text.swift
 // RUN: echo "public func phoûx() -> Int { return false }" > %t/français.swift
 // RUN: %target-swift-frontend -typecheck %s -I %t -I %S/../../Inputs/ -sdk "" -enable-source-import -module-name main -verify -show-diagnostics-after-fatal -verify-ignore-unknown