Private constructor for tuple element kind keypath in AST

Author: technicated

include/swift/AST/Expr.h

@@ -4861,22 +4861,28 @@ class KeyPathExpr : public Expr {
                        Expr *indexExpr,
                        ArrayRef<Identifier> subscriptLabels,
                        ArrayRef<ProtocolConformanceRef> indexHashables,
-                       unsigned tupleIndex,
                        Kind kind,
                        Type type,
                        SourceLoc loc);
+
+    // Private constructor for tuple element kind
+    Component(unsigned tupleIndex, Type elementType, SourceLoc loc)
+      : Component(nullptr, {}, nullptr, {}, {}, Kind::TupleElement,
+        elementType, loc) {
+      TupleIndex = tupleIndex;
+    }
 
   public:
     Component()
-      : Component(nullptr, {}, nullptr, {}, {}, 0, Kind::Invalid,
+      : Component(nullptr, {}, nullptr, {}, {}, Kind::Invalid,
                   Type(), SourceLoc())
     {}
 
     /// Create an unresolved component for a property.
     static Component forUnresolvedProperty(DeclName UnresolvedName,
                                            SourceLoc Loc) {
       return Component(nullptr,
-                       UnresolvedName, nullptr, {}, {}, 0,
+                       UnresolvedName, nullptr, {}, {},
                        Kind::UnresolvedProperty,
                        Type(),
                        Loc);
@@ -4902,22 +4908,22 @@ class KeyPathExpr : public Expr {
                                          SourceLoc loc) {
 
       return Component(&context,
-                       {}, index, subscriptLabels, {}, 0,
+                       {}, index, subscriptLabels, {},
                        Kind::UnresolvedSubscript,
                        Type(), loc);
     }
 
     /// Create an unresolved optional force `!` component.
     static Component forUnresolvedOptionalForce(SourceLoc BangLoc) {
-      return Component(nullptr, {}, nullptr, {}, {}, 0,
+      return Component(nullptr, {}, nullptr, {}, {},
                        Kind::OptionalForce,
                        Type(),
                        BangLoc);
     }
 
     /// Create an unresolved optional chain `?` component.
     static Component forUnresolvedOptionalChain(SourceLoc QuestionLoc) {
-      return Component(nullptr, {}, nullptr, {}, {}, 0,
+      return Component(nullptr, {}, nullptr, {}, {},
                        Kind::OptionalChain,
                        Type(),
                        QuestionLoc);
@@ -4927,7 +4933,7 @@ class KeyPathExpr : public Expr {
     static Component forProperty(ConcreteDeclRef property,
                                  Type propertyType,
                                  SourceLoc loc) {
-      return Component(nullptr, property, nullptr, {}, {}, 0,
+      return Component(nullptr, property, nullptr, {}, {},
                        Kind::Property,
                        propertyType,
                        loc);
@@ -4956,15 +4962,15 @@ class KeyPathExpr : public Expr {
 
     /// Create an optional-forcing `!` component.
     static Component forOptionalForce(Type forcedType, SourceLoc bangLoc) {
-      return Component(nullptr, {}, nullptr, {}, {}, 0,
+      return Component(nullptr, {}, nullptr, {}, {},
                        Kind::OptionalForce, forcedType,
                        bangLoc);
     }
 
     /// Create an optional-chaining `?` component.
     static Component forOptionalChain(Type unwrappedType,
                                       SourceLoc questionLoc) {
-      return Component(nullptr, {}, nullptr, {}, {}, 0,
+      return Component(nullptr, {}, nullptr, {}, {},
                        Kind::OptionalChain, unwrappedType,
                        questionLoc);
     }
@@ -4973,23 +4979,21 @@ class KeyPathExpr : public Expr {
     /// syntax but may appear when the non-optional result of an optional chain
     /// is implicitly wrapped.
     static Component forOptionalWrap(Type wrappedType) {
-      return Component(nullptr, {}, nullptr, {}, {}, 0,
+      return Component(nullptr, {}, nullptr, {}, {},
                        Kind::OptionalWrap, wrappedType,
                        SourceLoc());
     }
 
     static Component forIdentity(SourceLoc selfLoc) {
-      return Component(nullptr, {}, nullptr, {}, {}, 0,
+      return Component(nullptr, {}, nullptr, {}, {},
                        Kind::Identity, Type(),
                        selfLoc);
     }
 
     static Component forTupleElement(unsigned fieldNumber,
                                      Type elementType,
                                      SourceLoc loc) {
-      return Component(nullptr, {}, nullptr, {}, {}, fieldNumber,
-                       Kind::TupleElement, elementType,
-                       loc);
+      return Component(fieldNumber, elementType, loc);
     }
 
 

lib/AST/Expr.cpp

@@ -2185,27 +2185,19 @@ KeyPathExpr::Component::Component(ASTContext *ctxForCopyingLabels,
                      Expr *indexExpr,
                      ArrayRef<Identifier> subscriptLabels,
                      ArrayRef<ProtocolConformanceRef> indexHashables,
-                     unsigned tupleIndex,
                      Kind kind,
                      Type type,
                      SourceLoc loc)
     : Decl(decl), SubscriptIndexExpr(indexExpr), KindValue(kind),
       ComponentType(type), Loc(loc)
 {
+  assert(kind != Kind::TupleElement || subscriptLabels.empty());
   assert(subscriptLabels.size() == indexHashables.size()
          || indexHashables.empty());
   SubscriptLabelsData = subscriptLabels.data();
   SubscriptHashableConformancesData = indexHashables.empty()
     ? nullptr : indexHashables.data();
-  
-  if (kind == Kind::TupleElement) {
-    assert(subscriptLabels.empty()
-           && "subscript labels not empty for tuple element");
-
-    TupleIndex = tupleIndex;
-  } else {
-    SubscriptSize = subscriptLabels.size();
-  }
+  SubscriptSize = subscriptLabels.size();
 }
 
 KeyPathExpr::Component
@@ -2214,7 +2206,7 @@ KeyPathExpr::Component::forSubscriptWithPrebuiltIndexExpr(
        Type elementType, SourceLoc loc,
        ArrayRef<ProtocolConformanceRef> indexHashables) {
   return Component(&elementType->getASTContext(),
-                   subscript, index, labels, indexHashables, 0,
+                   subscript, index, labels, indexHashables,
                    Kind::Subscript, elementType, loc);
 }