[Runtime] Form function types based on mangled names.

Fixes some issues in the type decoder with function flags not getting
set when forming function types.

Author: DougGregor

include/swift/Demangling/TypeDecoder.h

@@ -255,12 +255,15 @@ class TypeDecoder {
 
       bool isThrow =
         Node->getChild(0)->getKind() == NodeKind::ThrowsAnnotation;
-      flags = flags.withThrows(true);
+      flags = flags.withThrows(isThrow);
 
+      bool hasParamFlags = false;
       std::vector<FunctionParam<BuiltType>> parameters;
       if (!decodeMangledFunctionInputType(Node->getChild(isThrow ? 1 : 0),
-                                          parameters))
+                                          parameters, hasParamFlags))
         return BuiltType();
+      flags = flags.withNumParameters(parameters.size())
+          .withParameterFlags(hasParamFlags);
 
       auto result = decodeMangledType(Node->getChild(isThrow ? 2 : 1));
       if (!result) return BuiltType();
@@ -435,11 +438,13 @@ class TypeDecoder {
 
   bool decodeMangledFunctionInputType(
       const Demangle::NodePointer &node,
-      std::vector<FunctionParam<BuiltType>> &params) {
+      std::vector<FunctionParam<BuiltType>> &params,
+      bool &hasParamFlags) {
     // Look through a couple of sugar nodes.
     if (node->getKind() == NodeKind::Type ||
         node->getKind() == NodeKind::ArgumentTuple) {
-      return decodeMangledFunctionInputType(node->getFirstChild(), params);
+      return decodeMangledFunctionInputType(node->getFirstChild(), params,
+                                            hasParamFlags);
     }
 
     auto decodeParamTypeAndFlags =
@@ -450,10 +455,12 @@ class TypeDecoder {
       case NodeKind::InOut:
         param.setInOut();
         node = node->getFirstChild();
+        hasParamFlags = true;
         break;
 
       case NodeKind::Shared:
         param.setShared();
+        hasParamFlags = true;
         node = node->getFirstChild();
         break;
 
@@ -483,6 +490,7 @@ class TypeDecoder {
 
         case NodeKind::VariadicMarker:
           param.setVariadic();
+          hasParamFlags = true;
           break;
 
         case NodeKind::Type:

stdlib/public/runtime/MetadataLookup.cpp

@@ -313,8 +313,24 @@ class DecodedMetadataBuilder {
   BuiltType createFunctionType(
                            ArrayRef<Demangle::FunctionParam<BuiltType>> params,
                            BuiltType result, FunctionTypeFlags flags) const {
-    // FIXME: Implement.
-    return BuiltType();
+    std::vector<BuiltType> paramTypes;
+    std::vector<uint32_t> paramFlags;
+
+    // Fill in the parameters.
+    paramTypes.reserve(params.size());
+    if (flags.hasParameterFlags())
+      paramFlags.reserve(params.size());
+    for (const auto &param : params) {
+      paramTypes.push_back(param.getType());
+      if (flags.hasParameterFlags())
+        paramFlags.push_back(param.getFlags().getIntValue());
+    }
+
+    return swift_getFunctionTypeMetadata(flags, paramTypes.data(),
+                                         flags.hasParameterFlags()
+                                           ? paramFlags.data()
+                                           : nullptr,
+                                         result);
   }
 
   BuiltType createTupleType(ArrayRef<BuiltType> elements,

test/Runtime/demangleToMetadata.swift

@@ -18,5 +18,52 @@ DemangleToMetadataTests.test("tuple types") {
   expectEqual(type(of: (a: (), b: ())), _typeByMangledName("yt1a_yt1bt")!)
 }
 
+func f0() { }
+var f0_thin: @convention(thin) () -> Void = f0
+var f0_c: @convention(c) () -> Void = f0
+
+#if _runtime(_ObjC)
+var f0_block: @convention(block) () -> Void = f0
+#endif
+
+func f0_throws() throws { }
+
+func f1(x: ()) { }
+func f2(x: (), y: ()) { }
+
+func f1_variadic(x: ()...) { }
+func f1_inout(x: inout ()) { }
+
+func f2_variadic_inout(x: ()..., y: inout ()) { }
+
+DemangleToMetadataTests.test("function types") {
+  // Conventions
+  expectEqual(type(of: f0), _typeByMangledName("yyc")!)
+  expectEqual(type(of: f0_thin), _typeByMangledName("yyXf")!)
+  expectEqual(type(of: f0_c), _typeByMangledName("yyXC")!)
+#if _runtime(_ObjC)
+  expectEqual(type(of: f0_block), _typeByMangledName("yyXB")!)
+#endif
+
+  // Throwing functions
+  expectEqual(type(of: f0_throws), _typeByMangledName("yyKc")!)
+
+  // More parameters.
+  expectEqual(type(of: f1), _typeByMangledName("yyyt_tc")!)
+  expectEqual(type(of: f2), _typeByMangledName("yyyt_yttc")!)
+
+  // Variadic parameters.
+  expectEqual(type(of: f1_variadic), _typeByMangledName("yyytd_tc")!)
+
+  // Inout parameters.
+  expectEqual(type(of: f1_inout), _typeByMangledName("yyytzc")!)
+
+  // Ownership parameters.
+  // FIXME: Shared/owned
+
+  // Mix-and-match.
+  expectEqual(type(of: f2_variadic_inout), _typeByMangledName("yyytd_ytztc")!)
+}
+
 runAllTests()