[sil] Restrict sil_isolated to only being able to be applied to any actor types.

I also added some docs to SIL.rst about sil_isolated as well.

Author: gottesmm

docs/SIL.rst

@@ -692,6 +692,18 @@ autorelease in the callee.
   type behaves like a non-generic type, as if the substitutions were
   actually applied to the underlying function type.
 
+- SIL functions may optionally mark a function parameter as
+  ``@sil_isolated``. An ``@sil_isolated`` parameter must be one of:
+
+  - An actor or any actor type.
+  - A generic type that conforms to Actor or AnyActor.
+
+  and must be the actor instance that a function is isolated to. Importantly
+  this means that global actor isolated nominal types are never
+  ``@sil_isolated``. Only one parameter can ever be marked as ``@sil_isolated``
+  since a function cannot be isolated to multiple actors at the same time.
+
+
 Async Functions
 ```````````````
 

lib/SIL/Verifier/SILVerifier.cpp

@@ -6580,6 +6580,35 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
             "transferring result means all results are transferring");
 
     // We should only ever have a single sil_isolated parameter.
+    bool foundIsolatedParameter = false;
+    for (const auto &parameterInfo : FTy->getParameters()) {
+      if (parameterInfo.hasOption(SILParameterInfo::Isolated)) {
+        auto argType = parameterInfo.getArgumentType(F.getModule(),
+                                                     FTy,
+                                                     F.getTypeExpansionContext());
+        if (argType->isOptional())
+          argType = argType->lookThroughAllOptionalTypes()->getCanonicalType();
+
+        auto genericSig = FTy->getInvocationGenericSignature();
+        auto &ctx = F.getASTContext();
+        auto *actorProtocol = ctx.getProtocol(KnownProtocolKind::Actor);
+        auto *anyActorProtocol = ctx.getProtocol(KnownProtocolKind::AnyActor);
+        bool genericTypeWithActorRequirement = llvm::any_of(
+            genericSig.getRequirements(), [&](const Requirement &other) {
+              if (other.getKind() != RequirementKind::Conformance)
+                return false;
+              if (other.getFirstType()->getCanonicalType() != argType)
+                return false;
+              auto *otherProtocol = other.getProtocolDecl();
+              return otherProtocol->inheritsFrom(actorProtocol) ||
+                     otherProtocol->inheritsFrom(anyActorProtocol);
+            });
+        require(argType->isAnyActorType() || genericTypeWithActorRequirement,
+                "Only any actor types can be isolated");
+        require(!foundIsolatedParameter, "Two isolated parameters");
+        foundIsolatedParameter = true;
+      }
+    }
     require(1 >= std::count_if(FTy->getParameters().begin(), FTy->getParameters().end(),
                                [](const SILParameterInfo &parameterInfo) {
                                  return parameterInfo.hasOption(SILParameterInfo::Isolated);