[thunk-lowering] Add support for mangling identity thunks.

This is just again using identity thunks to show that the behavior works before
I add in hop to main actor.

Author: gottesmm

include/swift/AST/ASTMangler.h

@@ -15,6 +15,7 @@
 
 #include "swift/AST/Decl.h"
 #include "swift/AST/FreestandingMacroExpansion.h"
+#include "swift/AST/SILThunkKind.h"
 #include "swift/AST/Types.h"
 #include "swift/Basic/Mangler.h"
 #include "swift/Basic/TaggedUnion.h"
@@ -314,6 +315,9 @@ class ASTMangler : public Mangler {
                                                 DifferentiabilityKind kind,
                                                 const AutoDiffConfig &config);
 
+  std::string mangleSILThunkKind(StringRef originalName,
+                                 SILThunkKind thunkKind);
+
   /// Mangle the AutoDiff generated declaration for the given:
   /// - Generated declaration kind: linear map struct or branching trace enum.
   /// - Mangled original function name.

include/swift/AST/SILThunkKind.h

@@ -0,0 +1,77 @@
+//===--- SILThunkKind.h ---------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2024 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
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file This file contains a kind that defines the types of thunks that can be
+/// generated using a thunk inst. It provides an AST level interface that lets
+/// one generate the derived function kind and is also used to make adding such
+/// kinds to the mangler trivial.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_SILTHUNKKIND_H
+#define SWIFT_AST_SILTHUNKKIND_H
+
+#include "swift/AST/Types.h"
+
+namespace swift {
+
+class SILType;
+
+struct SILThunkKind {
+  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;
+
+  SILThunkKind() : innerTy(InnerTy::Invalid) {}
+  SILThunkKind(InnerTy innerTy) : innerTy(innerTy) {}
+  SILThunkKind(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.
+  ///
+  /// Defined in Instructions.cpp
+  CanSILFunctionType getDerivedFunctionType(SILFunction *fn,
+                                            CanSILFunctionType inputFunction,
+                                            SubstitutionMap subMap) const;
+
+  /// Given the current enum state returned the derived output function from
+  /// \p inputFunction.
+  ///
+  /// Defined in Instructions.cpp
+  SILType getDerivedFunctionType(SILFunction *fn, SILType inputFunctionType,
+                                 SubstitutionMap subMap) const;
+
+  Demangle::MangledSILThunkKind getMangledKind() const {
+    switch (innerTy) {
+    case Invalid:
+      return Demangle::MangledSILThunkKind::Invalid;
+    case Identity:
+      return Demangle::MangledSILThunkKind::Identity;
+    }
+  }
+};
+
+} // namespace swift
+
+#endif

include/swift/Demangling/Demangle.h

@@ -136,6 +136,11 @@ enum class MangledDifferentiabilityKind : char {
   Linear = 'l',
 };
 
+enum class MangledSILThunkKind : char {
+  Invalid = 0,
+  Identity = 'I',
+};
+
 /// The pass that caused the specialization to occur. We use this to make sure
 /// that two passes that generate similar changes do not yield the same
 /// mangling. This currently cannot happen, so this is just a safety measure

include/swift/Demangling/DemangleNodes.def

@@ -291,6 +291,7 @@ NODE(ReflectionMetadataAssocTypeDescriptor)
 NODE(ReflectionMetadataSuperclassDescriptor)
 NODE(GenericTypeParamDecl)
 NODE(CurryThunk)
+NODE(SILThunkIdentity)
 NODE(DispatchThunk)
 NODE(MethodDescriptor)
 NODE(ProtocolRequirementsBaseDescriptor)

include/swift/SIL/SILInstruction.h

@@ -23,6 +23,7 @@
 #include "swift/AST/Decl.h"
 #include "swift/AST/GenericSignature.h"
 #include "swift/AST/ProtocolConformanceRef.h"
+#include "swift/AST/SILThunkKind.h"
 #include "swift/AST/SubstitutionMap.h"
 #include "swift/AST/TypeAlignments.h"
 #include "swift/Basic/Compiler.h"
@@ -5887,41 +5888,7 @@ 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());
-    }
-  };
+  using Kind = SILThunkKind;
 
   /// The type of thunk we are supposed to produce.
   Kind kind;

lib/AST/ASTMangler.cpp

