Reflection: Add SILBoxTypeRef, which can come up in capture descriptors

Author: slavapestov

docs/ABI.rst

@@ -935,6 +935,7 @@ Types
   type ::= 'Xw' type                         // @weak type
   type ::= 'XF' impl-function-type           // function implementation type
   type ::= 'Xf' type type                    // @thin function type
+  type ::= 'Xb' type                         // SIL @box type
   nominal-type ::= known-nominal-type
   nominal-type ::= substitution
   nominal-type ::= nominal-type-kind declaration-name

include/swift/Reflection/TypeRef.h

@@ -703,6 +703,33 @@ class UnmanagedStorageTypeRef final : public ReferenceStorageTypeRef {
   }
 };
 
+class SILBoxTypeRef final : public TypeRef {
+  const TypeRef *BoxedType;
+
+  static TypeRefID Profile(const TypeRef *BoxedType) {
+    TypeRefID ID;
+    ID.addPointer(BoxedType);
+    return ID;
+  }
+public:
+  SILBoxTypeRef(const TypeRef *BoxedType)
+    : TypeRef(TypeRefKind::SILBox), BoxedType(BoxedType) {}
+
+  template <typename Allocator>
+  static const SILBoxTypeRef *create(Allocator &A,
+                                     const TypeRef *BoxedType) {
+    FIND_OR_CREATE_TYPEREF(A, SILBoxTypeRef, BoxedType);
+  }
+
+  const TypeRef *getBoxedType() const {
+    return BoxedType;
+  }
+
+  static bool classof(const TypeRef *TR) {
+    return TR->getKind() == TypeRefKind::SILBox;
+  }
+};
+
 template <typename ImplClass, typename RetTy = void, typename... Args>
 class TypeRefVisitor {
 public:

include/swift/Reflection/TypeRefBuilder.h

@@ -229,6 +229,10 @@ class TypeRefBuilder {
     return WeakStorageTypeRef::create(*this, base);
   }
 
+  const SILBoxTypeRef *createSILBoxType(const TypeRef *base) {
+    return SILBoxTypeRef::create(*this, base);
+  }
+
   const ObjCClassTypeRef *
   createObjCClassType(const std::string &mangledName) {
     return ObjCClassTypeRef::create(*this, mangledName);

include/swift/Reflection/TypeRefs.def

@@ -33,5 +33,6 @@ TYPEREF(Opaque, TypeRef)
 TYPEREF(UnownedStorage, TypeRef)
 TYPEREF(UnmanagedStorage, TypeRef)
 TYPEREF(WeakStorage, TypeRef)
+TYPEREF(SILBox, TypeRef)
 
 #undef TYPEREF

include/swift/Remote/MetadataReader.h

@@ -243,6 +243,12 @@ class TypeDecoder {
         return BuiltType();
       return Builder.createWeakStorageType(base);
     }
+    case NodeKind::SILBoxType: {
+      auto base = decodeMangledType(Node->getChild(0));
+      if (!base)
+        return BuiltType();
+      return Builder.createSILBoxType(base);
+    }
     default:
       return BuiltType();
     }

lib/RemoteAST/RemoteAST.cpp

@@ -362,6 +362,10 @@ class RemoteASTTypeBuilder {
     return WeakStorageType::get(base, Ctx);
   }
 
+  Type createSILBoxType(Type base) {
+    return SILBoxType::get(base->getCanonicalType());
+  }
+
   Type createObjCClassType(StringRef name) {
     Identifier ident = Ctx.getIdentifier(name);
     auto typeDecl =

stdlib/public/Reflection/TypeLowering.cpp

@@ -552,6 +552,11 @@ class HasSingletonMetatype
     return MetatypeRepresentation::Thin;
   }
 
+  MetatypeRepresentation
+  visitSILBoxTypeRef(const SILBoxTypeRef *SB) {
+    return MetatypeRepresentation::Thin;
+  }
+
   MetatypeRepresentation
   visitGenericTypeParameterTypeRef(const GenericTypeParameterTypeRef *GTP) {
     assert(false && "Must have concrete TypeRef");
@@ -844,6 +849,11 @@ class LowerType
     return visitAnyStorageTypeRef(US->getType(), ReferenceKind::Unmanaged);
   }
 
+  const TypeInfo *visitSILBoxTypeRef(const SILBoxTypeRef *SB) {
+    return TC.getReferenceTypeInfo(ReferenceKind::Strong,
+                                   ReferenceCounting::Native);
+  }
+
   const TypeInfo *visitOpaqueTypeRef(const OpaqueTypeRef *O) {
     assert(false && "Can't lower opaque TypeRef");
     return nullptr;

stdlib/public/Reflection/TypeRef.cpp

@@ -204,6 +204,12 @@ class PrintTypeRef : public TypeRefVisitor<PrintTypeRef, void> {
     OS << ')';
   }
 
+  void visitSILBoxTypeRef(const SILBoxTypeRef *SB) {
+    printHeader("sil_box");
+    printRec(SB->getBoxedType());
+    OS << ')';
+  }
+
   void visitOpaqueTypeRef(const OpaqueTypeRef *O) {
     printHeader("opaque");
     OS << ')';
@@ -298,6 +304,10 @@ struct TypeRefIsConcrete
   bool visitUnmanagedStorageTypeRef(const UnmanagedStorageTypeRef *US) {
     return visit(US->getType());
   }
+
+  bool visitSILBoxTypeRef(const SILBoxTypeRef *SB) {
+    return visit(SB->getBoxedType());
+  }
 };
 
 const OpaqueTypeRef *
@@ -508,6 +518,10 @@ class ThickenMetatype
     return US;
   }
 
+  const TypeRef *visitSILBoxTypeRef(const SILBoxTypeRef *SB) {
+    return SILBoxTypeRef::create(Builder, visit(SB->getBoxedType()));
+  }
+
   const TypeRef *visitOpaqueTypeRef(const OpaqueTypeRef *O) {
     return O;
   }
@@ -660,6 +674,10 @@ class TypeRefSubstitution
     return UnmanagedStorageTypeRef::create(Builder, visit(US->getType()));
   }
 
+  const TypeRef *visitSILBoxTypeRef(const SILBoxTypeRef *SB) {
+    return SILBoxTypeRef::create(Builder, visit(SB->getBoxedType()));
+  }
+
   const TypeRef *visitOpaqueTypeRef(const OpaqueTypeRef *O) {
     return O;
   }

stdlib/public/Reflection/TypeRefBuilder.cpp

@@ -284,6 +284,7 @@ void ClosureContextInfo::dump(std::ostream &OS) {
     else
       MS.second->dump(OS);
   }
+  OS << "\n";
 }
 
 void TypeRefBuilder::dumpCaptureSection(std::ostream &OS) {

test/Reflection/typeref_decoding.result.txt

@@ -660,15 +660,18 @@ BUILTIN TYPES:
 CAPTURE DESCRIPTORS:
 ====================
 - Capture types:
-!!! Invalid typeref
+(sil_box
+  (generic_type_parameter depth=0 index=0))
 - Metadata sources:
 (generic_type_parameter depth=0 index=0)
 (closure_binding index=0)
+
 - Capture types:
 (struct Swift.Int)
 - Metadata sources:
 (generic_type_parameter depth=0 index=0)
 !!! Invalid matadata source
+
 - Capture types:
 (bound_generic_class TypesToReflect.C1
   (generic_type_parameter depth=0 index=1))
@@ -679,3 +682,4 @@ CAPTURE DESCRIPTORS:
 (generic_argument index=0
   (reference_capture index=1))
 
+