Thread Labels through TupleTypeRef.

Author: adrian-prantl

include/swift/Reflection/TypeRef.h

@@ -301,27 +301,48 @@ class BoundGenericTypeRef final : public TypeRef, public NominalTypeTrait {
 };
 
 class TupleTypeRef final : public TypeRef {
+protected:
   std::vector<const TypeRef *> Elements;
+  std::string Labels;
 
-  static TypeRefID Profile(const std::vector<const TypeRef *> &Elements) {
+  static TypeRefID Profile(const std::vector<const TypeRef *> &Elements,
+                           const std::string &Labels) {
     TypeRefID ID;
     for (auto Element : Elements)
       ID.addPointer(Element);
+    ID.addString(Labels);
     return ID;
   }
 
 public:
-  TupleTypeRef(std::vector<const TypeRef *> Elements)
-      : TypeRef(TypeRefKind::Tuple), Elements(std::move(Elements)) {}
+  TupleTypeRef(std::vector<const TypeRef *> Elements, std::string &&Labels)
+      : TypeRef(TypeRefKind::Tuple), Elements(std::move(Elements)),
+        Labels(Labels) {}
 
   template <typename Allocator>
   static const TupleTypeRef *create(Allocator &A,
-                                    std::vector<const TypeRef *> Elements) {
-    FIND_OR_CREATE_TYPEREF(A, TupleTypeRef, Elements);
-  }
-
-  const std::vector<const TypeRef *> &getElements() const {
-    return Elements;
+                                    std::vector<const TypeRef *> Elements,
+                                    std::string &&Labels) {
+    FIND_OR_CREATE_TYPEREF(A, TupleTypeRef, Elements, Labels);
+  }
+
+  const std::vector<const TypeRef *> &getElements() const { return Elements; };
+  const std::string &getLabelString() const { return Labels; };
+  std::vector<llvm::StringRef> getLabels() const {
+    std::vector<llvm::StringRef> Vec;
+    std::string::size_type End, Start = 0;
+    while (true) {
+      End = Labels.find(' ', Start);
+      if (End == std::string::npos)
+        break;
+      Vec.push_back(llvm::StringRef(Labels.data() + Start, End - Start));
+      Start = End + 1;
+    }
+    // A canonicalized TypeRef has an empty label string.
+    // Pad the vector with empty labels.
+    for (unsigned N = Vec.size(); N < Elements.size(); ++N)
+      Vec.push_back({});
+    return Vec;
   };
 
   static bool classof(const TypeRef *TR) {

include/swift/Reflection/TypeRefBuilder.h

@@ -405,9 +405,7 @@ class TypeRefBuilder {
 
   const TupleTypeRef *createTupleType(llvm::ArrayRef<const TypeRef *> elements,
                                       std::string &&labels) {
-    // FIXME: Add uniqueness checks in TupleTypeRef::Profile and
-    // unittests/Reflection/TypeRef.cpp if using labels for identity.
-    return TupleTypeRef::create(*this, elements);
+    return TupleTypeRef::create(*this, elements, std::move(labels));
   }
 
   const FunctionTypeRef *createFunctionType(

stdlib/public/Reflection/TypeLowering.cpp

@@ -2021,6 +2021,7 @@ class LowerType
   const TypeInfo *visitTupleTypeRef(const TupleTypeRef *T) {
     RecordTypeInfoBuilder builder(TC, RecordKind::Tuple);
     for (auto Element : T->getElements())
+      // The label is not going to be relevant/harmful for looking up type info.
       builder.addField("", Element, ExternalTypeInfo);
     return builder.build();
   }

stdlib/public/Reflection/TypeRef.cpp

@@ -109,8 +109,14 @@ class PrintTypeRef : public TypeRefVisitor<PrintTypeRef, void> {
 
   void visitTupleTypeRef(const TupleTypeRef *T) {
     printHeader("tuple");
-    for (auto element : T->getElements())
-      printRec(element);
+    T->getLabels();
+    auto Labels = T->getLabels();
+    for (auto NameElement : llvm::zip_first(Labels, T->getElements())) {
+      auto Label = std::get<0>(NameElement);
+      if (!Label.empty())
+        fprintf(file, "%s = ", Label.str().c_str());
+      printRec(std::get<1>(NameElement));
+    }
     fprintf(file, ")");
   }
 
@@ -459,9 +465,15 @@ class DemanglingForTypeRef
   Demangle::NodePointer visitTupleTypeRef(const TupleTypeRef *T) {
     auto tuple = Dem.createNode(Node::Kind::Tuple);
 
-    for (auto element : T->getElements()) {
+    auto Labels = T->getLabels();
+    for (auto LabelElement : llvm::zip(Labels, T->getElements())) {
       auto tupleElt = Dem.createNode(Node::Kind::TupleElement);
-      tupleElt->addChild(visit(element), Dem);
+      auto Label = std::get<0>(LabelElement);
+      if (!Label.empty()) {
+        auto name = Dem.createNode(Node::Kind::TupleElementName, Label);
+        tupleElt->addChild(name, Dem);
+      }
+      tupleElt->addChild(visit(std::get<1>(LabelElement)), Dem);
       tuple->addChild(tupleElt, Dem);
     }
     return tuple;
@@ -816,7 +828,8 @@ class ThickenMetatype
     std::vector<const TypeRef *> Elements;
     for (auto Element : T->getElements())
       Elements.push_back(visit(Element));
-    return TupleTypeRef::create(Builder, Elements);
+    std::string Labels = T->getLabelString();
+    return TupleTypeRef::create(Builder, Elements, std::move(Labels));
   }
 
   const TypeRef *visitFunctionTypeRef(const FunctionTypeRef *F) {
@@ -929,7 +942,8 @@ class TypeRefSubstitution
     std::vector<const TypeRef *> Elements;
     for (auto Element : T->getElements())
       Elements.push_back(visit(Element));
-    return TupleTypeRef::create(Builder, Elements);
+    std::string Labels = T->getLabelString();
+    return TupleTypeRef::create(Builder, Elements, std::move(Labels));
   }
 
   const TypeRef *visitFunctionTypeRef(const FunctionTypeRef *F) {