@@ -636,6 +636,16 @@ std::string ASTMangler::mangleSILDifferentiabilityWitness(StringRef originalName
   return finalize();
 }
 
+std::string ASTMangler::mangleSILThunkKind(StringRef originalName,
+                                           SILThunkKind thunkKind) {
+  beginManglingWithoutPrefix();
+  appendOperator(originalName);
+  // Prefix for thunk inst based thunks
+  auto code = (char)thunkKind.getMangledKind();
+  appendOperator("TT", StringRef(&code, 1));
+  return finalize();
+}
+
 std::string ASTMangler::mangleAutoDiffGeneratedDeclaration(
     AutoDiffGeneratedDeclarationKind declKind, StringRef origFnName,
     unsigned bbId, AutoDiffLinearMapKind linearMapKind,

lib/Demangling/Demangler.cpp

@@ -2791,6 +2791,15 @@ NodePointer Demangler::popProtocolConformance() {
 
 NodePointer Demangler::demangleThunkOrSpecialization() {
   switch (char c = nextChar()) {
+    // Thunks that are from a thunk inst. We take the TT namespace.
+    case 'T': {
+      switch (char c = nextChar()) {
+      case 'I':
+        return createWithChild(Node::Kind::SILThunkIdentity, popNode(isEntity));
+      default:
+        return nullptr;
+      }
+    }
     case 'c': return createWithChild(Node::Kind::CurryThunk, popNode(isEntity));
     case 'j': return createWithChild(Node::Kind::DispatchThunk, popNode(isEntity));
     case 'q': return createWithChild(Node::Kind::MethodDescriptor, popNode(isEntity));

lib/Demangling/NodePrinter.cpp

@@ -367,6 +367,7 @@ class NodePrinter {
     case Node::Kind::Constructor:
     case Node::Kind::CoroutineContinuationPrototype:
     case Node::Kind::CurryThunk:
+    case Node::Kind::SILThunkIdentity:
     case Node::Kind::DispatchThunk:
     case Node::Kind::Deallocator:
     case Node::Kind::IsolatedDeallocator:
@@ -1425,6 +1426,10 @@ NodePointer NodePrinter::print(NodePointer Node, unsigned depth,
     Printer << "curry thunk of ";
     print(Node->getChild(0), depth + 1);
     return nullptr;
+  case Node::Kind::SILThunkIdentity:
+    Printer << "identity thunk of ";
+    print(Node->getChild(0), depth + 1);
+    return nullptr;
   case Node::Kind::DispatchThunk:
     Printer << "dispatch thunk of ";
     print(Node->getChild(0), depth + 1);

lib/Demangling/OldRemangler.cpp

@@ -2525,6 +2525,11 @@ ManglingError Remangler::mangleCurryThunk(Node *node, unsigned depth) {
   return ManglingError::Success;
 }
 
+ManglingError Remangler::mangleSILThunkIdentity(Node *node, unsigned depth) {
+  Buffer << "<sil-identity-thunk>";
+  return ManglingError::Success;
+}
+
 ManglingError Remangler::mangleDispatchThunk(Node *node, unsigned depth) {
   Buffer << "<dispatch-thunk>";
   return ManglingError::Success;

lib/Demangling/Remangler.cpp

@@ -374,6 +374,9 @@ class Remangler : public RemanglerBase {
   ManglingError mangleKeyPathThunkHelper(Node *node, StringRef op,
                                          unsigned depth);
 
+  ManglingError mangleSILThunkIdentity(Node *node, StringRef op,
+                                       unsigned depth);
+
   ManglingError mangleAutoDiffFunctionOrSimpleThunk(Node *node, StringRef op,
                                                     unsigned depth);
 
@@ -3371,6 +3374,14 @@ ManglingError Remangler::mangleCurryThunk(Node *node, unsigned depth) {
   return ManglingError::Success;
 }
 
+ManglingError Remangler::mangleSILThunkIdentity(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1)); // type
+  // TT is for a thunk that is for a thunk inst... I is for identity.
+  Buffer << "TT"
+         << "I";
+  return ManglingError::Success;
+}
+
 ManglingError Remangler::mangleDispatchThunk(Node *node, unsigned depth) {
   RETURN_IF_ERROR(mangleSingleChildNode(node, depth + 1));
   Buffer << "Tj";