Add specialized emitter for partially applied super_method

This creates the heavy lifting in SILGen of emission of super methods
with the implicit self partially applied, which is still possible even
after removing curried function declaration syntax.

NFC for current IRGen - SILGen doesn't lead to here yet.

rdar://problem/22749732

Author: bitjammer

lib/SILGen/SILGenApply.cpp

@@ -180,6 +180,46 @@ static CanSILFunctionType getDynamicMethodLoweredType(SILGenFunction &gen,
   return replaceSelfTypeForDynamicLookup(ctx, methodTy, selfTy, methodName);
 }
 
+/// Emit a sequence of instructions to partially apply the self
+/// parameter of a super method invocation.
+static ManagedValue emitPartialSuperMethod(SILGenFunction &SGF,
+                                           SILDeclRef constant,
+                                           SILLocation loc,
+                                           ArrayRef<Substitution> subs,
+                                           ArrayRef<ManagedValue> values,
+                                           CanFunctionType formalApplyType,
+                                           SGFContext C) {
+
+  assert(values.size() == 1 &&
+         "Can only partially apply the self parameater of a super method call");
+
+  auto upcastedSelf = values.back();
+
+  auto self = cast<UpcastInst>(upcastedSelf.getValue())->getOperandRef().get();
+
+  auto constantInfo = SGF.getConstantInfo(constant);
+  SILValue superMethodVal = SGF.B.createSuperMethod(loc,
+                                                    self,
+                                                    constant,
+                                                    constantInfo.getSILType(),
+                                                    /*volatile*/
+                                                      constant.isForeign);
+
+  auto closureTy = SILGenBuilder::getPartialApplyResultType(
+    constantInfo.getSILType(),
+    1,
+    SGF.B.getModule(),
+    subs);
+
+  SILValue partialApply = SGF.B.createPartialApply(loc,
+                                                   superMethodVal,
+                                                   constantInfo.getSILType(),
+                                                   subs,
+                                                   { upcastedSelf.forward(SGF) },
+                                                   closureTy);
+  return ManagedValue::forUnmanaged(partialApply);
+}
+
 namespace {
 
 /// Abstractly represents a callee, and knows how to emit the entry point
@@ -650,6 +690,10 @@ class Callee {
     return Substitutions;
   }
 
+  SILDeclRef getMethodName() const {
+    return Method.MethodName;
+  }
+
   /// Return a specialized emission function if this is a function with a known
   /// lowering, such as a builtin, or return null if there is no specialized
   /// emitter.
@@ -663,9 +707,11 @@ class Callee {
     case Kind::StandaloneFunction: {
       return SpecializedEmitter::forDecl(SGM, StandaloneFunction);
     }
+    case Kind::SuperMethod: {
+      return SpecializedEmitter(emitPartialSuperMethod);
+    }
     case Kind::IndirectValue:
     case Kind::ClassMethod:
-    case Kind::SuperMethod:
     case Kind::WitnessMethod:
     case Kind::DynamicMethod:
       return None;
@@ -3235,6 +3281,15 @@ namespace {
                            uncurriedArgs,
                            formalApplyType,
                            uncurriedContext);
+        } else if (specializedEmitter->isLatePartialSuperEmitter()) {
+          auto emitter = specializedEmitter->getLatePartialSuperEmitter();
+          result = emitter(gen,
+                           callee.getMethodName(),
+                           uncurriedLoc.getValue(),
+                           callee.getSubstitutions(),
+                           uncurriedArgs,
+                           formalApplyType,
+                           uncurriedContext);
         } else {
           assert(specializedEmitter->isNamedBuiltin());
           auto builtinName = specializedEmitter->getBuiltinName();