SILGen: Fix latent bugs in emitApplyAllocatingInitializer()

The condition we want to test for emitting a downcast is isRequired(),
not isInheritable(). The latter is only true for convenience
initializers.

The other fix is that we actually have to emit a class_method
dispatch here to support class hierarchies conforming to literal
protocols.

Author: slavapestov

lib/SILGen/SILGenApply.cpp

@@ -4541,6 +4541,8 @@ static RValue emitApplyAllocatingInitializer(SILGenFunction &SGF,
     callee.emplace(Callee::forWitnessMethod(
         SGF, selfMetaVal.getType().getSwiftRValueType(),
         initRef, subs, loc));
+  } else if (getMethodDispatch(ctor) == MethodDispatch::Class) {
+    callee.emplace(Callee::forClassMethod(SGF, initRef, subs, loc));
   } else {
     callee.emplace(Callee::forDirect(SGF, initRef, subs, loc));
   }
@@ -4550,7 +4552,7 @@ static RValue emitApplyAllocatingInitializer(SILGenFunction &SGF,
   // For an inheritable initializer, determine whether we'll need to adjust the
   // result type.
   bool requiresDowncast = false;
-  if (ctor->isInheritable() && overriddenSelfType) {
+  if (ctor->isRequired() && overriddenSelfType) {
     CanType substResultType = substFormalType;
     for (unsigned i : range(ctor->getNumParameterLists())) {
       (void)i;

test/SILGen/literals.swift

@@ -0,0 +1,43 @@
+// RUN: %target-swift-emit-silgen -enable-sil-ownership %s | %FileCheck %s
+
+func takesOptionalFunction(_: (() -> ())?) {}
+
+struct CustomNull : ExpressibleByNilLiteral {
+  init(nilLiteral: ()) {}
+}
+
+func takesANull(_: CustomNull) {}
+
+// CHECK-LABEL: sil hidden @$S8literals4testyyF : $@convention(thin) () -> ()
+func test() {
+  // CHECK: [[NIL:%.*]] = enum $Optional<@callee_guaranteed () -> ()>, #Optional.none!enumelt
+  // CHECK: [[FN:%.*]] = function_ref @$S8literals21takesOptionalFunctionyyyycSgF
+  // CHECK: apply [[FN]]([[NIL]])
+  _ = takesOptionalFunction(nil)
+
+  // CHECK: [[METATYPE:%.*]] = metatype $@thin CustomNull.Type
+  // CHECK: [[NIL_FN:%.*]] = function_ref @$S8literals10CustomNullV10nilLiteralACyt_tcfC
+  // CHECK: [[NIL:%.*]] = apply [[NIL_FN]]([[METATYPE]])
+  // CHECK: [[FN:%.*]] = function_ref @$S8literals10takesANullyyAA10CustomNullVF
+  // CHECK: apply [[FN]]([[NIL]])
+  _ = takesANull(nil)
+}
+
+class CustomStringClass : ExpressibleByStringLiteral {
+  required init(stringLiteral value: String) {}
+  required init(extendedGraphemeClusterLiteral value: String) {}
+  required init(unicodeScalarLiteral value: String) {}
+}
+
+class CustomStringSubclass : CustomStringClass {}
+
+// CHECK-LABEL: sil hidden @$S8literals27returnsCustomStringSubclassAA0cdE0CyF : $@convention(thin) () -> @owned CustomStringSubclass
+// CHECK: [[METATYPE:%.*]] = metatype $@thick CustomStringSubclass.Type
+// CHECK: [[UPCAST:%.*]] = upcast [[METATYPE]] : $@thick CustomStringSubclass.Type to $@thick CustomStringClass.Type
+// CHECK: [[CTOR:%.*]] = class_method [[UPCAST]] : $@thick CustomStringClass.Type, #CustomStringClass.init!allocator.1 : (CustomStringClass.Type) -> (String) -> CustomStringClass, $@convention(method) (@owned String, @thick CustomStringClass.Type) -> @owned CustomStringClass
+// CHECK: [[RESULT:%.*]] = apply [[CTOR]]({{%.*}}, [[UPCAST]])
+// CHECK: [[DOWNCAST:%.*]] = unchecked_ref_cast [[RESULT]] : $CustomStringClass to $CustomStringSubclass
+// CHECK: return [[DOWNCAST]]
+func returnsCustomStringSubclass() -> CustomStringSubclass {
+  return "hello world"
+}