Reflection: Re-organize TypeLowering a bit to aid C API wrapper

Lowering a record type now returns the substituted types of all
fields as well as their lowerings.

Also fix a bit of code duplication.

Author: slavapestov

include/swift/Reflection/TypeLowering.h

@@ -82,6 +82,7 @@ class TypeInfo {
 struct FieldInfo {
   std::string Name;
   unsigned Offset;
+  const TypeRef *TR;
   const TypeInfo &TI;
 };
 
@@ -141,7 +142,9 @@ class TypeConverter {
   llvm::DenseMap<const TypeRef *, const TypeInfo *> Cache;
   llvm::DenseMap<std::pair<unsigned, unsigned>,
                  const ReferenceTypeInfo *> ReferenceCache;
-  const TypeInfo *RawPointerTI = nullptr;
+  const TypeRef *RawPointerTR = nullptr;
+  const TypeRef *NativeObjectTR = nullptr;
+  const TypeRef *UnknownObjectTR = nullptr;
   const TypeInfo *ThickFunctionTI = nullptr;
 
 public:
@@ -156,7 +159,9 @@ class TypeConverter {
   getReferenceTypeInfo(ReferenceKind Kind,
                        ReferenceCounting Refcounting);
 
-  const TypeInfo *getRawPointerTypeInfo();
+  const TypeRef *getRawPointerTypeRef();
+  const TypeRef *getNativeObjectTypeRef();
+  const TypeRef *getUnknownObjectTypeRef();
   const TypeInfo *getThickFunctionTypeInfo();
 
   template <typename TypeInfoTy, typename... Args>

stdlib/public/Reflection/TypeLowering.cpp

@@ -175,27 +175,34 @@ class RecordTypeInfoBuilder {
   unsigned Size, Alignment, Stride, NumExtraInhabitants;
   RecordKind Kind;
   std::vector<FieldInfo> Fields;
+  bool Invalid;
 
 public:
   RecordTypeInfoBuilder(TypeConverter &TC, RecordKind Kind)
     : TC(TC), Size(0), Alignment(1), Stride(0), NumExtraInhabitants(0),
-      Kind(Kind) {}
+      Kind(Kind), Invalid(false) {}
+
+  void addField(const std::string &Name, const TypeRef *TR) {
+    const TypeInfo *TI = TC.getTypeInfo(TR);
+    if (TI == nullptr) {
+      Invalid = true;
+      return;
+    }
 
-  void addField(const std::string &Name, const TypeInfo &TI) {
     // FIXME: I just made this up
     if (Size == 0)
-      NumExtraInhabitants = TI.getNumExtraInhabitants();
+      NumExtraInhabitants = TI->getNumExtraInhabitants();
     else
       NumExtraInhabitants = 0;
 
-    unsigned fieldSize = TI.getSize();
-    unsigned fieldAlignment = TI.getAlignment();
+    unsigned fieldSize = TI->getSize();
+    unsigned fieldAlignment = TI->getAlignment();
 
     // Align the current size appropriately
     Size = ((Size + fieldAlignment - 1) & ~(fieldAlignment - 1));
 
     // Add the field at the aligned offset
-    Fields.push_back({Name, Size, TI});
+    Fields.push_back({Name, Size, TR, *TI});
 
     // Update the aggregate size
     Size += fieldSize;
@@ -208,6 +215,9 @@ class RecordTypeInfoBuilder {
   }
 
   const RecordTypeInfo *build() {
+    if (Invalid)
+      return nullptr;
+
     return TC.makeTypeInfo<RecordTypeInfo>(
         Size, Alignment, Stride,
         NumExtraInhabitants, Kind, Fields);
@@ -227,10 +237,10 @@ TypeConverter::getReferenceTypeInfo(ReferenceKind Kind,
   const TypeRef *TR;
   switch (Refcounting) {
   case ReferenceCounting::Native:
-    TR = BuiltinTypeRef::create(Builder, "Bo");
+    TR = getNativeObjectTypeRef();
     break;
   case ReferenceCounting::Unknown:
-    TR = BuiltinTypeRef::create(Builder, "BO");
+    TR = getUnknownObjectTypeRef();
     break;
   }
 
@@ -254,26 +264,35 @@ TypeConverter::getThickFunctionTypeInfo() {
     return ThickFunctionTI;
 
   RecordTypeInfoBuilder builder(*this, RecordKind::ThickFunction);
-  auto *TI = getRawPointerTypeInfo();
-  if (TI == nullptr)
-    return nullptr;
-  builder.addField("function", *TI);
-  TI = getReferenceTypeInfo(ReferenceKind::Strong,
-                            ReferenceCounting::Native);
-  if (TI == nullptr)
-    return nullptr;
-  builder.addField("context", *TI);
+  builder.addField("function", getRawPointerTypeRef());
+  builder.addField("context", getNativeObjectTypeRef());
   ThickFunctionTI = builder.build();
 
   return ThickFunctionTI;
 }
 
-const TypeInfo *TypeConverter::getRawPointerTypeInfo() {
-  if (RawPointerTI != nullptr)
-    return RawPointerTI;
+const TypeRef *TypeConverter::getRawPointerTypeRef() {
+  if (RawPointerTR != nullptr)
+    return RawPointerTR;
+
+  RawPointerTR = BuiltinTypeRef::create(Builder, "Bp");
+  return RawPointerTR;
+}
+
+const TypeRef *TypeConverter::getNativeObjectTypeRef() {
+  if (NativeObjectTR != nullptr)
+    return NativeObjectTR;
+
+  NativeObjectTR = BuiltinTypeRef::create(Builder, "Bo");
+  return NativeObjectTR;
+}
+
+const TypeRef *TypeConverter::getUnknownObjectTypeRef() {
+  if (UnknownObjectTR != nullptr)
+    return UnknownObjectTR;
 
-  RawPointerTI = getTypeInfo(BuiltinTypeRef::create(Builder, "Bp"));
-  return RawPointerTI;
+  UnknownObjectTR = BuiltinTypeRef::create(Builder, "BO");
+  return UnknownObjectTR;
 }
 
 class LowerType
@@ -286,6 +305,14 @@ class LowerType
   LowerType(TypeConverter &TC) : TC(TC) {}
 
   const TypeInfo *visitBuiltinTypeRef(const BuiltinTypeRef *B) {
+    if (B->getMangledName() == "Bo") {
+      return TC.getReferenceTypeInfo(ReferenceKind::Strong,
+                                     ReferenceCounting::Native);
+    } else if (B->getMangledName() == "BO") {
+      return TC.getReferenceTypeInfo(ReferenceKind::Strong,
+                                     ReferenceCounting::Unknown);
+    }
+
     auto *descriptor = TC.getBuilder().getBuiltinTypeInfo(B);
     assert(descriptor != nullptr);
     return TC.makeTypeInfo<BuiltinTypeInfo>(descriptor);
@@ -303,12 +330,8 @@ class LowerType
                                      ReferenceCounting::Native);
     case FieldDescriptorKind::Struct: {
       RecordTypeInfoBuilder builder(TC, RecordKind::Struct);
-      for (auto Field : TC.getBuilder().getFieldTypeRefs(TR, FD)) {
-        auto *FieldTI = TC.getTypeInfo(Field.second);
-        if (FieldTI == nullptr)
-          return nullptr;
-        builder.addField(Field.first, *FieldTI);
-      }
+      for (auto Field : TC.getBuilder().getFieldTypeRefs(TR, FD))
+        builder.addField(Field.first, Field.second);
       return builder.build();
     }
     case FieldDescriptorKind::Enum: {
@@ -352,35 +375,22 @@ class LowerType
 
   const TypeInfo *visitTupleTypeRef(const TupleTypeRef *T) {
     RecordTypeInfoBuilder builder(TC, RecordKind::Tuple);
-    for (auto Element : T->getElements()) {
-      auto *FieldTI = TC.getTypeInfo(Element);
-      if (FieldTI == nullptr)
-        return nullptr;
-      builder.addField("", *FieldTI);
-    }
+    for (auto Element : T->getElements())
+      builder.addField("", Element);
     return builder.build();
   }
 
   const TypeInfo *visitFunctionTypeRef(const FunctionTypeRef *F) {
     switch (F->getFlags().getConvention()) {
-    case FunctionMetadataConvention::Swift: {
-      RecordTypeInfoBuilder builder(TC, RecordKind::ThickFunction);
-      auto *TI = TC.getRawPointerTypeInfo();
-      if (TI == nullptr)
-        return nullptr;
-      builder.addField("function", *TI);
-      TI = TC.getReferenceTypeInfo(ReferenceKind::Strong,
-                                   ReferenceCounting::Native);
-      builder.addField("context", *TI);
-      return builder.build();
-    }
+    case FunctionMetadataConvention::Swift:
+      return TC.getThickFunctionTypeInfo();
     case FunctionMetadataConvention::Block:
       // FIXME: Native convention if blocks are ever supported on Linux?
       return TC.getReferenceTypeInfo(ReferenceKind::Strong,
                                      ReferenceCounting::Unknown);
     case FunctionMetadataConvention::Thin:
     case FunctionMetadataConvention::CFunctionPointer:
-      return TC.getRawPointerTypeInfo();
+      return TC.getTypeInfo(TC.getRawPointerTypeRef());
     }
   }
 

test/Reflection/typeref_lowering.swift

@@ -119,3 +119,11 @@ V12TypeLowering14FunctionStruct
 // CHECK-NEXT:     (builtin size=8 alignment=8 stride=8 num_extra_inhabitants=1))
 // CHECK-NEXT:   (field name=cFunction offset=24
 // CHECK-NEXT:     (builtin size=8 alignment=8 stride=8 num_extra_inhabitants=1)))
+
+Bo
+// CHECK:      (builtin Builtin.NativeObject)
+// CHECK-NEXT: (reference kind=strong refcounting=native)
+
+BO
+// CHECK:      (builtin Builtin.UnknownObject)
+// CHECK-NEXT: (reference kind=strong refcounting=unknown)