Added support for tuples with dynamic layout (ie generic tuples)

Extracted a base CRTP class MetadataVisitor from NominalMetadataVisitor
Added new tuple metadata visitors extending the new MetadataVisitor

Author: technicated

lib/IRGen/GenKeyPath.cpp

@@ -1108,19 +1108,35 @@ emitKeyPathComponent(IRGenModule &IGM,
     break;
   case KeyPathPatternComponent::Kind::TupleElement:
     assert(baseTy->is<TupleType>() && "not a tuple");
-          
+
     SILType loweredTy = IGM.getSILTypes().getLoweredType(baseTy);
 
+    // Tuple with fixed layout
+    //
+    // This code is ALSO executed in the case of a tuple with dynamic layout,
+    // (see below) but only if `component.getTupleIndex()` is 0 - in that case
+    // the compiler knows that the tuple element is always at offset 0
     if (auto offset = getFixedTupleElementOffset(IGM, loweredTy, component.getTupleIndex())) {
       auto header = KeyPathComponentHeader
                       ::forStructComponentWithInlineOffset(/*isLet*/ false,
                                                            offset->getValue());
-        
+
       fields.addInt32(header.getData());
       break;
     }
-          
-    llvm_unreachable("could not get element offset");
+
+    // Tuple with dynamic layout
+    auto elementOffset = getStaticTupleElementOffset(IGM,
+                                                     loweredTy,
+                                                     component.getTupleIndex());
+
+    auto header = KeyPathComponentHeader
+      ::forStructComponentWithUnresolvedFieldOffset(/*isLet*/ false);
+    fields.addInt32(header.getData());
+    fields.addInt32(elementOffset.getValue());
+    break;
+
+    llvm_unreachable("could not get tuple element offset");
   }
 }
 

lib/IRGen/MetadataLayout.cpp

@@ -31,6 +31,7 @@
 #include "IRGenFunction.h"
 #include "StructMetadataVisitor.h"
 #include "ForeignClassMetadataVisitor.h"
+#include "TupleMetadataVisitor.h"
 
 #include "swift/Basic/LLVM.h"
 #include "llvm/ADT/Optional.h"
@@ -480,6 +481,39 @@ Address irgen::emitAddressOfSuperclassRefInClassMetadata(IRGenFunction &IGF,
   return IGF.Builder.CreateConstArrayGEP(addr, index, IGF.IGM.getPointerSize());
 }
 
+Size irgen::getStaticTupleElementOffset(IRGenModule &IGM,
+                                        SILType tupleType,
+                                        unsigned eltIdx) {
+  assert(tupleType.is<TupleType>() && "not a tuple type");
+
+  struct TupleElementOffsetScanner
+       : LayoutScanner<TupleElementOffsetScanner, TupleMetadataScanner> {
+  private:
+    using super = LayoutScanner;
+
+    // 8 seems a reasonable potential max number tuple elements to start with
+    llvm::SmallVector<Size, 8> Offsets;
+
+  public:
+    TupleElementOffsetScanner(IRGenModule &IGM, TupleType *const tupleType)
+      : super(IGM, tupleType) {}
+
+    void addElement(unsigned eltIdx, const TupleTypeElt &elt) {
+      Offsets.push_back(NextOffset);
+      super::addElement(eltIdx, elt);
+    }
+
+    Size getElementOffset(unsigned eltIdx) const {
+      return Offsets[eltIdx];
+    }
+  };
+
+  TupleElementOffsetScanner s(IGM, tupleType.getAs<TupleType>().getPointer());
+  s.layout();
+
+  return s.getElementOffset(eltIdx);
+}
+
 /*********************************** ENUMS ************************************/
 
 EnumMetadataLayout::EnumMetadataLayout(IRGenModule &IGM, EnumDecl *decl)

lib/IRGen/MetadataLayout.h

@@ -393,6 +393,10 @@ llvm::Value *emitClassFieldOffset(IRGenFunction &IGF,
 Address emitAddressOfSuperclassRefInClassMetadata(IRGenFunction &IGF,
                                                   llvm::Value *metadata);
 
+Size getStaticTupleElementOffset(IRGenModule &IGM,
+                                 SILType tupleType,
+                                 unsigned eltIdx);
+
 } // end namespace irgen
 } // end namespace swift
 

lib/IRGen/MetadataVisitor.h

@@ -0,0 +1,49 @@
+//===--- MetadataVisitor.h - CRTP for metadata layout -----------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// A CRTP helper class for preparing the common metadata of all metadata
+// objects.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_IRGEN_METADATAVISITOR_H
+#define SWIFT_IRGEN_METADATAVISITOR_H
+
+namespace swift {
+namespace irgen {
+
+/// A CRTP class for laying out a type metadata's common fields. Note that this
+/// does *not* handle the metadata template stuff.
+template <class Impl> class MetadataVisitor {
+protected:
+  Impl &asImpl() { return *static_cast<Impl*>(this); }
+
+  IRGenModule &IGM;
+
+  MetadataVisitor(IRGenModule &IGM) : IGM(IGM) {}
+
+public:
+  void layout() {
+    // Common fields.
+    asImpl().addValueWitnessTable();
+    asImpl().noteAddressPoint();
+    asImpl().addMetadataFlags();
+  }
+
+  /// This is the address point.
+  void noteAddressPoint() {}
+};
+
+} // end namespace irgen
+} // end namespace swift
+
+#endif

