[CSDiagnostics] Add diags for holes in generic parameter pack

Author: li3zhen1

include/swift/AST/DiagnosticsSema.def

@@ -4460,6 +4460,9 @@ ERROR(cannot_force_unwrap_nil_literal,none,
 ERROR(could_not_infer_placeholder,none,
       "could not infer type for placeholder", ())
 
+ERROR(could_not_infer_pack_element,none,
+      "could not infer pack element #%0 from context", (unsigned))
+      
 ERROR(type_of_expression_is_ambiguous,none,
       "type of expression is ambiguous without a type annotation", ())
 

include/swift/Sema/CSFix.h

@@ -262,6 +262,10 @@ enum class FixKind : uint8_t {
   /// is declared was not imported.
   SpecifyObjectLiteralTypeImport,
 
+  /// Type of the element in generic pack couldn't be inferred and has to be
+  /// specified explicitly.
+  SpecifyPackElementType,
+
   /// Allow any type (and not just class or class-constrained type) to
   /// be convertible to AnyObject.
   AllowNonClassTypeToConvertToAnyObject,
@@ -2737,6 +2741,25 @@ class SpecifyObjectLiteralTypeImport final : public ConstraintFix {
   }
 };
 
+class SpecifyPackElementType final : public ConstraintFix {
+  SpecifyPackElementType(ConstraintSystem &cs, ConstraintLocator *locator)
+        : ConstraintFix(cs, FixKind::SpecifyPackElementType, locator) {}
+public:
+  std::string getName() const override {
+    return "specify pack element type";
+  }
+
+  bool diagnose(const Solution &solution, bool asNote) const override;
+
+  static SpecifyPackElementType *create(ConstraintSystem &cs,
+                                        ConstraintLocator *locator);
+
+  static bool classof(const ConstraintFix *fix) {
+    return fix->getKind() == FixKind::SpecifyPackElementType;
+  }
+};
+
+
 class AddQualifierToAccessTopLevelName final : public ConstraintFix {
   AddQualifierToAccessTopLevelName(ConstraintSystem &cs,
                                    ConstraintLocator *locator)

lib/Sema/CSBindings.cpp

@@ -2549,6 +2549,14 @@ TypeVariableBinding::fixForHole(ConstraintSystem &cs) const {
     return std::make_pair(fix, defaultImpact);
   }
 
+  if (dstLocator->isLastElement<LocatorPathElt::PackElement>()) {
+
+    // A hole appears as an element of generic pack params
+    ConstraintFix *Fix = SpecifyPackElementType::create(cs, dstLocator);
+    return std::make_pair(Fix, defaultImpact);
+  }
+
+  return std::nullopt;
   return std::nullopt;
 }
 

lib/Sema/CSDiagnostics.cpp

@@ -8187,6 +8187,37 @@ bool UnableToInferClosureReturnType::diagnoseAsError() {
   return true;
 }
 
+bool UnableToInferGenericPackElementType::diagnoseAsError() {
+
+  const auto* locator = getLocator();
+  auto path = locator->getPath();
+
+  if (path.size() > 1) {
+    const auto applyArgToParamElt = (path.end() - 2)->getAs<LocatorPathElt::ApplyArgToParam>();
+
+    if (!applyArgToParamElt)
+      return false;
+
+    unsigned eltIdx = applyArgToParamElt->getArgIdx();
+    auto anchor = getAnchor();
+
+
+    // `nil` appears as an element of generic pack params, let's record a
+    // specify contextual type for nil fix.
+    if (isExpr<NilLiteralExpr>(anchor)) {
+      emitDiagnostic(diag::unresolved_nil_literal);
+      return true;
+    }
+
+    // unable to infer the type of an element of generic pack params
+    emitDiagnostic(diag::could_not_infer_pack_element, eltIdx);
+    return true;
+  }
+
+  return false;
+}
+
+
 static std::pair<StringRef, StringRef>
 getImportModuleAndDefaultType(const ASTContext &ctx,
                               const ObjectLiteralExpr *expr) {

lib/Sema/CSDiagnostics.h

@@ -2343,6 +2343,15 @@ class UnableToInferClosureReturnType final : public FailureDiagnostic {
   bool diagnoseAsError() override;
 };
 
+class UnableToInferGenericPackElementType final : public FailureDiagnostic {
+public:
+  UnableToInferGenericPackElementType(const Solution &solution,
+                                      ConstraintLocator *locator)
+      : FailureDiagnostic(solution, locator) {}
+
+  bool diagnoseAsError() override;
+};
+
 class UnableToInferProtocolLiteralType final : public FailureDiagnostic {
 public:
   UnableToInferProtocolLiteralType(const Solution &solution,

lib/Sema/CSFix.cpp

@@ -1972,6 +1972,20 @@ AllowNonClassTypeToConvertToAnyObject::create(ConstraintSystem &cs, Type type,
       AllowNonClassTypeToConvertToAnyObject(cs, type, locator);
 }
 
+
+bool SpecifyPackElementType::diagnose(const Solution &solution,
+                                      bool asNote) const {
+  UnableToInferGenericPackElementType failure(solution, getLocator());
+  return failure.diagnose(asNote);
+}
+
+SpecifyPackElementType *
+SpecifyPackElementType::create(ConstraintSystem &cs,
+                               ConstraintLocator *locator) {
+  return new (cs.getAllocator()) SpecifyPackElementType(cs, locator);
+}
+
+
 bool AddQualifierToAccessTopLevelName::diagnose(const Solution &solution,
                                                 bool asNote) const {
   MissingQualifierInMemberRefFailure failure(solution, getLocator());

lib/Sema/ConstraintSystem.cpp

@@ -5881,9 +5881,28 @@ void constraints::simplifyLocator(ASTNode &anchor,
       if (!elt)
         break;
 
+      // If the 3rd element is an PackElement, add the index of pack element within 
+      // packs to locate the correct element.
+      bool hasEltPack = false;
+      unsigned eltPackIdx = 0;
+      if (path.size() > 2) {
+        auto eltPack = path[2].getAs<LocatorPathElt::PackElement>();
+        if (eltPack) {
+          hasEltPack = true;
+          eltPackIdx = eltPack->getIndex();
+        }
+      }
+
       // Extract application argument.
       if (auto *args = anchorExpr->getArgs()) {
-        if (elt->getArgIdx() < args->size()) {
+        if (hasEltPack) {
+          if (elt->getArgIdx() + eltPackIdx < args->size()) {
+            anchor = args->getExpr(elt->getArgIdx() + eltPackIdx);
+            path = path.slice(3);
+            continue;
+          }
+        }
+        else if (elt->getArgIdx() < args->size()) {
           anchor = args->getExpr(elt->getArgIdx());
           path = path.slice(2);
           continue;

test/Constraints/variadic_generic_functions.swift

@@ -79,3 +79,21 @@ do {
 
   func bar<each T>() -> (repeat each T) {}
 }
+
+
+// apple/swift#69432 - Passing nil to a parameter pack fails to produce diagnostic for expression
+do {
+  func foo<each T>(_ value: repeat each T) {}
+
+  foo(nil) // expected-error {{'nil' requires a contextual type}}
+  foo(1, nil) // expected-error {{'nil' requires a contextual type}}
+  foo(nil, 1) // expected-error {{'nil' requires a contextual type}}
+
+  func bar<each T, U, each W>(_ t: repeat each T, u: U, w: repeat each W) {}
+
+  bar(1, nil, "Hello", nil, u: 3, w: 4, 8, nil) 
+  // expected-error@-1 {{'nil' requires a contextual type}}
+  // expected-error@-2 {{'nil' requires a contextual type}}
+  // expected-error@-3 {{'nil' requires a contextual type}}
+
+}