Reflection: Add function representation to FunctionTypeRef

Author: slavapestov

include/swift/Reflection/TypeRef.h

@@ -20,6 +20,7 @@
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/Casting.h"
+#include "swift/ABI/MetadataValues.h"
 
 #include <iostream>
 
@@ -187,16 +188,20 @@ class TupleTypeRef final : public TypeRef {
 class FunctionTypeRef final : public TypeRef {
   std::vector<const TypeRef *> Arguments;
   const TypeRef *Result;
+  FunctionTypeFlags Flags;
 
 public:
-  FunctionTypeRef(std::vector<const TypeRef *> Arguments, const TypeRef *Result)
-    : TypeRef(TypeRefKind::Function), Arguments(Arguments), Result(Result) {}
+  FunctionTypeRef(std::vector<const TypeRef *> Arguments, const TypeRef *Result,
+                  FunctionTypeFlags Flags)
+    : TypeRef(TypeRefKind::Function), Arguments(Arguments), Result(Result),
+      Flags(Flags) {}
 
   template <typename Allocator>
   static FunctionTypeRef *create(Allocator &A,
                                  std::vector<const TypeRef *> Arguments,
-                                 const TypeRef *Result) {
-    return A.template makeTypeRef<FunctionTypeRef>(Arguments, Result);
+                                 const TypeRef *Result,
+                                 FunctionTypeFlags Flags) {
+    return A.template makeTypeRef<FunctionTypeRef>(Arguments, Result, Flags);
   }
 
   const std::vector<const TypeRef *> &getArguments() const {
@@ -207,6 +212,10 @@ class FunctionTypeRef final : public TypeRef {
     return Result;
   }
 
+  FunctionTypeFlags getFlags() const {
+    return Flags;
+  }
+
   static bool classof(const TypeRef *TR) {
     return TR->getKind() == TypeRefKind::Function;
   }

include/swift/Reflection/TypeRefBuilder.h

@@ -148,8 +148,7 @@ class TypeRefBuilder {
                      const TypeRef *result,
                      FunctionTypeFlags flags) {
     // FIXME: don't ignore inOutArgs
-    // FIXME: don't ignore flags
-    return FunctionTypeRef::create(*this, args, result);
+    return FunctionTypeRef::create(*this, args, result, flags);
   }
 
   const ProtocolTypeRef *createProtocolType(const std::string &moduleName,

stdlib/public/Reflection/TypeRef.cpp

@@ -109,9 +109,25 @@ class PrintTypeRef : public TypeRefVisitor<PrintTypeRef, void> {
 
   void visitFunctionTypeRef(const FunctionTypeRef *F) {
     printHeader("function");
+
+    switch (F->getFlags().getConvention()) {
+    case FunctionMetadataConvention::Swift:
+      break;
+    case FunctionMetadataConvention::Block:
+      printField("convention", "block");
+      break;
+    case FunctionMetadataConvention::Thin:
+      printField("convention", "thin");
+      break;
+    case FunctionMetadataConvention::CFunctionPointer:
+      printField("convention", "c");
+      break;
+    }
+
     for (auto Arg : F->getArguments())
       printRec(Arg);
     printRec(F->getResult());
+
     OS << ')';
   }
 
@@ -455,7 +471,7 @@ class TypeRefSubstitution
     auto SubstitutedResult = visit(F->getResult());
 
     return FunctionTypeRef::create(Builder, SubstitutedArguments,
-                                   SubstitutedResult);
+                                   SubstitutedResult, F->getFlags());
   }
 
   const TypeRef *visitProtocolTypeRef(const ProtocolTypeRef *P) {

test/Reflection/Inputs/ConcreteTypes.swift

@@ -33,6 +33,8 @@ public struct S {
   public let aTuple: (C, Box<S>, Box<E>, Int)
   public let aMetatype: C.Type
   public let aFunction: (C, S, E, Int) -> (Int)
+  public let aFunctionWithThinRepresentation: @convention(thin) () -> ()
+  public let aFunctionWithCRepresentation: @convention(c) () -> ()
 
   public struct NestedS {
     public let aField: Int

test/Reflection/Inputs/ObjectiveCTypes.swift

@@ -4,10 +4,13 @@ public class OC : NSObject {
   public let nsObject: NSObject
   public let nsString: NSString
   public let cfString: CFString
-  public init(nsObject: NSObject, nsString: NSString, cfString: CFString) {
+  public let aBlock: @convention(block) () -> ()
+  public init(nsObject: NSObject, nsString: NSString, cfString: CFString,
+              aBlock: @convention(block) () -> ()) {
     self.nsObject = nsObject
     self.nsString = nsString
     self.cfString = cfString
+    self.aBlock = aBlock
   }
 }
 

test/Reflection/typeref_decoding.result.txt

@@ -87,6 +87,14 @@ aFunction: (TypesToReflect.C, TypesToReflect.S, TypesToReflect.E, Swift.Int) ->
   (struct Swift.Int)
   (struct Swift.Int))
 
+aFunctionWithThinRepresentation: @convention(thin) () -> ()
+(function convention=thin
+  (tuple))
+
+aFunctionWithCRepresentation: @convention(c) () -> ()
+(function convention=c
+  (tuple))
+
 TypesToReflect.E
 ----------------
 Class: TypesToReflect.C

test/Reflection/typeref_decoding_objc.result.txt

@@ -11,6 +11,10 @@ nsString: __ObjC.NSString
 cfString: __ObjC.CFString
 (class __ObjC.CFString)
 
+aBlock: @convention(block) () -> ()
+(function convention=block
+  (tuple))
+
 TypesToReflect.GenericOC
 ------------------------
 ocnss: TypesToReflect.GenericOC<__ObjC.NSString>