Read tuple labels in MetadataReader and preserve them in RemoteAST.

The metadata system doesn't actually unique based on labels
correctly, so the test case has to play some games.  That's
something that will be easier to fix when there are fewer
clients poking at the internals of the metadata runtime.

Author: rjmccall

include/swift/Reflection/TypeRefBuilder.h

@@ -138,7 +138,7 @@ class TypeRefBuilder {
 
   const TupleTypeRef *
   createTupleType(const std::vector<const TypeRef *> &elements,
-                  bool isVariadic) {
+                  std::string &&labels, bool isVariadic) {
     return TupleTypeRef::create(*this, elements, isVariadic);
   }
 

include/swift/Remote/MetadataReader.h

@@ -172,15 +172,39 @@ class TypeDecoder {
       return decodeMangledType(Node->getChild(0));
     case NodeKind::NonVariadicTuple:
     case NodeKind::VariadicTuple: {
-      std::vector<BuiltType> Elements;
-      for (auto element : *Node) {
-        auto elementType = decodeMangledType(element);
+      std::vector<BuiltType> elements;
+      std::string labels;
+      for (auto &element : *Node) {
+        if (element->getKind() != NodeKind::TupleElement)
+          return BuiltType();
+
+        // If the tuple element is labelled, add its label to 'labels'.
+        unsigned typeChildIndex = 0;
+        if (element->getChild(0)->getKind() == NodeKind::TupleElementName) {
+          // Add spaces to terminate all the previous labels if this
+          // is the first we've seen.
+          if (labels.empty()) labels.append(elements.size(), ' ');
+
+          // Add the label and its terminator.
+          labels += element->getChild(0)->getText();
+          labels += ' ';
+          typeChildIndex = 1;
+
+        // Otherwise, add a space if a previous element had a label.
+        } else if (!labels.empty()) {
+          labels += ' ';
+        }
+
+        // Decode the element type.
+        BuiltType elementType =
+          decodeMangledType(element->getChild(typeChildIndex));
         if (!elementType)
           return BuiltType();
-        Elements.push_back(elementType);
+
+        elements.push_back(elementType);
       }
-      bool Variadic = (Node->getKind() == NodeKind::VariadicTuple);
-      return Builder.createTupleType(Elements, Variadic);
+      bool variadic = (Node->getKind() == NodeKind::VariadicTuple);
+      return Builder.createTupleType(elements, std::move(labels), variadic);
     }
     case NodeKind::TupleElement:
       if (Node->getChild(0)->getKind() == NodeKind::TupleElementName)
@@ -459,24 +483,35 @@ class MetadataReader {
     case MetadataKind::Optional:
       return readNominalTypeFromMetadata(Meta);
     case MetadataKind::Tuple: {
-      auto TupleMeta = cast<TargetTupleTypeMetadata<Runtime>>(Meta);
-      std::vector<BuiltType> Elements;
-      StoredPointer ElementAddress = MetadataAddress +
+      auto tupleMeta = cast<TargetTupleTypeMetadata<Runtime>>(Meta);
+
+      std::vector<BuiltType> elementTypes;
+      elementTypes.reserve(tupleMeta->NumElements);
+
+      StoredPointer elementAddress = MetadataAddress +
         sizeof(TargetTupleTypeMetadata<Runtime>);
       using Element = typename TargetTupleTypeMetadata<Runtime>::Element;
-      for (StoredPointer i = 0; i < TupleMeta->NumElements; ++i,
-           ElementAddress += sizeof(Element)) {
-        Element E;
-        if (!Reader->readBytes(RemoteAddress(ElementAddress),
-                               (uint8_t*)&E, sizeof(Element)))
+      for (StoredPointer i = 0; i < tupleMeta->NumElements; ++i,
+           elementAddress += sizeof(Element)) {
+        Element element;
+        if (!Reader->readBytes(RemoteAddress(elementAddress),
+                               (uint8_t*)&element, sizeof(Element)))
           return BuiltType();
 
-        if (auto ElementTypeRef = readTypeFromMetadata(E.Type))
-          Elements.push_back(ElementTypeRef);
+        if (auto elementType = readTypeFromMetadata(element.Type))
+          elementTypes.push_back(elementType);
         else
           return BuiltType();
       }
-      return Builder.createTupleType(Elements, /*variadic*/ false);
+
+      // Read the labels string.
+      std::string labels;
+      if (tupleMeta->Labels &&
+          !Reader->readString(RemoteAddress(tupleMeta->Labels), labels))
+        return BuiltType();
+
+      return Builder.createTupleType(elementTypes, std::move(labels),
+                                     /*variadic*/ false);
     }
     case MetadataKind::Function: {
       auto Function = cast<TargetFunctionTypeMetadata<Runtime>>(Meta);

lib/RemoteAST/RemoteAST.cpp

@@ -184,14 +184,22 @@ class RemoteASTTypeBuilder {
     return genericType;
   }
 
-  Type createTupleType(ArrayRef<Type> eltTypes, bool isVariadic) {
+  Type createTupleType(ArrayRef<Type> eltTypes, StringRef labels,
+                       bool isVariadic) {
     // Just bail out on variadic tuples for now.
     if (isVariadic) return Type();
 
     SmallVector<TupleTypeElt, 4> elements;
     elements.reserve(eltTypes.size());
     for (auto eltType : eltTypes) {
-      elements.push_back(eltType);
+      Identifier label;
+      if (!labels.empty()) {
+        auto split = labels.split(' ');
+        if (!split.first.empty())
+          label = Ctx.getIdentifier(split.first);
+        labels = split.second;
+      }
+      elements.emplace_back(eltType, label);
     }
 
     return TupleType::get(elements, Ctx);

test/RemoteAST/structural_types.swift

@@ -5,18 +5,26 @@ func printType(_: Any.Type)
 
 typealias Fn1 = () -> ()
 printType(Fn1.self)
-// CHECK: () -> ()
+// CHECK: found type: () -> ()
 
 typealias Fn2 = (Int, Float) -> ()
 printType(Fn2.self)
-// CHECK: (Int, Float) -> ()
+// CHECK: found type: (Int, Float) -> ()
 
 typealias Tuple1 = (Int, Float, Int)
 printType(Tuple1.self)
-// CHECK: (Int, Float, Int)
+// CHECK: found type: (Int, Float, Int)
 
 printType(Int.Type.self)
-// CHECK: Int.Type
+// CHECK: found type: Int.Type
 
 printType(Tuple1.Type.self)
-// CHECK: (Int, Float, Int).Type
+// CHECK: found type: (Int, Float, Int).Type
+
+typealias Tuple2 = (Int.Type, x: Float, Int)
+printType(Tuple2.self)
+// CHECK: found type: (Int.Type, x: Float, Int)
+
+typealias Tuple3 = (x: Int, Float, y: Int.Type)
+printType(Tuple3.self)
+// CHECK: found type: (x: Int, Float, y: Int.Type)