Sema: Generic classes and subclasses of generic classes now inherit required initializers

Initializers are inherited by synthesizing an implicit decl which
delegates to super.init(). Previously this was only done if the
class and superclass were concrete.

The only thing missing was that we weren't computing an interface
type for the synthesized constructor. There are two steps to this:

- First, we must map the contextual types of the superclass
  initializer's ParamDecls to the subclass generic context.

- Second, we must set the interface type by calling the new
  configureInterfaceType() method, extracted from from
  validateGenericSignature().

Note that configureInterfaceType() now uses the new
AbstractFunctionDecl::hasThrows() flag to set the 'throws' bit on
the function type. Previously, validateGenericFuncSignature()
would look at getThrowsLoc().isValid(), which is not correct for
imported, implicitly-generated or de-serialized decls that 'throw',
because none of those have source location information.

We still don't allow inheriting initializers which have their
own generic parameter list, like 'init<T>(t: T) {...}'. That
requires a little bit more refactoring.

Progress on <rdar://problem/23376955>.

Author: slavapestov

lib/Sema/CodeSynthesis.cpp

@@ -2040,14 +2040,11 @@ swift::createDesignatedInitOverride(TypeChecker &tc,
                                     ClassDecl *classDecl,
                                     ConstructorDecl *superclassCtor,
                                     DesignatedInitKind kind) {
-  // Determine the initializer parameters.
-  Type superInitType = superclassCtor->getInitializerInterfaceType();
-  if (superInitType->is<GenericFunctionType>() ||
-      classDecl->getGenericParamsOfContext()) {
-    // FIXME: Handle generic initializers as well.
+  // FIXME: Inheriting initializers that have their own generic parameters
+  if (superclassCtor->getGenericParams())
     return nullptr;
-  }
 
+  // Determine the initializer parameters.
   auto &ctx = tc.Context;
 
   // Create the 'self' declaration and patterns.
@@ -2057,8 +2054,40 @@ swift::createDesignatedInitOverride(TypeChecker &tc,
   OptionSet<ParameterList::CloneFlags> options = ParameterList::Implicit;
   options |= ParameterList::Inherited;
   auto *bodyParams = superclassCtor->getParameterList(1)->clone(ctx,options);
-  
-  // Create the initializer declaration.
+
+  // If the superclass is generic, we need to map the superclass constructor's
+  // parameter types into the generic context of our class.
+  //
+  // We might have to apply substitutions, if for example we have a declaration
+  // like 'class A : B<Int>'.
+  auto superclassTy = classDecl->getSuperclass();
+  auto *superclassDecl = superclassTy->getAnyNominal();
+  if (superclassDecl->isGenericTypeContext()) {
+    if (auto *superclassSig = superclassDecl->getGenericSignatureOfContext()) {
+      auto *moduleDecl = classDecl->getParentModule();
+      auto subs = superclassTy->gatherAllSubstitutions(
+          moduleDecl, nullptr, nullptr);
+      auto subsMap = superclassSig->getSubstitutionMap(subs);
+
+      for (auto *decl : *bodyParams) {
+        // Map the parameter type to an interface type written in terms of
+        // the superclass generic signature.
+        auto paramTy = ArchetypeBuilder::mapTypeOutOfContext(
+            superclassDecl, decl->getType());
+
+        // Apply the superclass substitutions to produce an interface
+        // type in terms of the class generic signature.
+        auto paramSubstTy = paramTy.subst(moduleDecl, subsMap, SubstOptions());
+
+        // Map it to a contextual type in terms of the class's archetypes.
+        decl->overwriteType(ArchetypeBuilder::mapTypeIntoContext(
+            classDecl, paramSubstTy));
+      }
+    }
+  }
+
+  // Create the initializer declaration, inheriting the name,
+  // failability, and throws from the superclass initializer.
   auto ctor =
     new (ctx) ConstructorDecl(superclassCtor->getFullName(),
                               classDecl->getBraces().Start,
@@ -2068,20 +2097,27 @@ swift::createDesignatedInitOverride(TypeChecker &tc,
                               /*ThrowsLoc=*/SourceLoc(),
                               selfDecl, bodyParams,
                               /*GenericParams=*/nullptr, classDecl);
+
   ctor->setImplicit();
   ctor->setAccessibility(std::min(classDecl->getFormalAccess(),
                                   superclassCtor->getFormalAccess()));
 
   // Make sure the constructor is only as available as its superclass's
   // constructor.
-  AvailabilityInference::applyInferredAvailableAttrs(ctor, superclassCtor,
-                                                        ctx);
+  AvailabilityInference::applyInferredAvailableAttrs(ctor, superclassCtor, ctx);
 
   // Configure 'self'.
   auto selfType = configureImplicitSelf(tc, ctor);
 
-  // Set the type of the initializer.
+  // Set the interface type of the initializer.
+  if (classDecl->isGenericTypeContext()) {
+    ctor->setGenericSignature(classDecl->getGenericSignatureOfContext());
+    tc.configureInterfaceType(ctor);
+  }
+
+  // Set the contextual type of the initializer. This will go away one day.
   configureConstructorType(ctor, selfType, bodyParams->getType(ctx));
+
   if (superclassCtor->isObjC()) {
     // Inherit the @objc name from the superclass initializer, if it
     // has one.

lib/Sema/TypeCheckDecl.cpp

@@ -7446,8 +7446,7 @@ void TypeChecker::addImplicitConstructors(NominalTypeDecl *decl) {
          classDecl->getSuperclass()->getAnyNominal()->isInvalid() ||
          classDecl->getSuperclass()->getAnyNominal()
            ->addedImplicitInitializers());
-  if (classDecl->hasSuperclass() && !classDecl->isGenericContext() &&
-      !classDecl->getSuperclass()->isSpecialized()) {
+  if (classDecl->hasSuperclass()) {
     bool canInheritInitializers = !FoundDesignatedInit;
 
     // We can't define these overrides if we have any uninitialized

lib/Sema/TypeCheckGeneric.cpp

@@ -553,9 +553,16 @@ bool TypeChecker::validateGenericFuncSignature(AbstractFunctionDecl *func) {
     return true;
   }
 
-  // Compute the function type.
+  configureInterfaceType(func);
+  return false;
+}
+
+void TypeChecker::configureInterfaceType(AbstractFunctionDecl *func) {
   Type funcTy;
   Type initFuncTy;
+
+  auto *sig = func->getGenericSignature();
+
   if (auto fn = dyn_cast<FuncDecl>(func)) {
     funcTy = fn->getBodyResultTypeLoc().getType();
 
@@ -631,73 +638,11 @@ bool TypeChecker::validateGenericFuncSignature(AbstractFunctionDecl *func) {
     // to begin with, but fixing that requires a lot of reengineering for local
     // definitions in generic contexts.
     if (sig && i == e-1) {
-      if (func->getGenericParams()) {
-        // Collect all generic params referenced in parameter types,
-        // return type or requirements.
-        SmallPtrSet<GenericTypeParamDecl *, 4> referencedGenericParams;
-        argTy.visit([&referencedGenericParams](Type t) {
-          if (isa<GenericTypeParamType>(t.getCanonicalTypeOrNull())) {
-            referencedGenericParams.insert(
-                t->castTo<GenericTypeParamType>()->getDecl());
-          }
-        });
-        funcTy.visit([&referencedGenericParams](Type t) {
-          if (isa<GenericTypeParamType>(t.getCanonicalTypeOrNull())) {
-            referencedGenericParams.insert(
-                t->castTo<GenericTypeParamType>()->getDecl());
-          }
-        });
-
-        auto requirements = sig->getRequirements();
-        for (auto req : requirements) {
-          if (req.getKind() == RequirementKind::SameType) {
-            // Same type requirements may allow for generic
-            // inference, even if this generic parameter
-            // is not mentioned in the function signature.
-            // TODO: Make the test more precise.
-            auto left = req.getFirstType();
-            auto right = req.getSecondType();
-            // For now consider any references inside requirements
-            // as a possibility to infer the generic type.
-            left.visit([&referencedGenericParams](Type t) {
-              if (isa<GenericTypeParamType>(t.getCanonicalTypeOrNull())) {
-                referencedGenericParams.insert(
-                    t->castTo<GenericTypeParamType>()->getDecl());
-              }
-            });
-            right.visit([&referencedGenericParams](Type t) {
-              if (isa<GenericTypeParamType>(t.getCanonicalTypeOrNull())) {
-                referencedGenericParams.insert(
-                    t->castTo<GenericTypeParamType>()->getDecl());
-              }
-            });
-          }
-        }
-
-        // Find the depth of the function's own generic parameters.
-        unsigned fnGenericParamsDepth = func->getGenericParams()->getDepth();
-
-        // Check that every generic parameter type from the signature is
-        // among referencedArchetypes.
-        for (auto *genParam : sig->getGenericParams()) {
-          auto *paramDecl = genParam->getDecl();
-          if (paramDecl->getDepth() != fnGenericParamsDepth)
-            continue;
-          if (!referencedGenericParams.count(paramDecl)) {
-            // Produce an error that this generic parameter cannot be bound.
-            diagnose(paramDecl->getLoc(), diag::unreferenced_generic_parameter,
-                     paramDecl->getNameStr());
-            func->setInvalid();
-          }
-        }
-      }
-
       funcTy = GenericFunctionType::get(sig, argTy, funcTy, info);
       if (initFuncTy)
         initFuncTy = GenericFunctionType::get(sig, initArgTy, initFuncTy, info);
     } else {
       funcTy = FunctionType::get(argTy, funcTy, info);
-
       if (initFuncTy)
         initFuncTy = FunctionType::get(initArgTy, initFuncTy, info);
     }
@@ -707,7 +652,53 @@ bool TypeChecker::validateGenericFuncSignature(AbstractFunctionDecl *func) {
   func->setInterfaceType(funcTy);
   if (initFuncTy)
     cast<ConstructorDecl>(func)->setInitializerInterfaceType(initFuncTy);
-  return false;
+
+  if (func->getGenericParams()) {
+    // Collect all generic params referenced in parameter types,
+    // return type or requirements.
+    SmallPtrSet<GenericTypeParamDecl *, 4> referencedGenericParams;
+
+    auto visitorFn = [&referencedGenericParams](Type t) {
+      if (auto *paramTy = t->getAs<GenericTypeParamType>())
+        referencedGenericParams.insert(paramTy->getDecl());
+    };
+
+    funcTy->castTo<AnyFunctionType>()->getInput().visit(visitorFn);
+    funcTy->castTo<AnyFunctionType>()->getResult().visit(visitorFn);
+
+    auto requirements = sig->getRequirements();
+    for (auto req : requirements) {
+      if (req.getKind() == RequirementKind::SameType) {
+        // Same type requirements may allow for generic
+        // inference, even if this generic parameter
+        // is not mentioned in the function signature.
+        // TODO: Make the test more precise.
+        auto left = req.getFirstType();
+        auto right = req.getSecondType();
+        // For now consider any references inside requirements
+        // as a possibility to infer the generic type.
+        left.visit(visitorFn);
+        right.visit(visitorFn);
+      }
+    }
+
+    // Find the depth of the function's own generic parameters.
+    unsigned fnGenericParamsDepth = func->getGenericParams()->getDepth();
+
+    // Check that every generic parameter type from the signature is
+    // among referencedArchetypes.
+    for (auto *genParam : sig->getGenericParams()) {
+      auto *paramDecl = genParam->getDecl();
+      if (paramDecl->getDepth() != fnGenericParamsDepth)
+        continue;
+      if (!referencedGenericParams.count(paramDecl)) {
+        // Produce an error that this generic parameter cannot be bound.
+        diagnose(paramDecl->getLoc(), diag::unreferenced_generic_parameter,
+                 paramDecl->getNameStr());
+        func->setInvalid();
+      }
+    }
+  }
 }
 
 GenericSignature *TypeChecker::validateGenericSignature(

lib/Sema/TypeChecker.h

@@ -921,6 +921,9 @@ class TypeChecker final : public LazyResolver {
 
   void markInvalidGenericSignature(ValueDecl *VD);
 
+  /// Configure the interface type of a function declaration.
+  void configureInterfaceType(AbstractFunctionDecl *func);
+
   /// Validate the signature of a generic function.
   ///
   /// \param func The generic function.

test/IRGen/generic_classes_objc.sil

@@ -32,6 +32,11 @@ bb0(%0 : $GenericInheritsObjC<T>):
   unreachable
 }
 
+sil @_TToFC20generic_classes_objc19GenericInheritsObjCcfT7bellsOnSi_GSQGS0_x__ : $@convention(objc_method) <T> (Int, @owned GenericInheritsObjC<T>) -> @owned GenericInheritsObjC<T> {
+bb0(%0 : $Int, %1 : $GenericInheritsObjC<T>):
+  unreachable
+}
+
 // CHECK: @_TMPC20generic_classes_objc20GenericInheritsObjC2
 
 class GenericInheritsObjC2<E> : Gizmo {
@@ -54,3 +59,8 @@ sil @_TToFC20generic_classes_objc20GenericInheritsObjC2cfT_GS0_x_ : $@convention
 bb0(%0 : $GenericInheritsObjC2<T>):
   unreachable
 }
+
+sil @_TToFC20generic_classes_objc20GenericInheritsObjC2cfT7bellsOnSi_GSQGS0_x__ : $@convention(objc_method) <T> (Int, @owned GenericInheritsObjC<T>) -> @owned GenericInheritsObjC<T> {
+bb0(%0 : $Int, %1 : $GenericInheritsObjC<T>):
+  unreachable
+}

test/IRGen/objc_generic_class_metadata.sil

@@ -16,6 +16,8 @@ import objc_generics
 // CHECK:         %objc_class* @"OBJC_CLASS_$_GenericClass"
 class Subclass: GenericClass<NSString> {}
 
+sil_vtable Subclass {}
+
 sil @metatype_sink : $@convention(thin) <T> (@thick T.Type) -> ()
 sil @objc_class_sink : $@convention(thin) <T: AnyObject> (@objc_metatype T.Type) -> ()
 
@@ -54,6 +56,16 @@ entry:
   return undef : $()
 }
 
+sil @_TToFC27objc_generic_class_metadata8SubclasscfT5thingGSQCSo8NSString__GSQS0__ : $@convention(objc_method) (ImplicitlyUnwrappedOptional<NSString>, @owned Subclass) -> @owned ImplicitlyUnwrappedOptional<Subclass> {
+entry(%0: $ImplicitlyUnwrappedOptional<NSString>, %1: $Subclass):
+  unreachable
+}
+
+sil @_TToFC27objc_generic_class_metadata8SubclasscfT_S0_ : $@convention(objc_method) (@owned Subclass) -> @owned Subclass {
+entry(%0: $Subclass):
+  unreachable
+}
+
 // CHECK-LABEL: define linkonce_odr hidden %swift.type* @_TMaCSo12GenericClass()
 // CHECK:         [[T0:%.*]] = load %objc_class*, %objc_class** @"OBJC_CLASS_REF_$_GenericClass",
 // CHECK:         call %objc_class* @rt_swift_getInitializedObjCClass(%objc_class* [[T0]])

test/Interpreter/classes.swift

@@ -173,20 +173,37 @@ print((b as Bank).deposit(Account(owner: "A")))
 
 // rdar://25412647
 
-private class Parent <T> {
-    func doSomething() {
-        overriddenMethod()
-    }
+private class Parent<T> {
+  required init() {}
 
-    func overriddenMethod() {
-        fatalError("You should override this method in child class")
-    }
+  func doSomething() {
+    overriddenMethod()
+  }
+
+  func overriddenMethod() {
+    fatalError("You should override this method in child class")
+  }
 }
 
 private class Child: Parent<String> {
-    override func overriddenMethod() {
-        print("Heaven!")
-    }
+  override func overriddenMethod() {
+    print("Heaven!")
+  }
 }
 
 Child().doSomething() // CHECK: Heaven!
+
+// rdar://23376955
+
+protocol Makeable {
+  init()
+  func doSomething()
+}
+
+extension Parent : Makeable {}
+
+func makeOne<T : Makeable>(_: T.Type) -> T {
+  return T()
+}
+
+makeOne(Child.self).doSomething() // CHECK: Heaven!

test/SILGen/objc_thunks.swift

@@ -276,6 +276,10 @@ class Wotsit<T> : Gizmo {
 
   // Ivar destroyer
   // CHECK: sil hidden @_TToF{{.*}}WotsitE
+
+  // CHECK-LABEL: sil hidden [thunk] @_TToFC11objc_thunks6WotsitcfT_GSQGS0_x__ : $@convention(objc_method) <T> (@owned Wotsit<T>) -> @owned ImplicitlyUnwrappedOptional<Wotsit<T>>
+
+  // CHECK-LABEL: sil hidden [thunk] @_TToFC11objc_thunks6WotsitcfT7bellsOnSi_GSQGS0_x__ : $@convention(objc_method) <T> (Int, @owned Wotsit<T>) -> @owned ImplicitlyUnwrappedOptional<Wotsit<T>>
 }
 
 // CHECK-NOT: sil hidden [thunk] @_TToF{{.*}}Wotsit{{.*}}

test/decl/inherit/initializer.swift

@@ -110,6 +110,27 @@ func testSubUnnamed(_ i: Int, d: Double, s: String, f: Float) {
   _ = SubUnnamed(f)
 }
 
+// rdar://problem/17960407 - Inheritance of generic initializers
+class ConcreteBase {
+  required init(i: Int) {}
+}
+
+class GenericDerived<T> : ConcreteBase {}
+
+class GenericBase<T> {
+  required init(t: T) {}
+}
+
+class GenericDerived2<U> : GenericBase<(U, U)> {}
+
+class ConcreteDerived : GenericBase<Int> {}
+
+func testGenericInheritance() {
+  _ = GenericDerived<Int>(i: 10)
+  _ = GenericDerived2<Int>(t: (10, 100))
+  _ = ConcreteDerived(t: 1000)
+}
+
 // FIXME: <rdar://problem/16331406> Implement inheritance of variadic designated initializers
 class SuperVariadic {
   init(ints: Int...) { } // expected-note{{variadic superclass initializer defined here}}