[silgen] Use Builtin.ImplicitActor instead of Optional<any Actor> to represent the implicit isolated parameter.

NOTE: We are not performing any bitmasking at all now. This is so that we can
transition the code base/tests to expect Builtin.ImplicitActor instead
of Optional<any Actor>.

NOTE: The actual test changes are in the next commit. I did this to make it
easier to review the changes.

This should not have any user visible changes.

(cherry picked from commit 788abd0)

Author: gottesmm

include/swift/SIL/ConcurrencyUtils.h

@@ -0,0 +1,38 @@
+//===--- ConcurrencyUtils.h -----------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2025 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SIL_CONCURRENCYUTILS_H
+#define SWIFT_SIL_CONCURRENCYUTILS_H
+
+#include "swift/SIL/SILType.h"
+
+namespace swift {
+
+class SILValue;
+class SILBuilder;
+class SILLocation;
+
+/// Clear the implicit isolated bits of value.
+///
+/// \p value must be Builtin.ImplicitActor
+///
+/// \p finalType if empty, we always return
+/// Builtin.ImplicitActor. Otherwise we bitcast to finalType after
+/// tieing the lifetime of the result to \p value.
+SILValue clearImplicitActorBits(SILBuilder &b, SILLocation loc, SILValue value,
+                                SILType finalType = {});
+
+SILValue setImplicitActorBits(SILBuilder &b, SILLocation loc, SILValue value);
+
+} // namespace swift
+
+#endif

include/swift/SIL/SILBuilder.h

@@ -1337,6 +1337,17 @@ class SILBuilder {
         forwardingOwnershipKind));
   }
 
