[sil] Add a new instruction called ThunkInst.

For now this will only be used for HopToMainActorIfNeeded thunks. I am creating
this now since in the past there has only been one option for creating
thunks... to create the thunk in SILGen using SILGenThunk. This code is hard to
test and there is a lot of it. By using an instruction here we get a few benefits:

1. We decouple SILGen from needing to generate new kinds of thunks. This means
that SILGenThunk does not need to expand to handle more thunks.

2. All thunks implemented via ThunkInst will be easy to test in a decoupled way
with SIL tests.

3. Even though this stabilizes the patient, we still have many thunks in SILGen
and various parts of the compiler. Over time, we can swap to this model,
allowing us to hopefully eventually delete SILGenThunk.

Author: gottesmm

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -1601,3 +1601,6 @@ final public class CheckedCastAddrBranchInst : TermInst {
     }
   }
 }
+
+final public class ThunkInst : Instruction {
+}

SwiftCompilerSources/Sources/SIL/Registration.swift

@@ -256,4 +256,5 @@ public func registerSILClasses() {
   register(AwaitAsyncContinuationInst.self)
   register(CheckedCastBranchInst.self)
   register(CheckedCastAddrBranchInst.self)
+  register(ThunkInst.self)
 }

docs/SIL.rst

@@ -8107,6 +8107,40 @@ passed to a function (materializeForSet) which escapes the closure in a way not
 expressed by the convert's users. The mandatory pass must ensure the lifetime
 in a conservative way.
 
