Merge pull request #42589 from jckarter/begin-partial-apply-simplification-pass

[SIL] Initial work on PartialApplySimplification pass

Author: jckarter

include/swift/AST/Attr.def

@@ -84,6 +84,7 @@ TYPE_ATTR(pseudogeneric)
 TYPE_ATTR(yields)
 TYPE_ATTR(yield_once)
 TYPE_ATTR(yield_many)
+TYPE_ATTR(captures_generics)
 
 // SIL metatype attributes.
 TYPE_ATTR(thin)

include/swift/AST/SILLayout.h

@@ -89,14 +89,17 @@ class SILLayout final : public llvm::FoldingSetNode,
 
   enum : unsigned {
     IsMutable = 0x1,
+    CapturesGenericEnvironment = 0x2,
   };
 
-  static constexpr const unsigned NumFlags = 1;
+  static constexpr const unsigned NumFlags = 2;
 
-  static unsigned getFlagsValue(bool Mutable) {
+  static unsigned getFlagsValue(bool Mutable, bool CapturesGenerics) {
     unsigned flags = 0;
     if (Mutable)
       flags |= IsMutable;
+    if (CapturesGenerics)
+      flags |= CapturesGenericEnvironment;
 
     assert(flags >> NumFlags == 0
            && "more flags than flag bits?!");
@@ -109,15 +112,17 @@ class SILLayout final : public llvm::FoldingSetNode,
   unsigned NumFields;
 
   SILLayout(CanGenericSignature Signature,
-            ArrayRef<SILField> Fields);
+            ArrayRef<SILField> Fields,
+            bool CapturesGenericEnvironment);
 
   SILLayout(const SILLayout &) = delete;
   SILLayout &operator=(const SILLayout &) = delete;
 public:
   /// Get or create a layout.
   static SILLayout *get(ASTContext &C,
                         CanGenericSignature Generics,
-                        ArrayRef<SILField> Fields);
+                        ArrayRef<SILField> Fields,
+                        bool CapturesGenericEnvironment);
 
   /// Get the generic signature in which this layout exists.
   CanGenericSignature getGenericSignature() const {
@@ -129,6 +134,12 @@ class SILLayout final : public llvm::FoldingSetNode,
     return GenericSigAndFlags.getInt() & IsMutable;
   }
 
+  /// True if the layout captures the generic arguments it is substituted with
+  /// and can provide generic bindings when passed as a closure argument.
+  bool capturesGenericEnvironment() const {
+    return GenericSigAndFlags.getInt() & CapturesGenericEnvironment;
+  }
+  
   /// Get the fields inside the layout.
   ArrayRef<SILField> getFields() const {
     return llvm::makeArrayRef(getTrailingObjects<SILField>(), NumFields);
@@ -137,11 +148,13 @@ class SILLayout final : public llvm::FoldingSetNode,
   /// Produce a profile of this layout, for use in a folding set.
   static void Profile(llvm::FoldingSetNodeID &id,
                       CanGenericSignature Generics,
-                      ArrayRef<SILField> Fields);
+                      ArrayRef<SILField> Fields,
+                      bool CapturesGenericEnvironment);
 
   /// Produce a profile of this locator, for use in a folding set.
   void Profile(llvm::FoldingSetNodeID &id) {
-    Profile(id, getGenericSignature(), getFields());
+    Profile(id, getGenericSignature(), getFields(),
+            capturesGenericEnvironment());
   }
 };
 

include/swift/SIL/SILBuilder.h

@@ -420,14 +420,15 @@ class SILBuilder {
 
   AllocBoxInst *createAllocBox(SILLocation Loc, CanSILBoxType BoxType,
                                Optional<SILDebugVariable> Var = None,
-                               bool hasDynamicLifetime = false) {
+                               bool hasDynamicLifetime = false,
+                               bool reflection = false) {
     llvm::SmallString<4> Name;
     Loc.markAsPrologue();
     assert((!dyn_cast_or_null<VarDecl>(Loc.getAsASTNode<Decl>()) || Var) &&
            "location is a VarDecl, but SILDebugVariable is empty");
     return insert(AllocBoxInst::create(getSILDebugLocation(Loc), BoxType, *F,
                                        substituteAnonymousArgs(Name, Var, Loc),
-                                       hasDynamicLifetime));
+                                       hasDynamicLifetime, reflection));
   }
 
   AllocExistentialBoxInst *

