Merge pull request #7364 from DougGregor/structural-same-type

swift-ci · web-flow · commit 41a0f6dbbd22 · 2017-02-09T15:28:13.000-08:00
diff --git a/include/swift/AST/ArchetypeBuilder.h b/include/swift/AST/ArchetypeBuilder.h
@@ -169,10 +169,15 @@ class ArchetypeBuilder {
                                 Type Superclass,
                                 RequirementSource Source);
 
-  /// \brief Add a new same-type requirement specifying that the given potential
-  /// archetypes should map to the equivalent archetype.
-  bool addSameTypeRequirement(Type T1, Type T2, RequirementSource Source,
-                              PotentialArchetype *basePA = nullptr);
+  /// \brief Add a new same-type requirement specifying that the given two
+  /// types should be the same.
+  ///
+  /// \param diagnoseMismatch Callback invoked when the types in the same-type
+  /// requirement mismatch.
+  bool addSameTypeRequirement(
+                        Type T1, Type T2, RequirementSource Source,
+                        PotentialArchetype *basePA,
+                        llvm::function_ref<void(Type, Type)> diagnoseMismatch);
 
   /// Add the requirements placed on the given abstract type parameter
   /// to the given potential archetype.
@@ -251,9 +256,12 @@ class ArchetypeBuilder {
   ///
   /// Adding an already-checked requirement cannot fail. This is used to
   /// re-inject requirements from outer contexts.
-  void addRequirement(const Requirement &req, RequirementSource source);
+  ///
+  /// \returns true if this requirement makes the set of requirements
+  /// inconsistent, in which case a diagnostic will have been issued.
+  bool addRequirement(const Requirement &req, RequirementSource source);
 
-  void addRequirement(const Requirement &req, RequirementSource source,
+  bool addRequirement(const Requirement &req, RequirementSource source,
                       PotentialArchetype *basePA,
                       llvm::SmallPtrSetImpl<ProtocolDecl *> &Visited);
 
diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def
@@ -1579,6 +1579,9 @@ ERROR(requires_same_type_conflict,none,
 ERROR(requires_generic_param_same_type_does_not_conform,none,
       "same-type constraint type %0 does not conform to required protocol %1",
       (Type, Identifier))
+ERROR(requires_same_concrete_type,none,
+      "generic signature requires types %0 and %1 to be the same", (Type, Type))
+
 ERROR(mutiple_layout_constraints,none,
       "multiple layout constraints cannot be used at the same time: %0 and %1",
       (LayoutConstraint, LayoutConstraint))
diff --git a/include/swift/AST/TypeMatcher.h b/include/swift/AST/TypeMatcher.h
diff --git a/lib/AST/ArchetypeBuilder.cpp b/lib/AST/ArchetypeBuilder.cpp
@@ -24,6 +24,7 @@
 #include "swift/AST/Module.h"
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/ProtocolConformance.h"
+#include "swift/AST/TypeMatcher.h"
 #include "swift/AST/TypeRepr.h"
 #include "swift/AST/TypeWalker.h"
 #include "swift/Basic/Defer.h"
@@ -1315,13 +1316,17 @@ bool ArchetypeBuilder::addSameTypeRequirementBetweenArchetypes(
   Type concrete2 = T2->getConcreteType();
   
   if (concrete1 && concrete2) {
-    if (!concrete1->isEqual(concrete2)) {
-      Diags.diagnose(Source.getLoc(), diag::requires_same_type_conflict,
-                     T1->getDependentType(/*FIXME: */{ }, true), concrete1,
-                     concrete2);
-      return true;
-      
-    }
+    bool mismatch =
+      addSameTypeRequirement(concrete1, concrete2, Source, nullptr,
+        [&](Type type1, Type type2) {
+          Diags.diagnose(Source.getLoc(),
+                         diag::requires_same_type_conflict,
+                         T1->getDependentType(/*FIXME: */{ }, true), type1,
+                         type2);
+
+        });
+
+    if (mismatch) return true;
   } else if (concrete1) {
     assert(!T2->ConcreteType
            && "already formed archetype for concrete-constrained parameter");
@@ -1389,12 +1394,17 @@ bool ArchetypeBuilder::addSameTypeRequirementToConcrete(
   // If we've already been bound to a type, we're either done, or we have a
   // problem.
   if (auto oldConcrete = T->getConcreteType()) {
-    if (!oldConcrete->isEqual(Concrete)) {
-      Diags.diagnose(Source.getLoc(), diag::requires_same_type_conflict,
-                     T->getDependentType(/*FIXME: */{ }, true), oldConcrete,
-                     Concrete);
-      return true;
-    }
+    bool mismatch =
+      addSameTypeRequirement(oldConcrete, Concrete, Source, nullptr,
+        [&](Type type1, Type type2) {
+          Diags.diagnose(Source.getLoc(),
+                         diag::requires_same_type_conflict,
+                         T->getDependentType(/*FIXME: */{ }, true), type1,
+                         type2);
+
+        });
+
+    if (mismatch) return true;
     return false;
   }
   
@@ -1458,27 +1468,51 @@ bool ArchetypeBuilder::addSameTypeRequirementToConcrete(
   return false;
 }
 
-bool ArchetypeBuilder::addSameTypeRequirement(Type Reqt1, Type Reqt2,
-                                              RequirementSource Source,
-                                              PotentialArchetype *basePA) {
-  // Find the potential archetypes.
-  PotentialArchetype *T1 = resolveArchetype(Reqt1, basePA);
-  PotentialArchetype *T2 = resolveArchetype(Reqt2, basePA);
+bool ArchetypeBuilder::addSameTypeRequirement(
+                        Type type1, Type type2,
+                        RequirementSource source,
+                        PotentialArchetype *basePA,
+                        llvm::function_ref<void(Type, Type)> diagnoseMismatch) {
+  // Local class to handle matching the two sides of the same-type constraint.
+  class ReqTypeMatcher : public TypeMatcher<ReqTypeMatcher> {
+    ArchetypeBuilder &builder;
+    RequirementSource source;
+    PotentialArchetype *basePA;
+    llvm::function_ref<void(Type, Type)> diagnoseMismatch;
+
+  public:
+    ReqTypeMatcher(ArchetypeBuilder &builder,
+                   RequirementSource source,
+                   PotentialArchetype *basePA,
+                   llvm::function_ref<void(Type, Type)> diagnoseMismatch)
+      : builder(builder), source(source), basePA(basePA),
+        diagnoseMismatch(diagnoseMismatch) { }
+
+    bool mismatch(TypeBase *firstType, TypeBase *secondType,
+                  Type sugaredFirstType) {
+      // Find the potential archetypes.
+      PotentialArchetype *pa1 = builder.resolveArchetype(firstType, basePA);
+      PotentialArchetype *pa2 = builder.resolveArchetype(secondType, basePA);
+
+      // If both sides of the requirement are type parameters, equate them.
+      if (pa1 && pa2)
+        return !builder.addSameTypeRequirementBetweenArchetypes(pa1, pa2,
+                                                                source);
+
+      // If just one side is a type parameter, map it to a concrete type.
+      if (pa1)
+        return !builder.addSameTypeRequirementToConcrete(pa1, secondType,
+                                                         source);
+      if (pa2)
+        return !builder.addSameTypeRequirementToConcrete(pa2, sugaredFirstType,
+                                                         source);
+
+      diagnoseMismatch(sugaredFirstType, secondType);
+      return false;
+    }
+  } matcher(*this, source, basePA, diagnoseMismatch);
 
-  // Require that at least one side of the requirement be a potential archetype.
-  if (!T1 && !T2) {
-    Diags.diagnose(Source.getLoc(), diag::requires_no_same_type_archetype);
-    return true;
-  }
-  
-  // If both sides of the requirement are open archetypes, combine them.
-  if (T1 && T2)
-    return addSameTypeRequirementBetweenArchetypes(T1, T2, Source);
-  
-  // Otherwise, we're binding an open archetype.
-  if (T1)
-    return addSameTypeRequirementToConcrete(T1, Reqt2, Source);
-  return addSameTypeRequirementToConcrete(T2, Reqt1, Source);
+  return !matcher.match(type1, type2);
 }
 
 // Local function to mark the given associated type as recursive,
@@ -1623,46 +1657,58 @@ bool ArchetypeBuilder::addRequirement(const RequirementRepr &Req) {
   }
 
   case RequirementReprKind::SameType:
-    return addSameTypeRequirement(Req.getFirstType(), 
-                                  Req.getSecondType(),
-                                  RequirementSource(RequirementSource::Explicit,
-                                                    Req.getEqualLoc()));
+    // Require that at least one side of the requirement contain a type
+    // parameter.
+    if (!Req.getFirstType()->hasTypeParameter() &&
+        !Req.getSecondType()->hasTypeParameter()) {
+      Diags.diagnose(Req.getEqualLoc(), diag::requires_no_same_type_archetype)
+        .highlight(Req.getFirstTypeLoc().getSourceRange())
+        .highlight(Req.getSecondTypeLoc().getSourceRange());
+      return true;
+    }
+
+    return addRequirement(Requirement(RequirementKind::SameType,
+                                      Req.getFirstType(),
+                                      Req.getSecondType()),
+                          RequirementSource(RequirementSource::Explicit,
+                                            Req.getEqualLoc()));
   }
 
   llvm_unreachable("Unhandled requirement?");
 }
 
-void ArchetypeBuilder::addRequirement(const Requirement &req, 
+bool ArchetypeBuilder::addRequirement(const Requirement &req,
                                       RequirementSource source) {
   llvm::SmallPtrSet<ProtocolDecl *, 8> Visited;
-  addRequirement(req, source, nullptr, Visited);
+  return addRequirement(req, source, nullptr, Visited);
 }
 
-void ArchetypeBuilder::addRequirement(
+bool ArchetypeBuilder::addRequirement(
     const Requirement &req, RequirementSource source,
     PotentialArchetype *basePA,
     llvm::SmallPtrSetImpl<ProtocolDecl *> &Visited) {
   switch (req.getKind()) {
   case RequirementKind::Superclass: {
+    // FIXME: Diagnose this.
     PotentialArchetype *pa = resolveArchetype(req.getFirstType(), basePA);
-    if (!pa) return;
+    if (!pa) return false;
 
     assert(req.getSecondType()->getClassOrBoundGenericClass());
-    addSuperclassRequirement(pa, req.getSecondType(), source);
-    return;
+    return addSuperclassRequirement(pa, req.getSecondType(), source);
   }
 
   case RequirementKind::Layout: {
+    // FIXME: Diagnose this.
     PotentialArchetype *pa = resolveArchetype(req.getFirstType(), basePA);
-    if (!pa) return;
+    if (!pa) return false;
 
-    (void)addLayoutRequirement(pa, req.getLayoutConstraint(), source);
-    return;
+    return addLayoutRequirement(pa, req.getLayoutConstraint(), source);
   }
 
   case RequirementKind::Conformance: {
+    // FIXME: Diagnose this.
     PotentialArchetype *pa = resolveArchetype(req.getFirstType(), basePA);
-    if (!pa) return;
+    if (!pa) return false;
 
     SmallVector<ProtocolDecl *, 4> conformsTo;
     (void)req.getSecondType()->isExistentialType(conformsTo);
@@ -1673,16 +1719,21 @@ void ArchetypeBuilder::addRequirement(
         markPotentialArchetypeRecursive(pa, proto, source);
         continue;
       }
-      (void)addConformanceRequirement(pa, proto, source, Visited);
+      if (addConformanceRequirement(pa, proto, source, Visited)) return true;
     }
 
-    return;
+    return false;
   }
 
   case RequirementKind::SameType:
-    addSameTypeRequirement(req.getFirstType(), req.getSecondType(), source,
-                           basePA);
-    return;
+    return addSameTypeRequirement(
+             req.getFirstType(), req.getSecondType(), source, basePA,
+             [&](Type type1, Type type2) {
+               if (source.getLoc().isValid())
+                 Diags.diagnose(source.getLoc(),
+                                diag::requires_same_concrete_type, type1,
+                                type2);
+             });
   }
 
   llvm_unreachable("Unhandled requirement?");
diff --git a/lib/Sema/CSDiag.cpp b/lib/Sema/CSDiag.cpp
@@ -1186,11 +1186,13 @@ static bool findGenericSubstitutions(DeclContext *dc, Type paramType,
     GenericVisitor(DeclContext *dc, TypeSubstitutionMap &archetypesMap)
       : dc(dc), archetypesMap(archetypesMap) {}
     
-    bool mismatch(TypeBase *paramType, TypeBase *argType) {
+    bool mismatch(TypeBase *paramType, TypeBase *argType,
+                  Type sugaredFirstType) {
       return paramType->isEqual(argType);
     }
     
-    bool mismatch(SubstitutableType *paramType, TypeBase *argType) {
+    bool mismatch(SubstitutableType *paramType, TypeBase *argType,
+                  Type sugaredFirstType) {
       Type type = paramType;
       if (type->is<GenericTypeParamType>()) {
         assert(dc);
diff --git a/lib/Sema/TypeCheckProtocol.cpp b/lib/Sema/TypeCheckProtocol.cpp
@@ -3270,7 +3270,8 @@ ConformanceChecker::inferTypeWitnessesViaValueWitness(ValueDecl *req,
       : Conformance(conformance), Inferred(inferred) { }
 
     /// Structural mismatches imply that the witness cannot match.
-    bool mismatch(TypeBase *firstType, TypeBase *secondType) {
+    bool mismatch(TypeBase *firstType, TypeBase *secondType,
+                  Type sugaredFirstType) {
       // If either type hit an error, don't stop yet.
       if (firstType->hasError() || secondType->hasError())
         return true;
@@ -3281,7 +3282,7 @@ ConformanceChecker::inferTypeWitnessesViaValueWitness(ValueDecl *req,
 
     /// Deduce associated types from dependent member types in the witness.
     bool mismatch(DependentMemberType *firstDepMember,
-                  TypeBase *secondType) {
+                  TypeBase *secondType, Type sugaredFirstType) {
       // If the second type is an error, don't look at it further.
       if (secondType->hasError())
         return true;
@@ -3298,7 +3299,7 @@ ConformanceChecker::inferTypeWitnessesViaValueWitness(ValueDecl *req,
 
     /// FIXME: Recheck the type of Self against the second type?
     bool mismatch(GenericTypeParamType *selfParamType,
-                  TypeBase *secondType) {
+                  TypeBase *secondType, Type sugaredFirstType) {
       return true;
     }
   };
diff --git a/test/Constraints/same_types.swift b/test/Constraints/same_types.swift
@@ -72,7 +72,7 @@ func test4<T: Barrable>(_ t: T) -> Y where T.Bar == Y {
 }
 
 func fail3<T: Barrable>(_ t: T) -> X
-  where T.Bar == X { // expected-error{{'X' does not conform to required protocol 'Fooable'}}
+  where T.Bar == X { // expected-error {{'X' does not conform to required protocol 'Fooable'}}
   return t.bar // expected-error{{cannot convert return expression of type 'T.Bar' to return type 'X'}}
 }
 
@@ -99,7 +99,7 @@ func fail4<T: Barrable>(_ t: T) -> (Y, Z)
 func fail5<T: Barrable>(_ t: T) -> (Y, Z)
   where
   T.Bar.Foo == Z,
-  T.Bar == Y { // expected-error 2{{generic parameter 'T.Bar.Foo' cannot be equal to both 'Z' and 'Y.Foo' (aka 'X')}}
+  T.Bar == Y { // expected-error 2{{generic parameter 'T.Bar.Foo' cannot be equal to both 'Z' and 'X'}}
   return (t.bar, t.bar.foo) // expected-error{{cannot convert return expression of type 'X' to return type 'Z'}}
 }
 
@@ -161,7 +161,7 @@ struct S1<T : P> {
 S1<Q>().foo(x: 1, y: 2)
 
 struct S2<T : P> where T.A == T.B {
-  func foo<X, Y>(x: X, y: Y) where X == T.A, Y == T.B {  // expected-error 2 {{same-type requirement makes generic parameters 'X' and 'Y' equivalent}}
+  func foo<X, Y>(x: X, y: Y) where X == T.A, Y == T.B {  // expected-error 2{{same-type requirement makes generic parameters 'X' and 'Y' equivalent}}
     print(X.self)
     print(Y.self)
     print(x)
@@ -201,5 +201,45 @@ struct S4<T : P> {
 
 S4<QQ>().foo(x: SS())
 
+// rdar://problem/29333056 - allow deeper matching of same-type constraints.
+struct X1<A, B> { }
+
+protocol P1 {
+  associatedtype Assoc
+}
+
+func structuralSameType1<A: P1, B: P1, T, U, V, W>(_: A, _: B, _: T, _: U, _: V, _: W)
+  where A.Assoc == X1<T, U>, B.Assoc == X1<V, W>, A.Assoc == B.Assoc { }
+// expected-error@-1{{same-type requirement makes generic parameters 'T' and 'V' equivalent}}
+// expected-error@-2{{same-type requirement makes generic parameters 'T' and 'V' equivalent}}
+// expected-error@-3{{same-type requirement makes generic parameters 'U' and 'W' equivalent}}
+// expected-error@-4{{same-type requirement makes generic parameters 'U' and 'W' equivalent}}
+
+typealias Tuple2<T, U> = (T, U)
+
+func structuralSameType2<A: P1, B: P1, T, U, V, W>(_: A, _: B, _: T, _: U, _: V, _: W)
+  where A.Assoc == Tuple2<T, U>, B.Assoc == Tuple2<V, W>, A.Assoc == B.Assoc { }
+// expected-error@-1{{same-type requirement makes generic parameters 'T' and 'V' equivalent}}
+// expected-error@-2{{same-type requirement makes generic parameters 'T' and 'V' equivalent}}
+// expected-error@-3{{same-type requirement makes generic parameters 'U' and 'W' equivalent}}
+// expected-error@-4{{same-type requirement makes generic parameters 'U' and 'W' equivalent}}
+
+func structuralSameType3<T, U, V, W>(_: T, _: U, _: V, _: W)
+  where X1<T, U> == X1<V, W> { }
+// expected-error@-1{{same-type requirement makes generic parameters 'T' and 'V' equivalent}}
+// expected-error@-2{{same-type requirement makes generic parameters 'T' and 'V' equivalent}}
+// expected-error@-3{{same-type requirement makes generic parameters 'U' and 'W' equivalent}}
+// expected-error@-4{{same-type requirement makes generic parameters 'U' and 'W' equivalent}}
+
+protocol P2 {
+  associatedtype Assoc1
+  associatedtype Assoc2
+}
+
+func structuralSameTypeRecursive1<T: P2, U>(_: T, _: U)
+  where T.Assoc1 == Tuple2<T.Assoc1, U> // expected-error 2{{same-type constraint 'T.Assoc1' == '(T.Assoc1, U)' is recursive}}
+{ }
+
+
 // FIXME: Remove -verify-ignore-unknown.
 // <unknown>:0: error: unexpected error produced: generic parameter τ_0_0.Bar.Foo cannot be equal to both 'Y.Foo' (aka 'X') and 'Z'
diff --git a/test/attr/attr_specialize.swift b/test/attr/attr_specialize.swift