+
+thunk
+`````
+::
+
+  sil-instruction ::= 'thunk' sil-thunk-attr* sil-value sil-apply-substitution-list? () sil-type
+  sil-thunk-attr ::= '[' thunk-kind ']'
+  sil-thunk-kind ::= identity
+
+  %1 = thunk [identity] %0() : $@convention(thin) (T) -> U
+  // %0 must be of a function type $T -> U
+  // %1 will be of type @callee_guaranteed (T) -> U since we are creating an
+  // "identity" thunk.
+  
+  %1 = thunk [identity] %0<T>() : $@convention(thin) (τ_0_0) -> ()
+  // %0 must be of a function type $T -> ()
+  // %1 will be of type @callee_guaranteed <τ_0_0> (τ_0_0) -> () since we are creating a
+  // "identity" thunk.
+
+Takes in a function and depending on the kind produces a new function result
+that is ``@callee_guaranteed``. The specific way that the function type of the
+input is modified by this instruction depends on the specific sil-thunk-kind of
+the instruction. So for instance, the hop_to_mainactor_if_needed thunk just
+returns a callee_guaranteed version of the input function... but one could
+imagine a "reabstracted" thunk kind that would produce the appropriate
+reabstracted thunk kind.
+
+This instructions is lowered to a true think in Lowered SIL by the ThunkLowering
+pass.
+
+It is assumed that like `partial_apply`_, if we need a substitution map, it will be
+attached to `thunk`_. This ensures that we have the substitution
+map already created if we need to create a `partial_apply`_.
+
 classify_bridge_object
 ``````````````````````
 ::

include/swift/AST/DiagnosticsParse.def

@@ -2165,5 +2165,11 @@ ERROR(sending_repeated,none,
 ERROR(sending_cannot_be_used_with_borrowing,none,
       "'%0' cannot be used together with 'borrowing'", (StringRef))
 
+ERROR(sil_thunkinst_failed_to_parse_kind,none,
+      "'%0' is not a valid thunk kind supported by ThunkInst", (StringRef))
+
+ERROR(sil_failed_to_parse_sil_optional,none,
+      "Expected SIL optional value of the form '[' NAME ']'", ())
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/AST/Types.h

@@ -5027,6 +5027,11 @@ class SILFunctionType final
     return getCalleeConvention() == ParameterConvention::Direct_Guaranteed;
   }
 
+  /// Return a copy of this SILFunctionType with its CalleConvention changed to
+  /// \p newCalleeConvention.
+  CanSILFunctionType
+  getWithCalleeConvention(ParameterConvention newCalleeConvention);
+
   /// Is this some kind of coroutine?
   bool isCoroutine() const {
     return getCoroutineKind() != SILCoroutineKind::None;

include/swift/SIL/SILBuilder.h

@@ -1240,6 +1240,17 @@ class SILBuilder {
         WithoutActuallyEscaping, forwardingOwnershipKind));
   }
 
+  ThunkInst *createThunk(SILLocation Loc, SILValue Op, ThunkInst::Kind kind,
+                         SubstitutionMap substitutionMap = {}) {
+    return insert(ThunkInst::create(getSILDebugLocation(Loc), Op, getModule(),
+                                    F, kind, substitutionMap));
+  }
+
+  ThunkInst *createIdentityThunk(SILLocation Loc, SILValue Op,
+                                 SubstitutionMap substitutionMap = {}) {
+    return createThunk(Loc, Op, ThunkInst::Kind::Identity, substitutionMap);
+  }
+
   ConvertEscapeToNoEscapeInst *
   createConvertEscapeToNoEscape(SILLocation Loc, SILValue Op, SILType Ty,
                                 bool lifetimeGuaranteed) {

include/swift/SIL/SILCloner.h

@@ -1783,6 +1783,15 @@ SILCloner<ImplClass>::visitConvertFunctionInst(ConvertFunctionInst *Inst) {
                     : ValueOwnershipKind(OwnershipKind::None)));
 }
 
+template <typename ImplClass>
+void SILCloner<ImplClass>::visitThunkInst(ThunkInst *Inst) {
+  getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  recordClonedInstruction(
+      Inst, getBuilder().createThunk(getOpLocation(Inst->getLoc()),
+                                     getOpValue(Inst->getOperand()),
+                                     Inst->getThunkKind()));
+}
+
 template <typename ImplClass>
 void SILCloner<ImplClass>::visitConvertEscapeToNoEscapeInst(
     ConvertEscapeToNoEscapeInst *Inst) {

include/swift/SIL/SILInstruction.h

@@ -5868,6 +5868,78 @@ class ConvertFunctionInst final
   bool onlyConvertsSendable() const;
 };
 
+class ThunkInst final
+    : public UnaryInstructionWithTypeDependentOperandsBase<
+          SILInstructionKind::ThunkInst, ThunkInst, SingleValueInstruction> {
+public:
+  struct Kind {
+    enum InnerTy {
+      Invalid = 0,
+
+      /// A thunk that just calls the passed in function. Used for testing
+      /// purposes of the underlying thunking machinery.
+      Identity = 1,
+
+      MaxValue = Identity,
+    };
+
+    InnerTy innerTy;
+
+    Kind() : innerTy(InnerTy::Invalid) {}
+    Kind(InnerTy innerTy) : innerTy(innerTy) {}
+    Kind(unsigned inputInnerTy) : innerTy(InnerTy(inputInnerTy)) {
+      assert(inputInnerTy <= MaxValue && "Invalid value");
+    }
+
+    operator InnerTy() const { return innerTy; }
+
+    /// Given the current enum state returned the derived output function from
+    /// \p inputFunction.
+    CanSILFunctionType getDerivedFunctionType(SILFunction *fn,
+                                              CanSILFunctionType inputFunction,
+                                              SubstitutionMap subMap) const;
+
+    SILType getDerivedFunctionType(SILFunction *fn, SILType inputFunctionType,
+                                   SubstitutionMap subMap) const {
+      auto fType = inputFunctionType.castTo<SILFunctionType>();
+      return SILType::getPrimitiveType(
+          getDerivedFunctionType(fn, fType, subMap),
+          inputFunctionType.getCategory());
+    }
+  };
+
+  /// The type of thunk we are supposed to produce.
+  Kind kind;
+
+  /// The substitutions being applied to the callee when we generate thunks for
+  /// it. E.x.: if we generate a partial_apply, this will be the substitution
+  /// map used to generate the partial_apply.
+  SubstitutionMap substitutions;
+
+private:
+  friend SILBuilder;
+
+  ThunkInst(SILDebugLocation debugLoc, SILValue operand,
+            ArrayRef<SILValue> typeDependentOperands, SILType outputType,
+            Kind kind, SubstitutionMap subs)
+      : UnaryInstructionWithTypeDependentOperandsBase(
+            debugLoc, operand, typeDependentOperands, outputType),
+        kind(kind), substitutions(subs) {}
+
+  static ThunkInst *create(SILDebugLocation debugLoc, SILValue operand,
+                           SILModule &mod, SILFunction *func, Kind kind,
+                           SubstitutionMap subs);
+
+public:
+  Kind getThunkKind() const { return kind; }
+
+  SubstitutionMap getSubstitutionMap() const { return substitutions; }
+
+  CanSILFunctionType getOrigCalleeType() const {
+    return getOperand()->getType().castTo<SILFunctionType>();
+  }
+};
+
 /// ConvertEscapeToNoEscapeInst - Change the type of a escaping function value
 /// to a trivial function type (@noescape T -> U).
 class ConvertEscapeToNoEscapeInst final

include/swift/SIL/SILNodes.def

@@ -405,6 +405,8 @@ ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
 #include "swift/AST/ReferenceStorage.def"
     SINGLE_VALUE_INST(ConvertFunctionInst, convert_function,
                       SingleValueInstruction, None, DoesNotRelease)
+    SINGLE_VALUE_INST(ThunkInst, thunk,
+                      SingleValueInstruction, MayHaveSideEffects, MayRelease)
     SINGLE_VALUE_INST(ConvertEscapeToNoEscapeInst, convert_escape_to_noescape,
                       SingleValueInstruction, None, DoesNotRelease)
     SINGLE_VALUE_INST(RefToBridgeObjectInst, ref_to_bridge_object,

lib/IRGen/IRGenSIL.cpp

@@ -1425,6 +1425,10 @@ class IRGenSILFunction :
   void visitIncrementProfilerCounterInst(IncrementProfilerCounterInst *I);
 
   void visitConvertFunctionInst(ConvertFunctionInst *i);
+  void visitThunkInst(ThunkInst *i) {
+    llvm_unreachable(
+        "Should have been lowered before IRGen by the ThunkLowering pass");
+  }
   void visitConvertEscapeToNoEscapeInst(ConvertEscapeToNoEscapeInst *i);
   void visitUpcastInst(UpcastInst *i);
   void visitAddressToPointerInst(AddressToPointerInst *i);