Merge pull request #70488 from kavon/ncgenerics-stdlib-building-v2

[NCGenerics] Fix more issues while building the stdlib

Author: kavon

include/swift/AST/Types.h

@@ -614,6 +614,11 @@ class alignas(1 << TypeAlignInBits) TypeBase
     static_assert(!isSugaredType<T>(), "isa desugars types");
     return isa<T>(getDesugaredType());
   }
+
+  template <typename First, typename Second, typename... Rest>
+  bool is() {
+    return is<First>() || is<Second, Rest...>();
+  }
 
   template <typename T>
   T *castTo() {

lib/AST/Module.cpp

@@ -1671,8 +1671,10 @@ ProtocolConformanceRef ModuleDecl::lookupConformance(Type type,
     if (auto nominal = type->getAnyNominal()) {
       ImplicitKnownProtocolConformanceRequest icvRequest{nominal, *kp};
       if (getASTContext().evaluator.hasActiveRequest(icvRequest) ||
-          getASTContext().evaluator.hasActiveRequest(request))
+          getASTContext().evaluator.hasActiveRequest(request)) {
+        assert(!getInvertibleProtocolKind(*kp));
         return ProtocolConformanceRef::forInvalid();
+      }
     }
   }
 
@@ -1731,13 +1733,35 @@ static ProtocolConformanceRef getBuiltinTupleTypeConformance(
   return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
 }
 
+using EitherFunctionType =
+    llvm::PointerUnion<const SILFunctionType *, const FunctionType *>;
+
 /// Whether the given function type conforms to Sendable.
