Merge pull request #21154 from slavapestov/fully-concrete-generic-devirt-5.0

Fix devirtualization of conditional conformance where all generic parameters are concrete [5.0]

Author: AnnaZaks

lib/AST/ASTContext.cpp

@@ -4048,6 +4048,10 @@ SILFunctionType::SILFunctionType(GenericSignature *genericSig, ExtInfo ext,
 
   // Make sure the interface types are sane.
   if (genericSig) {
+    assert(!genericSig->areAllParamsConcrete() &&
+           "If all generic parameters are concrete, SILFunctionType should "
+           "not have a generic signature at all");
+
     for (auto gparam : genericSig->getGenericParams()) {
       (void)gparam;
       assert(gparam->isCanonical() && "generic signature is not canonicalized");

lib/IRGen/GenProto.cpp

@@ -3095,7 +3095,7 @@ GenericTypeRequirements::GenericTypeRequirements(IRGenModule &IGM,
   // We only need to do something here if the declaration context is
   // somehow generic.
   auto ncGenerics = typeDecl->getGenericSignatureOfContext();
-  if (!ncGenerics) return;
+  if (!ncGenerics || ncGenerics->areAllParamsConcrete()) return;
 
   // Construct a representative function type.
   auto generics = ncGenerics->getCanonicalSignature();

lib/SILGen/SILGenType.cpp

@@ -608,31 +608,41 @@ SILFunction *SILGenModule::emitProtocolWitness(
 
   // The generic environment for the witness thunk.
   auto *genericEnv = witness.getSyntheticEnvironment();
+  CanGenericSignature genericSig;
+  if (genericEnv)
+    genericSig = genericEnv->getGenericSignature()->getCanonicalSignature();
 
   // The type of the witness thunk.
-  auto substReqtTy =
-        cast<AnyFunctionType>(reqtOrigTy.subst(reqtSubMap)->getCanonicalType());
-
-  // If there's something to map to for the witness thunk, the conformance
-  // should be phrased in the same terms. This particularly applies to classes
-  // where a thunk for a method in a conformance like `extension Class: P where
-  // T: Q` will go from its native signature of `<τ_0_0 where τ_0_0: Q>` (with T
-  // canonicalised to τ_0_0), to `<τ_0_0, τ_1_0 where τ_0_0: Class<τ_1_0>,
-  // τ_1_0: Q>` (with T now represented by τ_1_0). Find the right conformance by
-  // looking for the conformance of 'Self'.
+  auto reqtSubstTy = cast<AnyFunctionType>(
+    reqtOrigTy->substGenericArgs(reqtSubMap)
+      ->getCanonicalType(genericSig));
+
+  // Generic signatures where all parameters are concrete are lowered away
+  // at the SILFunctionType level.
+  if (genericSig && genericSig->areAllParamsConcrete()) {
+    genericSig = nullptr;
+    genericEnv = nullptr;
+  }
+
+  // Rewrite the conformance in terms of the requirement environment's Self
+  // type, which might have a different generic signature than the type
+  // itself.
+  //
+  // For example, if the conforming type is a class and the witness is defined
+  // in a protocol extension, the generic signature will have an additional
+  // generic parameter representing Self, so the generic parameters of the
+  // class will all be shifted down by one.
   if (reqtSubMap) {
     auto requirement = conformance.getRequirement();
     auto self = requirement->getSelfInterfaceType()->getCanonicalType();
 
     conformance = *reqtSubMap.lookupConformance(self, requirement);
   }
 
-  CanAnyFunctionType reqtSubstTy =
-    CanAnyFunctionType::get(genericEnv ? genericEnv->getGenericSignature()
-                                                   ->getCanonicalSignature()
-                                       : nullptr,
-                            substReqtTy->getParams(),
-                            substReqtTy.getResult(),
+  reqtSubstTy =
+    CanAnyFunctionType::get(genericSig,
+                            reqtSubstTy->getParams(),
+                            reqtSubstTy.getResult(),
                             reqtOrigTy->getExtInfo());
 
   // Coroutine lowering requires us to provide these substitutions
@@ -649,10 +659,6 @@ SILFunction *SILGenModule::emitProtocolWitness(
     }
   }
 
-  // FIXME: this needs to pull out the conformances/witness-tables for any
-  // conditional requirements from the witness table and pass them to the
-  // underlying function in the thunk.
-
   // Lower the witness thunk type with the requirement's abstraction level.
   auto witnessSILFnType = getNativeSILFunctionType(
       M, AbstractionPattern(reqtOrigTy), reqtSubstTy,

test/SILGen/conditional_conformance.swift

@@ -16,6 +16,13 @@ extension Conformance: P1 where A: P2 {
   func normal() {}
   func generic<T: P3>(_: T) {}
 }
+
+// This is defined below but is emitted before any witness tables.
+// Just make sure it does not have a generic signature.
+//
+// CHECK-LABEL: sil private [transparent] [thunk] @$s23conditional_conformance16SameTypeConcreteVyxGAA2P1AASiRszlAaEP6normalyyFTW : $@convention(witness_method: P1) (@in_guaranteed SameTypeConcrete<Int>) -> ()
+
+
 // CHECK-LABEL: sil_witness_table hidden <A where A : P2> Conformance<A>: P1 module conditional_conformance {
 // CHECK-NEXT:    method #P1.normal!1: <Self where Self : P1> (Self) -> () -> () : @$s23conditional_conformance11ConformanceVyxGAA2P1A2A2P2RzlAaEP6normalyyFTW	// protocol witness for P1.normal() in conformance <A> Conformance<A>
 // CHECK-NEXT:    method #P1.generic!1: <Self where Self : P1><T where T : P3> (Self) -> (T) -> () : @$s23conditional_conformance11ConformanceVyxGAA2P1A2A2P2RzlAaEP7genericyyqd__AA2P3Rd__lFTW	// protocol witness for P1.generic<A>(_:) in conformance <A> Conformance<A>
@@ -34,14 +41,17 @@ extension ConformanceAssoc: P1 where A: P4, A.AT: P2 {
 // CHECK-NEXT:    conditional_conformance (A.AT: P2): dependent
 // CHECK-NEXT:  }
 
-/*
-FIXME: same type constraints are modelled incorrectly.
 struct SameTypeConcrete<B> {}
 extension SameTypeConcrete: P1 where B == Int {
   func normal() {}
   func generic<T: P3>(_: T) {}
 }
 
+// CHECK-LABEL: sil_witness_table hidden <B where B == Int> SameTypeConcrete<B>: P1 module conditional_conformance {
+// CHECK-NEXT:    method #P1.normal!1: <Self where Self : P1> (Self) -> () -> () : @$s23conditional_conformance16SameTypeConcreteVyxGAA2P1AASiRszlAaEP6normalyyFTW	// protocol witness for P1.normal() in conformance <A> SameTypeConcrete<A>
+// CHECK-NEXT:    method #P1.generic!1: <Self where Self : P1><T where T : P3> (Self) -> (T) -> () : @$s23conditional_conformance16SameTypeConcreteVyxGAA2P1AASiRszlAaEP7genericyyqd__AA2P3Rd__lFTW	// protocol witness for P1.generic<A>(_:) in conformance <A> SameTypeConcrete<A>
+// CHECK-NEXT:  }
+
 struct SameTypeGeneric<C, D> {}
 extension SameTypeGeneric: P1 where C == D {
   func normal() {}
@@ -59,7 +69,6 @@ extension Everything: P1 where G: P2, H == Int, I == J, K == [L] {
   func normal() {}
   func generic<T: P3>(_: T) {}
 }
-*/
 
 struct IsP2: P2 {}
 struct IsNotP2 {}

test/SILOptimizer/devirt_conditional_conformance.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend -O -Xllvm -sil-inline-generics=false -Xllvm -sil-disable-pass=GlobalOpt %s -emit-sil -sil-verify-all | %FileCheck %s
+// RUN: %target-swift-frontend -O -Xllvm -sil-inline-generics=false -Xllvm -sil-disable-pass=GlobalOpt %s -emit-sil -sil-verify-all | tee /tmp/xxx | %FileCheck %s
 
 
 public protocol Foo {
@@ -44,13 +44,41 @@ func genericLayer<T: Bar>(_ x: T) {
 // CHECK-LABEL: sil @$s30devirt_conditional_conformance12throughLayeryyF : $@convention(thin) () -> ()
 // CHECK: function_ref @$s30devirt_conditional_conformance10foo_markeryyF
 // CHECK: function_ref @$s30devirt_conditional_conformance10bar_markeryyF
+// CHECK: return
 public func throughLayer() {
   genericLayer(Inner())
 }
 
 // CHECK-LABEL: sil @$s30devirt_conditional_conformance6directyyF : $@convention(thin) () -> ()
 // CHECK: function_ref @$s30devirt_conditional_conformance10foo_markeryyF
 // CHECK: function_ref @$s30devirt_conditional_conformance10bar_markeryyF
+// CHECK: return
 public func direct() {
   callFoo(Outer(x: Inner()))
 }
+
+// Conditional conformance that constraints all generic parameters completely
+// <rdar://problem/46571799>
+public protocol Fish {
+  func fish_method()
+}
+
+@inline(never)
+func fish_marker() {}
+
+extension Outer: Fish where T == Int {
+  public func fish_method() {
+    fish_marker()
+  }
+}
+
+func callFish<T : Fish>(_ x: T) {
+  x.fish_method()
+}
+
+// CHECK-LABEL: sil @$s30devirt_conditional_conformance8testFishyyF : $@convention(thin) () -> ()
+// CHECK: function_ref @$s30devirt_conditional_conformance11fish_markeryyF : $@convention(thin) () -> ()
+// CHECK: return
+public func testFish() {
+  callFish(Outer(x: 0))
+}