Strengthen verification of the operand of hop_to_executor and extract_executor.

Author: rjmccall

lib/SIL/Verifier/SILVerifier.cpp

@@ -1069,6 +1069,24 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
             what + " must be Optional<Builtin.Executor>");
   }
 
+  /// Require the operand to be an object of some type that conforms to
+  /// Actor or DistributedActor.
+  void requireAnyActorType(SILValue value, bool allowOptional,
+                           bool allowExecutor, const Twine &what) {
+    auto type = value->getType();
+    require(type.isObject(), what + " must be an object type");
+
+    auto actorType = type.getASTType();
+    if (allowOptional) {
+      if (auto objectType = actorType.getOptionalObjectType())
+        actorType = objectType;
+    }
+    if (allowExecutor && isa<BuiltinExecutorType>(actorType))
+      return;
+    require(actorType->isAnyActorType(),
+            what + " must be some kind of actor type");
+  }
+
   /// Assert that two types are equal.
   void requireSameType(Type type1, Type type2, const Twine &complaint) {
     _require(type1->isEqual(type2), complaint,
@@ -5806,10 +5824,21 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     if (HI->getModule().getStage() == SILStage::Lowered) {
       requireOptionalExecutorType(executor,
                                   "hop_to_executor operand in lowered SIL");
+    } else {
+      requireAnyActorType(executor,
+                          /*allow optional*/ true,
+                          /*allow executor*/ true,
+                          "hop_to_executor operand");
     }
   }
 
   void checkExtractExecutorInst(ExtractExecutorInst *EEI) {
+    requireObjectType(BuiltinExecutorType, EEI,
+                      "extract_executor result");
+    requireAnyActorType(EEI->getExpectedExecutor(),
+                        /*allow optional*/ false,
+                        /*allow executor*/ false,
+                        "extract_executor operand");
     if (EEI->getModule().getStage() == SILStage::Lowered) {
       require(false,
               "extract_executor instruction should have been lowered away");

lib/SILOptimizer/Mandatory/LowerHopToActor.cpp

@@ -112,21 +112,19 @@ static bool isOptionalBuiltinExecutor(SILType type) {
 void LowerHopToActor::recordDominatingInstFor(SILInstruction *inst) {
   SILValue actor;
   if (auto *hop = dyn_cast<HopToExecutorInst>(inst)) {
+    // hop_to_executor can take optional and non-optional Builtin.Executor
+    // values directly.  If we see Optional<Builtin.Executor>, there's
+    // nothing to do.
     actor = hop->getTargetExecutor();
-    // If hop_to_executor was emitted with an optional executor operand,
-    // there's nothing to derive.
-    if (isOptionalBuiltinExecutor(actor->getType())) {
+    if (isOptionalBuiltinExecutor(actor->getType()))
       return;
-    }
   } else if (auto *extract = dyn_cast<ExtractExecutorInst>(inst)) {
+    // extract_executor can only take non-optional actor values.
     actor = extract->getExpectedExecutor();
   } else {
     return;
   }
 
-  if (isOptionalBuiltinExecutor(actor->getType()))
-    return;
-
   auto *dominatingInst = ExecutorDerivationForActor.lookup(actor);
   if (dominatingInst) {
     DominatingActorHops.insert(dominatingInst, inst);

test/SILOptimizer/consume_operator_kills_addresses_dbginfo.sil

@@ -19,11 +19,6 @@ public protocol P {
 sil @forceSplit : $@convention(thin) @async () -> ()
 sil @genericUse : $@convention(thin) <τ_0_0> (@in_guaranteed τ_0_0) -> ()
 
-enum Optional<T> {
-case some(T)
-case none
-}
-
 ///////////
 // Tests //
 ///////////