[Generic signature builder] diagnose typealiases with the same name and different types.

At the moment, these are only done on demand, when the typealias is
actually used somewhere, because there's currently a recursive
validation loop that stops doing it more eagerly from working in many
cases.

Author: huonw

include/swift/AST/DiagnosticsSema.def

@@ -1581,6 +1581,9 @@ ERROR(requires_generic_param_same_type_does_not_conform,none,
       (Type, Identifier))
 ERROR(requires_same_concrete_type,none,
       "generic signature requires types %0 and %1 to be the same", (Type, Type))
+ERROR(protocol_typealias_conflict, none,
+      "typealias %0 requires types %1 and %2 to be the same",
+      (Identifier, Type, Type))
 
 ERROR(mutiple_layout_constraints,none,
       "multiple layout constraints cannot be used at the same time: %0 and %1",

lib/AST/GenericSignatureBuilder.cpp

@@ -864,14 +864,44 @@ auto GenericSignatureBuilder::PotentialArchetype::getNestedType(
 
     for (auto member : proto->lookupDirect(nestedName)) {
       PotentialArchetype *pa;
-      
+      std::function<void(Type, Type)> diagnoseMismatch;
+
       if (auto assocType = dyn_cast<AssociatedTypeDecl>(member)) {
         // Resolve this nested type to this associated type.
         pa = new PotentialArchetype(this, assocType);
+
+        diagnoseMismatch = [&](Type first, Type second) {
+          llvm_unreachable(
+              "associated type shouldn't result in new mismatches");
+        };
       } else if (auto alias = dyn_cast<TypeAliasDecl>(member)) {
         // Resolve this nested type to this type alias.
         pa = new PotentialArchetype(this, alias);
 
+        diagnoseMismatch = [&](Type first, Type second) {
+          if (auto NAT = dyn_cast<NameAliasType>(first.getPointer())) {
+            if (NAT->getDecl() == member) {
+              // If we have typealias T = Foo and Foo is completely concrete
+              // (e.g. Array<Int?>), then the subst will leave the NameAliasType
+              // intact. However, this means, if there's a
+              // concrete-type-mismatch at the top level, the default error
+              // message will be "ProtocolName.T (aka Foo)", but the "T" bit is
+              // already in the error message so it's better to print only
+              // "Foo".
+              first = NAT->getSinglyDesugaredType();
+            }
+          }
+          builder.Diags.diagnose(member->getLoc(),
+                                 diag::protocol_typealias_conflict,
+                                 member->getName(), first, second);
+        };
+
+        // FIXME (recursive decl validation): if the alias doesn't have an
+        // interface type when getNestedType is called while building a
+        // protocol's generic signature (i.e. during validation), then it'll
+        // fail completely, because building that alias's interface type
+        // requires the protocol to be validated. This seems to occur when the
+        // alias's RHS involves archetypes from the protocol.
         if (!alias->hasInterfaceType())
           builder.getLazyResolver()->resolveDeclSignature(alias);
         if (!alias->hasInterfaceType())
@@ -891,7 +921,7 @@ auto GenericSignatureBuilder::PotentialArchetype::getNestedType(
 
         builder.addSameTypeRequirement(ResolvedType::forNewTypeAlias(pa),
                                        builder.resolve(type),
-                                       sameNestedTypeSource);
+                                       sameNestedTypeSource, diagnoseMismatch);
       } else
         continue;
 
@@ -904,12 +934,14 @@ auto GenericSignatureBuilder::PotentialArchetype::getNestedType(
 
         // Produce a same-type constraint between the two same-named
         // potential archetypes.
-        builder.addSameTypeRequirement(pa, nested.front(), sameNestedTypeSource);
+        builder.addSameTypeRequirement(pa, nested.front(), sameNestedTypeSource,
+                                       diagnoseMismatch);
       } else {
         nested.push_back(pa);
 
         if (repNested) {
-          builder.addSameTypeRequirement(pa, repNested, sameNestedTypeSource);
+          builder.addSameTypeRequirement(pa, repNested, sameNestedTypeSource,
+                                         diagnoseMismatch);
         }
       }
 
@@ -1478,8 +1510,14 @@ bool GenericSignatureBuilder::addConformanceRequirement(PotentialArchetype *PAT,
         if (addInheritedRequirements(AssocType, AssocPA, Source, Visited))
           return true;
       }
-
-      continue;
+    } else if (auto TypeAlias = dyn_cast<TypeAliasDecl>(Member)) {
+        // FIXME: this should check that the typealias is makes sense (e.g. has
+        // the same/compatible type as typealiases in parent protocols) and
+        // set-up any same type requirements required. Forcing the PA to be
+        // created with getNestedType is currently worse than useless due to the
+        // 'recursive decl validation' FIXME in that function: it creates an
+        // unresolved PA that prints an error later.
+      (void)TypeAlias;
     }
 
     // FIXME: Requirement declarations.

test/Generics/protocol_type_aliases.swift

@@ -2,6 +2,9 @@
 // RUN: %target-typecheck-verify-swift -typecheck -debug-generic-signatures %s > %t.dump 2>&1
 // RUN: %FileCheck %s < %t.dump
 
+
+func sameType<T>(_: T.Type, _: T.Type) {}
+
 protocol P {
     associatedtype A
     typealias X = A
@@ -12,9 +15,9 @@ protocol Q {
 
 // CHECK-LABEL: .requirementOnNestedTypeAlias@
 // CHECK-NEXT: Requirements:
-// CHECK-NEXT:   τ_0_0 : Q [Explicit @ 19:51]
-// CHECK-NEXT:   τ_0_0[.Q].B : P [Explicit @ 19:51 -> Protocol requirement (Q)]
-// CHECK-NEXT:   τ_0_0[.Q].B[.P].A == Int [Explicit @ 19:62]
+// CHECK-NEXT:   τ_0_0 : Q [Explicit @ 22:51]
+// CHECK-NEXT:   τ_0_0[.Q].B : P [Explicit @ 22:51 -> Protocol requirement (Q)]
+// CHECK-NEXT:   τ_0_0[.Q].B[.P].A == Int [Explicit @ 22:62]
 // CHECK: Canonical generic signature: <τ_0_0 where τ_0_0 : Q, τ_0_0.B.A == Int>
 func requirementOnNestedTypeAlias<T>(_: T) where T: Q, T.B.X == Int {}
 
@@ -31,18 +34,83 @@ protocol Q2 {
 
 // CHECK-LABEL: .requirementOnConcreteNestedTypeAlias@
 // CHECK-NEXT: Requirements:
-// CHECK-NEXT:   τ_0_0 : Q2 [Explicit @ 39:59]
-// CHECK-NEXT:   τ_0_0[.Q2].B : P2 [Explicit @ 39:59 -> Protocol requirement (Q2)]
-// CHECK-NEXT:   τ_0_0[.Q2].C == S<T.B.A> [Explicit @ 39:69]
+// CHECK-NEXT:   τ_0_0 : Q2 [Explicit @ 42:59]
+// CHECK-NEXT:   τ_0_0[.Q2].B : P2 [Explicit @ 42:59 -> Protocol requirement (Q2)]
+// CHECK-NEXT:   τ_0_0[.Q2].C == S<T.B.A> [Explicit @ 42:69]
 // CHECK-NEXT:   τ_0_0[.Q2].B[.P2].X == S<T.B.A> [Nested type match]
 // CHECK: Canonical generic signature: <τ_0_0 where τ_0_0 : Q2, τ_0_0.C == S<τ_0_0.B.A>>
 func requirementOnConcreteNestedTypeAlias<T>(_: T) where T: Q2, T.C == T.B.X {}
 
 // CHECK-LABEL: .concreteRequirementOnConcreteNestedTypeAlias@
 // CHECK-NEXT: Requirements:
-// CHECK-NEXT:   τ_0_0 : Q2 [Explicit @ 48:67]
-// CHECK-NEXT:   τ_0_0[.Q2].B : P2 [Explicit @ 48:67 -> Protocol requirement (Q2)]
+// CHECK-NEXT:   τ_0_0 : Q2 [Explicit @ 51:67]
+// CHECK-NEXT:   τ_0_0[.Q2].B : P2 [Explicit @ 51:67 -> Protocol requirement (Q2)]
 // CHECK-NEXT:   τ_0_0[.Q2].C == τ_0_0[.Q2].B[.P2].A [Explicit]
 // CHECK-NEXT:   τ_0_0[.Q2].B[.P2].X == S<T.B.A> [Nested type match]
 // CHECK: Canonical generic signature: <τ_0_0 where τ_0_0 : Q2, τ_0_0.C == τ_0_0.B.A>
 func concreteRequirementOnConcreteNestedTypeAlias<T>(_: T) where T: Q2, S<T.C> == T.B.X {}
+
+
+// Incompatable concrete typealias types are flagged as such
+protocol P3 {
+    typealias T = Int // expected-error{{typealias 'T' requires types 'Int' and 'Float' to be the same}}
+}
+protocol Q3: P3 {
+    typealias T = Float
+}
+
+protocol P3_1 {
+    typealias T = Float // expected-error{{typealias 'T' requires types 'Float' and 'Int' to be the same}}
+}
+protocol Q3_1: P3, P3_1 {}
+
+// FIXME: these shouldn't be necessary to trigger the errors above, but are, due to
+// the 'recusive decl validation' FIXME in GenericSignatureBuilder.cpp.
+func useTypealias<T: Q3>(_: T, _: T.T) {}
+func useTypealias1<T: Q3_1>(_: T, _: T.T) {}
+
+// Subprotocols can force associated types in their parents to be concrete, and
+// this should be understood for types constrained by the subprotocols.
+protocol Q4: P {
+    typealias A = Int
+}
+protocol Q5: P {
+    typealias X = Int
+}
+
+// fully generic functions that manipulate the archetypes in a P
+func getP_A<T: P>(_: T.Type) -> T.A.Type { return T.A.self }
+func getP_X<T: P>(_: T.Type) -> T.X.Type { return T.X.self }
+
+// ... which we use to check if the compiler is following through the concrete
+// same-type constraints implied by the subprotocols.
+func checkQ4_A<T: Q4>(x: T.Type) { sameType(getP_A(x), Int.self) }
+func checkQ4_X<T: Q4>(x: T.Type) { sameType(getP_X(x), Int.self) }
+
+// FIXME: these do not work, seemingly mainly due to the 'recursive decl validation'
+// FIXME in GenericSignatureBuilder.cpp.
+/*
+func checkQ5_A<T: Q5>(x: T.Type) { sameType(getP_A(x), Int.self) }
+func checkQ5_X<T: Q5>(x: T.Type) { sameType(getP_X(x), Int.self) }
+*/
+
+
+// Typealiases happen to allow imposing same type requirements between parent
+// protocols
+protocol P6_1 {
+    associatedtype A
+}
+protocol P6_2 {
+    associatedtype B
+}
+protocol Q6: P6_1, P6_2 {
+    typealias A = B
+}
+
+func getP6_1_A<T: P6_1>(_: T.Type) -> T.A.Type { return T.A.self }
+func getP6_2_B<T: P6_2>(_: T.Type) -> T.B.Type { return T.B.self }
+
+func checkQ6<T: Q6>(x: T.Type) {
+    sameType(getP6_1_A(x), getP6_2_B(x))
+}
+