[RemoteAST] Fix metadata reader to properly read function metadata

Author: xedin

include/swift/Remote/MetadataReader.h

@@ -798,38 +798,17 @@ class MetadataReader {
     }
     case MetadataKind::Function: {
       auto Function = cast<TargetFunctionTypeMetadata<Runtime>>(Meta);
-      auto numParameters = Function->getNumParameters();
 
       std::vector<FunctionParam<BuiltType>> Parameters;
-      StoredPointer ArgumentAddress = MetadataAddress +
-        sizeof(TargetFunctionTypeMetadata<Runtime>);
-      StoredPointer ParameterFlagsAddress =
-                    ArgumentAddress + (numParameters * sizeof(StoredPointer));
-
-      for (unsigned i = 0; i < numParameters; ++i,
-           ArgumentAddress += sizeof(StoredPointer),
-           ParameterFlagsAddress += sizeof(uint32_t)) {
-        StoredPointer ParamMetadata;
-        if (!Reader->readInteger(RemoteAddress(ArgumentAddress),
-                                 &ParamMetadata))
+      for (unsigned i = 0, n = Function->getNumParameters(); i != n; ++i) {
+        auto ParamTypeRef = readTypeFromMetadata(Function->getParameter(i));
+        if (!ParamTypeRef)
           return BuiltType();
 
-        if (auto ParamTypeRef = readTypeFromMetadata(ParamMetadata)) {
-          FunctionParam<BuiltType> Param;
-          Param.setType(ParamTypeRef);
-
-          if (Function->hasParameterFlags()) {
-            uint32_t ParameterFlags;
-            if (!Reader->readInteger(RemoteAddress(ParameterFlagsAddress),
-                                     &ParameterFlags))
-              return BuiltType();
-              Param.setFlags(ParameterFlags::fromIntValue(ParameterFlags));
-          }
-
-          Parameters.push_back(std::move(Param));
-        } else {
-          return BuiltType();
-        }
+        FunctionParam<BuiltType> Param;
+        Param.setType(ParamTypeRef);
+        Param.setFlags(Function->getParameterFlags(i));
+        Parameters.push_back(std::move(Param));
       }
 
       auto Result = readTypeFromMetadata(Function->ResultType);
@@ -1203,8 +1182,26 @@ class MetadataReader {
         return _readMetadata<TargetExistentialMetatypeMetadata>(address);
       case MetadataKind::ForeignClass:
         return _readMetadata<TargetForeignClassMetadata>(address);
-      case MetadataKind::Function:
-        return _readMetadata<TargetFunctionTypeMetadata>(address);
+      case MetadataKind::Function: {
+        StoredSize flagsValue;
+        auto flagsAddr =
+            address + TargetFunctionTypeMetadata<Runtime>::OffsetToFlags;
+        if (!Reader->readInteger(RemoteAddress(flagsAddr), &flagsValue))
+          return nullptr;
+
+        auto flags =
+            TargetFunctionTypeFlags<StoredSize>::fromIntValue(flagsValue);
+
+        using Parameter =
+            ConstTargetMetadataPointer<Runtime, swift::TargetMetadata>;
+        auto totalSize = sizeof(TargetFunctionTypeMetadata<Runtime>) +
+                         flags.getNumParameters() * sizeof(Parameter);
+
+        if (flags.hasParameterFlags())
+          totalSize += flags.getNumParameters() * sizeof(uint32_t);
+
+        return _readMetadata(address, totalSize);
+      }
       case MetadataKind::HeapGenericLocalVariable:
         return _readMetadata<TargetGenericBoxHeapMetadata>(address);
       case MetadataKind::HeapLocalVariable:

include/swift/Runtime/Metadata.h

@@ -1745,29 +1745,22 @@ using EnumMetadata = TargetEnumMetadata<InProcess>;
 template <typename Runtime>
 struct TargetFunctionTypeMetadata : public TargetMetadata<Runtime> {
   using StoredSize = typename Runtime::StoredSize;
-  using Parameter = const TargetMetadata<Runtime> *;
+  using Parameter = ConstTargetMetadataPointer<Runtime, swift::TargetMetadata>;
 
   TargetFunctionTypeFlags<StoredSize> Flags;
 
   /// The type metadata for the result type.
   ConstTargetMetadataPointer<Runtime, swift::TargetMetadata> ResultType;
 
-  TargetPointer<Runtime, Parameter> getParameters() {
-    return reinterpret_cast<TargetPointer<Runtime, Parameter>>(this + 1);
-  }
-
-  TargetPointer<Runtime, const Parameter> getParameters() const {
-    return reinterpret_cast<TargetPointer<Runtime, const Parameter>>(this + 1);
-  }
+  Parameter *getParameters() { return reinterpret_cast<Parameter *>(this + 1); }
 
-  TargetPointer<Runtime, uint32_t> getParameterFlags() {
-    return reinterpret_cast<TargetPointer<Runtime, uint32_t>>(
-                  reinterpret_cast<Parameter *>(this + 1) + getNumParameters());
+  const Parameter *getParameters() const {
+    return reinterpret_cast<const Parameter *>(this + 1);
   }
 
-  TargetPointer<Runtime, const uint32_t> getParameterFlags() const {
-    return reinterpret_cast<TargetPointer<Runtime, const uint32_t>>(
-            reinterpret_cast<const Parameter *>(this + 1) + getNumParameters());
+  Parameter getParameter(unsigned index) const {
+    assert(index < getNumParameters());
+    return getParameters()[index];
   }
 
   ParameterFlags getParameterFlags(unsigned index) const {
@@ -1790,6 +1783,15 @@ struct TargetFunctionTypeMetadata : public TargetMetadata<Runtime> {
   static bool classof(const TargetMetadata<Runtime> *metadata) {
     return metadata->getKind() == MetadataKind::Function;
   }
+
+  uint32_t *getParameterFlags() {
+    return reinterpret_cast<uint32_t *>(getParameters() + getNumParameters());
+  }
+
+  const uint32_t *getParameterFlags() const {
+    return reinterpret_cast<const uint32_t *>(getParameters() +
+                                              getNumParameters());
+  }
 };
 using FunctionTypeMetadata = TargetFunctionTypeMetadata<InProcess>;
 

stdlib/public/runtime/Casting.cpp

@@ -1927,7 +1927,7 @@ static bool _dynamicCastToFunction(OpaqueValue *dest,
       return _fail(src, srcType, targetType, flags);
 
     for (unsigned i = 0, e = srcFn->getNumParameters(); i < e; ++i) {
-      if (srcFn->getParameters()[i] != targetFn->getParameters()[i] ||
+      if (srcFn->getParameter(i) != targetFn->getParameter(i) ||
           srcFn->getParameterFlags(i) != targetFn->getParameterFlags(i))
         return _fail(src, srcType, targetType, flags);
     }

stdlib/public/runtime/Demangle.cpp

@@ -320,7 +320,7 @@ swift::_swift_buildDemanglingForMetadata(const Metadata *type,
 
     std::vector<NodePointer> inputs;
     for (unsigned i = 0, e = func->getNumParameters(); i < e; ++i) {
-      auto param = func->getParameters()[i];
+      auto param = func->getParameter(i);
       auto flags = func->getParameterFlags(i);
       auto input = _swift_buildDemanglingForMetadata(param, Dem);
 

stdlib/public/runtime/Metadata.cpp

@@ -337,7 +337,10 @@ class FunctionCacheEntry {
         Result(result) {}
 
     FunctionTypeFlags getFlags() const { return Flags; }
-    const Metadata *const *getParameters() const { return Parameters; }
+    const Metadata *getParameter(unsigned index) const {
+      assert(index < Flags.getNumParameters());
+      return Parameters[index];
+    }
     const Metadata *getResult() const { return Result; }
 
     const uint32_t *getParameterFlags() const {
@@ -367,8 +370,8 @@ class FunctionCacheEntry {
       return result;
 
     for (unsigned i = 0, e = keyFlags.getNumParameters(); i != e; ++i) {
-      if (auto result = comparePointers(key.getParameters()[i],
-                                        Data.getParameters()[i]))
+      if (auto result =
+              comparePointers(key.getParameter(i), Data.getParameter(i)))
         return result;
 
       if (auto result =
@@ -537,7 +540,7 @@ FunctionCacheEntry::FunctionCacheEntry(Key key) {
   Data.ResultType = key.getResult();
 
   for (unsigned i = 0; i < numParameters; ++i) {
-    Data.getParameters()[i] = key.getParameters()[i];
+    Data.getParameters()[i] = key.getParameter(i);
     if (flags.hasParameterFlags())
       Data.getParameterFlags()[i] = key.getParameterFlags(i).getIntValue();
   }

test/RemoteAST/structural_types.swift

@@ -54,3 +54,11 @@ printType(Tuple2.self)
 typealias Tuple3 = (x: Int, Float, y: Int.Type)
 printType(Tuple3.self)
 // CHECK: found type: (x: Int, Float, y: Int.Type)
+
+func foo<T>(_: T) {
+  var f = T.self
+  printType(f)
+}
+
+foo() { (x: Int) -> Int in return x }
+// CHECK: found type: (Int) -> Int