Very minimal POC of tuple KP feature

Author: Toma91

include/swift/SIL/SILInstruction.h

@@ -2397,10 +2397,10 @@ class KeyPathPatternComponent {
     StoredProperty,
     GettableProperty,
     SettableProperty,
+    TupleElement,
     OptionalChain,
     OptionalForce,
     OptionalWrap,
-    TupleElement,
   };
 
   // Description of a captured index value and its Hashable conformance for a
@@ -2439,7 +2439,10 @@ class KeyPathPatternComponent {
   // Value is the VarDecl* for StoredProperty, the SILFunction* of the
   // Getter for computed properties, or the Kind for other kinds
   llvm::PointerIntPair<void *, KindPackingBits, unsigned> ValueAndKind;
-  llvm::PointerIntPair<SILFunction *, 2,
+  
+  // Setter is the SILFunction* of the Setter for computed properties, or the
+  // tuple index for tuple elements
+  llvm::PointerIntPair<void *, 2,
                        ComputedPropertyId::KindType> SetterAndIdKind;
   ComputedPropertyId::ValueType IdValue;
   ArrayRef<Index> Indices;
@@ -2486,6 +2489,15 @@ class KeyPathPatternComponent {
            && "not an optional component");
   }
 
+  /// Constructor for tuple element.
+  KeyPathPatternComponent(unsigned tupleIndex, CanType componentType)
+    : ValueAndKind((void*)((uintptr_t)Kind::TupleElement << KindPackingBits), PackedStored),
+    SetterAndIdKind((void*)((uintptr_t)tupleIndex << 2), (ComputedPropertyId::KindType)0),
+    ComponentType(componentType)
+  {
+    // fixme: [technicated] magic << 2 shift
+  }
+
 public:
   KeyPathPatternComponent() : ValueAndKind(nullptr, 0) {}
 
@@ -2497,7 +2509,8 @@ class KeyPathPatternComponent {
     auto packedKind = ValueAndKind.getInt();
     switch ((PackedKind)packedKind) {
     case PackedStored:
-      return Kind::StoredProperty;
+      return SetterAndIdKind.getPointer()
+        ? Kind::TupleElement : Kind::StoredProperty;
     case PackedComputed:
       return SetterAndIdKind.getPointer()
         ? Kind::SettableProperty : Kind::GettableProperty;
@@ -2567,7 +2580,7 @@ class KeyPathPatternComponent {
     case Kind::TupleElement:
       llvm_unreachable("not a settable computed property");
     case Kind::SettableProperty:
-      return SetterAndIdKind.getPointer();
+      return static_cast<SILFunction*>(SetterAndIdKind.getPointer());
     }
     llvm_unreachable("unhandled kind");
   }
@@ -2663,7 +2676,8 @@ class KeyPathPatternComponent {
     case Kind::SettableProperty:
       llvm_unreachable("not a tuple element");
     case Kind::TupleElement:
-      llvm_unreachable("[technicated]");
+      // fixme: [technicated] magic >> 2 shift
+      return (uintptr_t)SetterAndIdKind.getPointer() >> 2;
     }
     llvm_unreachable("unhandled kind");
   }
@@ -2719,6 +2733,11 @@ class KeyPathPatternComponent {
     }
     return KeyPathPatternComponent(kind, ty);
   }
+    
+  static KeyPathPatternComponent forTupleElement(unsigned tupleIndex,
+                                                 CanType ty) {
+    return KeyPathPatternComponent(tupleIndex, ty);
+  }
 
   void incrementRefCounts() const;
   void decrementRefCounts() const;

lib/IRGen/GenKeyPath.cpp

@@ -24,6 +24,7 @@
 #include "GenMeta.h"
 #include "GenProto.h"
 #include "GenStruct.h"
+#include "GenTuple.h"
 #include "GenType.h"
 #include "GenericRequirement.h"
 #include "IRGenDebugInfo.h"
@@ -1106,8 +1107,22 @@ emitKeyPathComponent(IRGenModule &IGM,
     fields.addInt32(KeyPathComponentHeader::forOptionalWrap().getData());
     break;
   case KeyPathPatternComponent::Kind::TupleElement:
-    llvm_unreachable("[technicated]");
-    break;
+    if (!baseTy->is<TupleType>()) {
+      llvm_unreachable("not a tuple");
+    }
+
+    SILType loweredTy = IGM.getSILTypes().getLoweredType(baseTy);
+
+    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");
   }
 }
 

lib/SIL/SILVerifier.cpp

@@ -385,7 +385,7 @@ void verifyKeyPathComponent(SILModule &M,
     break;
   }
   case KeyPathPatternComponent::Kind::TupleElement: {
-    llvm_unreachable("[technicated]");
+    //llvm_unreachable("[technicated]");
     break;
   }
   }

lib/SILGen/SILGen.h

@@ -360,7 +360,7 @@ class LLVM_LIBRARY_VISIBILITY SILGenModule : public ASTVisitor<SILGenModule> {
                               bool forPropertyDescriptor);
 
   KeyPathPatternComponent
-  emitKeyPathComponentForTupleElement();
+  emitKeyPathComponentForTupleElement(unsigned tupleIndex, CanType baseTy);
 
   /// Known functions for bridging.
   SILDeclRef getStringToNSStringFn();

lib/SILGen/SILGenExpr.cpp

@@ -3575,8 +3575,17 @@ SILGenModule::emitKeyPathComponentForDecl(SILLocation loc,
 }
 
 KeyPathPatternComponent
-SILGenModule::emitKeyPathComponentForTupleElement() {
-    llvm_unreachable("technicated");
+SILGenModule::emitKeyPathComponentForTupleElement(unsigned tupleIndex,
+                                                  CanType baseTy) {
+  if (!baseTy->is<TupleType>()) {
+    llvm_unreachable("baseTy is expected to be a TupleType");
+  }
+
+  auto elementTy = baseTy->getAs<TupleType>()
+    ->getElementType(tupleIndex)
+    ->getCanonicalType();
+
+  return KeyPathPatternComponent::forTupleElement(tupleIndex, elementTy);
 }
 
 RValue RValueEmitter::visitKeyPathExpr(KeyPathExpr *E, SGFContext C) {
@@ -3650,8 +3659,10 @@ RValue RValueEmitter::visitKeyPathExpr(KeyPathExpr *E, SGFContext C) {
     }
 
     case KeyPathExpr::Component::Kind::TupleElement: {
+      auto tupleIndex = component.getTupleIndex();
       loweredComponents.push_back(
-        SGF.SGM.emitKeyPathComponentForTupleElement());
+        SGF.SGM.emitKeyPathComponentForTupleElement(tupleIndex,
+                                                    baseTy));
 
       baseTy = loweredComponents.back().getComponentType();