Merge pull request swiftlang#71137 from kavon/ncgenerics-enable-stdlib-v1

NCGenerics: synthesize Copyable/Escapable decls

Author: kavon

include/swift/AST/ASTContext.h

@@ -801,6 +801,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()
@@ -1195,6 +1197,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;
@@ -1206,6 +1249,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:
@@ -1251,6 +1295,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;
@@ -1259,7 +1313,7 @@ ProtocolDecl *ASTContext::getProtocol(KnownProtocolKind kind) const {
   if (!M)
     return nullptr;
   M->lookupValue(getIdentifier(getProtocolName(kind)),
-                 NLKind::UnqualifiedLookup,
+                 NameLookupKind,
                  ModuleLookupFlags::ExcludeMacroExpansions,
                  results);
 
@@ -1270,6 +1324,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;
 }
 
@@ -6408,7 +6470,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

@@ -4931,7 +4931,7 @@ InverseMarking TypeDecl::getMarking(InvertibleProtocolKind ip) const {
 static TypeDecl::CanBeInvertible::Result
 conformanceExists(TypeDecl const *decl, InvertibleProtocolKind ip) {
   auto *proto = decl->getASTContext().getProtocol(getKnownProtocolKind(ip));
-  assert(proto);
+  assert(proto && "missing Copyable/Escapable from stdlib!");
 
   // Handle protocols specially, without building a GenericSignature.
   if (auto *protoDecl = dyn_cast<ProtocolDecl>(decl))
@@ -6624,34 +6624,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;
     }
   });
@@ -6784,6 +6785,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/Requirement.cpp

@@ -358,8 +358,7 @@ void InverseRequirement::expandDefaults(
     auto protos = InverseRequirement::expandDefault(gp);
     for (auto ip : protos) {
       auto proto = ctx.getProtocol(getKnownProtocolKind(ip));
-      if (!proto)
-        llvm_unreachable("failed to load Copyable/Escapable/etc from stdlib!");
+      assert(proto && "missing Copyable/Escapable from stdlib!");
 
       auto protoTy = proto->getDeclaredInterfaceType();
       result.push_back({{RequirementKind::Conformance, gp, protoTy},

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/AST/Type.cpp

@@ -388,7 +388,7 @@ static void expandDefaultProtocols(
       continue;
 
     auto proto = ctx.getProtocol(getKnownProtocolKind(ip));
-    assert(proto);
+    assert(proto && "missing Copyable/Escapable from stdlib!");
 
     protocols.push_back(proto);
   }

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/TypeCheckInvertible.cpp

@@ -161,8 +161,8 @@ static void tryEmitContainmentFixits(InFlightDiagnostic &&diag,
 static bool conformsToInvertible(CanType type, InvertibleProtocolKind ip) {
   auto &ctx = type->getASTContext();
 
-  auto *invertible = ctx.getProtocol(getKnownProtocolKind(ip));
-  assert(invertible && "failed to load Copyable/Escapable from stdlib!");
+  auto *proto = ctx.getProtocol(getKnownProtocolKind(ip));
+  assert(proto && "missing Copyable/Escapable from stdlib!");
 
   // Must not have a type parameter!
   assert(!type->hasTypeParameter() && "caller forgot to mapTypeIntoContext!");
@@ -177,8 +177,8 @@ static bool conformsToInvertible(CanType type, InvertibleProtocolKind ip) {
                     SILTokenType>()));
 
   const bool conforms =
-      (bool) invertible->getParentModule()->checkConformance(
-          type, invertible,
+      (bool) proto->getParentModule()->checkConformance(
+          type, proto,
           /*allowMissing=*/false);
 
   return conforms;
@@ -468,13 +468,9 @@ ProtocolConformance *deriveConformanceForInvertible(Evaluator &evaluator,
     // All types already start with conformances to the invertible protocols in
     // this case, within `NominalTypeDecl::prepareConformanceTable`.
     //
-    // I'm currently unsure what happens when rebuilding a module from its
-    // interface, so this might not be unreachable code just yet.
-    if (SWIFT_ENABLE_EXPERIMENTAL_NONCOPYABLE_GENERICS &&
-        file->getKind() != FileUnitKind::Synthesized) {
-      llvm_unreachable("when can this actually happen??");
-    }
-
+    // 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);
   }