SILCombine: handle properties in superclasses in the keypath optimization

We ended up with invalid ref_element_addr instructions which let the SILVerifier crash.
Inserting upcasts fixes this.

rdar://problem/56410011

Author: eeckstein

lib/SILOptimizer/SILCombiner/SILCombinerApplyVisitors.cpp

@@ -600,9 +600,23 @@ static SILValue createKeypathProjections(SILValue keyPath, SILValue root,
     if (addr->getType().getStructOrBoundGenericStruct()) {
       addr = builder.createStructElementAddr(loc, addr, storedProperty);
     } else if (addr->getType().getClassOrBoundGenericClass()) {
-      LoadInst *Ref = builder.createLoad(loc, addr,
+      SingleValueInstruction *Ref = builder.createLoad(loc, addr,
                                          LoadOwnershipQualifier::Unqualified);
       insertEndAccess(beginAccess, /*isModify*/ false, builder);
+
+      // Handle the case where the storedProperty is in a super class.
+      while (Ref->getType().getClassOrBoundGenericClass() !=
+             storedProperty->getDeclContext()) {
+        SILType superCl = Ref->getType().getSuperclass();
+        if (!superCl) {
+          // This should never happen, because the property should be in the
+          // decl or in a superclass of it. Just handle this to be on the safe
+          // side.
+          return SILValue();
+        }
+        Ref = builder.createUpcast(loc, Ref, superCl);
+      }
+
       addr = builder.createRefElementAddr(loc, Ref, storedProperty);
 
       // Class members need access enforcement.

test/SILOptimizer/optimize_keypath.swift

@@ -41,6 +41,16 @@ final class GenClass<T : P> : P {
   }
 }
 
+class Base<T> {
+  final var i: Int = 12
+}
+
+class DerivedClass<T> : Base<T> {
+}
+
+final class DerivedClass2 : DerivedClass<Int> {
+}
+
 final class SimpleClass : P {
   var i: Int
   static var numObjs = 0
@@ -97,6 +107,33 @@ func testGenClassRead<T>(_ c: GenClass<T>) -> T {
   return c[keyPath: kp]
 }
 
+// CHECK-LABEL: sil {{.*}}testDerivedClassRead
+// CHECK: [[C:%[0-9]+]] = upcast %0
+// CHECK: [[E:%[0-9]+]] = ref_element_addr [[C]]
+// CHECK: [[A:%[0-9]+]] = begin_access [read] [dynamic] [no_nested_conflict] [[E]]
+// CHECK: [[V:%[0-9]+]] = load [[A]]
+// CHECK: end_access [[A]]
+// CHECK: return [[V]]
+@inline(never)
+@_semantics("optimize.sil.specialize.generic.never")
+func testDerivedClassRead<T>(_ c: DerivedClass<T>) -> Int {
+  let kp = \DerivedClass<T>.i
+  return c[keyPath: kp]
+}
+
+// CHECK-LABEL: sil {{.*}}testDerivedClass2Read
+// CHECK: [[C:%[0-9]+]] = upcast %0
+// CHECK: [[E:%[0-9]+]] = ref_element_addr [[C]]
+// CHECK: [[A:%[0-9]+]] = begin_access [read] [dynamic] [no_nested_conflict] [[E]]
+// CHECK: [[V:%[0-9]+]] = load [[A]]
+// CHECK: end_access [[A]]
+// CHECK: return [[V]]
+@inline(never)
+func testDerivedClass2Read(_ c: DerivedClass2) -> Int {
+  let kp = \DerivedClass2.i
+  return c[keyPath: kp]
+}
+
 // CHECK-LABEL: sil {{.*}}testGenClassWrite
 // CHECK: [[S:%[0-9]+]] = alloc_stack $T
 // CHECK: [[E:%[0-9]+]] = ref_element_addr %0
@@ -233,6 +270,12 @@ func testit() {
   // CHECK-OUTPUT: GenClassRead: 29
   print("GenClassRead: \(testGenClassRead(GenClass(SimpleClass(29))).i)")
 
+  // CHECK-OUTPUT: DerivedClassRead: 12
+  print("DerivedClassRead: \(testDerivedClassRead(DerivedClass<Int>())))")
+
+  // CHECK-OUTPUT: DerivedClass2Read: 12
+  print("DerivedClass2Read: \(testDerivedClass2Read(DerivedClass2())))")
+
   // CHECK-OUTPUT: GenClassWrite: 30
   let c = GenClass(SimpleClass(0))
   testGenClassWrite(c, SimpleClass(30))