lib/IRGen/NominalMetadataVisitor.h

@@ -18,39 +18,26 @@
 #ifndef SWIFT_IRGEN_NOMINALMETADATAVISITOR_H
 #define SWIFT_IRGEN_NOMINALMETADATAVISITOR_H
 
-#include "llvm/ADT/SmallVector.h"
-#include "swift/AST/Decl.h"
-#include "swift/AST/SubstitutionMap.h"
-#include "swift/SIL/TypeLowering.h"
 #include "GenericRequirement.h"
 #include "GenProto.h"
 #include "IRGenModule.h"
+#include "MetadataVisitor.h"
 
 namespace swift {
 namespace irgen {
 
-/// A CRTP class for laying out type metadata.  Note that this does
-/// *not* handle the metadata template stuff.
-template <class Impl> class NominalMetadataVisitor {
-protected:
-  Impl &asImpl() { return *static_cast<Impl*>(this); }
+/// A CRTP class for laying out type metadata for nominal types. Note that this
+/// does *not* handle the metadata template stuff.
+template <class Impl> class NominalMetadataVisitor
+       : public MetadataVisitor<Impl> {
+  using super = MetadataVisitor<Impl>;
 
 protected:
-  IRGenModule &IGM;
+  using super::asImpl;
 
-  NominalMetadataVisitor(IRGenModule &IGM) : IGM(IGM) {}
+  NominalMetadataVisitor(IRGenModule &IGM) : super(IGM) {}
 
 public:
-  void layout() {
-    // Common fields.
-    asImpl().addValueWitnessTable();
-    asImpl().noteAddressPoint();
-    asImpl().addMetadataFlags();
-  }
-
-  /// This is the address point.
-  void noteAddressPoint() {}
-
   /// Add fields related to the generics of this class declaration.
   /// TODO: don't add new fields that are implied by the superclass
   /// fields.  e.g., if B<T> extends A<T>, the witness for T in A's
@@ -63,7 +50,7 @@ template <class Impl> class NominalMetadataVisitor {
     // Note that we intentionally don't std::forward 'args'.
     asImpl().noteStartOfGenericRequirements(args...);
 
-    GenericTypeRequirements requirements(IGM, typeDecl);
+    GenericTypeRequirements requirements(super::IGM, typeDecl);
     for (auto reqt : requirements.getRequirements()) {
       if (reqt.Protocol) {
         asImpl().addGenericWitnessTable(args...);

lib/IRGen/TupleMetadataVisitor.h

@@ -0,0 +1,81 @@
+//===--- TupleMetadataVisitor.h - CRTP for tuple metadata ------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// A CRTP class useful for laying out tuple metadata.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_IRGEN_TUPLEMETADATALAYOUT_H
+#define SWIFT_IRGEN_TUPLEMETADATALAYOUT_H
+
+//#include "NominalMetadataVisitor.h"
+
+namespace swift {
+namespace irgen {
+
+/// A CRTP class for laying out tuple metadata.
+///
+/// This produces an object corresponding to a TupleTypeMetadata type.
+/// It does not itself doing anything special for metadata templates.
+template <class Impl> struct TupleMetadataVisitor
+       : public MetadataVisitor<Impl> {
+  using super = MetadataVisitor<Impl>;
+
+protected:
+  using super::asImpl;
+
+  TupleType *const Target;
+
+  TupleMetadataVisitor(IRGenModule &IGM, TupleType *const target)
+    : super(IGM), Target(target) {}
+
+public:
+  void layout() {
+    super::layout();
+
+    asImpl().addNumElementsInfo();
+    asImpl().addLabelsInfo();
+
+    for (unsigned i = 0, n = Target->getNumElements(); i < n; ++i) {
+      asImpl().addElement(i, Target->getElement(i));
+    }
+  }
+};
+
+/// An "implementation" of TupleMetadataVisitor that just scans through
+/// the metadata layout, maintaining the offset of all tuple elements.
+template <class Impl> class TupleMetadataScanner
+       : public TupleMetadataVisitor<Impl> {
+  using super = TupleMetadataVisitor<Impl>;
+
+protected:
+  Size NextOffset = Size(0);
+
+  TupleMetadataScanner(IRGenModule &IGM, TupleType *const target)
+    : super(IGM, target) {}
+
+public:
+  void addValueWitnessTable() { addPointer(); }
+  void addMetadataFlags() { addPointer(); }
+  void addNumElementsInfo() { addPointer(); }
+  void addLabelsInfo() { addPointer(); }
+  void addElement(unsigned idx,
+                  const TupleTypeElt &e) { addPointer(); addPointer(); }
+
+private:
+  void addPointer() { NextOffset += super::IGM.getPointerSize(); }
+};
+
+} // end namespace irgen
+} // end namespace swift
+
+#endif