NCGenerics: sometimes synth. Copyable/Escapable

When the Swift module is not available, we'll synthesize the
Copyable/Escapable decls into the Builtin module.

In the future, it might be nice to just do this always, and define
typealiases for those types in the stdlib to refer to the ones in the
builtin module.

Author: kavon

include/swift/AST/ASTContext.h

@@ -792,6 +792,13 @@ class ASTContext final {
 
   /// Retrieve a specific, known protocol.
   ProtocolDecl *getProtocol(KnownProtocolKind kind) const;
+
+  /// Synthesizes the given invertible protocol decl into the stdlib (preferred)
+  /// or, if the stdlib is not available, the Builtin module.
+  ///
+  /// Does *not* perform any name lookup to check whether, the module already
+  /// contains a decl with the same name, only does synthesis.
+  ProtocolDecl *synthesizeInvertibleProtocolDecl(InvertibleProtocolKind ip) const;
 
   /// Determine whether the given nominal type is one of the standard
   /// library or Cocoa framework types that is known to be bridged by another

include/swift/AST/KnownIdentifiers.def

@@ -90,6 +90,7 @@ IDENTIFIER(enqueue)
 IDENTIFIER(erasing)
 IDENTIFIER(error)
 IDENTIFIER(errorDomain)
+IDENTIFIER(Escapable)
 IDENTIFIER(Failure)
 IDENTIFIER(first)
 IDENTIFIER(forKeyedSubscript)

lib/AST/ASTContext.cpp

@@ -630,6 +630,8 @@ struct ASTContext::Implementation {
 
   /// The declared interface type of Builtin.TheTupleType.
   BuiltinTupleType *TheTupleType = nullptr;
+
+  std::array<ProtocolDecl *, NumInvertibleProtocols> InvertibleProtocolDecls = {};
 };
 
 ASTContext::Implementation::Implementation()
@@ -1189,6 +1191,47 @@ Type ASTContext::get##NAME##Type() const { \
 
 #include "swift/AST/KnownSDKTypes.def"
 
+ProtocolDecl *
+ASTContext::synthesizeInvertibleProtocolDecl(InvertibleProtocolKind ip) const {
+  const uint8_t index = (uint8_t)ip;
+  if (auto *proto = getImpl().InvertibleProtocolDecls[index])
+    return proto;
+
+  ModuleDecl *stdlib = getStdlibModule();
+  FileUnit *file = nullptr;
+  if (stdlib) {
+    file = &stdlib->getFiles()[0]->getOrCreateSynthesizedFile();
+  } else {
+    file = &TheBuiltinModule->getMainFile(FileUnitKind::Builtin);
+  }
+
+  // No need to form an inheritance clause; invertible protocols do not
+  // implicitly inherit from other invertible protocols.
+  auto identifier = getIdentifier(getProtocolName(getKnownProtocolKind(ip)));
+  ProtocolDecl *protocol = new (*this) ProtocolDecl(file,
+                                                  SourceLoc(), SourceLoc(),
+                                                  identifier,
+                                                  /*primaryAssocTypes=*/{},
+                                                  /*inherited=*/{},
+                                                  /*whereClause=*/nullptr);
+  protocol->setImplicit(true);
+
+  // @_marker
+  protocol->getAttrs().add(new (*this) MarkerAttr(/*implicit=*/true));
+
+  // public
+  protocol->setAccess(AccessLevel::Public);
+
+  // Hack to get name lookup to work after synthesizing it into the stdlib.
+  if (stdlib) {
+    cast<SynthesizedFileUnit>(file)->addTopLevelDecl(protocol);
+    stdlib->clearLookupCache();
+  }
+
+  getImpl().InvertibleProtocolDecls[index] = protocol;
+  return protocol;
+}
+
 ProtocolDecl *ASTContext::getProtocol(KnownProtocolKind kind) const {
   // Check whether we've already looked for and cached this protocol.
   unsigned index = (unsigned)kind;
@@ -1200,6 +1243,7 @@ ProtocolDecl *ASTContext::getProtocol(KnownProtocolKind kind) const {
   SmallVector<ValueDecl *, 1> results;
 
   const ModuleDecl *M;
+  NLKind NameLookupKind = NLKind::UnqualifiedLookup;
   switch (kind) {
   case KnownProtocolKind::BridgedNSError:
   case KnownProtocolKind::BridgedStoredNSError:
@@ -1245,6 +1289,16 @@ ProtocolDecl *ASTContext::getProtocol(KnownProtocolKind kind) const {
   case KnownProtocolKind::UnsafeCxxMutableRandomAccessIterator:
     M = getLoadedModule(Id_Cxx);
     break;
+  case KnownProtocolKind::Copyable:
+  case KnownProtocolKind::Escapable:
+    // If there's no stdlib, do qualified lookup in the Builtin module,
+    // which will trigger the correct synthesis of the protocols in that module.
+    M = getStdlibModule();
+    if (!M) {
+      NameLookupKind = NLKind::QualifiedLookup;
+      M = TheBuiltinModule;
+    }
+    break;
   default:
     M = getStdlibModule();
     break;
@@ -1253,7 +1307,7 @@ ProtocolDecl *ASTContext::getProtocol(KnownProtocolKind kind) const {
   if (!M)
     return nullptr;
   M->lookupValue(getIdentifier(getProtocolName(kind)),
-                 NLKind::UnqualifiedLookup,
+                 NameLookupKind,
                  ModuleLookupFlags::ExcludeMacroExpansions,
                  results);
 
@@ -1264,6 +1318,14 @@ ProtocolDecl *ASTContext::getProtocol(KnownProtocolKind kind) const {
     }
   }
 
+  // If the invertible protocol wasn't found in the stdlib, synthesize it there.
+  if (auto ip = getInvertibleProtocolKind(kind)) {
+    assert(M == getStdlibModule());
+    auto *protocol = synthesizeInvertibleProtocolDecl(*ip);
+    getImpl().KnownProtocols[index] = protocol;
+    return protocol;
+  }
+
   return nullptr;
 }
 
@@ -6394,7 +6456,7 @@ BuiltinTupleDecl *ASTContext::getBuiltinTupleDecl() {
   if (result)
     return result;
 
-  auto *dc = TheBuiltinModule->getFiles()[0];
+  auto *dc = &TheBuiltinModule->getMainFile(FileUnitKind::Builtin);
 
   result = new (*this) BuiltinTupleDecl(Id_TheTupleType, dc);
   result->setAccess(AccessLevel::Public);

lib/AST/Builtins.cpp

@@ -2404,6 +2404,11 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
   if (Id == Context.Id_TheTupleType)
     return Context.getBuiltinTupleDecl();
 
+  if (Id == Context.Id_Copyable)
+    return Context.synthesizeInvertibleProtocolDecl(InvertibleProtocolKind::Copyable);
+  if (Id == Context.Id_Escapable)
+    return Context.synthesizeInvertibleProtocolDecl(InvertibleProtocolKind::Escapable);
+
   SmallVector<Type, 4> Types;
   StringRef OperationName = getBuiltinBaseName(Context, Id.str(), Types);
 

lib/AST/Decl.cpp

@@ -6590,34 +6590,35 @@ bool ProtocolDecl::inheritsFrom(const ProtocolDecl *super) const {
 }
 
 bool ProtocolDecl::requiresInvertible(InvertibleProtocolKind ip) const {
-  // Specially handle when asking if an invertible protocol requires another.
+  // Protocols don't inherit from themselves.
   if (auto thisIP = getInvertibleProtocolKind()) {
-    if (SWIFT_ENABLE_EXPERIMENTAL_NONCOPYABLE_GENERICS) {
-      // Hardcode that the invertible protocols do not require themselves.
-      // Otherwise, defer to what the stdlib says by walking the protocol.
-      if (thisIP == ip)
-        return false;
-    } else {
-      // The stdlib was NOT built with noncopyable generics, so claim that
-      // this invertible protocol require no others.
-      // FIXME: this configuration will eventually go away.
+    if (thisIP == ip)
       return false;
-    }
   }
 
   auto kp = ::getKnownProtocolKind(ip);
+
+  // Otherwise, check for inverses on all of the inherited protocols. If there
+  // is one protocol missing an inverse for this `super` protocol, then it is
+  // implicitly inherited.
   return walkInheritedProtocols([kp, ip](ProtocolDecl *proto) {
     if (proto->isSpecificProtocol(kp))
-      return TypeWalker::Action::Stop; // it is required.
+      return TypeWalker::Action::Stop; // It is explicitly inherited.
+
+    // There is no implicit inheritance of an invertible protocol requirement
+    // on an invertible protocol itself.
+    if (proto->getInvertibleProtocolKind())
+      return TypeWalker::Action::Continue;
 
+    // Otherwise, check to see if there's an inverse on this protocol.
     switch (proto->getMarking(ip).getInverse().getKind()) {
     case InverseMarking::Kind::None:
-      return TypeWalker::Action::Stop; // it is required.
+      return TypeWalker::Action::Stop; // No inverse, so implicitly inherited.
 
     case InverseMarking::Kind::LegacyExplicit:
     case InverseMarking::Kind::Explicit:
     case InverseMarking::Kind::Inferred:
-      // the implicit requirement was suppressed on this protocol, keep looking.
+      // The implicit requirement was suppressed on this protocol, keep looking.
       return TypeWalker::Action::Continue;
     }
   });
@@ -6750,6 +6751,7 @@ ProtocolDecl::setLazyPrimaryAssociatedTypeMembers(
 void ProtocolDecl::computeKnownProtocolKind() const {
   auto module = getModuleContext();
   if (module != module->getASTContext().getStdlibModule() &&
+      module != module->getASTContext().TheBuiltinModule &&
       !module->getName().is("Foundation") &&
       !module->getName().is("_Differentiation") &&
       !module->getName().is("_Concurrency") &&

lib/AST/RequirementMachine/RequirementLowering.cpp

@@ -1037,7 +1037,10 @@ StructuralRequirementsRequest::evaluate(Evaluator &evaluator,
 
   desugarRequirements(result, inverses, errors);
 
-  InverseRequirement::expandDefaults(ctx, needsDefaultRequirements, result);
+  // We do not expand defaults for invertible protocols themselves.
+  if (!proto->getInvertibleProtocolKind())
+    InverseRequirement::expandDefaults(ctx, needsDefaultRequirements, result);
+
   applyInverses(ctx, needsDefaultRequirements, inverses, result, errors);
 
   diagnoseRequirementErrors(ctx, errors,

lib/SILGen/SILGenTopLevel.cpp

@@ -377,9 +377,8 @@ void SILGenTopLevel::visitSourceFile(SourceFile *SF) {
 
   if (auto *SynthesizedFile = SF->getSynthesizedFile()) {
     for (auto *D : SynthesizedFile->getTopLevelDecls()) {
-      if (isa<ExtensionDecl>(D)) {
-        visit(D);
-      }
+      assert(isa<ExtensionDecl>(D) || isa<ProtocolDecl>(D));
+      visit(D);
     }
   }
 

lib/Sema/TypeChecker.cpp

@@ -290,21 +290,27 @@ TypeCheckSourceFileRequest::evaluate(Evaluator &eval, SourceFile *SF) const {
       }
     }
 
-    // Type-check macro-generated or implicitly-synthesized extensions.
+    // Type-check macro-generated or implicitly-synthesized decls.
     if (auto *synthesizedSF = SF->getSynthesizedFile()) {
       for (auto *decl : synthesizedSF->getTopLevelDecls()) {
-        auto extension = cast<ExtensionDecl>(decl);
-
-        // Limit typechecking of synthesized _implicit_ extensions to conformance
-        // checking. This is done because a conditional conformance to Copyable
-        // is synthesized as an extension, based on the markings of `~Copyable`
-        // in a value type. This call to `checkConformancesInContext` will
-        // the actual check to verify that the conditional extension is correct,
-        // as it may be an invalid conformance.
-        if (extension->isImplicit())
-          TypeChecker::checkConformancesInContext(extension);
-        else
-          TypeChecker::typeCheckDecl(extension);
+        assert(isa<ExtensionDecl>(decl) || isa<ProtocolDecl>(decl));
+
+        // Limit typechecking of synthesized _implicit_ extensions to
+        // conformance checking. This is done because a conditional
+        // conformance to Copyable is synthesized as an extension, based on
+        // the markings of ~Copyable in a value type. This call to
+        // checkConformancesInContext will the actual check to verify that
+        // the conditional extension is correct, as it may be an invalid
+        // conformance.
+        if (auto *extension = dyn_cast<ExtensionDecl>(decl)) {
+          if (extension->isImplicit()) {
+            TypeChecker::checkConformancesInContext(extension);
+            continue;
+          }
+        }
+
+        // For other kinds of decls, do normal typechecking.
+        TypeChecker::typeCheckDecl(decl);
       }
     }
     SF->typeCheckDelayedFunctions();

stdlib/public/core/Misc.swift

@@ -169,17 +169,8 @@ func _rethrowsViaClosure(_ fn: () throws -> ()) rethrows {
   try fn()
 }
 
-#if $NoncopyableGenerics && $NonescapableTypes
-@_marker public protocol Copyable: ~Escapable {}
-@_marker public protocol Escapable: ~Copyable {}
-
-#elseif $NoncopyableGenerics
 @_marker public protocol Copyable {}
-@_marker public protocol Escapable: ~Copyable {}
 
-#else
-@_marker public protocol Copyable {}
 @_marker public protocol Escapable {}
-#endif
 
 @_marker public protocol _BitwiseCopyable {}

test/Sema/copyable_constraint.swift

@@ -2,8 +2,8 @@
 // >> First verify that when building the stdlib, we do have the copyable constraint. Note the module-name!!
 // RUN: %target-swift-frontend -typecheck -verify -parse-stdlib -module-name Swift %s
 
-// FIXME: Now demonstrate that plain -parse-stdlib, such as in some arbitrary test, doesn't get the Copyable constraint :(
-// RUN: not %target-swift-frontend -typecheck -verify -parse-stdlib %s
+// Demonstrate that plain -parse-stdlib, such as in some arbitrary test, does still get the Copyable constraint
+// RUN: %target-swift-frontend -typecheck -verify -parse-stdlib %s
 
 @_marker public protocol Copyable {}