SIL: Simpler and more correct TypeLowering::getConstantOverrideInfo()

We can use the new adjustSuperclassMemberDeclType() method here
to eliminate some code duplication and fix some corner cases with
generic method overrides.

Fixes <rdar://problem/18560464>, <https://bugs.swift.org/browse/SR-2427>,
<https://bugs.swift.org/browse/SR-2721>.

Author: slavapestov

lib/SIL/SILFunctionType.cpp

@@ -2041,10 +2041,14 @@ SILConstantInfo TypeConverter::getConstantOverrideInfo(SILDeclRef derived,
   auto selfInterfaceTy = derivedInterfaceTy.getInput()->getRValueInstanceType();
 
   auto overrideInterfaceTy =
-      selfInterfaceTy->getTypeOfMember(M.getSwiftModule(), baseInterfaceTy,
-                                       base.getDecl()->getDeclContext());
-
-  // Copy generic signature from derived to the override type
+      selfInterfaceTy->adjustSuperclassMemberDeclType(
+          derived.getDecl(), base.getDecl(), baseInterfaceTy,
+          /*resolver=*/nullptr);
+
+  // Copy generic signature from derived to the override type, to handle
+  // the case where the base member is not generic (because the base class
+  // is concrete) but the derived member is generic (because the derived
+  // class is generic).
   if (auto derivedInterfaceFnTy = derivedInterfaceTy->getAs<GenericFunctionType>()) {
     auto overrideInterfaceFnTy = overrideInterfaceTy->castTo<AnyFunctionType>();
     overrideInterfaceTy =
@@ -2054,23 +2058,6 @@ SILConstantInfo TypeConverter::getConstantOverrideInfo(SILDeclRef derived,
                                  overrideInterfaceFnTy->getExtInfo());
   }
 
-  // Replace occurrences of 'Self' in the signature with the derived type.
-  // FIXME: these should all be modeled with a DynamicSelfType.
-  overrideInterfaceTy =
-      overrideInterfaceTy->replaceSelfParameterType(selfInterfaceTy);
-  
-  bool hasDynamicSelf = false;
-  if (auto funcDecl = dyn_cast<FuncDecl>(derived.getDecl()))
-    hasDynamicSelf = funcDecl->hasDynamicSelf();
-  else if (isa<ConstructorDecl>(derived.getDecl()))
-    hasDynamicSelf = true;
-  
-  if (hasDynamicSelf) {
-    overrideInterfaceTy =
-        overrideInterfaceTy->replaceCovariantResultType(selfInterfaceTy,
-                                                        base.uncurryLevel + 1);
-  }
-
   // Lower the formal AST type.
   auto overrideLoweredInterfaceTy = getLoweredASTFunctionType(
       cast<AnyFunctionType>(overrideInterfaceTy->getCanonicalType()),

test/SILGen/vtable_thunks_reabstraction.swift

@@ -92,3 +92,33 @@ class ConcreteOptional<X>: Opaque<S?> {
   override func variantOptionality(x: S??) -> S? { return x! }
 }
  */
+
+// Make sure we remap the method's innermost generic parameters
+// to the correct depth
+class GenericBase<T> {
+  func doStuff<U>(t: T, u: U) {}
+  init<U>(t: T, u: U) {}
+}
+
+class ConcreteSub : GenericBase<Int> {
+  override func doStuff<U>(t: Int, u: U) {
+    super.doStuff(t: t, u: u)
+  }
+  override init<U>(t: Int, u: U) {
+    super.init(t: t, u: u)
+  }
+}
+
+class ConcreteBase {
+  init<U>(t: Int, u: U) {}
+  func doStuff<U>(t: Int, u: U) {}
+}
+
+class GenericSub<T> : ConcreteBase {
+  override init<U>(t: Int, u: U) {
+    super.init(t: t, u: u)
+  }
+  override func doStuff<U>(t: Int, u: U) {
+    super.doStuff(t: t, u: u)
+  }
+}

test/attr/attr_override.swift

@@ -380,4 +380,25 @@ class MismatchOptional3 : MismatchOptionalBase {
   override func result() -> Optional<Int> { return nil } // expected-error {{cannot override instance method result type 'Int' with optional type 'Optional<Int>'}} {{none}}
 }
 
+// Make sure we remap the method's innermost generic parameters
+// to the correct depth
+class GenericBase<T> {
+  func doStuff<U>(t: T, u: U) {}
+  init<U>(t: T, u: U) {}
+}
+
+class ConcreteSub : GenericBase<Int> {
+  override func doStuff<U>(t: Int, u: U) {}
+  override init<U>(t: Int, u: U) {}
+}
+
+class ConcreteBase {
+  init<U>(t: Int, u: U) {}
+  func doStuff<U>(t: Int, u: U) {}
 
+}
+
+class GenericSub<T> : ConcreteBase {
+  override init<U>(t: Int, u: U) {}
+  override func doStuff<U>(t: Int, u: U) {}
+}