+  /// Create an unchecked_value_cast when Ownership SSA is enabled and
+  /// unchecked_bitwise_cast otherwise.
+  ///
+  /// Intended to be used in utility code that needs to support both Ownership
+  /// SSA and non-Ownership SSA code.
+  SILValue emitUncheckedValueCast(SILLocation loc, SILValue op, SILType ty) {
+    if (hasOwnership())
+      return createUncheckedValueCast(loc, op, ty);
+    return createUncheckedBitwiseCast(loc, op, ty);
+  }
+
   RefToBridgeObjectInst *createRefToBridgeObject(SILLocation Loc, SILValue Ref,
                                                  SILValue Bits) {
     return createRefToBridgeObject(Loc, Ref, Bits, Ref->getOwnershipKind());

lib/SIL/IR/SILFunctionType.cpp

@@ -1715,11 +1715,7 @@ class DestructureInputs {
     // implicit isolation parameter.
     if (IsolationInfo && IsolationInfo->isCallerIsolationInheriting() &&
         Convs.hasCallerIsolationParameter()) {
-      auto actorProtocol = TC.Context.getProtocol(KnownProtocolKind::Actor);
-      auto actorType =
-          ExistentialType::get(actorProtocol->getDeclaredInterfaceType());
-      addParameter(-1,
-                   CanType(actorType).wrapInOptionalType(),
+      addParameter(-1, CanType(TC.Context.TheImplicitActorType),
                    ParameterConvention::Direct_Guaranteed,
                    ParameterTypeFlags().withIsolated(true),
                    true /*implicit leading parameter*/);

lib/SIL/IR/TypeLowering.cpp

@@ -2393,6 +2393,19 @@ namespace {
           UnsafeValueBufferTypeLowering(silType, Expansion, isSensitive);
     }
 
+    TypeLowering *
+    visitBuiltinImplicitActorType(CanBuiltinImplicitActorType type,
+                                  AbstractionPattern origType,
+                                  IsTypeExpansionSensitive_t isSensitive) {
+      auto silType = SILType::getPrimitiveObjectType(type);
+      auto properties = SILTypeProperties();
+      properties.setTypeExpansionSensitive(isSensitive);
+      properties.setNonTrivial();
+      properties.setLexical(IsLexical);
+      return new (TC)
+          MiscNontrivialTypeLowering(silType, properties, Expansion);
+    }
+
     TypeLowering *visitPackType(CanPackType packType,
                                 AbstractionPattern origType,
                                 IsTypeExpansionSensitive_t isSensitive) {

lib/SIL/Utils/CMakeLists.txt

@@ -2,6 +2,7 @@ target_sources(swiftSIL PRIVATE
   BasicBlockUtils.cpp
   BitDataflow.cpp
   CalleeCache.cpp
+  ConcurrencyUtils.cpp
   DebugUtils.cpp
   Dominance.cpp
   DynamicCasts.cpp

lib/SIL/Utils/ConcurrencyUtils.cpp

@@ -0,0 +1,32 @@
+//===--- ConcurrencyUtils.cpp ---------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2025 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/SIL/ConcurrencyUtils.h"
+
+#include "swift/SIL/SILBuilder.h"
+#include "swift/SIL/SILLocation.h"
+
+using namespace swift;
+
+SILValue swift::clearImplicitActorBits(SILBuilder &b, SILLocation loc,
+                                       SILValue value, SILType finalType) {
+  if (!finalType)
+    finalType = SILType::getBuiltinImplicitActorType(b.getASTContext());
+  if (value->getType() == finalType)
+    return value;
+  return b.emitUncheckedValueCast(loc, value, finalType);
+}
+
+SILValue swift::setImplicitActorBits(SILBuilder &b, SILLocation loc,
+                                     SILValue value) {
+  return value;
+}

lib/SILGen/ConcurrencyUtils.h

@@ -0,0 +1,70 @@
+//===--- ConcurrencyUtils.h -----------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2025 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_SILGEN_CONCURRENCYUTILS_H
+#define SWIFT_SILGEN_CONCURRENCYUTILS_H
+
+#include "RValue.h"
+#include "SILGenFunction.h"
+
+#include "swift/SIL/ConcurrencyUtils.h"
+
+namespace swift {
+
+class SILLocation;
+class Expr;
+
+namespace Lowering {
+
+class SILGenFunction;
+class RValue;
+class ManagedValue;
+
+inline ManagedValue clearImplicitActorBits(SILGenFunction &SGF, SILLocation loc,
+                                           ManagedValue implicitIsolatedActor,
+                                           SILType type = {}) {
+  return ManagedValue::forBorrowedRValue(clearImplicitActorBits(
+      SGF.B, loc, implicitIsolatedActor.getUnmanagedValue(), type));
+}
+
+/// Clear the TBI bits if AArch64HasTBI is set. Otherwise clear the low tagged
+/// bits.
+///
+/// \param expr - the expression which yielded this r-value; its type
+///   will become the substituted formal type of this r-value
+/// \param implicitIsolatedActor should be an Optional<any Actor>.
+inline RValue clearImplicitActorBits(SILGenFunction &SGF, Expr *expr,
+                                     ManagedValue implicitIsolatedActor,
+                                     SILType type = {}) {
+  return RValue(SGF, expr,
+                clearImplicitActorBits(SGF, SILLocation(expr),
+                                       implicitIsolatedActor, type));
+}
+
+inline ManagedValue setImplicitActorBits(SILGenFunction &SGF, SILLocation loc,
+                                         ManagedValue implicitIsolatedActor) {
+  return ManagedValue::forBorrowedRValue(setImplicitActorBits(
+      SGF.B, loc, implicitIsolatedActor.getUnmanagedValue()));
+}
+
+inline RValue setImplicitActorBits(SILGenFunction &SGF, Expr *expr,
+                                   ManagedValue implicitIsolatedActor) {
+  return RValue(
+      SGF, expr,
+      setImplicitActorBits(SGF, SILLocation(expr), implicitIsolatedActor));
+}
+
+} // namespace Lowering
+
+} // namespace swift
+
+#endif

lib/SILGen/SILGenApply.cpp

@@ -13,6 +13,7 @@
 #include "ArgumentScope.h"
 #include "ArgumentSource.h"
 #include "Callee.h"
+#include "ConcurrencyUtils.h"
 #include "Conversion.h"
 #include "ExecutorBreadcrumb.h"
 #include "FormalEvaluation.h"
@@ -5860,8 +5861,12 @@ ApplyOptions CallEmission::emitArgumentsForNormalApply(
     args.push_back({});
     // NOTE: Even though this calls emitActorInstanceIsolation, this also
     // handles glboal actor isolated cases.
-    args.back().push_back(SGF.emitActorInstanceIsolation(
-        callSite->Loc, executor, executor.getType().getASTType()));
+    auto erasedActor =
+        SGF.emitActorInstanceIsolation(callSite->Loc, executor,
+                                       executor.getType().getASTType())
+            .borrow(SGF, callSite->Loc);
+    args.back().push_back(
+        SGF.B.convertToImplicitActor(callSite->Loc, erasedActor));
   }
 
   uncurriedLoc = callSite->Loc;

lib/SILGen/SILGenBridging.cpp

@@ -1667,23 +1667,22 @@ void SILGenFunction::emitNativeToForeignThunk(SILDeclRef thunk) {
       isolatedParameter && isolatedParameter->hasOption(SILParameterInfo::ImplicitLeading)) {
     assert(F.isAsync() && "Can only be async");
     assert(isolation && "No isolation?!");
-    switch (isolation->getKind()) {
-    case ActorIsolation::Unspecified:
-    case ActorIsolation::Nonisolated:
-    case ActorIsolation::NonisolatedUnsafe:
-    case ActorIsolation::CallerIsolationInheriting:
-      args.push_back(emitNonIsolatedIsolation(loc).getValue());
-      break;
-    case ActorIsolation::ActorInstance:
-      llvm::report_fatal_error("Should never see this");
-      break;
-    case ActorIsolation::GlobalActor:
-      args.push_back(emitLoadGlobalActorExecutor(isolation->getGlobalActor()));
-      break;
-    case ActorIsolation::Erased:
-      llvm::report_fatal_error("Should never see this");
-      break;
-    }
+    auto value = [&]() -> SILValue {
+      switch (isolation->getKind()) {
+      case ActorIsolation::Unspecified:
+      case ActorIsolation::Nonisolated:
+      case ActorIsolation::NonisolatedUnsafe:
+      case ActorIsolation::CallerIsolationInheriting:
+        return emitNonIsolatedIsolation(loc).getValue();
+      case ActorIsolation::ActorInstance:
+        llvm::report_fatal_error("Should never see this");
+      case ActorIsolation::GlobalActor:
+        return emitLoadGlobalActorExecutor(isolation->getGlobalActor());
+      case ActorIsolation::Erased:
+        llvm::report_fatal_error("Should never see this");
+      }
+    }();
+    args.push_back(B.convertToImplicitActor(loc, value));
   }
 
   // Bridge the arguments.

lib/SILGen/SILGenBuilder.cpp

@@ -1244,3 +1244,16 @@ ManagedValue SILGenBuilder::borrowObjectRValue(SILGenFunction &SGF,
   }
   return SGF.emitFormalEvaluationManagedBeginBorrow(loc, value);
 }
+
+SILValue SILGenBuilder::convertToImplicitActor(SILLocation loc,
+                                               SILValue value) {
+  auto type = SILType::getBuiltinImplicitActorType(getASTContext());
+  if (value->getType() == type)
+    return value;
+  assert(value->getType() == SILType::getOpaqueIsolationType(getASTContext()) &&
+         "Can only convert Optional<any Actor> to "
+         "Builtin.ImplicitActor");
+  if (value->getOwnershipKind() != OwnershipKind::Guaranteed)
+    value = SGF.emitManagedBeginBorrow(loc, value).getValue();
+  return createUncheckedValueCast(loc, value, type);
+}