Remove the implicit nil inhabitant of Builtin.Executor,

rjmccall · rjmccall · commit ec5215bf4f0a · 2021-04-30T03:11:56.000-04:00
and traffic in Optional&lt;Builtin.Executor&gt; in various places.
diff --git a/include/swift/AST/Builtins.def b/include/swift/AST/Builtins.def
@@ -757,11 +757,11 @@ BUILTIN_MISC_OPERATION(DestroyTaskGroup,
   BUILTIN_MISC_OPERATION(Id, Name, Attrs, Overload)
 #endif
 
-// getCurrentExecutor: () async -> Builtin.Executor
+// getCurrentExecutor: () async -> Builtin.Executor?
 //
 // Retrieve the ExecutorRef on which the current asynchronous
-// function is executing.
-// Does not retain an actor executor.
+// function is executing, or nil if the function isn't running
+// anywhere in particular.
 BUILTIN_MISC_OPERATION_WITH_SILGEN(GetCurrentExecutor, "getCurrentExecutor", "", Special)
 
 // getCurrentAsyncTask: () -> Builtin.NativeObject
diff --git a/lib/AST/Builtins.cpp b/lib/AST/Builtins.cpp
@@ -1407,7 +1407,7 @@ static ValueDecl *getGetCurrentAsyncTask(ASTContext &ctx, Identifier id) {
 static ValueDecl *getGetCurrentExecutor(ASTContext &ctx, Identifier id) {
   return getBuiltinFunction(ctx, id, _async(_thin),
                             _parameters(),
-                            _executor);
+                            _optional(_executor));
 }
 
 static ValueDecl *getCancelAsyncTask(ASTContext &ctx, Identifier id) {
diff --git a/lib/IRGen/GenBuiltin.cpp b/lib/IRGen/GenBuiltin.cpp
@@ -223,7 +223,6 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,
   // emitGetCurrentExecutor has no arguments.
   if (Builtin.ID == BuiltinValueKind::GetCurrentExecutor) {
     emitGetCurrentExecutor(IGF, out);
-
     return;
   }
 
diff --git a/lib/IRGen/GenConcurrency.cpp b/lib/IRGen/GenConcurrency.cpp
@@ -65,14 +65,12 @@ class ExecutorTypeInfo :
     return ".impl";
   }
 
-  // The identity pointer is a heap object reference, but it's
-  // nullable because of the generic executor.
+  // The identity pointer is a heap object reference.
   bool mayHaveExtraInhabitants(IRGenModule &IGM) const override {
     return true;
   }
-
   PointerInfo getPointerInfo(IRGenModule &IGM) const {
-    return PointerInfo::forHeapObject(IGM).withNullable(IsNullable);
+    return PointerInfo::forHeapObject(IGM);
   }
   unsigned getFixedExtraInhabitantCount(IRGenModule &IGM) const override {
     return getPointerInfo(IGM).getExtraInhabitantCount(IGM);
@@ -89,18 +87,17 @@ class ExecutorTypeInfo :
     src = projectFirstElement(IGF, src);
     return getPointerInfo(IGF.IGM).getExtraInhabitantIndex(IGF, src);
   }
-  APInt getFixedExtraInhabitantMask(IRGenModule &IGM) const override {
-    auto pointerSize = IGM.getPointerSize();
-    auto mask = BitPatternBuilder(IGM.Triple.isLittleEndian());
-    mask.appendSetBits(pointerSize.getValueInBits());
-    mask.appendClearBits(pointerSize.getValueInBits());
-    return mask.build().getValue();
-  }
   void storeExtraInhabitant(IRGenFunction &IGF, llvm::Value *index,
                             Address dest, SILType T,
                             bool isOutlined) const override {
-    dest = projectFirstElement(IGF, dest);
-    getPointerInfo(IGF.IGM).storeExtraInhabitant(IGF, index, dest);
+    // Store the extra-inhabitant value in the first (identity) word.
+    auto first = projectFirstElement(IGF, dest);
+    getPointerInfo(IGF.IGM).storeExtraInhabitant(IGF, index, first);
+
+    // Zero the second word.
+    auto second = projectSecondElement(IGF, dest);
+    IGF.Builder.CreateStore(llvm::ConstantInt::get(IGF.IGM.ExecutorSecondTy, 0),
+                            second);
   }
 };
 
