Merge pull request swiftlang#36708 from nate-chandler/eliminate-pal

[IRGen] Restore previous async non-constant PAF emission.

Author: nate-chandler

docs/ABI/Mangling.rst

@@ -147,7 +147,6 @@ Globals
   // TODO check this::
   global ::= mangled-name 'TA'                     // partial application forwarder
   global ::= mangled-name 'Ta'                     // ObjC partial application forwarder
-  global ::= mangled-name 'Tw' index               // async partial apply thunk for a non-constant function
   global ::= mangled-name 'TQ' index               // Async await continuation partial function
   global ::= mangled-name 'TY' index               // Async suspend continuation partial function
 

include/swift/AST/ASTDemangler.h

@@ -59,8 +59,6 @@ class ASTBuilder {
   using BuiltType = swift::Type;
   using BuiltTypeDecl = swift::GenericTypeDecl *; // nominal or type alias
   using BuiltProtocolDecl = swift::ProtocolDecl *;
-  using BuiltSubstitution = std::pair<Type, Type>;
-  using BuiltRequirement = swift::Requirement;
   explicit ASTBuilder(ASTContext &ctx) : Ctx(ctx) {}
 
   ASTContext &getASTContext() { return Ctx; }
@@ -103,14 +101,11 @@ class ASTBuilder {
       FunctionMetadataDifferentiabilityKind diffKind);
 
   Type createImplFunctionType(
-      Demangle::ImplParameterConvention calleeConvention,
-      BuiltRequirement *witnessMethodConformanceRequirement,
-      ArrayRef<BuiltType> GenericParameters,
-      ArrayRef<BuiltRequirement> Requirements,
-      ArrayRef<Demangle::ImplFunctionParam<Type>> params,
-      ArrayRef<Demangle::ImplFunctionResult<Type>> results,
-      Optional<Demangle::ImplFunctionResult<Type>> errorResult,
-      ImplFunctionTypeFlags flags);
+    Demangle::ImplParameterConvention calleeConvention,
+    ArrayRef<Demangle::ImplFunctionParam<Type>> params,
+    ArrayRef<Demangle::ImplFunctionResult<Type>> results,
+    Optional<Demangle::ImplFunctionResult<Type>> errorResult,
+    ImplFunctionTypeFlags flags);
 
   Type createProtocolCompositionType(ArrayRef<ProtocolDecl *> protocols,
                                      Type superclass,
@@ -135,6 +130,8 @@ class ASTBuilder {
 
   Type createSILBoxType(Type base);
   using BuiltSILBoxField = llvm::PointerIntPair<Type, 1>;
+  using BuiltSubstitution = std::pair<Type, Type>;
+  using BuiltRequirement = swift::Requirement;
   using BuiltLayoutConstraint = swift::LayoutConstraint;
   Type createSILBoxTypeWithLayout(ArrayRef<BuiltSILBoxField> Fields,
                                   ArrayRef<BuiltSubstitution> Substitutions,

include/swift/AST/IRGenOptions.h

@@ -159,6 +159,9 @@ struct PointerAuthOptions : clang::PointerAuthOptions {
   /// values.
   PointerAuthSchema AsyncSwiftDynamicReplacements;
 
+  /// Like PartialApplyCapture but for use with AsyncFunctionPointer values.
+  PointerAuthSchema AsyncPartialApplyCapture;
+
   /// The parent async context stored within a child async context.
   PointerAuthSchema AsyncContextParent;
 

include/swift/Demangling/DemangleNodes.def

@@ -313,7 +313,6 @@ NODE(AutoDiffSubsetParametersThunk)
 NODE(AutoDiffDerivativeVTableThunk)
 NODE(DifferentiabilityWitness)
 NODE(IndexSubset)
-NODE(AsyncNonconstantPartialApplyThunk)
 NODE(AsyncAwaitResumePartialFunction)
 NODE(AsyncSuspendResumePartialFunction)
 

include/swift/Demangling/TypeDecoder.h

@@ -814,12 +814,9 @@ class TypeDecoder {
     }
     case NodeKind::ImplFunctionType: {
       auto calleeConvention = ImplParameterConvention::Direct_Unowned;
-      BuiltRequirement *witnessMethodConformanceRequirement = nullptr;
       llvm::SmallVector<ImplFunctionParam<BuiltType>, 8> parameters;
       llvm::SmallVector<ImplFunctionResult<BuiltType>, 8> results;
       llvm::SmallVector<ImplFunctionResult<BuiltType>, 8> errorResults;
-      llvm::SmallVector<BuiltType, 4> genericParameters;
-      llvm::SmallVector<BuiltRequirement, 4> requirements;
       ImplFunctionTypeFlags flags;
 
       for (unsigned i = 0; i < Node->getNumChildren(); i++) {
@@ -852,9 +849,6 @@ class TypeDecoder {
           } else if (text == "block") {
             flags =
               flags.withRepresentation(ImplFunctionRepresentation::Block);
-          } else if (text == "witness_method") {
-            flags = flags.withRepresentation(
-                ImplFunctionRepresentation::WitnessMethod);
           }
         } else if (child->getKind() == NodeKind::ImplFunctionAttribute) {
           if (!child->hasText())
@@ -892,27 +886,6 @@ class TypeDecoder {
           if (decodeImplFunctionPart(child, errorResults))
             return MAKE_NODE_TYPE_ERROR0(child,
                                          "failed to decode function part");
-        } else if (child->getKind() == NodeKind::DependentGenericSignature) {
-          llvm::SmallVector<unsigned, 4> genericParamsAtDepth;
-
-          if (auto error = decodeDependentGenericSignatureNode(
-                  child, requirements, genericParamsAtDepth))
-            return *error;
-          if (flags.getRepresentation() ==
-              ImplFunctionRepresentation::WitnessMethod) {
-            // By convention, the first requirement of a witness method is the
-            // conformance of Self to the protocol.
-            witnessMethodConformanceRequirement = &requirements[0];
-          }
-
-          for (unsigned long depth = 0, depths = genericParamsAtDepth.size();
-               depth < depths; ++depth) {
-            for (unsigned index = 0; index < genericParamsAtDepth[depth];
-                 ++index) {
-              genericParameters.emplace_back(
-                  Builder.createGenericTypeParameterType(depth, index));
-            }
-          }
         } else {
           return MAKE_NODE_TYPE_ERROR0(child, "unexpected kind");
         }
@@ -933,11 +906,11 @@ class TypeDecoder {
       // TODO: Some cases not handled above, but *probably* they cannot
       // appear as the types of values in SIL (yet?):
       // - functions with yield returns
+      // - functions with generic signatures
       // - foreign error conventions
-      return Builder.createImplFunctionType(
-          calleeConvention, witnessMethodConformanceRequirement,
-          genericParameters, requirements, parameters, results, errorResult,
-          flags);
+      return Builder.createImplFunctionType(calleeConvention,
+                                            parameters, results,
+                                            errorResult, flags);
     }
 
     case NodeKind::ArgumentTuple:
@@ -1108,12 +1081,35 @@ class TypeDecoder {
           return MAKE_NODE_TYPE_ERROR0(substNode, "expected type list");
 
         auto *dependentGenericSignatureNode = Node->getChild(1);
+        if (dependentGenericSignatureNode->getKind() !=
+            NodeKind::DependentGenericSignature)
+          return MAKE_NODE_TYPE_ERROR0(dependentGenericSignatureNode,
+                                       "expected dependent generic signature");
+        if (dependentGenericSignatureNode->getNumChildren() < 1)
+          return MAKE_NODE_TYPE_ERROR(
+              dependentGenericSignatureNode,
+              "fewer children (%zu) than required (1)",
+              dependentGenericSignatureNode->getNumChildren());
+        decodeRequirement<BuiltType, BuiltRequirement, BuiltLayoutConstraint,
+                          BuilderType>(
+            dependentGenericSignatureNode, requirements, Builder/*,
+            [&](NodePointer Node) -> BuiltType {
+              return decodeMangledType(Node).getType();
+            },
+            [&](LayoutConstraintKind Kind) -> BuiltLayoutConstraint {
+              return {}; // Not implemented!
+            },
+            [&](LayoutConstraintKind Kind, unsigned SizeInBits,
+                unsigned Alignment) -> BuiltLayoutConstraint {
+              return {}; // Not Implemented!
+              }*/);
+        // The number of generic parameters at each depth are in a mini
+        // state machine and come first.
         llvm::SmallVector<unsigned, 4> genericParamsAtDepth;
-        if (auto error = decodeDependentGenericSignatureNode(
-                dependentGenericSignatureNode, requirements,
-                genericParamsAtDepth))
-          return *error;
-
+        for (auto *reqNode : *dependentGenericSignatureNode)
+          if (reqNode->getKind() == NodeKind::DependentGenericParamCount)
+            if (reqNode->hasIndex())
+              genericParamsAtDepth.push_back(reqNode->getIndex());
         unsigned depth = 0;
         unsigned index = 0;
         for (auto *subst : *substNode) {
@@ -1463,43 +1459,6 @@ class TypeDecoder {
     params.push_back(std::move(param));
     return true;
   }
-
-  llvm::Optional<TypeLookupError> decodeDependentGenericSignatureNode(
-      NodePointer dependentGenericSignatureNode,
-      llvm::SmallVectorImpl<BuiltRequirement> &requirements,
-      llvm::SmallVectorImpl<unsigned> &genericParamsAtDepth) {
-    using NodeKind = Demangle::Node::Kind;
-    if (dependentGenericSignatureNode->getKind() !=
-        NodeKind::DependentGenericSignature)
-      return llvm::Optional<TypeLookupError>(
-          MAKE_NODE_TYPE_ERROR0(dependentGenericSignatureNode,
-                                "expected dependent generic signature"));
-    if (dependentGenericSignatureNode->getNumChildren() < 1)
-      return llvm::Optional<TypeLookupError>(MAKE_NODE_TYPE_ERROR(
-          dependentGenericSignatureNode,
-          "fewer children (%zu) than required (1)",
-          dependentGenericSignatureNode->getNumChildren()));
-    decodeRequirement<BuiltType, BuiltRequirement, BuiltLayoutConstraint,
-                      BuilderType>(dependentGenericSignatureNode, requirements,
-                                   Builder /*,
-[&](NodePointer Node) -> BuiltType {
-return decodeMangledType(Node).getType();
-},
-[&](LayoutConstraintKind Kind) -> BuiltLayoutConstraint {
-return {}; // Not implemented!
-},
-[&](LayoutConstraintKind Kind, unsigned SizeInBits,
-unsigned Alignment) -> BuiltLayoutConstraint {
-return {}; // Not Implemented!
-}*/);
-    // The number of generic parameters at each depth are in a mini
-    // state machine and come first.
-    for (auto *reqNode : *dependentGenericSignatureNode)
-      if (reqNode->getKind() == NodeKind::DependentGenericParamCount)
-        if (reqNode->hasIndex())
-          genericParamsAtDepth.push_back(reqNode->getIndex());
-    return llvm::None;
-  }
 };
 
 template <typename BuilderType>

include/swift/IRGen/IRGenSILPasses.h

@@ -19,7 +19,6 @@ namespace irgen {
 /// Create a pass to hoist alloc_stack instructions with non-fixed size.
 SILTransform *createAllocStackHoisting();
 SILTransform *createLoadableByAddress();
-SILTransform *createPartialApplyLowering();
 
 } // end namespace irgen
 } // end namespace swift

include/swift/Reflection/TypeRefBuilder.h

@@ -418,14 +418,9 @@ class TypeRefBuilder {
       FunctionMetadataDifferentiabilityKind diffKind) {
     return FunctionTypeRef::create(*this, params, result, flags, diffKind);
   }
-  using BuiltSubstitution = std::pair<const TypeRef *, const TypeRef *>;
-  using BuiltRequirement = TypeRefRequirement;
 
   const FunctionTypeRef *createImplFunctionType(
       Demangle::ImplParameterConvention calleeConvention,
-      BuiltRequirement *witnessMethodConformanceRequirement,
-      const llvm::SmallVectorImpl<BuiltType> &genericParameters,
-      const llvm::SmallVectorImpl<BuiltRequirement> &requirements,
       llvm::ArrayRef<Demangle::ImplFunctionParam<const TypeRef *>> params,
       llvm::ArrayRef<Demangle::ImplFunctionResult<const TypeRef *>> results,
       llvm::Optional<Demangle::ImplFunctionResult<const TypeRef *>> errorResult,
@@ -545,6 +540,8 @@ class TypeRefBuilder {
   }
 
   using BuiltSILBoxField = typename SILBoxTypeWithLayoutTypeRef::Field;
+  using BuiltSubstitution = std::pair<const TypeRef *, const TypeRef *>;
+  using BuiltRequirement = TypeRefRequirement;
   using BuiltLayoutConstraint = TypeRefLayoutConstraint;
   BuiltLayoutConstraint getLayoutConstraint(LayoutConstraintKind kind) {
     // FIXME: Implement this.

include/swift/SILOptimizer/PassManager/Passes.def

@@ -298,8 +298,6 @@ IRGEN_PASS(LoadableByAddress, "loadable-address",
      "SIL Large Loadable type by-address lowering.")
 PASS(MandatorySILLinker, "mandatory-linker",
      "Deserialize all referenced SIL functions that are shared or transparent")
-IRGEN_PASS(PartialApplyLowering, "partial-apply-lowering",
-           "Partial Apply Lowering")
 PASS(PerformanceSILLinker, "performance-linker",
      "Deserialize all referenced SIL functions")
 PASS(RawSILInstLowering, "raw-sil-inst-lowering",

lib/AST/ASTDemangler.cpp

@@ -483,24 +483,11 @@ getResultDifferentiability(ImplResultDifferentiability diffKind) {
 
 Type ASTBuilder::createImplFunctionType(
     Demangle::ImplParameterConvention calleeConvention,
-    BuiltRequirement *witnessMethodConformanceRequirement,
-    ArrayRef<BuiltType> GenericParameters,
-    ArrayRef<BuiltRequirement> Requirements,
     ArrayRef<Demangle::ImplFunctionParam<Type>> params,
     ArrayRef<Demangle::ImplFunctionResult<Type>> results,
     Optional<Demangle::ImplFunctionResult<Type>> errorResult,
     ImplFunctionTypeFlags flags) {
   GenericSignature genericSig;
-  if (GenericParameters.size() > 0) {
-    llvm::SmallVector<GenericTypeParamType *, 4> CastGenericParameters;
-    for (auto Parameter : GenericParameters) {
-      CastGenericParameters.push_back(
-          Parameter->castTo<GenericTypeParamType>());
-    }
-    genericSig = GenericSignature::get(CastGenericParameters, Requirements);
-  } else {
-    assert(Requirements.size() == 0);
-  }
 
   SILCoroutineKind funcCoroutineKind = SILCoroutineKind::None;
   ParameterConvention funcCalleeConvention =
@@ -585,15 +572,11 @@ Type ASTBuilder::createImplFunctionType(
                    representation, flags.isPseudogeneric(), !flags.isEscaping(),
                    flags.isSendable(), flags.isAsync(), diffKind, clangFnType)
                    .build();
-  auto witnessMethodConformance =
-      witnessMethodConformanceRequirement
-          ? ProtocolConformanceRef(
-                witnessMethodConformanceRequirement->getProtocolDecl())
-          : ProtocolConformanceRef();
-  return SILFunctionType::get(
-      genericSig, einfo, funcCoroutineKind, funcCalleeConvention, funcParams,
-      funcYields, funcResults, funcErrorResult,
-      SubstitutionMap(), SubstitutionMap(), Ctx, witnessMethodConformance);
+
+  return SILFunctionType::get(genericSig, einfo, funcCoroutineKind,
+                              funcCalleeConvention, funcParams, funcYields,
+                              funcResults, funcErrorResult,
+                              SubstitutionMap(), SubstitutionMap(), Ctx);
 }
 
 Type ASTBuilder::createProtocolCompositionType(

lib/Demangling/Demangler.cpp

@@ -123,7 +123,6 @@ bool swift::Demangle::isFunctionAttr(Node::Kind kind) {
     case Node::Kind::DynamicallyReplaceableFunctionKey:
     case Node::Kind::DynamicallyReplaceableFunctionVar:
     case Node::Kind::AsyncFunctionPointer:
-    case Node::Kind::AsyncNonconstantPartialApplyThunk:
     case Node::Kind::AsyncAwaitResumePartialFunction:
     case Node::Kind::AsyncSuspendResumePartialFunction:
       return true;
@@ -2536,11 +2535,6 @@ NodePointer Demangler::demangleThunkOrSpecialization() {
         return demangleAutoDiffFunctionOrSimpleThunk(
             Node::Kind::AutoDiffFunction);
       }
-    case 'w': {
-      NodePointer discriminator = demangleIndexAsNode();
-      return createWithChild(Node::Kind::AsyncNonconstantPartialApplyThunk,
-                             discriminator);
-    }
     default:
       return nullptr;
   }