SILGen: Stub out support for invoking foreign async methods.

Allow SILGen to not crash when invoking foreign async methods by emitting
`undef` for the completion callback going into the call, and for the
results that would be channeled back through awaiting the continuation.

Author: jckarter

lib/ClangImporter/ImportName.cpp

@@ -1965,12 +1965,12 @@ ImportedName NameImporter::importNameImpl(const clang::NamedDecl *D,
           method->hasRelatedResultType(), method->isInstanceMethod(),
           result.getAsyncInfo().map(
             [](const ForeignAsyncConvention::Info &info) {
-              return info.CompletionHandlerParamIndex;
+              return info.completionHandlerParamIndex();
             }),
           result.getAsyncInfo().map(
             [&](const ForeignAsyncConvention::Info &info) {
               return method->getDeclName().getObjCSelector().getNameForSlot(
-                  info.CompletionHandlerParamIndex);
+                                            info.completionHandlerParamIndex());
             }),
           *this);
     }

lib/SILGen/Callee.h

@@ -13,6 +13,7 @@
 #ifndef SWIFT_SILGEN_CALLEE_H
 #define SWIFT_SILGEN_CALLEE_H
 
+#include "swift/AST/ForeignAsyncConvention.h"
 #include "swift/AST/ForeignErrorConvention.h"
 #include "swift/AST/Types.h"
 #include "swift/SIL/AbstractionPattern.h"
