Basic SILGen for @isolated(any).

The main piece that's still missing here is support for closures;
they actually mostly work, but they infer the wrong isolation for
actor-isolated closures (it's not expressed in the type, so obviously
they're non-isolated), so it's not really functional.  We also have
a significant problem where reabstraction thunks collide incorrectly
because we don't mangle (or represent!) formal isolation into
SILFunctionType; that's another follow-up.  Otherwise, I think SILGen
is working.

Author: rjmccall

include/swift/AST/DiagnosticsSIL.def

@@ -130,6 +130,10 @@ ERROR(deserialize_function_type_mismatch,Fatal,
       "type mismatch of function '%0', declared as %1 but used in a swift module as %2",
       (StringRef, Type, Type))
 
+ERROR(without_actually_escaping_on_isolated_any,none,
+      "withoutActuallyEscaping is currently unimplemented for @isolated(any) "
+      "function values", ())
+
 // Capture before declaration diagnostics.
 ERROR(capture_before_declaration,none,
       "closure captures %0 before it is declared", (Identifier))

include/swift/AST/Types.h

@@ -5512,10 +5512,10 @@ class SILFunctionType final
     StringRef getMessage() const;
   };
 
-  /// Returns no-error if this SILFunctionType is ABI compatible with \p
-  /// other. Otherwise, it returns a true error with a message in
-  /// std::error_code. This is only meant to be used in assertions. When
-  /// assertions are disabled, this just returns true.
+  /// Returns no-error if this SILFunctionType can be trivially
+  /// converted (i.e. without introducing a thunk) to the given
+  /// function type.  Otherwise, it returns an error with a message in
+  /// std::error_code.
   ABICompatibilityCheckResult
   isABICompatibleWith(CanSILFunctionType other,
                       SILFunction &context) const;

include/swift/Demangling/TypeDecoder.h

@@ -866,6 +866,7 @@ class TypeDecoder {
       } else if (Node->getChild(firstChildIdx)->getKind() ==
                  NodeKind::IsolatedAnyFunctionType) {
         extFlags = extFlags.withIsolatedAny();
+        ++firstChildIdx;
       }
 
       FunctionMetadataDifferentiabilityKind diffKind;

include/swift/SIL/AbstractionPattern.h

@@ -1566,6 +1566,16 @@ class AbstractionPattern {
                             bool ignoreFinalParam,
     llvm::function_ref<void(FunctionParamGenerator &param)> function) const;
 
+  /// Return the start index of the given formal parameter in the lowered
+  /// parameter sequence corresponding to a function with this abstraction
+  /// pattern.
+  unsigned getLoweredParamIndex(unsigned formalIndex) const;
+
+  /// If this abstraction pattern is recursively expanded and flattened
+  /// in the normal way for parameters and results, how many values does
+  /// it correspond to?
+  unsigned getFlattenedValueCount() const;
+
   /// Given that the value being abstracted is optional, return the
   /// abstraction pattern for its object type.
   AbstractionPattern getOptionalObjectType() const;

include/swift/SIL/SILInstruction.h

@@ -3957,15 +3957,18 @@ class ExtractExecutorInst
 };
 
 /// Extract the isolation of an @isolated(any) function value.
+///
+/// The operand and result must always have guaranteed ownership.
 class FunctionExtractIsolationInst
     : public UnaryInstructionBase<SILInstructionKind::FunctionExtractIsolationInst,
