[Reflection] Add Foreign, ObjC, and Opaque type references

These likely don't have Swift type metadata but might be useful to
record or instantiate based on what kind of metadata is encountered for
the sake of memory tools.

Author: bitjammer

include/swift/Reflection/Records.h

@@ -22,18 +22,47 @@
 namespace swift {
 namespace reflection {
 
+class FieldRecordFlags {
+  using int_type = uint32_t;
+  enum : int_type {
+    IsObjC = 0x00000001,
+  };
+  int_type Data;
+public:
+  bool isObjC() const {
+    return Data & IsObjC;
+  }
+
+  void setIsObjC(bool ObjC) {
+    if (ObjC)
+      Data |= IsObjC;
+    else
+      Data &= ~IsObjC;
+  }
+
+  int_type getRawValue() const {
+    return Data;
+  }
+};
+
 class FieldRecord {
+  const FieldRecordFlags Flags;
   const RelativeDirectPointer<const char> MangledTypeName;
   const RelativeDirectPointer<const char> FieldName;
 
 public:
+  FieldRecord() = delete;
   std::string getMangledTypeName() const {
     return MangledTypeName.get();
   }
 
   std::string getFieldName()  const {
     return FieldName.get();
   }
+
+  bool isObjC() const {
+    return Flags.isObjC();
+  }
 };
 
 struct FieldRecordIterator {

include/swift/Reflection/ReflectionContext.h

@@ -1,4 +1,4 @@
-//===--- ReflectionContext.h - Swift Type Reflection Context ----*- C++ -*-===//
+  //===--- ReflectionContext.h - Swift Type Reflection Context ----*- C++ -*-===//
 //
 // This source file is part of the Swift.org open source project
 //

include/swift/Reflection/TypeRef.h

@@ -366,6 +366,47 @@ class AssociatedTypeRef final : public TypeRef {
   }
 };
 
+class ForeignClassTypeRef final : public TypeRef {
+  std::string Name;
+public:
+  ForeignClassTypeRef(std::string Name)
+    : TypeRef(TypeRefKind::ForeignClass), Name(Name) {}
+  static const std::shared_ptr<ForeignClassTypeRef> Unnamed;
+
+  std::string getName() const {
+    return Name;
+  }
+
+  static bool classof(const TypeRef *TR) {
+    return TR->getKind() == TypeRefKind::ForeignClass;
+  }
+};
+
+class ObjCClassTypeRef final : public TypeRef {
+  std::string Name;
+public:
+  ObjCClassTypeRef(std::string Name)
+    : TypeRef(TypeRefKind::ObjCClass), Name(Name) {}
+  static const std::shared_ptr<ObjCClassTypeRef> Unnamed;
+
+  std::string getName() const {
+    return Name;
+  }
+
+  static bool classof(const TypeRef *TR) {
+    return TR->getKind() == TypeRefKind::ObjCClass;
+  }
+};
+  
+class OpaqueTypeRef final : public TypeRef {
+public:
+  OpaqueTypeRef() : TypeRef(TypeRefKind::Opaque) {}
+  static const std::shared_ptr<OpaqueTypeRef> Opaque;
+  static bool classof(const TypeRef *TR) {
+    return TR->getKind() == TypeRefKind::Opaque;
+  }
+};
+
 template <typename ImplClass, typename RetTy = void, typename... Args>
 class TypeRefVisitor {
 public:
@@ -504,6 +545,23 @@ class PrintTypeRef : public TypeRefVisitor<PrintTypeRef, void> {
     printField("name", AT->getName());
     OS << ')';
   }
+
+  void visitForeignClassTypeRef(const ForeignClassTypeRef *F) {
+    printHeader("foreign");
+    printField("name", F->getName());
+    OS << ')';
+  }
+
+  void visitObjCClassTypeRef(const ObjCClassTypeRef *OC) {
+    printHeader("objective-c-class");
+    printField("name", OC->getName());
+    OS << ')';
+  }
+  
+  void visitOpaqueTypeRef(const OpaqueTypeRef *O) {
+    printHeader("opaque");
+    OS << ')';
+  }
 };
 
 TypeRefPointer decodeDemangleNode(Demangle::NodePointer Node) {

include/swift/Reflection/TypeRefs.def

@@ -28,5 +28,8 @@ TYPEREF(ExistentialMetatype, TypeRef)
 TYPEREF(GenericTypeParameter, TypeRef)
 TYPEREF(DependentMember, TypeRef)
 TYPEREF(Associated, TypeRef)
+TYPEREF(ForeignClass, TypeRef)
+TYPEREF(ObjCClass, TypeRef)
+TYPEREF(Opaque, TypeRef)
 
 #undef TYPEREF

lib/CMakeLists.txt

@@ -12,6 +12,7 @@ add_subdirectory(Markup)
 add_subdirectory(Option)
 add_subdirectory(Parse)
 add_subdirectory(PrintAsObjC)
+add_subdirectory(Reflection)
 add_subdirectory(Sema)
 add_subdirectory(Serialization)
 if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")

lib/IRGen/GenReflection.cpp

@@ -18,6 +18,7 @@
 #include "swift/AST/Decl.h"
 #include "swift/AST/IRGenOptions.h"
 #include "swift/AST/ProtocolConformance.h"
+#include "swift/Reflection/Records.h"
 
 #include "ConstantBuilder.h"
 #include "IRGenModule.h"
@@ -120,10 +121,15 @@ class AssociatedTypeMetadataBuilder : public ReflectionMetadataBuilder {
 
 class FieldTypeMetadataBuilder : public ReflectionMetadataBuilder {
 
-  const uint32_t fieldRecordSize = 8;
+  const uint32_t fieldRecordSize = 12;
   ArrayRef<const NominalTypeDecl *> NominalTypeDecls;
 
   void addFieldDecl(const ValueDecl *value) {
+    swift::reflection::FieldRecordFlags Flags;
+    Flags.setIsObjC(value->isObjC());
+
+    addConstantInt32(Flags.getRawValue());
+
     auto type = value->getInterfaceType()->getCanonicalType();
     addTypeRef(value->getModuleContext(), type);
 

lib/Reflection/CMakeLists.txt

@@ -0,0 +1,2 @@
+add_swift_library(swiftReflection
+  TypeRef.cpp)

lib/Reflection/TypeRef.cpp

@@ -0,0 +1,30 @@
+//===--- TypeRef.h - Swift Type References for Reflection -------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See http://swift.org/LICENSE.txt for license information
+// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// Implements the structures of type references for property and enum
+// case reflection.
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/Reflection/TypeRef.h"
+
+using namespace swift;
+using namespace reflection;
+
+const std::shared_ptr<ForeignClassTypeRef>
+ForeignClassTypeRef::Unnamed = std::make_shared<ForeignClassTypeRef>("");
+
+const std::shared_ptr<ObjCClassTypeRef>
+ObjCClassTypeRef::Unnamed = std::make_shared<ObjCClassTypeRef>("");
+
+const std::shared_ptr<OpaqueTypeRef>
+OpaqueTypeRef::Opaque = std::make_shared<OpaqueTypeRef>();

test/Reflection/Inputs/ConcreteTypes.swift

@@ -1,3 +1,7 @@
+#if _runtime(_ObjC)
+import Foundation
+#endif
+
 public class Box<Treasure> {
   public let item: Treasure
   public init(item: Treasure) {
@@ -40,3 +44,30 @@ public enum E {
   indirect case IndirectTuple(C, S, E, Int)
   case Metatype(E.Type)
 }
+
+#if _runtime(_ObjC)
+
+public class OC : NSObject {
+  public let aClass: C
+  public let aStruct: S
+  public let anEnum: E
+  public let aTuple: (C, S, E, Int)
+  public let aMetatype: C.Type
+  public let aFunction: (C, S, E, Int) -> (Int)
+  public let nsObject: NSObject
+  public let nsString: NSString
+  public let cfString: CFString
+  public init(aClass: C, aStruct: S, anEnum: E, aTuple: (C, S, E, Int), aMetatype: C.Type, aFunction: (C, S, E, Int) -> Int, nsObject: NSObject, nsString: NSString, cfString: CFString) {
+    self.aClass = aClass
+    self.aStruct = aStruct
+    self.anEnum = anEnum
+    self.aTuple = aTuple
+    self.aMetatype = aMetatype
+    self.aFunction = aFunction
+    self.nsObject = nsObject
+    self.nsString = nsString
+    self.cfString = cfString
+  }
+}
+
+#endif

test/Reflection/Inputs/GenericTypes.swift

@@ -1,3 +1,7 @@
+#if _runtime(_ObjC)
+import Foundation
+#endif
+
 public class C1<T> : ClassBoundP {
   public typealias Function = C1<T> -> S1<T> -> E1<T> -> Int
   public typealias Tuple = (C1<T>, S1<T>, E1<T>, Int)
@@ -158,3 +162,16 @@ extension E4 : P1, P2, P3 {
   public typealias Outer = U
   public typealias Second = U
 }
+
+#if _runtime(_ObjC)
+
+public class GenericOC<T> : NSObject {
+  public let ocnss: GenericOC<NSString>
+  public let occfs: GenericOC<CFString>
+  public init(nss: GenericOC<NSString>, cfs: GenericOC<CFString>) {
+    self.ocnss = nss
+    self.occfs = cfs
+  }
+}
+
+#endif

test/Reflection/typeref_decoding.swift

@@ -2,3 +2,4 @@
 // RUN: %target-swiftc_driver %S/Inputs/ConcreteTypes.swift %S/Inputs/GenericTypes.swift %S/Inputs/Protocols.swift -emit-module -emit-library -module-name TypesToReflect -Xfrontend -enable-reflection-metadata -o %t/libTypesToReflect
 // RUN: %target-swift-reflection-test -binary-filename %t/libTypesToReflect -dump-reflection-sections > %t/typeref_decoding.txt
 // RUN: diff -u %S/typeref_decoding.result.txt %t/typeref_decoding.txt
+// UNSUPPORTED: objc_interop