@@ -139,9 +136,9 @@ void irgen::emitBuildDefaultActorExecutorRef(IRGenFunction &IGF,
   unsigned flags = unsigned(ExecutorRefFlags::DefaultActor);
 
   llvm::Value *identity =
-    IGF.Builder.CreateBitCast(actor, IGF.IGM.ExecutorFirstTy);
+    IGF.Builder.CreatePtrToInt(actor, IGF.IGM.ExecutorFirstTy);
   llvm::Value *impl =
-    IGF.IGM.getSize(Size(flags));
+    llvm::ConstantInt::get(IGF.IGM.ExecutorSecondTy, flags);
 
   out.add(identity);
   out.add(impl);
@@ -153,10 +150,10 @@ void irgen::emitBuildOrdinarySerialExecutorRef(IRGenFunction &IGF,
                                        ProtocolConformanceRef executorConf,
                                                Explosion &out) {
   llvm::Value *identity =
-    IGF.Builder.CreateBitCast(executor, IGF.IGM.ExecutorFirstTy);
+    IGF.Builder.CreatePtrToInt(executor, IGF.IGM.ExecutorFirstTy);
   llvm::Value *impl =
     emitWitnessTableRef(IGF, executorType, executorConf);
-  impl = IGF.Builder.CreatePtrToInt(impl, IGF.IGM.SizeTy);
+  impl = IGF.Builder.CreatePtrToInt(impl, IGF.IGM.ExecutorSecondTy);
 
   out.add(identity);
   out.add(impl);
diff --git a/lib/IRGen/IRGenModule.cpp b/lib/IRGen/IRGenModule.cpp
@@ -620,7 +620,7 @@ IRGenModule::IRGenModule(IRGenerator &irgen,
   SwiftTaskPtrTy = SwiftTaskTy->getPointerTo(DefaultAS);
   SwiftAsyncLetPtrTy = Int8PtrTy; // we pass it opaquely (AsyncLet*)
   SwiftTaskGroupPtrTy = Int8PtrTy; // we pass it opaquely (TaskGroup*)
-  ExecutorFirstTy = RefCountedPtrTy;
+  ExecutorFirstTy = SizeTy;
   ExecutorSecondTy = SizeTy;
   SwiftExecutorTy = createStructType(*this, "swift.executor", {
     ExecutorFirstTy,      // identity
diff --git a/lib/IRGen/IRGenModule.h b/lib/IRGen/IRGenModule.h
@@ -735,7 +735,7 @@ class IRGenModule {
   llvm::PointerType *SwiftAsyncLetPtrTy;
   llvm::PointerType *SwiftTaskGroupPtrTy;
   llvm::PointerType *SwiftJobPtrTy;
-  llvm::PointerType *ExecutorFirstTy;
+  llvm::IntegerType *ExecutorFirstTy;
   llvm::IntegerType *ExecutorSecondTy;
   llvm::FunctionType *TaskContinuationFunctionTy;
   llvm::PointerType *TaskContinuationFunctionPtrTy;
diff --git a/lib/IRGen/IRGenSIL.cpp b/lib/IRGen/IRGenSIL.cpp
@@ -6156,12 +6156,8 @@ void IRGenSILFunction::visitCheckedCastAddrBranchInst(
 }
 
 void IRGenSILFunction::visitHopToExecutorInst(HopToExecutorInst *i) {
-  if (!i->getFunction()->isAsync()) {
-    // This should never occur.
-    assert(false && "The hop_to_executor should have been eliminated");
-    return;
-  }
-  assert(i->getTargetExecutor()->getType().is<BuiltinExecutorType>());
+  assert(i->getTargetExecutor()->getType().getOptionalObjectType()
+           .is<BuiltinExecutorType>());
   llvm::Value *resumeFn = Builder.CreateIntrinsicCall(
           llvm::Intrinsic::coro_async_resume, {});
 
diff --git a/lib/SIL/Verifier/SILVerifier.cpp b/lib/SIL/Verifier/SILVerifier.cpp
@@ -832,6 +832,15 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
             valueDescription + " cannot apply to a function type");
   }
 
+  /// Require the operand to be `$Optional<Builtin.Executor>`.
+  void requireOptionalExecutorType(SILValue value, const Twine &what) {
+    auto type = value->getType();
+    require(type.isObject(), what + " must be an object type");
+    auto objectType = type.getASTType().getOptionalObjectType();
+    require(objectType && objectType == M->getASTContext().TheExecutorType,
+            what + " must be Optional<Builtin.Executor>");
+  }
+
   /// Assert that two types are equal.
   void requireSameType(Type type1, Type type2, const Twine &complaint) {
     _require(type1->isEqual(type2), complaint,
@@ -1822,6 +1831,7 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
     }
 
     auto builtinKind = BI->getBuiltinKind();
+    auto arguments = BI->getArguments();
 
     // Check that 'getCurrentAsyncTask' only occurs within an async function.
     if (builtinKind == BuiltinValueKind::GetCurrentAsyncTask) {
@@ -1832,7 +1842,6 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
 
     if (builtinKind == BuiltinValueKind::InitializeDefaultActor ||
         builtinKind == BuiltinValueKind::DestroyDefaultActor) {
-      auto arguments = BI->getArguments();
       require(arguments.size() == 1,
               "default-actor builtin can only operate on a single object");
       auto argType = arguments[0]->getType().getASTType();
@@ -1844,23 +1853,32 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
       return;
     }
 
+    // Check that 'getCurrentAsyncTask' only occurs within an async function.
+    if (builtinKind == BuiltinValueKind::GetCurrentExecutor) {
+      require(F.isAsync(),
+              "getCurrentExecutor can only be used in an async function");
+      require(arguments.empty(), "getCurrentExecutor takes no arguments");
+      requireOptionalExecutorType(BI, "result of getCurrentExecutor");
+      return;
+    }
+
     if (builtinKind == BuiltinValueKind::BuildOrdinarySerialExecutorRef ||
         builtinKind == BuiltinValueKind::BuildDefaultActorExecutorRef) {
-      requireObjectType(BuiltinExecutorType, BI,
-                        "result of building a serial executor");
-      auto arguments = BI->getArguments();
       require(arguments.size() == 1,
               "builtin expects one argument");
       require(arguments[0]->getType().isObject(),
               "operand of builtin should have object type");
+      requireObjectType(BuiltinExecutorType, BI,
+                        "result of build*ExecutorRef");
+      return;
     }
 
     if (builtinKind == BuiltinValueKind::BuildMainActorExecutorRef) {
-      requireObjectType(BuiltinExecutorType, BI,
-                        "result of buildSerialExecutorRef");
-      auto arguments = BI->getArguments();
       require(arguments.size() == 0,
               "buildMainActorExecutorRef expects no arguments");
+      requireObjectType(BuiltinExecutorType, BI,
+                        "result of build*ExecutorRef");
+      return;
     }
   }
   
@@ -4792,9 +4810,8 @@ class SILVerifier : public SILVerifierBase<SILVerifier> {
   void checkHopToExecutorInst(HopToExecutorInst *HI) {
     auto executor = HI->getTargetExecutor();
     if (HI->getModule().getStage() == SILStage::Lowered) {
-      requireObjectType(BuiltinExecutorType, executor->getType(),
-                        "hop_to_executor instruction must take a "
-                        "Builtin.Executor in lowered SIL");
+      requireOptionalExecutorType(executor,
+                                  "hop_to_executor operand in lowered SIL");
     }
   }
 
diff --git a/lib/SILGen/SILGenProlog.cpp b/lib/SILGen/SILGenProlog.cpp
@@ -704,7 +704,7 @@ SILValue SILGenFunction::emitGetCurrentExecutor(SILLocation loc) {
   return B.createBuiltin(
       loc,
       ctx.getIdentifier(getBuiltinName(BuiltinValueKind::GetCurrentExecutor)),
-      getLoweredType(ctx.TheExecutorType),
+      getLoweredType(OptionalType::get(ctx.TheExecutorType)),
       SubstitutionMap(), { });
 }
 
diff --git a/lib/SILOptimizer/Mandatory/LowerHopToActor.cpp b/lib/SILOptimizer/Mandatory/LowerHopToActor.cpp
@@ -57,7 +57,7 @@ class LowerHopToActor {
   bool processHop(HopToExecutorInst *hop);
   bool processExtract(ExtractExecutorInst *extract);
 
-  SILValue emitGetExecutor(SILLocation loc, SILValue actor);
+  SILValue emitGetExecutor(SILLocation loc, SILValue actor, bool makeOptional);
 
 public:
   LowerHopToActor(SILFunction *f, DominanceInfo *dominance)
@@ -85,19 +85,25 @@ bool LowerHopToActor::run() {
   return changed;
 }
 
+static bool isOptionalBuiltinExecutor(SILType type) {
+  if (auto objectType = type.getOptionalObjectType())
+    return objectType.is<BuiltinExecutorType>();
+  return false;
+}
+
 /// Search for hop_to_executor instructions with actor-typed operands.
 bool LowerHopToActor::processHop(HopToExecutorInst *hop) {
   auto actor = hop->getTargetExecutor();
 
-  // Ignore hops that are already to Builtin.Executor.
-  if (actor->getType().is<BuiltinExecutorType>())
+  // Ignore hops that are already to Optional<Builtin.Executor>.
+  if (isOptionalBuiltinExecutor(actor->getType()))
     return false;
 
   B.setInsertionPoint(hop);
 
   // Get the dominating executor value for this actor, if available,
   // or else emit code to derive it.
-  SILValue executor = emitGetExecutor(hop->getLoc(), actor);
+  SILValue executor = emitGetExecutor(hop->getLoc(), actor, /*optional*/true);
 
   B.createHopToExecutor(hop->getLoc(), executor);
 
@@ -109,12 +115,12 @@ bool LowerHopToActor::processHop(HopToExecutorInst *hop) {
 bool LowerHopToActor::processExtract(ExtractExecutorInst *extract) {
   // Dig out the executor.
   auto executor = extract->getExpectedExecutor();
-  if (!executor->getType().is<BuiltinExecutorType>()) {
+  if (!isOptionalBuiltinExecutor(executor->getType())) {
     B.setInsertionPoint(extract);
-
-    executor = emitGetExecutor(extract->getLoc(), executor);
+    executor = emitGetExecutor(extract->getLoc(), executor, /*optional*/false);
   }
 
+  // Unconditionally replace the extract with the executor.
   extract->replaceAllUsesWith(executor);
   extract->eraseFromParent();
   return true;
@@ -138,12 +144,17 @@ static AccessorDecl *getUnownedExecutorGetter(ASTContext &ctx,
   return nullptr;
 }
 
-SILValue LowerHopToActor::emitGetExecutor(SILLocation loc, SILValue actor) {
+SILValue LowerHopToActor::emitGetExecutor(SILLocation loc, SILValue actor,
+                                          bool makeOptional) {
   // Get the dominating executor value for this actor, if available,
   // or else emit code to derive it.
   SILValue executor = ExecutorForActor.lookup(actor);
-  if (executor)
+  if (executor) {
+    if (makeOptional)
+      executor = B.createOptionalSome(loc, executor,
+                           SILType::getOptionalType(executor->getType()));
     return executor;
+  }
 
   // This is okay because actor types have to be classes and so never
   // have multiple abstraction patterns.
@@ -197,9 +208,14 @@ SILValue LowerHopToActor::emitGetExecutor(SILLocation loc, SILValue actor) {
   // force the actor to stay alive.
   executor = B.createMarkDependence(loc, unmarkedExecutor, actor);
 
-  // Cache the result for later.
+  // Cache the non-optional result for later.
   ExecutorForActor.insert(actor, executor);
 
+  // Inject the result into an optional if requested.
+  if (makeOptional)
+    executor = B.createOptionalSome(loc, executor,
+                           SILType::getOptionalType(executor->getType()));
+
   return executor;
 }
 
diff --git a/test/IRGen/async/builtin_executor.sil b/test/IRGen/async/builtin_executor.sil
@@ -0,0 +1,27 @@
+// RUN: %target-swift-frontend -enable-experimental-concurrency -primary-file %s -module-name=test -disable-llvm-optzns -disable-swift-specific-llvm-optzns -emit-ir -sil-verify-all | %IRGenFileCheck %s
+
+// REQUIRES: concurrency
+
+sil_stage canonical
+
+import Builtin
+import Swift
+import _Concurrency
+
+// CHECK: define{{.*}} swiftcc { [[INT]], [[INT]] } @test_none()
+sil @test_none : $() -> Optional<Builtin.Executor> {
+bb0:
+  // CHECK: ret { [[INT]], [[INT]] } zeroinitializer
+  %0 = enum $Optional<Builtin.Executor>, #Optional.none
+  return %0 : $Optional<Builtin.Executor>
+}
+
+// CHECK: define{{.*}} swiftcc { [[INT]], [[INT]] } @test_some([[INT]] %0, [[INT]] %1)
+sil @test_some : $(Builtin.Executor) -> Optional<Builtin.Executor> {
+bb0(%0 : $Builtin.Executor):
+  // CHECK:      [[T0:%.*]] = insertvalue { [[INT]], [[INT]] } undef, [[INT]] %0, 0
+  // CHECK-NEXT: [[T1:%.*]] = insertvalue { [[INT]], [[INT]] } [[T0]], [[INT]] %1, 1
+  // CHECK-NEXT: ret { [[INT]], [[INT]] } [[T1]]
+  %1 = enum $Optional<Builtin.Executor>, #Optional.some, %0 : $Builtin.Executor
+  return %1 : $Optional<Builtin.Executor>
+}
diff --git a/test/IRGen/async/hop_to_executor.sil b/test/IRGen/async/hop_to_executor.sil
@@ -9,28 +9,28 @@ import Swift
 import _Concurrency
 
 // CHECK-LABEL: define{{.*}} void @test_simple(
-// CHECK-SAME: %swift.context* swiftasync %0, %swift.refcounted* %1, [[INT]] %2)
+// CHECK-SAME: %swift.context* swiftasync %0, [[INT]] %1, [[INT]] %2)
 // CHECK: [[CTX:%[0-9]+]] = bitcast %swift.context* %0
 // CHECK: [[RESUME:%[0-9]+]] = call i8* @llvm.coro.async.resume()
-// CHECK-x86_64: call {{.*}} @llvm.coro.suspend.async{{.*}}(i32 0, i8* [[RESUME]], i8* bitcast (i8* (i8*)* @__swift_async_resume_get_context to i8*), i8* bitcast (void (i8*, %swift.refcounted*, [[INT]], %swift.context*)* @__swift_suspend_point to i8*), i8* [[RESUME]], %swift.refcounted* %1, [[INT]] %2, %swift.context* {{%[0-9]+}})
-// CHECK-arm64e: call {{.*}} @llvm.coro.suspend.async{{.*}}(i32 0, i8* [[RESUME]], i8* bitcast (i8* (i8*)* @__swift_async_resume_get_context to i8*), i8* bitcast (void (i8*, %swift.refcounted*, [[INT]], %swift.context*)* @__swift_suspend_point to i8*), i8* [[RESUME]], %swift.refcounted* %1, [[INT]] %2, %swift.context* {{%[0-9]+}})
+// CHECK-x86_64: call {{.*}} @llvm.coro.suspend.async{{.*}}(i32 0, i8* [[RESUME]], i8* bitcast (i8* (i8*)* @__swift_async_resume_get_context to i8*), i8* bitcast (void (i8*, [[INT]], [[INT]], %swift.context*)* @__swift_suspend_point to i8*), i8* [[RESUME]], [[INT]] %1, [[INT]] %2, %swift.context* {{%[0-9]+}})
+// CHECK-arm64e: call {{.*}} @llvm.coro.suspend.async{{.*}}(i32 0, i8* [[RESUME]], i8* bitcast (i8* (i8*)* @__swift_async_resume_get_context to i8*), i8* bitcast (void (i8*, [[INT]], [[INT]], %swift.context*)* @__swift_suspend_point to i8*), i8* [[RESUME]], [[INT]] %1, [[INT]] %2, %swift.context* {{%[0-9]+}})
 // CHECK: [[RET_CONTINUATION:%.*]] = bitcast void (%swift.context*)* {{.*}} to i8*
 // CHECK:  call i1 (i8*, i1, ...) @llvm.coro.end.async(i8* {{.*}}, i1 false, void (i8*, %swift.context*)* @[[TAIL_CALL_FUNC:.*]], i8* [[RET_CONTINUATION]]
 // CHECK: unreachable
 
-sil @test_simple : $@async (@guaranteed Builtin.Executor) -> () {
-bb0(%0 : $Builtin.Executor):
-  hop_to_executor %0 : $Builtin.Executor
+sil @test_simple : $@async (@guaranteed Optional<Builtin.Executor>) -> () {
+bb0(%0 : $Optional<Builtin.Executor>):
+  hop_to_executor %0 : $Optional<Builtin.Executor>
   %3 = tuple ()
   return %3 : $()
 }
 
 // CHECK-LABEL: define internal swift{{(tail)?}}cc void @__swift_suspend_point
-// CHECK-SAME:  (i8* [[RESUME_FN:%0]], %swift.refcounted* %1, [[INT]] %2, %swift.context* [[CTXT:%[^,]+]])
+// CHECK-SAME:  (i8* [[RESUME_FN:%0]], [[INT]] %1, [[INT]] %2, %swift.context* [[CTXT:%[^,]+]])
 // CHECK-arm64e: [[RESUME_FN_INT:%[^,]+]] = ptrtoint i8* [[RESUME_FN]] to i64
 // CHECK-arm64e: [[PTRAUTH_SIGN:%[^,]+]] = call i64 @llvm.ptrauth.sign.i64(i64 [[RESUME_FN_INT]], i32 0, i64 0)
 // CHECK-arm64e: [[RESUME_FN:%[^,]+]] = inttoptr i64 [[PTRAUTH_SIGN]] to i8*
-// CHECK:    {{(must)?}}tail call swift{{(tail)?}}cc void @swift_task_switch(%swift.context* swiftasync [[CTXT]], i8* [[RESUME_FN]], %swift.refcounted* %1, [[INT]] %2)
+// CHECK:    {{(must)?}}tail call swift{{(tail)?}}cc void @swift_task_switch(%swift.context* swiftasync [[CTXT]], i8* [[RESUME_FN]], [[INT]] %1, [[INT]] %2)
 // CHECK:    ret void
 
 // CHECK: define{{.*}} void @[[TAIL_CALL_FUNC]](i8* %0, %swift.context* %1)
diff --git a/test/SILGen/async_initializer.swift b/test/SILGen/async_initializer.swift
diff --git a/test/SILGen/hop_to_executor.swift b/test/SILGen/hop_to_executor.swift
diff --git a/test/SILOptimizer/lower_hop_to_actor.sil b/test/SILOptimizer/lower_hop_to_actor.sil
diff --git a/test/SILOptimizer/optimize_hop_to_executor.sil b/test/SILOptimizer/optimize_hop_to_executor.sil

Original file line number	Diff line number	Diff line change
`@@ -1407,7 +1407,7 @@ static ValueDecl *getGetCurrentAsyncTask(ASTContext &ctx, Identifier id) {`
`1407`	`1407`	`static ValueDecl *getGetCurrentExecutor(ASTContext &ctx, Identifier id) {`
`1408`	`1408`	`return getBuiltinFunction(ctx, id, _async(_thin),`
`1409`	`1409`	`_parameters(),`
`1410`		`- _executor);`
	`1410`	`+ _optional(_executor));`
`1411`	`1411`	`}`
`1412`	`1412`
`1413`	`1413`	`static ValueDecl *getCancelAsyncTask(ASTContext &ctx, Identifier id) {`
Original file line number	Diff line number	Diff line change
`@@ -223,7 +223,6 @@ void irgen::emitBuiltinCall(IRGenFunction &IGF, const BuiltinInfo &Builtin,`
`223`	`223`	`// emitGetCurrentExecutor has no arguments.`
`224`	`224`	`if (Builtin.ID == BuiltinValueKind::GetCurrentExecutor) {`
`225`	`225`	`emitGetCurrentExecutor(IGF, out);`
`226`		`-`
`227`	`226`	`return;`
`228`	`227`	`}`
`229`	`228`
Original file line number	Diff line number	Diff line change
`@@ -704,7 +704,7 @@ SILValue SILGenFunction::emitGetCurrentExecutor(SILLocation loc) {`
`704`	`704`	`return B.createBuiltin(`
`705`	`705`	`loc,`
`706`	`706`	`ctx.getIdentifier(getBuiltinName(BuiltinValueKind::GetCurrentExecutor)),`
`707`		`- getLoweredType(ctx.TheExecutorType),`
	`707`	`+ getLoweredType(OptionalType::get(ctx.TheExecutorType)),`
`708`	`708`	`SubstitutionMap(), { });`
`709`	`709`	`}`
`710`	`710`