[CSDiagnostics] Diagnose situations when value pack expansion does expect a tuple argument

Diagnose situation when a single argument to tuple type is passed to
a value pack expansion parameter that expects distinct N elements:

```swift
struct S<each T> {
  func test(x: Int, _: repeat each T) {}
}

S<Int, String>().test(x: 42, (2, "b"))
```

Author: xedin

include/swift/AST/DiagnosticsSema.def

@@ -5423,6 +5423,14 @@ ERROR(tuple_duplicate_label,none,
       "cannot create a tuple with a duplicate element label", ())
 ERROR(multiple_ellipsis_in_tuple,none,
       "only a single element can be variadic", ())
+ERROR(cannot_convert_tuple_into_pack_expansion_parameter,none,
+      "value pack expansion at parameter #%0 expects %1 separate arguments"
+      "%select{|; remove extra parentheses to change tuple into separate arguments}2",
+      (unsigned, unsigned, bool))
+NOTE(cannot_convert_tuple_into_pack_expansion_parameter_note,none,
+     "value pack expansion at parameter #%0 expects %1 separate arguments",
+     (unsigned, unsigned))
+
 
 ERROR(expansion_not_same_shape,none,
       "pack expansion %0 requires that %1 and %2 have the same shape",

lib/Sema/CSDiagnostics.cpp

@@ -8859,3 +8859,45 @@ bool GlobalActorFunctionMismatchFailure::diagnoseAsError() {
   emitDiagnostic(message, getFromType(), getToType());
   return true;
 }
+
+bool DestructureTupleToUseWithPackExpansionParameter::diagnoseAsError() {
+  auto *locator = getLocator();
+  auto argLoc = locator->castLastElementTo<LocatorPathElt::ApplyArgToParam>();
+
+  {
+    auto diagnostic =
+        emitDiagnostic(diag::cannot_convert_tuple_into_pack_expansion_parameter,
+                       argLoc.getParamIdx(), ParamShape->getNumElements(),
+                       isExpr<TupleExpr>(getAnchor()));
+
+    if (auto *tupleExpr = getAsExpr<TupleExpr>(getAnchor())) {
+      diagnostic.fixItRemove(tupleExpr->getLParenLoc());
+      diagnostic.fixItRemove(tupleExpr->getRParenLoc());
+    }
+  }
+
+  auto selectedOverload = getCalleeOverloadChoiceIfAvailable(getLocator());
+  if (!selectedOverload)
+    return true;
+
+  if (auto *decl = selectedOverload->choice.getDeclOrNull()) {
+    emitDiagnosticAt(decl, diag::decl_declared_here, decl->getName());
+  }
+
+  return true;
+}
+
+bool DestructureTupleToUseWithPackExpansionParameter::diagnoseAsNote() {
+  auto selectedOverload = getCalleeOverloadChoiceIfAvailable(getLocator());
+  if (!selectedOverload || !selectedOverload->choice.isDecl())
+    return false;
+
+  auto *choice = selectedOverload->choice.getDecl();
+  auto argLoc =
+      getLocator()->castLastElementTo<LocatorPathElt::ApplyArgToParam>();
+
+  emitDiagnosticAt(
+      choice, diag::cannot_convert_tuple_into_pack_expansion_parameter_note,
+      argLoc.getParamIdx(), ParamShape->getNumElements());
+  return true;
+}

lib/Sema/CSDiagnostics.h

@@ -2976,6 +2976,30 @@ class GlobalActorFunctionMismatchFailure final : public ContextualFailure {
   bool diagnoseTupleElement();
 };
 
+/// Diagnose situation when a single argument to tuple type is passed to
+/// a value pack expansion parameter that expects distinct N elements:
+///
+/// ```swift
+/// struct S<each T> {
+///   func test(x: Int, _: repeat each T) {}
+/// }
+///
+/// S<Int, String>().test(x: 42, (2, "b"))
+/// ```
+class DestructureTupleToUseWithPackExpansionParameter final
+    : public FailureDiagnostic {
+  PackType *ParamShape;
+
+public:
+  DestructureTupleToUseWithPackExpansionParameter(const Solution &solution,
+                                                  PackType *paramShape,
+                                                  ConstraintLocator *locator)
+      : FailureDiagnostic(solution, locator), ParamShape(paramShape) {}
+
+  bool diagnoseAsError() override;
+  bool diagnoseAsNote() override;
+};
+
 } // end namespace constraints
 } // end namespace swift