include/swift/SIL/SILInstruction.h

@@ -461,11 +461,11 @@ class SILInstruction : public llvm::ilist_node<SILInstruction> {
     locationStorage = loc.storage;
   }
 
-  /// Return the next instruction or nullptr if this is the last instruction in
-  /// its block.
+  /// Return the previous instruction, or nullptr if this is the first
+  /// instruction in its block.
   SILInstruction *getPreviousInstruction();
 
-  /// Return the previous instruction or nullptr if this is the first
+  /// Return the next instruction, or nullptr if this is the final
   /// instruction in its block.
   SILInstruction *getNextInstruction();
 
@@ -2289,30 +2289,38 @@ class AllocRefDynamicInst final
 class AllocBoxInst final
     : public InstructionBaseWithTrailingOperands<
                                            SILInstructionKind::AllocBoxInst,
-                                           AllocBoxInst, AllocationInst, char> {
+                                           AllocBoxInst, AllocationInst, char>
+{
   friend SILBuilder;
 
   TailAllocatedDebugVariable VarInfo;
 
-  bool dynamicLifetime = false;
+  unsigned HasDynamicLifetime : 1;
+  unsigned Reflection : 1;
 
   AllocBoxInst(SILDebugLocation DebugLoc, CanSILBoxType BoxType,
                ArrayRef<SILValue> TypeDependentOperands, SILFunction &F,
-               Optional<SILDebugVariable> Var, bool hasDynamicLifetime);
+               Optional<SILDebugVariable> Var, bool hasDynamicLifetime,
+               bool reflection = false);
 
   static AllocBoxInst *create(SILDebugLocation Loc, CanSILBoxType boxType,
                               SILFunction &F,
                               Optional<SILDebugVariable> Var,
-                              bool hasDynamicLifetime);
+                              bool hasDynamicLifetime,
+                              bool reflection = false);
 
 public:
   CanSILBoxType getBoxType() const {
     return getType().castTo<SILBoxType>();
   }
 
-  void setDynamicLifetime() { dynamicLifetime = true; }
-  bool hasDynamicLifetime() const { return dynamicLifetime; }
+  void setDynamicLifetime() { HasDynamicLifetime = true; }
+  bool hasDynamicLifetime() const { return HasDynamicLifetime; }
 
+  /// True if the box should be emitted with reflection metadata for its
+  /// contents.
+  bool emitReflectionMetadata() const { return Reflection; }
+  
   // Return the type of the memory stored in the alloc_box.
   SILType getAddressType() const;
 

include/swift/SIL/SILType.h

