Address review comments

Author: asl

docs/SIL.rst

@@ -6116,8 +6116,8 @@ when the coroutine reaches a ``return`` instruction.
 The operand must always be the token result of a ``begin_apply``
 instruction, which is why it need not specify a type.
 
-If a coroutine produces normal results on ``resume`` path, they
-will be produced by ``end_apply``.
+The result of ``end_apply`` is the normal result of the coroutine function (the
+operand of the ``return`` instruction)."
 
 When throwing coroutines are supported, there will need to be a
 ``try_end_apply`` instruction.

lib/SIL/IR/ValueOwnership.cpp

@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "swift/SIL/ApplySite.h"
 #include "swift/SIL/SILVisitor.h"
 #include "swift/SIL/SILBuiltinVisitor.h"
 #include "swift/SIL/SILModule.h"
@@ -346,14 +347,18 @@ ValueOwnershipKind ValueOwnershipKindClassifier::visitSILFunctionArgument(
   return Arg->getOwnershipKind();
 }
 
-ValueOwnershipKind ValueOwnershipKindClassifier::visitApplyInst(ApplyInst *ai) {
-  auto *f = ai->getFunction();
-  bool isTrivial = ai->getType().isTrivial(*f);
+// We have to separate out ResultType here as `begin_apply` does not produce
+// normal results, `end_apply` does and there might be multiple `end_apply`'s
+// that correspond to a single `begin_apply`.
+static ValueOwnershipKind visitFullApplySite(FullApplySite fai,
+                                             SILType ResultType) {
+  auto *f = fai->getFunction();
+  bool isTrivial = ResultType.isTrivial(*f);
   // Quick is trivial check.
   if (isTrivial)
     return OwnershipKind::None;
 
-  SILFunctionConventions fnConv(ai->getSubstCalleeType(), f->getModule());
+  SILFunctionConventions fnConv(fai.getSubstCalleeType(), f->getModule());
   auto results = fnConv.getDirectSILResults();
   // No results => None.
   if (results.empty())
@@ -362,7 +367,7 @@ ValueOwnershipKind ValueOwnershipKindClassifier::visitApplyInst(ApplyInst *ai) {
   // Otherwise, map our results to their ownership kinds and then merge them!
   auto resultOwnershipKinds =
       makeTransformRange(results, [&](const SILResultInfo &info) {
-        return info.getOwnershipKind(*f, ai->getSubstCalleeType());
+        return info.getOwnershipKind(*f, fai.getSubstCalleeType());
       });
   auto mergedOwnershipKind = ValueOwnershipKind::merge(resultOwnershipKinds);
   if (!mergedOwnershipKind) {
@@ -372,31 +377,12 @@ ValueOwnershipKind ValueOwnershipKindClassifier::visitApplyInst(ApplyInst *ai) {
   return mergedOwnershipKind;
 }
 
-ValueOwnershipKind ValueOwnershipKindClassifier::visitEndApplyInst(EndApplyInst *eai) {
-  auto *bai = eai->getBeginApply();
-  auto *f = bai->getFunction();
-  bool isTrivial = eai->getType().isTrivial(*f);
-  // Quick is trivial check.
-  if (isTrivial)
-    return OwnershipKind::None;
-
-  SILFunctionConventions fnConv(bai->getSubstCalleeType(), f->getModule());
-  auto results = fnConv.getDirectSILResults();
-  // No results => None.
-  if (results.empty())
-    return OwnershipKind::None;
-
-  // Otherwise, map our results to their ownership kinds and then merge them!
-  auto resultOwnershipKinds =
-      makeTransformRange(results, [&](const SILResultInfo &info) {
-        return info.getOwnershipKind(*f, bai->getSubstCalleeType());
-      });
-  auto mergedOwnershipKind = ValueOwnershipKind::merge(resultOwnershipKinds);
-  if (!mergedOwnershipKind) {
-    llvm_unreachable("Forwarding inst with mismatching ownership kinds?!");
-  }
+ValueOwnershipKind ValueOwnershipKindClassifier::visitApplyInst(ApplyInst *ai) {
+  return visitFullApplySite(ai, ai->getType());
+}
 
-  return mergedOwnershipKind;
+ValueOwnershipKind ValueOwnershipKindClassifier::visitEndApplyInst(EndApplyInst *eai) {
+  return visitFullApplySite(eai->getBeginApply(), eai->getType());
 }
 
 ValueOwnershipKind ValueOwnershipKindClassifier::visitLoadInst(LoadInst *LI) {

lib/SIL/Parser/ParseSIL.cpp

@@ -2649,20 +2649,10 @@ bool SILParser::parseSpecificSILInstruction(SILBuilder &B,
   }
   case SILInstructionKind::EndApplyInst: {
     UnresolvedValueName argName;
-    if (parseValueName(argName))
-      return true;
-
-    if (P.Tok.getKind() != tok::kw_as) {
-      P.diagnose(P.Tok, diag::expected_tok_in_sil_instr, "as");
-      return true;
-    }
-    P.consumeToken(tok::kw_as);
-
     SILType ResultTy;
-    if (parseSILType(ResultTy))
-      return true;
 
-    if (parseSILDebugLocation(InstLoc, B))
+    if (parseValueName(argName) || parseVerbatim("as") ||
+        parseSILType(ResultTy) || parseSILDebugLocation(InstLoc, B))
       return true;
 
     SILType expectedTy = SILType::getSILTokenType(P.Context);

lib/SIL/Verifier/SILVerifier.cpp

@@ -1951,34 +1951,11 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
             "operand of end_apply must be a begin_apply");
 
     BeginApplyInst *bai = AI->getBeginApply();
-    
     SILFunctionConventions calleeConv(bai->getSubstCalleeType(), F.getModule());
-    auto calleeResults = calleeConv.getResults();
-    auto results = AI->getResults();
-
-    require(results.size() == 1,
-            "end_apply must have a single result");
-
-    if (auto tupleTy = results[0]->getType().getAs<TupleType>()) {
-      require(tupleTy.getElementTypes().size() == calleeResults.size(),
-              "length mismatch in callee results vs. end_apply results");
-
-      for (auto typeAndIdx : llvm::enumerate(tupleTy->getElementTypes())) {
-        SILType elTy = SILType::getPrimitiveObjectType(typeAndIdx.value()->getCanonicalType());
-        requireSameType(
-          elTy,
-          calleeConv.getSILType(calleeResults[typeAndIdx.index()], F.getTypeExpansionContext()),
-          "callee result type does not match end_apply result type");
-      }
-    } else {
-      require(calleeResults.size() == 1,
-              "callee must have a single result");
 
-      requireSameType(
-        results[0]->getType(),
-        calleeConv.getSILType(calleeResults[0], F.getTypeExpansionContext()),
-        "callee result type does not match end_apply result type");
-    }
+    requireSameType(
+      AI->getType(), calleeConv.getSILResultType(F.getTypeExpansionContext()),
+      "callee result type does not match end_apply result type");
   }
 
   void verifyLLVMIntrinsic(BuiltinInst *BI, llvm::Intrinsic::ID ID) {