Sema: Implement new behavior of extensions with non-copyable generics

We want extensions to introduce default Copyable/Escapable just like
other generic contexts, so that once Optional adopts ~Copyable,
an `extension Optional` actually adds `Wrapped: Copyable` by default.

Author: slavapestov

lib/AST/RequirementMachine/RequirementMachineRequests.cpp

@@ -791,6 +791,10 @@ InferredGenericSignatureRequest::evaluate(
     return false;
   };
 
+  // "Local" generic parameters to which we apply default Copyable and
+  // Escapable.
+  SmallVector<Type, 4> paramTypes;
+
   if (genericParamList) {
     // Extensions never have a parent signature.
     assert(genericParamList->getOuterParameters() == nullptr || !parentSig);
@@ -807,6 +811,10 @@ InferredGenericSignatureRequest::evaluate(
     // We walk them backwards to order outer parameters before inner
     // parameters.
     for (auto *gpList : llvm::reverse(gpLists)) {
+      for (auto *gpDecl : *gpList) {
+        paramTypes.push_back(gpDecl->getDeclaredInterfaceType());
+      }
+
       assert(gpList->size() > 0 &&
              "Parsed an empty generic parameter list?");
 
@@ -864,15 +872,16 @@ InferredGenericSignatureRequest::evaluate(
 
   desugarRequirements(requirements, inverses, errors);
 
+  if (!genericParamList && allowConcreteGenericParams) {
+    for (auto paramTy : genericParams) {
+      paramTypes.push_back(paramTy);
+    }
+  }
+
   // After realizing requirements, expand default requirements only for local
   // generic parameters, as the outer parameters have already been expanded.
-  SmallVector<Type, 4> localGPs;
-  if (genericParamList)
-    for (auto *gtpd : genericParamList->getParams())
-      localGPs.push_back(gtpd->getDeclaredInterfaceType());
-
-  InverseRequirement::expandDefaults(ctx, localGPs, requirements);
-  applyInverses(ctx, localGPs, inverses, requirements, errors);
+  InverseRequirement::expandDefaults(ctx, paramTypes, requirements);
+  applyInverses(ctx, paramTypes, inverses, requirements, errors);
 
   // Re-order requirements so that inferred requirements appear last. This
   // ensures that if an inferred requirement is redundant with some other
@@ -947,7 +956,7 @@ InferredGenericSignatureRequest::evaluate(
     if (attempt == 0) {
       machine->computeRequirementDiagnostics(errors, inverses, loc);
       diagnoseRequirementErrors(ctx, errors,
-                                allowConcreteGenericParams
+                                (allowConcreteGenericParams || !genericParamList)
                                 ? AllowConcreteTypePolicy::All
                                 : AllowConcreteTypePolicy::AssocTypes);
     }
@@ -978,7 +987,7 @@ InferredGenericSignatureRequest::evaluate(
                                            std::move(machine));
     }
 
-    if (!allowConcreteGenericParams) {
+    if (genericParamList && !allowConcreteGenericParams) {
       for (auto genericParam : result.getInnermostGenericParams()) {
         auto reduced = result.getReducedType(genericParam);
 

lib/Sema/TypeCheckAttr.cpp

@@ -3073,7 +3073,7 @@ SerializeAttrGenericSignatureRequest::evaluate(Evaluator &evaluator,
       WhereClauseOwner(const_cast<AbstractFunctionDecl *>(FD), attr),
       /*addedRequirements=*/{},
       /*inferenceSources=*/{},
-      /*allowConcreteGenericParams=*/true};
+      /*allowConcreteGenericParams=*/false};
 
   auto specializedSig = evaluateOrDefault(Ctx.evaluator, request,
                                           GenericSignatureWithError())

lib/Sema/TypeCheckGeneric.cpp

@@ -679,9 +679,6 @@ GenericSignatureRequest::evaluate(Evaluator &evaluator,
     }
   }
 
-  if (!genericParams && where)
-    allowConcreteGenericParams = true;
-
   GenericSignature parentSig;
   SmallVector<TypeLoc, 2> inferenceSources;
   SmallVector<Requirement, 2> extraReqs;
@@ -793,7 +790,9 @@ GenericSignatureRequest::evaluate(Evaluator &evaluator,
     // the right sugared types, since we don't want to expose the
     // name of the generic parameter of BuiltinTupleDecl itself.
     if (extraReqs.empty() && !ext->getTrailingWhereClause() &&
-        !isa<BuiltinTupleDecl>(extendedNominal)) {
+        !isa<BuiltinTupleDecl>(extendedNominal) &&
+        !ctx.LangOpts.hasFeature(Feature::NoncopyableGenerics)) {
+      // FIXME: Recover this optimization even with NoncopyableGenerics on.
       return parentSig;
     }
 

test/Generics/inverse_generics.swift

@@ -138,14 +138,13 @@ typealias err1 = RequireCopyable<Maybe<NC>>
 typealias err2 = RequireCopyable<NC>
 // expected-error@-1{{type 'NC' does not conform to protocol 'Copyable'}}
 
-// plain extension doesn't treat Self as Copyable
-extension Maybe {
+extension Maybe where Wrapped: ~Copyable {
   func check1(_ t: RequireCopyable<Self>) {}
   // expected-error@-1 {{type 'Wrapped' does not conform to protocol 'Copyable'}}
   // expected-error@-2 {{'RequireCopyable' requires that 'Wrapped' conform to 'Copyable'}}
 }
 
-extension Maybe where Self: Copyable {
+extension Maybe {
   func check2(_ t: RequireCopyable<Self>) {}
 }
 
@@ -181,8 +180,7 @@ enum EnumExtendo {}
 extension EnumExtendo: ~Copyable {} // expected-error {{cannot apply inverse '~Copyable' to extension}}
 
 extension NeedsCopyable where Self: ~Copyable {}
-// expected-error@-1 {{cannot add inverse constraint 'Self: ~Copyable' on generic parameter 'Self' defined in outer scope}}
-// expected-error@-2 {{'Self' required to be 'Copyable' but is marked with '~Copyable'}}
+// expected-error@-1 {{'Self' required to be 'Copyable' but is marked with '~Copyable'}}
 
 protocol NoCopyP: ~Copyable {}
 

test/Generics/inverse_protocols.swift

@@ -7,7 +7,7 @@ protocol Eq: ~Copyable {
   func different(from: borrowing Self) -> Bool
 }
 
-extension Eq {
+extension Eq where Self: ~Copyable {
   func different(from other: borrowing Self) -> Bool { !same(as: other) }
 }
 

test/Generics/inverse_scoping.swift

@@ -19,10 +19,10 @@ protocol P {
 
 protocol U {}
 
-extension U where Self: ~Copyable {} // expected-error {{cannot add inverse constraint 'Self: ~Copyable' on generic parameter 'Self' defined in outer scope}}
+extension U where Self: ~Copyable {}
 // expected-error@-1 {{'Self' required to be 'Copyable' but is marked with '~Copyable'}}
 
-extension P {
+extension P where Self: ~Copyable {
   func g() where Self: ~Copyable, // expected-error {{cannot add inverse constraint 'Self: ~Copyable' on generic parameter 'Self' defined in outer scope}}
                                   // FIXME: why no similar 2nd error as Escapable here on Self?
 
@@ -53,7 +53,7 @@ struct S<T> {
             {}
 }
 
-extension S where T: NoCopyReq & ~Copyable {} // expected-error {{cannot add inverse constraint 'T: ~Copyable' on generic parameter 'T' defined in outer scope}}
+extension S where T: NoCopyReq & ~Copyable {}
 // expected-error@-1 {{'T' required to be 'Copyable' but is marked with '~Copyable'}}
 
 struct ExtraInverse<T: ~Copyable> {

test/Generics/inverse_signatures.swift

@@ -202,7 +202,7 @@ struct ImplicitCond<T: ~Escapable & ~Copyable> {}
 
 // CHECK-LABEL: ExtensionDecl line={{.*}} base=ImplicitCond
 // CHECK-NEXT: (normal_conformance type="ImplicitCond<T>" protocol="Empty")
-extension ImplicitCond: Empty {}
+extension ImplicitCond: Empty where T: ~Copyable, T: ~Escapable {}
 
 
 // NOTE: the following extensions were implicitly synthesized, so they appear at the end!

test/ModuleInterface/Inputs/Swiftskell.swift

@@ -19,18 +19,12 @@ public protocol Eq: ~Copyable {
   static func /=(_ a: borrowing Self, _ b: borrowing Self) -> Bool
 }
 
-public extension Eq {
+public extension Eq where Self: ~Copyable {
   static func /=(_ a: borrowing Self, _ b: borrowing Self) -> Bool {
     return !(a == b)
   }
 }
 
-public extension Eq where Self: Equatable {
-  static func ==(_ a: borrowing Self, _ b: borrowing Self) -> Bool {
-    return a == b
-  }
-}
-
 /// MARK: Result
 public enum Either<Success, Failure: Error> {
   case success(Success)
@@ -70,13 +64,13 @@ public enum Maybe<Value: ~Copyable> {
   case nothing
 }
 
-extension Maybe: Show {
+extension Maybe: Show where Value: ~Copyable {
   public borrowing func show() -> String {
     fatalError("need borrowing switches")
   }
 }
 
-extension Maybe: Eq where Value: Eq {
+extension Maybe: Eq where Value: Eq, Value: ~Copyable {
   public static func ==(_ a: borrowing Self, _ b: borrowing Self) -> Bool {
     fatalError("need borrowing switches")
   }

test/ModuleInterface/noncopyable_generics.swift

@@ -108,7 +108,7 @@ import NoncopyableGenerics_Misc
 // Synthesized conditional conformances are next
 
 // CHECK-MISC: #if compiler(>=5.3) && $NoncopyableGenerics
-// CHECK-MISC-NEXT: extension {{.*}}.Hello : Swift.Copyable where T : Swift.Copyable {
+// CHECK-MISC-NEXT: extension {{.*}}.Hello : Swift.Copyable where T : ~Escapable {
 
 ////////////////////////////////////////////////////////////////////////
 //    At the end, ensure there are no synthesized Copyable extensions
@@ -127,10 +127,7 @@ import Swiftskell
 // CHECK-NEXT: public protocol Eq : ~Copyable {
 
 // CHECK: #if compiler(>=5.3) && $NoncopyableGenerics
-// CHECK-NEXT: extension Swiftskell.Eq {
-
-// CHECK: #if compiler(>=5.3) && $NoncopyableGenerics
-// CHECK-NEXT: extension Swiftskell.Eq where Self : Swift.Equatable {
+// CHECK-NEXT: extension Swiftskell.Eq where Self : ~Copyable {
 
 // CHECK: #if compiler(>=5.3) && $NoncopyableGenerics
 // CHECK-NEXT: public protocol Generator : ~Copyable {
@@ -143,10 +140,10 @@ import Swiftskell
 // CHECK-NEXT: public enum Maybe<Value> where Value : ~Copyable {
 
 // CHECK: #if compiler(>=5.3) && $NoncopyableGenerics
-// CHECK-NEXT: extension Swiftskell.Maybe : Swiftskell.Show {
+// CHECK-NEXT: extension Swiftskell.Maybe : Swiftskell.Show where Value : ~Copyable {
 
 // CHECK: #if compiler(>=5.3) && $NoncopyableGenerics
-// CHECK-NEXT: extension Swiftskell.Maybe : Swiftskell.Eq where Value : Swiftskell.Eq {
+// CHECK-NEXT: extension Swiftskell.Maybe : Swiftskell.Eq where Value : Swiftskell.Eq, Value : ~Copyable {
 
 // CHECK: #if compiler(>=5.3) && $NoncopyableGenerics
 // CHECK-NEXT: public func maybe<A, B>(_ defaultVal: B, _ fn: (consuming A) -> B) -> (consuming Swiftskell.Maybe<A>) -> B where A : ~Copyable

test/Serialization/noncopyable_generics.swift

@@ -19,7 +19,7 @@
 
 // CHECK-PRINT-DAG: protocol Generator<Value> {
 // CHECK-PRINT-DAG: enum Maybe<Wrapped> where Wrapped : ~Copyable {
-// CHECK-PRINT-DAG: extension Maybe : Copyable where Wrapped : Copyable {
+// CHECK-PRINT-DAG: extension Maybe : Copyable {
 // CHECK-PRINT-DAG: func ncIdentity<T>(_ t: consuming T) -> T where T : ~Copyable
 // CHECK-PRINT-DAG: protocol Either<Left, Right> : ~Copyable {
 // CHECK-PRINT-DAG:   associatedtype Left : ~Copyable