@@ -427,7 +427,13 @@ class SILType {
 
   /// True if the given type has at least the size and alignment of a native
   /// pointer.
-  bool isPointerSizeAndAligned();
+  bool isPointerSizeAndAligned(SILModule &M,
+                               ResilienceExpansion expansion) const;
+
+  /// True if the layout of the given type consists of a single native Swift-
+  /// refcounted object reference, possibly nullable.
+  bool isSingleSwiftRefcounted(SILModule &M,
+                               ResilienceExpansion expansion) const;
 
   /// True if `operTy` can be cast by single-reference value into `resultTy`.
   static bool canRefCast(SILType operTy, SILType resultTy, SILModule &M);
@@ -613,6 +619,12 @@ class SILType {
   llvm::hash_code getHashCode() const {
     return llvm::hash_combine(*this);
   }
+  
+  /// If a type is visibly a singleton aggregate (a tuple with one element, a
+  /// struct with one field, or an enum with a single payload case), return the
+  /// type of its field, which it is guaranteed to have identical layout to.
+  SILType getSingletonAggregateFieldType(SILModule &M,
+                                         ResilienceExpansion expansion) const;
 
   //
   // Accessors for types used in SIL instructions:

include/swift/SILOptimizer/PassManager/Passes.def

@@ -446,6 +446,8 @@ PASS(MoveFunctionCanonicalization, "sil-move-function-canon",
      "function checking.")
 PASS(DebugInfoCanonicalizer, "sil-onone-debuginfo-canonicalizer",
      "Canonicalize debug info at -Onone by propagating debug info into coroutine funclets")
+PASS(PartialApplySimplification, "partial-apply-simplification",
+     "Transform partial_apply instructions into explicit closure box constructions")
 PASS(PruneVTables, "prune-vtables",
      "Mark class methods that do not require vtable dispatch")
 PASS_RANGE(AllPasses, AADumper, PruneVTables)

lib/AST/ASTContext.cpp

@@ -5374,10 +5374,17 @@ std::string ASTContext::getEntryPointFunctionName() const {
 
 SILLayout *SILLayout::get(ASTContext &C,
                           CanGenericSignature Generics,
-                          ArrayRef<SILField> Fields) {
+                          ArrayRef<SILField> Fields,
+                          bool CapturesGenericEnvironment) {
+  // The "captures generic environment" flag is meaningless if there are
+  // no generic arguments to capture.
+  if (!Generics || Generics->areAllParamsConcrete()) {
+    CapturesGenericEnvironment = false;
+  }
+  
   // Profile the layout parameters.
   llvm::FoldingSetNodeID id;
-  Profile(id, Generics, Fields);
+  Profile(id, Generics, Fields, CapturesGenericEnvironment);
 
   // Return an existing layout if there is one.
   void *insertPos;
@@ -5390,7 +5397,8 @@ SILLayout *SILLayout::get(ASTContext &C,
   void *memory = C.Allocate(totalSizeToAlloc<SILField>(Fields.size()),
                             alignof(SILLayout));
 
-  auto newLayout = ::new (memory) SILLayout(Generics, Fields);
+  auto newLayout = ::new (memory) SILLayout(Generics, Fields,
+                                            CapturesGenericEnvironment);
   Layouts.InsertNode(newLayout, insertPos);
   return newLayout;
 }
@@ -5423,7 +5431,8 @@ CanSILBoxType SILBoxType::get(CanType boxedType) {
   auto genericParam = singleGenericParamSignature.getGenericParams()[0];
   auto layout = SILLayout::get(ctx, singleGenericParamSignature,
                                SILField(CanType(genericParam),
-                                        /*mutable*/ true));
+                                        /*mutable*/ true),
+                               /*captures generic env*/ false);
 
   auto subMap =
     SubstitutionMap::get(

lib/AST/ASTDemangler.cpp

@@ -710,7 +710,8 @@ Type ASTBuilder::createSILBoxTypeWithLayout(
     silFields.emplace_back(field.getPointer()->getCanonicalType(),
                            field.getInt());
   SILLayout *layout =
-      SILLayout::get(Ctx, signature.getCanonicalSignature(), silFields);
+      SILLayout::get(Ctx, signature.getCanonicalSignature(), silFields,
+                     /*captures generics*/ false);
 
   SubstitutionMap substs;
   if (signature)

lib/AST/ASTPrinter.cpp

@@ -6085,6 +6085,11 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
   }
 
   void visitSILBoxType(SILBoxType *T) {
+    // Print attributes.
+    if (T->getLayout()->capturesGenericEnvironment()) {
+      Printer << "@captures_generics ";
+    }
+    
     {
       // A box layout has its own independent generic environment. Don't try
       // to print it with the environment's generic params.

lib/AST/SILLayout.cpp

@@ -72,8 +72,10 @@ static void verifyFields(CanGenericSignature Sig, ArrayRef<SILField> Fields) {
 #endif
 
 SILLayout::SILLayout(CanGenericSignature Sig,
-                     ArrayRef<SILField> Fields)
-  : GenericSigAndFlags(Sig, getFlagsValue(anyMutable(Fields))),
+                     ArrayRef<SILField> Fields,
+                     bool CapturesGenericEnvironment)
+  : GenericSigAndFlags(Sig,
+                 getFlagsValue(anyMutable(Fields), CapturesGenericEnvironment)),
     NumFields(Fields.size())
 {
 #ifndef NDEBUG
@@ -87,8 +89,10 @@ SILLayout::SILLayout(CanGenericSignature Sig,
 
 void SILLayout::Profile(llvm::FoldingSetNodeID &id,
                         CanGenericSignature Generics,
-                        ArrayRef<SILField> Fields) {
+                        ArrayRef<SILField> Fields,
+                        bool CapturesGenericEnvironment) {
   id.AddPointer(Generics.getPointer());
+  id.AddBoolean(CapturesGenericEnvironment);
   for (auto &field : Fields) {
     id.AddPointer(field.getLoweredType().getPointer());
     id.AddBoolean(field.isMutable());