-static bool isSendableFunctionType(const FunctionType *functionType) {
-  if (functionType->isSendable())
-    return true;
+static bool isSendableFunctionType(EitherFunctionType eitherFnTy) {
+  FunctionTypeRepresentation representation;
+
+  if (auto silFnTy = eitherFnTy.dyn_cast<const SILFunctionType *>()) {
+    if (silFnTy->isSendable())
+      return true;
+
+    // convert SILFunctionTypeRepresentation -> FunctionTypeRepresentation
+    auto converted = convertRepresentation(silFnTy->getRepresentation());
+    if (!converted)
+      return false;
+
+    representation = *converted;
+
+  } else {
+    auto functionType = eitherFnTy.get<const FunctionType *>();
+
+    if (functionType->isSendable())
+      return true;
+
+    representation = functionType->getExtInfo().getRepresentation();
+  }
 
   // C and thin function types have no captures, so they are Sendable.
-  switch (functionType->getExtInfo().getRepresentation()) {
+  switch (representation) {
   case FunctionTypeRepresentation::Block:
   case FunctionTypeRepresentation::Swift:
     return false;
@@ -1749,41 +1773,47 @@ static bool isSendableFunctionType(const FunctionType *functionType) {
 }
 
 /// Whether the given function type conforms to Escapable.
-static bool isEscapableFunctionType(const FunctionType *functionType) {
-  if (functionType->isNoEscape())
-    return false;
+static bool isEscapableFunctionType(EitherFunctionType eitherFnTy) {
+  if (auto silFnTy = eitherFnTy.dyn_cast<const SILFunctionType *>()) {
+    return !silFnTy->isNoEscape();
+  }
 
-  // FIXME: do we need to also include autoclosures??
+  auto functionType = eitherFnTy.get<const FunctionType *>();
 
-  return true;
+  // TODO: what about autoclosures?
+  return !functionType->isNoEscape();
 }
 
 /// Synthesize a builtin function type conformance to the given protocol, if
 /// appropriate.
 static ProtocolConformanceRef getBuiltinFunctionTypeConformance(
-    Type type, const FunctionType *functionType, ProtocolDecl *protocol) {
+    Type type, EitherFunctionType functionType, ProtocolDecl *protocol) {
   ASTContext &ctx = protocol->getASTContext();
-  // @Sendable function types are Sendable.
-  if (protocol->isSpecificProtocol(KnownProtocolKind::Sendable) &&
-      isSendableFunctionType(functionType)) {
-    return ProtocolConformanceRef(
-        ctx.getBuiltinConformance(type, protocol,
-                                  BuiltinConformanceKind::Synthesized));
-  }
 
-  // Functions cannot permanently destroy a move-only var/let
-  // that they capture, so it's safe to copy functions, like classes.
-  if (protocol->isSpecificProtocol(KnownProtocolKind::Copyable)) {
+  auto synthesizeConformance = [&]() -> ProtocolConformanceRef {
     return ProtocolConformanceRef(
         ctx.getBuiltinConformance(type, protocol,
                                   BuiltinConformanceKind::Synthesized));
-  }
+  };
 
-  if (protocol->isSpecificProtocol(KnownProtocolKind::Escapable) &&
-      isEscapableFunctionType(functionType)) {
-    return ProtocolConformanceRef(
-        ctx.getBuiltinConformance(type, protocol,
-                                  BuiltinConformanceKind::Synthesized));
+  if (auto kp = protocol->getKnownProtocolKind()) {
+    switch (*kp) {
+    case KnownProtocolKind::Escapable:
+      if (isEscapableFunctionType(functionType))
+        return synthesizeConformance();
+      break;
+    case KnownProtocolKind::Sendable:
+      // @Sendable function types are Sendable.
+      if (isSendableFunctionType(functionType))
+        return synthesizeConformance();
+      break;
+    case KnownProtocolKind::Copyable:
+      // Functions cannot permanently destroy a move-only var/let
+      // that they capture, so it's safe to copy functions, like classes.
+      return synthesizeConformance();
+    default:
+      break;
+    }
   }
 
   return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
@@ -1959,6 +1989,11 @@ LookupConformanceInModuleRequest::evaluate(
     return getBuiltinFunctionTypeConformance(type, functionType, protocol);
   }
 
+  // SIL function types in the AST can conform to protocols
+  if (auto silFn = type->getAs<SILFunctionType>()) {
+    return getBuiltinFunctionTypeConformance(type, silFn, protocol);
+  }
+
   // Metatypes can conform to protocols.
   if (auto metatypeType = type->getAs<AnyMetatypeType>()) {
     return getBuiltinMetaTypeTypeConformance(type, metatypeType, protocol);
@@ -1969,6 +2004,18 @@ LookupConformanceInModuleRequest::evaluate(
     return getBuiltinBuiltinTypeConformance(type, builtinType, protocol);
   }
 
+#ifndef NDEBUG
+  // Ensure we haven't missed queries for the specialty SIL types
+  // in the AST in conformance to one of the invertible protocols.
+  if (auto kp = protocol->getKnownProtocolKind())
+    if (getInvertibleProtocolKind(*kp))
+      assert(!(type->is<SILFunctionType,
+                        SILBoxType,
+                        SILMoveOnlyWrappedType,
+                        SILPackType,
+                        SILTokenType>()));
+#endif
+
   auto nominal = type->getAnyNominal();
 
   // If we don't have a nominal type, there are no conformances.

lib/SIL/IR/SIL.cpp

@@ -296,14 +296,14 @@ bool SILModule::isTypeMetadataForLayoutAccessible(SILType type) {
   return ::isTypeMetadataForLayoutAccessible(*this, type);
 }
 
-static bool isUnsupportedKeyPathValueType(Type ty) {
+static bool isUnsupportedKeyPathValueType(Type ty, GenericEnvironment *env) {
   // Visit lowered positions.
   if (auto tupleTy = ty->getAs<TupleType>()) {
     for (auto eltTy : tupleTy->getElementTypes()) {
       if (eltTy->is<PackExpansionType>())
         return true;
 
-      if (isUnsupportedKeyPathValueType(eltTy))
+      if (isUnsupportedKeyPathValueType(eltTy, env))
         return true;
     }
 
@@ -321,19 +321,19 @@ static bool isUnsupportedKeyPathValueType(Type ty) {
       if (paramTy->is<PackExpansionType>())
         return true;
 
-      if (isUnsupportedKeyPathValueType(paramTy))
+      if (isUnsupportedKeyPathValueType(paramTy, env))
         return true;
     }
 
-    if (isUnsupportedKeyPathValueType(funcTy->getResult()))
+    if (isUnsupportedKeyPathValueType(funcTy->getResult(), env))
       return true;
   }
 
   // Noncopyable types aren't supported by key paths in their current form.
   // They would also need a new ABI that's yet to be implemented in order to
   // be properly supported, so let's suppress the descriptor for now if either
   // the container or storage type of the declaration is non-copyable.
-  if (ty->isNoncopyable())
+  if (ty->isNoncopyable(env))
     return true;
 
   return false;
@@ -398,7 +398,8 @@ bool AbstractStorageDecl::exportsPropertyDescriptor() const {
     llvm_unreachable("should be definition linkage?");
   }
 
-  if (isUnsupportedKeyPathValueType(getValueInterfaceType())) {
+  auto *env = getDeclContext()->getGenericEnvironmentOfContext();
+  if (isUnsupportedKeyPathValueType(getValueInterfaceType(), env)) {
     return false;
   }
 

lib/SIL/IR/TypeLowering.cpp

@@ -116,15 +116,16 @@ CaptureKind TypeConverter::getDeclCaptureKind(CapturedValue capture,
   assert(var->hasStorage() &&
          "should not have attempted to directly capture this variable");
 
+  auto contextTy = var->getTypeInContext();
   auto &lowering = getTypeLowering(
-      var->getTypeInContext(), TypeExpansionContext::noOpaqueTypeArchetypesSubstitution(
+      contextTy, TypeExpansionContext::noOpaqueTypeArchetypesSubstitution(
                           expansion.getResilienceExpansion()));
 
   // If this is a noncopyable 'let' constant that is not a shared paramdecl or
   // used by a noescape capture, then we know it is boxed and want to pass it in
   // its boxed form so we can obey Swift's capture reference semantics.
   if (!var->supportsMutation()
-      && lowering.getLoweredType().getASTType()->isNoncopyable()
+      && contextTy->isNoncopyable()
       && !capture.isNoEscape()) {
       auto *param = dyn_cast<ParamDecl>(var);
       if (!param || (param->getValueOwnership() != ValueOwnership::Shared &&

lib/SILGen/SILGenBridging.cpp

@@ -759,7 +759,7 @@ static ManagedValue emitNativeToCBridgedNonoptionalValue(SILGenFunction &SGF,
       [&](SubstitutableType *t) -> Type {
         return nativeType;
       },
-      MakeAbstractConformanceForGenericType());
+      LookUpConformanceInModule(SGF.SGM.SwiftModule));
 
     // The intrinsic takes a T; reabstract to the generic abstraction
     // pattern.

lib/Sema/TypeCheckInvertible.cpp

@@ -159,17 +159,28 @@ static void tryEmitContainmentFixits(InFlightDiagnostic &&diag,
 /// MARK: conformance queries
 
 static bool conformsToInvertible(CanType type, InvertibleProtocolKind ip) {
-  assert(!type->hasTypeParameter() && "forgot to mapTypeIntoContext first");
   auto &ctx = type->getASTContext();
 
+  auto *invertible = ctx.getProtocol(getKnownProtocolKind(ip));
+  assert(invertible);
+
   // Pack expansions such as `repeat T` themselves do not have conformances,
   // so check its pattern type for conformance.
   if (auto *pet = type->getAs<PackExpansionType>()) {
     type = pet->getPatternType()->getCanonicalType();
   }
 
-  auto *invertible = ctx.getProtocol(getKnownProtocolKind(ip));
-  assert(invertible);
+  // Must either not have a type parameter, or in the case of a
+  // BoundGenericXType, have a nominal available.
+  assert(!type->hasTypeParameter() || type.getAnyNominal()
+          && "caller forgot to mapTypeIntoContext!");
+
+  // The SIL types in the AST do not have real conformances, and should have
+  // been handled earlier.
+  assert(!(type->is<SILBoxType,
+                    SILMoveOnlyWrappedType,
+                    SILPackType,
+                    SILTokenType>()));
 
   const bool conforms =
       (bool)TypeChecker::conformsToProtocol(type,