Reflection: Add type lowering for class references and functions

Also add slightly inaccurate lowering for the special case of an
optional of a reference type. I need to rethink the approach for
extra inhabitants and enums, but this suffices for now.

Author: slavapestov

include/swift/Reflection/TypeLowering.h

@@ -19,20 +19,42 @@
 #define SWIFT_REFLECTION_TYPELOWERING_H
 
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/Support/Casting.h"
 
 #include <iostream>
 #include <memory>
 
 namespace swift {
 namespace reflection {
 
+using llvm::cast;
+using llvm::dyn_cast;
+
 class TypeRef;
 class TypeRefBuilder;
 
+enum class RecordKind : unsigned {
+  Tuple,
+  Struct,
+  ThickFunction,
+};
+
+enum class ReferenceCounting : unsigned {
+  Native,
+  Unknown
+};
+
+enum class ReferenceKind : unsigned {
+  Strong,
+  Unowned,
+  Weak,
+  Unmanaged
+};
+
 enum class TypeInfoKind : unsigned {
   Builtin,
-  Struct,
-  Tuple,
+  Record,
+  Reference,
 };
 
 class TypeInfo {
@@ -65,32 +87,84 @@ struct FieldInfo {
 
 /// Class instances, structs, tuples
 class RecordTypeInfo : public TypeInfo {
+  RecordKind SubKind;
   std::vector<FieldInfo> Fields;
 
 public:
-  RecordTypeInfo(TypeInfoKind Kind,
-                 unsigned Size, unsigned Alignment,
+  RecordTypeInfo(unsigned Size, unsigned Alignment,
                  unsigned Stride, unsigned NumExtraInhabitants,
-                 const std::vector<FieldInfo> &Fields)
-    : TypeInfo(Kind, Size, Alignment, Stride, NumExtraInhabitants),
-      Fields(Fields) {}
+                 RecordKind SubKind, const std::vector<FieldInfo> &Fields)
+    : TypeInfo(TypeInfoKind::Record, Size, Alignment, Stride,
+               NumExtraInhabitants),
+      SubKind(SubKind), Fields(Fields) {}
 
+  RecordKind getRecordKind() const { return SubKind; }
   unsigned getNumFields() const { return Fields.size(); }
   const std::vector<FieldInfo> &getFields() const { return Fields; }
+
+  static bool classof(const TypeInfo *TI) {
+    return TI->getKind() == TypeInfoKind::Record;
+  }
+};
+
+/// References to classes, closure contexts and anything else with an
+/// 'isa' pointer
+class ReferenceTypeInfo : public TypeInfo {
+  ReferenceKind SubKind;
+  ReferenceCounting Refcounting;
+
+public:
+  ReferenceTypeInfo(unsigned Size, unsigned Alignment,
+                    unsigned Stride, unsigned NumExtraInhabitants,
+                    ReferenceKind SubKind, ReferenceCounting Refcounting)
+    : TypeInfo(TypeInfoKind::Reference, Size, Alignment, Stride,
+               NumExtraInhabitants),
+      SubKind(SubKind), Refcounting(Refcounting) {}
+
+  ReferenceKind getReferenceKind() const {
+    return SubKind;
+  }
+
+  ReferenceCounting getReferenceCounting() const {
+    return Refcounting;
+  }
+
+  static bool classof(const TypeInfo *TI) {
+    return TI->getKind() == TypeInfoKind::Reference;
+  }
 };
 
 /// This class owns the memory for all TypeInfo instances that it vends.
 class TypeConverter {
   TypeRefBuilder &Builder;
   std::vector<std::unique_ptr<const TypeInfo>> Pool;
   llvm::DenseMap<const TypeRef *, const TypeInfo *> Cache;
+  llvm::DenseMap<std::pair<unsigned, unsigned>,
+                 const ReferenceTypeInfo *> ReferenceCache;
+  const TypeInfo *RawPointerTI = nullptr;
+  const TypeInfo *ThickFunctionTI = nullptr;
 
 public:
   explicit TypeConverter(TypeRefBuilder &Builder) : Builder(Builder) {}
 
   TypeRefBuilder &getBuilder() { return Builder; }
 
   const TypeInfo *getTypeInfo(const TypeRef *TR);
+
+  /* Not really public */
+  const ReferenceTypeInfo *
+  getReferenceTypeInfo(ReferenceKind Kind,
+                       ReferenceCounting Refcounting);
+
+  const TypeInfo *getRawPointerTypeInfo();
+  const TypeInfo *getThickFunctionTypeInfo();
+
+  template <typename TypeInfoTy, typename... Args>
+  const TypeInfoTy *makeTypeInfo(Args... args) {
+    auto TI = new TypeInfoTy(::std::forward<Args>(args)...);
+    Pool.push_back(std::unique_ptr<const TypeInfo>(TI));
+    return TI;
+  }
 };
 
 }