-                                  SingleValueInstruction>
+                                  OwnershipForwardingSingleValueInstruction>
 {
   friend SILBuilder;
 
   FunctionExtractIsolationInst(SILDebugLocation debugLoc, SILValue fnValue,
                                SILType type)
-      : UnaryInstructionBase(debugLoc, fnValue, type) { }
+      : UnaryInstructionBase(debugLoc, fnValue, type,
+                             OwnershipKind::Guaranteed) { }
 
 public:
   SILValue getFunction() const { return getOperand(); }
@@ -11047,6 +11050,7 @@ OwnershipForwardingSingleValueInstruction::classof(SILInstructionKind kind) {
   case SILInstructionKind::BridgeObjectToRefInst:
   case SILInstructionKind::ThinToThickFunctionInst:
   case SILInstructionKind::UnconditionalCheckedCastInst:
+  case SILInstructionKind::FunctionExtractIsolationInst:
     return true;
   default:
     return false;

lib/SIL/IR/AbstractionPattern.cpp

@@ -1355,6 +1355,56 @@ CanType AbstractionPattern::getObjCMethodAsyncCompletionHandlerForeignType(
   return foreignCHTy;
 }
 
+unsigned AbstractionPattern::getLoweredParamIndex(unsigned formalIndex) const {
+  switch (getKind()) {
+  // In the most general abstraction pattern, tuple parameters are
+  // not expanded, so the lowered parameter index matches the formal
+  // index.
+  case Kind::Opaque:
+  case Kind::OpaqueFunction:
+  case Kind::OpaqueDerivativeFunction:
+    return formalIndex;
+
+  case Kind::Type: {
+    // Total the flattened value count of the parameters prior to the
+    // given formal index.
+    unsigned loweredIndex = 0;
+    for (auto i : range(formalIndex)) {
+      loweredIndex += getFunctionParamType(i).getFlattenedValueCount();
+    }
+    return loweredIndex;
+  }
+
+  default:
+    // FIXME: to implement this, we'd need to adjust for the implicit
+    // rearrangement and hidden arguments that we can get from import.
+    // It's definitely doable, but it's currently unnecessary given the
+    // limited situations in which we use this method.  I'm very sorry
+    // if you hit this time bomb.
+    llvm_unreachable("not yet implemented");
+  }
+}
+
+unsigned AbstractionPattern::getFlattenedValueCount() const {
+  // The count is always 1 unless the original type is a tuple.
+  if (!isTuple())
+    return 1;
+
+  // Add up the elements.
+  unsigned count = 0;
+  for (auto elt : getTupleElementTypes()) {
+    // Expansion components turn into a single pack parameter.
+    if (elt.isPackExpansion()) {
+      count++;
+
+    // Recursively expand scalar components.
+    } else {
+      count += elt.getFlattenedValueCount();
+    }
+  }
+  return count;
+}
+
 AbstractionPattern
 AbstractionPattern::getFunctionParamType(unsigned index) const {
   switch (getKind()) {

lib/SIL/IR/SILFunctionType.cpp

@@ -3166,7 +3166,7 @@ CanSILFunctionType swift::buildSILFunctionThunkType(
     if (fn->getLoweredFunctionType()->isPseudogeneric())
       extInfoBuilder = extInfoBuilder.withIsPseudogeneric();
 
-  // Add the function type as the parameter.
+  // Add the formal parameters of the expected type to the thunk.
   auto contextConvention =
       fn->getTypeLowering(sourceType).isTrivial()
           ? ParameterConvention::Direct_Unowned
@@ -3175,6 +3175,17 @@ CanSILFunctionType swift::buildSILFunctionThunkType(
   params.append(expectedType->getParameters().begin(),
                 expectedType->getParameters().end());
 
+  // Thunk functions can never be @isolated(any); we have to erase to that
+  // by partial application.  Remove the attribute and add the capture
+  // parameter.  This must always be the first capture.
+  if (extInfoBuilder.hasErasedIsolation()) {
+    extInfoBuilder = extInfoBuilder.withErasedIsolation(false);
+    auto paramTy = SILType::getOpaqueIsolationType(fn->getASTContext());
+    params.push_back({paramTy.getASTType(),
+                      ParameterConvention::Direct_Guaranteed});
+  }
+
+  // The next capture is the source function.
   if (!differentiationThunkKind ||
       *differentiationThunkKind == DifferentiationThunkKind::Reabstraction) {
     params.push_back({sourceType,
@@ -4839,6 +4850,10 @@ using ABICompatibilityCheckResult =
 ABICompatibilityCheckResult
 SILFunctionType::isABICompatibleWith(CanSILFunctionType other,
                                      SILFunction &context) const {
+  // Most of the checks here are symmetric, but for those that aren't,
+  // the question is whether the ABI makes it safe to use a value of
+  // this type as if it had type `other`.
+
   // The calling convention and function representation can't be changed.
   if (getRepresentation() != other->getRepresentation())
     return ABICompatibilityCheckResult::DifferentFunctionRepresentations;
@@ -4853,8 +4868,8 @@ SILFunctionType::isABICompatibleWith(CanSILFunctionType other,
   }
 
   // @isolated(any) imposes an additional requirement on the context
-  // storage and cannot be added.
-  if (other->hasErasedIsolation() != hasErasedIsolation())
+  // storage and cannot be added.  It can safely be removed, however.
+  if (other->hasErasedIsolation() && !hasErasedIsolation())
     return ABICompatibilityCheckResult::DifferentErasedIsolation;
 
   // Check the results.
@@ -4908,11 +4923,14 @@ SILFunctionType::isABICompatibleWith(CanSILFunctionType other,
 
     if (param1.getConvention() != param2.getConvention())
       return {ABICompatibilityCheckResult::DifferingParameterConvention, i};
+    // Note that the diretionality here is reversed from the other cases
+    // because of contravariance: parameters of the *second* type will be
+    // trivially converted to be parameters of the *first* type.
     if (!areABICompatibleParamsOrReturns(
-            param1.getSILStorageType(context.getModule(), this,
-                                     context.getTypeExpansionContext()),
             param2.getSILStorageType(context.getModule(), other,
                                      context.getTypeExpansionContext()),
+            param1.getSILStorageType(context.getModule(), this,
+                                     context.getTypeExpansionContext()),
             &context))
       return {ABICompatibilityCheckResult::ABIIncompatibleParameterType, i};
   }

lib/SIL/Verifier/SILVerifier.cpp

@@ -7089,12 +7089,15 @@ void SILVTable::verify(const SILModule &M) const {
 
     if (M.getStage() != SILStage::Lowered &&
         !M.getASTContext().LangOpts.hasFeature(Feature::Embedded)) {
+      // Note the direction of the compatibility check: the witness
+      // function must be compatible with being used as the requirement
+      // type.
       SILVerifier(*entry.getImplementation(), /*calleeCache=*/nullptr,
                                               /*SingleFunction=*/true,
                                               /*checkLinearLifetime=*/ false)
           .requireABICompatibleFunctionTypes(
-              baseInfo.getSILType().castTo<SILFunctionType>(),
               entry.getImplementation()->getLoweredFunctionType(),
+              baseInfo.getSILType().castTo<SILFunctionType>(),
               "vtable entry for " + baseName + " must be ABI-compatible",
               *entry.getImplementation());
     }

lib/SILGen/SILGenApply.cpp

@@ -2247,28 +2247,6 @@ ManagedValue SILGenFunction::emitStringLiteral(SILLocation loc,
 //                             Argument Emission
 //===----------------------------------------------------------------------===//
 
-/// Count the number of SILParameterInfos that are needed in order to
-/// pass the given argument.
-static unsigned getFlattenedValueCount(AbstractionPattern origType) {
-  // The count is always 1 unless the original type is a tuple.
-  if (!origType.isTuple())
-    return 1;
-
-  // Add up the elements.
-  unsigned count = 0;
-  for (auto elt : origType.getTupleElementTypes()) {
-    // Expansion components turn into a single pack parameter.
-    if (elt.isPackExpansion()) {
-      count++;
-
-    // Recursively expand scalar components.
-    } else {
-      count += getFlattenedValueCount(elt);
-    }
-  }
-  return count;
-}
-
 /// Count the number of SILParameterInfos that are needed in order to
 /// pass the given argument.
 static unsigned getFlattenedValueCount(AbstractionPattern origType,
@@ -2277,7 +2255,7 @@ static unsigned getFlattenedValueCount(AbstractionPattern origType,
   if (foreignSelf.isStatic())
     return 0;
 
-  return getFlattenedValueCount(origType);
+  return origType.getFlattenedValueCount();
 }
 
 namespace {
@@ -3756,7 +3734,7 @@ class ArgEmitter {
 
   void emitExpandedBorrowed(Expr *arg, AbstractionPattern origParamType) {
     CanType substArgType = arg->getType()->getCanonicalType();
-    auto count = getFlattenedValueCount(origParamType);
+    auto count = origParamType.getFlattenedValueCount();
     auto claimedParams = claimNextParameters(count);
 
     SILType loweredSubstArgType = SGF.getLoweredType(substArgType);
@@ -5642,7 +5620,9 @@ RValue SILGenFunction::emitApply(
     case ActorIsolation::ActorInstance:
       if (unsigned paramIndex =
               implicitActorHopTarget->getActorInstanceParameter()) {
-        executor = emitLoadActorExecutor(loc, args[paramIndex-1]);
+        auto isolatedIndex = calleeTypeInfo.origFormalType
+          ->getLoweredParamIndex(paramIndex - 1);
+        executor = emitLoadActorExecutor(loc, args[isolatedIndex]);
       } else {
         executor = emitLoadActorExecutor(loc, args.back());
       }
@@ -5654,7 +5634,8 @@ RValue SILGenFunction::emitApply(
       break;
 
     case ActorIsolation::Erased:
-      llvm_unreachable("hop to erased isolation currently unimplemented");
+      executor = emitLoadErasedExecutor(loc, fn);
+      break;
 
     case ActorIsolation::Unspecified:
     case ActorIsolation::Nonisolated: