[NCGenerics] fix type lowering

TypeDecl::canBeNoncopyable is never going to be fully accurate. In this
instance, we were incorrectly treating some types like `S<T: ~Copyable>`
 as noncopyable, and thus non-trivial, despite them in some cases being
 Copyable.

Author: kavon

include/swift/AST/Types.h

@@ -647,11 +647,19 @@ class alignas(1 << TypeAlignInBits) TypeBase
 
   /// Returns true if this type lacks conformance to Copyable in the context,
   /// if provided.
-  bool isNoncopyable(const DeclContext *dc = nullptr);
+  bool isNoncopyable(GenericEnvironment *env = nullptr);
+  bool isNoncopyable(const DeclContext *dc) {
+    assert(dc);
+    return isNoncopyable(dc->getGenericEnvironmentOfContext());
+  };
 
   /// Returns true if this type conforms to Escapable in the context,
   /// if provided.
-  bool isEscapable(const DeclContext *dc = nullptr);
+  bool isEscapable(GenericEnvironment *env = nullptr);
+  bool isEscapable(const DeclContext *dc) {
+    assert(dc);
+    return isEscapable(dc->getGenericEnvironmentOfContext());
+  };
 
   /// Does the type have outer parenthesis?
   bool hasParenSugar() const { return getKind() == TypeKind::Paren; }

lib/AST/ASTPrinter.cpp

@@ -1737,7 +1737,8 @@ void PrintAST::printGenericSignature(
         genericParams.slice(paramIdx, lastParamIdx - paramIdx);
 
     SmallVector<InverseRequirement, 2> inversesAtDepth;
-    reconstituteInverses(genericSig, genericParamsAtDepth, inversesAtDepth);
+    if (flags & CollapseDefaultReqs)
+      reconstituteInverses(genericSig, genericParamsAtDepth, inversesAtDepth);
 
     SmallVector<Requirement, 2> requirementsAtDepth;
     getRequirementsAtDepth(genericSig, depth, requirementsAtDepth);

lib/AST/Decl.cpp

@@ -4910,12 +4910,13 @@ InverseMarking TypeDecl::getMarking(InvertibleProtocolKind ip) const {
 }
 
 bool TypeDecl::canBeNoncopyable() const {
-  return getMarking(InvertibleProtocolKind::Copyable).getInverse().isPresent();
+  auto copyable = getMarking(InvertibleProtocolKind::Copyable);
+  return bool(copyable.getInverse()) && !copyable.getPositive();
 }
 
 bool TypeDecl::isEscapable() const {
   auto escapable = getMarking(InvertibleProtocolKind::Escapable);
-  return !escapable.getInverse().isPresent();
+  return !escapable.getInverse() || bool(escapable.getPositive());
 }
 
 Type TypeDecl::getDeclaredInterfaceType() const {

lib/AST/Type.cpp

@@ -177,24 +177,22 @@ static bool alwaysNoncopyable(Type ty) {
   return false; // otherwise, the conservative assumption is it's copyable.
 }
 
-static CanType preprocessType(const DeclContext *dc, Type orig) {
+static CanType preprocessType(GenericEnvironment *env, Type orig) {
   Type type = orig;
 
   // Turn any type parameters into archetypes.
-  if (dc) {
+  if (env)
     if (!type->hasArchetype() || type->hasOpenedExistential())
-      if (auto env = dc->getGenericEnvironmentOfContext())
-        type = GenericEnvironment::mapTypeIntoContext(env, type);
-  }
+      type = GenericEnvironment::mapTypeIntoContext(env, type);
 
   // Strip @lvalue and canonicalize.
   auto canType = type->getRValueType()->getCanonicalType();
   return canType;
 }
 
 /// \returns true iff this type lacks conformance to Copyable.
-bool TypeBase::isNoncopyable(const DeclContext *dc) {
-  auto canType = preprocessType(dc, this);
+bool TypeBase::isNoncopyable(GenericEnvironment *env) {
+  auto canType = preprocessType(env, this);
   auto &ctx = canType->getASTContext();
 
   // for legacy-mode queries that are not dependent on conformances to Copyable
@@ -205,8 +203,8 @@ bool TypeBase::isNoncopyable(const DeclContext *dc) {
   return evaluateOrDefault(ctx.evaluator, request, /*default=*/true);
 }
 
-bool TypeBase::isEscapable(const DeclContext *dc) {
-  auto canType = preprocessType(dc, this);
+bool TypeBase::isEscapable(GenericEnvironment *env) {
+  auto canType = preprocessType(env, this);
   auto &ctx = canType->getASTContext();
 
   // for legacy-mode queries that are not dependent on conformances to Escapable

lib/SIL/IR/TypeLowering.cpp

@@ -2406,15 +2406,19 @@ namespace {
       properties =
           applyLifetimeAnnotation(D->getLifetimeAnnotation(), properties);
 
-      if (D->canBeNoncopyable()) {
+      GenericEnvironment *env = nullptr;
+      if (auto sig = origType.getGenericSignatureOrNull())
+        env = sig.getGenericEnvironment();
+
+      if (structType->isNoncopyable(env)) {
         properties.setNonTrivial();
         properties.setLexical(IsLexical);
         if (properties.isAddressOnly())
           return handleMoveOnlyAddressOnly(structType, properties);
         return new (TC) MoveOnlyLoadableStructTypeLowering(
             structType, properties, Expansion);
       }
-      if (!D->isEscapable()) {
+      if (!structType->isEscapable(env)) {
         properties.setNonTrivial();
       }
       return handleAggregateByProperties<LoadableStructTypeLowering>(structType,
@@ -2493,7 +2497,11 @@ namespace {
       properties =
           applyLifetimeAnnotation(D->getLifetimeAnnotation(), properties);
 
-      if (D->canBeNoncopyable()) {
+      GenericEnvironment *env = nullptr;
+      if (auto sig = origType.getGenericSignatureOrNull())
+        env = sig.getGenericEnvironment();
+
+      if (enumType->isNoncopyable(env)) {
         properties.setNonTrivial();
         properties.setLexical(IsLexical);
         if (properties.isAddressOnly())
@@ -2502,6 +2510,8 @@ namespace {
             MoveOnlyLoadableEnumTypeLowering(enumType, properties, Expansion);
       }
 
+      assert(enumType->isEscapable(env) && "missing typelowering case here!");
+
       return handleAggregateByProperties<LoadableEnumTypeLowering>(enumType,
                                                                    properties);
     }

test/SILGen/typelowering_inverses.swift

@@ -0,0 +1,51 @@
+// RUN: %target-swift-frontend -emit-silgen -enable-experimental-feature NoncopyableGenerics -disable-availability-checking -module-name main %s | %FileCheck %s
+
+struct NC: ~Copyable {}
+
+struct RudeStruct<T: ~Copyable>: Copyable {
+    let thing: Int
+}
+
+enum RudeEnum<T: ~Copyable>: Copyable {
+  case holder(Int)
+  case whatever
+}
+
+struct CondCopyableStruct<T: ~Copyable> {}
+
+enum CondCopyableEnum<T: ~Copyable> {
+  case some(T)
+  case none
+}
+
+// MARK: ensure certain types are treated as trivial (no ownership in func signature).
+
+// CHECK: sil hidden [ossa] @$s4main5checkyyAA10RudeStructVySiGF : $@convention(thin) (RudeStruct<Int>) -> () {
+func check(_ t: RudeStruct<Int>) {}
+
+// CHECK: sil hidden [ossa] @$s4main5checkyyAA10RudeStructVyAA2NCVGF : $@convention(thin) (RudeStruct<NC>) -> () {
+func check(_ t: RudeStruct<NC>) {}
+
+// CHECK: sil hidden [ossa] @$s4main5checkyyAA8RudeEnumOySiGF : $@convention(thin) (RudeEnum<Int>) -> () {
+func check(_ t: RudeEnum<Int>) {}
+
+// CHECK: sil hidden [ossa] @$s4main5checkyyAA8RudeEnumOyAA2NCVGF : $@convention(thin) (RudeEnum<NC>) -> () {
+func check(_ t: RudeEnum<NC>) {}
+
+// CHECK: sil hidden [ossa] @$s4main5checkyyAA18CondCopyableStructVySiGF : $@convention(thin) (CondCopyableStruct<Int>) -> () {
+func check(_ t: CondCopyableStruct<Int>) {}
+
+// CHECK: sil hidden [ossa] @$s4main5checkyyAA18CondCopyableStructVyAA2NCVGF : $@convention(thin) (@guaranteed CondCopyableStruct<NC>) -> () {
+func check(_ t: borrowing CondCopyableStruct<NC>) {}
+
+// CHECK: sil hidden [ossa] @$s4main5checkyyAA16CondCopyableEnumOySiGF : $@convention(thin) (CondCopyableEnum<Int>) -> () {
+func check(_ t: CondCopyableEnum<Int>) {}
+
+// CHECK: sil hidden [ossa] @$s4main5checkyyAA16CondCopyableEnumOyAA2NCVGF : $@convention(thin) (@guaranteed CondCopyableEnum<NC>) -> () {
+func check(_ t: borrowing CondCopyableEnum<NC>) {}
+
+// CHECK: sil hidden [ossa] @$s4main5checkyyAA16CondCopyableEnumOyxGs0D0Rzs9EscapableRzlF : $@convention(thin) <T where T : Copyable, T : Escapable> (@in_guaranteed CondCopyableEnum<T>) -> () {
+func check<T>(_ t: CondCopyableEnum<T>) {}
+
+// CHECK: sil hidden [ossa] @$s4main5checkyyAA16CondCopyableEnumOyxGs9EscapableRzlF : $@convention(thin) <U where U : Escapable> (@in_guaranteed CondCopyableEnum<U>) -> () {
+func check<U: ~Copyable>(_ t: borrowing CondCopyableEnum<U>) {}