Sema: Add diagnostics for ShapeOf constraint

Author: slavapestov

include/swift/AST/DiagnosticsSema.def

@@ -2104,6 +2104,9 @@ NOTE(type_does_not_inherit_or_conform_requirement,none,
 ERROR(types_not_equal,none,
       "%0 requires the types %1 and %2 be equivalent",
       (Type, Type, Type))
+ERROR(types_not_same_shape,none,
+      "%0 requires the type packs %1 and %2 have the same shape",
+      (Type, Type, Type))
 ERROR(type_does_not_conform_owner,none,
       "%0 requires that %1 conform to %2", (Type, Type, Type))
 ERROR(type_does_not_conform_in_decl_ref,none,
@@ -2133,6 +2136,12 @@ ERROR(types_not_equal_decl,none,
 ERROR(types_not_equal_in_decl_ref,none,
       "referencing %0 %1 on %2 requires the types %3 and %4 be equivalent",
       (DescriptiveDeclKind, DeclName, Type, Type, Type))
+ERROR(types_not_same_shape_decl,none,
+      "%0 %1 requires the type packs %2 and %3 have the same shape",
+      (DescriptiveDeclKind, DeclName, Type, Type))
+ERROR(types_not_same_shape_in_decl_ref,none,
+      "referencing %0 %1 on %2 requires the type packs %3 and %4 have the same shape",
+      (DescriptiveDeclKind, DeclName, Type, Type, Type))
 ERROR(types_not_inherited_decl,none,
       "%0 %1 requires that %2 inherit from %3",
       (DescriptiveDeclKind, DeclName, Type, Type))
@@ -2155,6 +2164,10 @@ NOTE(candidate_types_equal_requirement,none,
      "candidate requires that the types %0 and %1 be equivalent "
      "(requirement specified as %2 == %3)",
      (Type, Type, Type, Type))
+NOTE(candidate_types_same_shape_requirement,none,
+     "candidate requires that the type packs %0 and %1 have the same shape "
+     "(requirement specified as %2.shape == %3.shape)",
+     (Type, Type, Type, Type))
 NOTE(candidate_types_inheritance_requirement,none,
      "candidate requires that %1 inherit from %2 "
      "(requirement specified as %2 : %3)",

include/swift/Sema/CSFix.h

@@ -93,6 +93,10 @@ enum class FixKind : uint8_t {
   /// and assume that types are equal.
   SkipSameTypeRequirement,
 
+  /// Skip same-shape generic requirement constraint,
+  /// and assume that pack types have the same shape.
+  SkipSameShapeRequirement,
+
   /// Skip superclass generic requirement constraint,
   /// and assume that types are related.
   SkipSuperclassRequirement,
@@ -655,6 +659,34 @@ class SkipSameTypeRequirement final : public ConstraintFix {
   }
 };
 
+/// Skip same-shape generic requirement constraint,
+/// and assume that types are equal.
+class SkipSameShapeRequirement final : public ConstraintFix {
+  Type LHS, RHS;
+
+  SkipSameShapeRequirement(ConstraintSystem &cs, Type lhs, Type rhs,
+                           ConstraintLocator *locator)
+      : ConstraintFix(cs, FixKind::SkipSameShapeRequirement, locator), LHS(lhs),
+        RHS(rhs) {}
+
+public:
+  std::string getName() const override {
+    return "skip same-shape generic requirement";
+  }
+
+  bool diagnose(const Solution &solution, bool asNote = false) const override;
+
+  Type lhsType() { return LHS; }
+  Type rhsType() { return RHS; }
+
+  static SkipSameShapeRequirement *create(ConstraintSystem &cs, Type lhs,
+                                          Type rhs, ConstraintLocator *locator);
+
+  static bool classof(ConstraintFix *fix) {
+    return fix->getKind() == FixKind::SkipSameTypeRequirement;
+  }
+};
+
 /// Skip 'superclass' generic requirement constraint,
 /// and assume that types are equal.
 class SkipSuperclassRequirement final : public ConstraintFix {

lib/Sema/CSDiagnostics.h

@@ -435,6 +435,40 @@ class SameTypeRequirementFailure final : public RequirementFailure {
   }
 };
 
+/// Diagnose failures related to same-shape generic requirements, e.g.
+/// ```swift
+/// func foo<T..., U...>(t: T..., u: U...) -> (T, U)... {}
+/// func bar<T..., U...>(t: T..., u: U...) {
+///   foo(t: t..., u: u...)
+/// }
+/// ```
+///
+/// `S.T` is not the same type as `Int`, which is required by `foo`.
+class SameShapeRequirementFailure final : public RequirementFailure {
+public:
+  SameShapeRequirementFailure(const Solution &solution, Type lhs, Type rhs,
+                              ConstraintLocator *locator)
+      : RequirementFailure(solution, lhs, rhs, locator) {
+#ifndef NDEBUG
+    auto reqElt = locator->castLastElementTo<LocatorPathElt::AnyRequirement>();
+    assert(reqElt.getRequirementKind() == RequirementKind::SameShape);
+#endif
+  }
+
+protected:
+  DiagOnDecl getDiagnosticOnDecl() const override {
+    return diag::types_not_same_shape_decl;
+  }
+
+  DiagInReference getDiagnosticInRereference() const override {
+    return diag::types_not_same_shape_in_decl_ref;
+  }
+
+  DiagAsNote getDiagnosticAsNote() const override {
+    return diag::candidate_types_same_shape_requirement;
+  }
+};
+
 /// Diagnose failures related to superclass generic requirements, e.g.
 /// ```swift
 /// class A {

lib/Sema/CSFix.cpp

@@ -465,6 +465,18 @@ SkipSameTypeRequirement::create(ConstraintSystem &cs, Type lhs, Type rhs,
   return new (cs.getAllocator()) SkipSameTypeRequirement(cs, lhs, rhs, locator);
 }
 
+bool SkipSameShapeRequirement::diagnose(const Solution &solution,
+                                       bool asNote) const {
+  SameShapeRequirementFailure failure(solution, LHS, RHS, getLocator());
+  return failure.diagnose(asNote);
+}
+
+SkipSameShapeRequirement *
+SkipSameShapeRequirement::create(ConstraintSystem &cs, Type lhs, Type rhs,
+                                 ConstraintLocator *locator) {
+  return new (cs.getAllocator()) SkipSameShapeRequirement(cs, lhs, rhs, locator);
+}
+
 bool SkipSuperclassRequirement::diagnose(const Solution &solution,
                                          bool asNote) const {
   SuperclassRequirementFailure failure(solution, LHS, RHS, getLocator());

lib/Sema/CSSimplify.cpp

@@ -4222,16 +4222,14 @@ static ConstraintFix *fixRequirementFailure(ConstraintSystem &cs, Type type1,
   auto *reqLoc = cs.getConstraintLocator(anchor, path);
 
   switch (req.getRequirementKind()) {
-  case RequirementKind::SameShape:
-    llvm_unreachable("Same-shape requirement not supported here");
-
-  case RequirementKind::SameType: {
+  case RequirementKind::SameType:
     return SkipSameTypeRequirement::create(cs, type1, type2, reqLoc);
-  }
 
-  case RequirementKind::Superclass: {
+  case RequirementKind::SameShape:
+    return SkipSameShapeRequirement::create(cs, type1, type2, reqLoc);
+
+  case RequirementKind::Superclass:
     return SkipSuperclassRequirement::create(cs, type1, type2, reqLoc);
-  }
 
   case RequirementKind::Layout:
   case RequirementKind::Conformance:
@@ -13642,6 +13640,7 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
 
   case FixKind::AddConformance:
   case FixKind::SkipSameTypeRequirement:
+  case FixKind::SkipSameShapeRequirement:
   case FixKind::SkipSuperclassRequirement: {
     return recordFix(fix, assessRequirementFailureImpact(*this, type1,
                                                          fix->getLocator()))

lib/Sema/TypeCheckProtocol.cpp

@@ -910,6 +910,13 @@ static Optional<RequirementMatch> findMissingGenericRequirementForSolutionFix(
     missingType = requirementFix->rhsType();
     break;
   }
+  case FixKind::SkipSameShapeRequirement: {
+    requirementKind = RequirementKind::SameShape;
+    auto requirementFix = (SkipSameShapeRequirement *)fix;
+    type = requirementFix->lhsType();
+    missingType = requirementFix->rhsType();
+    break;
+  }
   case FixKind::SkipSuperclassRequirement: {
     requirementKind = RequirementKind::Superclass;
     auto requirementFix = (SkipSuperclassRequirement *)fix;

test/Constraints/variadic_generic_constraints.swift

@@ -56,11 +56,21 @@ takesParallelSequences(t: Array<String>(), Set<Int>(), u: Array<Int>(), Set<Stri
 // Same-shape requirements
 
 func zip<T..., U...>(t: T..., u: U...) -> ((T, U)...) {}
+// expected-note@-1 {{where 'T' = 'U', 'U' = 'Pack{T...}'}}
 
 let _ = zip()  // ok
 let _ = zip(t: 1, u: "hi")  // ok
 let _ = zip(t: 1, 2, u: "hi", "hello")  // ok
 let _ = zip(t: 1, 2, 3, u: "hi", "hello", "greetings")  // ok
 
 // FIXME: Bad diagnostic
-let _ = zip(t: 1, u: "hi", "hello", "greetings")  // expected-error {{type of expression is ambiguous without more context}}
+let _ = zip(t: 1, u: "hi", "hello", "greetings")  // expected-error {{type of expression is ambiguous without more context}}
+
+func goodCallToZip<T..., U...>(t: T..., u: U...) where ((T, U)...): Any {
+  _ = zip(t: t..., u: u...)
+}
+
+func badCallToZip<T..., U...>(t: T..., u: U...) {
+  _ = zip(t: t..., u: u...)
+  // expected-error@-1 {{global function 'zip(t:u:)' requires the type packs 'U' and 'Pack{T...}' have the same shape}}
+}