[Typechecker] Ban tuples with duplicate labels

Author: theblixguy

include/swift/AST/DiagnosticsSema.def

@@ -3488,6 +3488,8 @@ ERROR(tuple_single_element,none,
       "cannot create a single-element tuple with an element label", ())
 ERROR(tuple_ellipsis,none,
       "cannot create a variadic tuple", ())
+ERROR(tuple_duplicate_label,none,
+      "cannot create a tuple with a duplicate element label", ())
 ERROR(enum_element_ellipsis,none,
       "variadic enum cases are not supported", ())
 

lib/Sema/MiscDiagnostics.cpp

@@ -269,6 +269,27 @@ static void diagSyntacticUseRestrictions(TypeChecker &TC, const Expr *E,
         }
       }
 
+      // Diagnose tuple expressions with duplicate element label
+      if (auto *tupleExpr = dyn_cast<TupleExpr>(E)) {
+        auto diagnose = false;
+
+        llvm::SmallDenseSet<Identifier> names;
+        names.reserve(tupleExpr->getNumElements());
+
+        for (auto name : tupleExpr->getElementNames()) {
+          if (names.count(name) == 1) {
+            diagnose = true;
+            break;
+          }
+
+          names.insert(name);
+        }
+
+        if (diagnose) {
+          TC.diagnose(tupleExpr->getLoc(), diag::tuple_duplicate_label);
+        }
+      }
+
       return { true, E };
     }
 

lib/Sema/TypeCheckPattern.cpp

@@ -313,7 +313,7 @@ class ResolvePattern : public ASTVisitor<ResolvePattern,
   Pattern *visitExprPattern(ExprPattern *P) {
     if (P->isResolved())
       return P;
-    
+
     // Try to convert to a pattern.
     Pattern *exprAsPattern = visit(P->getSubExpr());
     // If we failed, keep the ExprPattern as is.

lib/Sema/TypeCheckType.cpp

@@ -3138,7 +3138,10 @@ Type TypeResolver::resolveTupleType(TupleTypeRepr *repr,
                                     TypeResolutionOptions options) {
   SmallVector<TupleTypeElt, 8> elements;
   elements.reserve(repr->getNumElements());
-  
+
+  llvm::SmallDenseSet<Identifier> seenEltNames;
+  seenEltNames.reserve(repr->getNumElements());
+
   auto elementOptions = options;
   if (!repr->isParenType()) {
     elementOptions = elementOptions.withoutContext(true);
@@ -3153,14 +3156,23 @@ Type TypeResolver::resolveTupleType(TupleTypeRepr *repr,
   }
 
   bool hadError = false;
+  bool foundDupLabel = false;
   for (unsigned i = 0, end = repr->getNumElements(); i != end; ++i) {
     auto *tyR = repr->getElementType(i);
 
     Type ty = resolveType(tyR, elementOptions);
     if (!ty || ty->hasError())
       hadError = true;
 
-    elements.emplace_back(ty, repr->getElementName(i), ParameterTypeFlags());
+    auto eltName = repr->getElementName(i);
+
+    if (seenEltNames.count(eltName) == 1) {
+      foundDupLabel = true;
+    }
+
+    seenEltNames.insert(eltName);
+
+    elements.emplace_back(ty, eltName, ParameterTypeFlags());
   }
 
   if (hadError)
@@ -3179,6 +3191,11 @@ Type TypeResolver::resolveTupleType(TupleTypeRepr *repr,
     elements[0] = TupleTypeElt(elements[0].getType());
   }
 
+  // Tuples with duplicate element labels are not permitted
+  if (foundDupLabel) {
+    diagnose(repr->getLoc(), diag::tuple_duplicate_label);
+  }
+
   return TupleType::get(elements, Context);
 }
 

test/Constraints/tuple.swift

@@ -289,3 +289,13 @@ func singleElementTuple() {
   let _ = ((label: 123)) // expected-error {{cannot create a single-element tuple with an element label}} {{13-20=}}
   let _ = ((label: 123)).label // expected-error {{cannot create a single-element tuple with an element label}} {{13-20=}}
 }
+
+// Tuples with duplicate labels
+
+let dupLabel1: (foo: Int, foo: Int) = (foo: 1, foo: 2) // expected-error 2{{cannot create a tuple with a duplicate element label}}
+
+func dupLabel2(x a: Int, x b: Int) -> (y: Int, y: Int) { // expected-error {{cannot create a tuple with a duplicate element label}}
+  return (a, b)
+}
+
+let _ = (bar: 0, bar: "") // expected-error {{cannot create a tuple with a duplicate element label}}