@@ -25,8 +26,12 @@ class CalleeTypeInfo {
   CanSILFunctionType substFnType;
   Optional<AbstractionPattern> origResultType;
   CanType substResultType;
-  Optional<ForeignErrorConvention> foreignError;
-  ImportAsMemberStatus foreignSelf;
+  struct ForeignInfo {
+    Optional<ForeignErrorConvention> error;
+    Optional<ForeignAsyncConvention> async;
+    ImportAsMemberStatus self;
+  };
+  ForeignInfo foreign;
 
 private:
   Optional<SILFunctionTypeRepresentation> overrideRep;
@@ -37,17 +42,19 @@ class CalleeTypeInfo {
   CalleeTypeInfo(CanSILFunctionType substFnType,
                  AbstractionPattern origResultType, CanType substResultType,
                  const Optional<ForeignErrorConvention> &foreignError,
+                 const Optional<ForeignAsyncConvention> &foreignAsync,
                  ImportAsMemberStatus foreignSelf,
                  Optional<SILFunctionTypeRepresentation> overrideRep = None)
       : substFnType(substFnType), origResultType(origResultType),
-        substResultType(substResultType), foreignError(foreignError),
-        foreignSelf(foreignSelf), overrideRep(overrideRep) {}
+        substResultType(substResultType),
+        foreign{foreignError, foreignAsync, foreignSelf},
+        overrideRep(overrideRep) {}
 
   CalleeTypeInfo(CanSILFunctionType substFnType,
                  AbstractionPattern origResultType, CanType substResultType,
                  Optional<SILFunctionTypeRepresentation> overrideRep = None)
       : substFnType(substFnType), origResultType(origResultType),
-        substResultType(substResultType), foreignError(), foreignSelf(),
+        substResultType(substResultType), foreign(),
         overrideRep(overrideRep) {}
 
   SILFunctionTypeRepresentation getOverrideRep() const {

lib/SILGen/ResultPlan.cpp

@@ -451,6 +451,33 @@ class TupleInitializationResultPlan final : public ResultPlan {
   }
 };
 
+class ForeignAsyncInitializationPlan final : public ResultPlan {
+  SILGenFunction &SGF;
+  SILLocation loc;
+public:
+  ForeignAsyncInitializationPlan(SILGenFunction &SGF, SILLocation loc)
+    : SGF(SGF), loc(loc) {
+  }
+  
+  void
+  gatherIndirectResultAddrs(SILGenFunction &SGF, SILLocation loc,
+                            SmallVectorImpl<SILValue> &outList) const override {
+    // TODO: Move values from the continuation result buffer to the individual
+    // out argument buffers, unless we were able to emit the resume buffer
+    // in-place.
+  }
+  
+  RValue finish(SILGenFunction &SGF, SILLocation loc, CanType substType,
+                ArrayRef<ManagedValue> &directResults) override {
+    // There should be no direct results from the call.
+    assert(directResults.empty());
+    
+    // TODO: Get the actual result values from the awaited continuation.
+    // For now, produce an undef RValue.
+    return SGF.emitUndefRValue(loc, substType);
+  }
+};
+
 class ForeignErrorInitializationPlan final : public ResultPlan {
   SILLocation loc;
   LValue lvalue;
@@ -467,7 +494,7 @@ class ForeignErrorInitializationPlan final : public ResultPlan {
                                  ResultPlanPtr &&subPlan)
       : loc(loc), subPlan(std::move(subPlan)) {
     unsigned errorParamIndex =
-        calleeTypeInfo.foreignError->getErrorParameterIndex();
+        calleeTypeInfo.foreign.error->getErrorParameterIndex();
     auto substFnType = calleeTypeInfo.substFnType;
     SILParameterInfo errorParameter =
         substFnType->getParameters()[errorParamIndex];
@@ -543,51 +570,56 @@ class ForeignErrorInitializationPlan final : public ResultPlan {
 /// If the initialization is non-null, the result plan will emit into it.
 ResultPlanPtr ResultPlanBuilder::buildTopLevelResult(Initialization *init,
                                                      SILLocation loc) {
-  // First check if we do not have a foreign error. If we don't, just call
-  // build.
-  auto foreignError = calleeTypeInfo.foreignError;
-  if (!foreignError) {
+  // First check if we have a foreign error and/or async convention.
+  if (auto foreignAsync = calleeTypeInfo.foreign.async) {
+    // Create a result plan that gets the result schema from the completion
+    // handler callback's arguments.
+    // completion handler.
+    return ResultPlanPtr(new ForeignAsyncInitializationPlan(SGF, loc));
+    
+  } else if (auto foreignError = calleeTypeInfo.foreign.error) {
+    // Handle the foreign error first.
+    //
+    // The plan needs to be built using the formal result type after foreign-error
+    // adjustment.
+    switch (foreignError->getKind()) {
+    // These conventions make the formal result type ().
+    case ForeignErrorConvention::ZeroResult:
+    case ForeignErrorConvention::NonZeroResult:
+      assert(calleeTypeInfo.substResultType->isVoid());
+      allResults.clear();
+      break;
+
+    // These conventions leave the formal result alone.
+    case ForeignErrorConvention::ZeroPreservedResult:
+    case ForeignErrorConvention::NonNilError:
+      break;
+
+    // This convention changes the formal result to the optional object type; we
+    // need to make our own make SILResultInfo array.
+    case ForeignErrorConvention::NilResult: {
+      assert(allResults.size() == 1);
+      auto substFnTy = calleeTypeInfo.substFnType;
+      CanType objectType = allResults[0]
+                               .getReturnValueType(SGF.SGM.M, substFnTy,
+                                                   SGF.getTypeExpansionContext())
+                               .getOptionalObjectType();
+      SILResultInfo optResult = allResults[0].getWithInterfaceType(objectType);
+      allResults.clear();
+      allResults.push_back(optResult);
+      break;
+    }
+    }
+
+    ResultPlanPtr subPlan = build(init, calleeTypeInfo.origResultType.getValue(),
+                                  calleeTypeInfo.substResultType);
+    return ResultPlanPtr(new ForeignErrorInitializationPlan(
+        SGF, loc, calleeTypeInfo, std::move(subPlan)));
+  } else {
+    // Otherwise, we can just call build.
     return build(init, calleeTypeInfo.origResultType.getValue(),
                  calleeTypeInfo.substResultType);
   }
-
-  // Otherwise, handle the foreign error first.
-  //
-  // The plan needs to be built using the formal result type after foreign-error
-  // adjustment.
-  switch (foreignError->getKind()) {
-  // These conventions make the formal result type ().
-  case ForeignErrorConvention::ZeroResult:
-  case ForeignErrorConvention::NonZeroResult:
-    assert(calleeTypeInfo.substResultType->isVoid());
-    allResults.clear();
-    break;
-
-  // These conventions leave the formal result alone.
-  case ForeignErrorConvention::ZeroPreservedResult:
-  case ForeignErrorConvention::NonNilError:
-    break;
-
-  // This convention changes the formal result to the optional object type; we
-  // need to make our own make SILResultInfo array.
-  case ForeignErrorConvention::NilResult: {
-    assert(allResults.size() == 1);
-    auto substFnTy = calleeTypeInfo.substFnType;
-    CanType objectType = allResults[0]
-                             .getReturnValueType(SGF.SGM.M, substFnTy,
-                                                 SGF.getTypeExpansionContext())
-                             .getOptionalObjectType();
-    SILResultInfo optResult = allResults[0].getWithInterfaceType(objectType);
-    allResults.clear();
-    allResults.push_back(optResult);
-    break;
-  }
-  }
-
-  ResultPlanPtr subPlan = build(init, calleeTypeInfo.origResultType.getValue(),
-                                calleeTypeInfo.substResultType);
-  return ResultPlanPtr(new ForeignErrorInitializationPlan(
-      SGF, loc, calleeTypeInfo, std::move(subPlan)));
 }
 
 /// Build a result plan for the results of an apply.