[Archetype builder] Simplify handling of typealiases in protocols.

PotentialArchetype::getNestedType() was effectively reimplementing a
simplified form of mapTypeOutOfContext(), missing some cases in the
process. Just use mapTypeOutOfContext() and resolveArchetype(). While
here, stop re-implementing the addSameType* operations; just call them
directly. With these changes, we no longer need the "typealias in
protocol is too complex" diagnostic.

Eliminates another use of getSelfTypeInContext().

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -564,9 +564,6 @@ ERROR(invalid_member_type_suggest,none,
 ERROR(invalid_member_reference,none,
       "%0 %1 is not a member type of %2",
       (DescriptiveDeclKind, Identifier, Type))
-ERROR(invalid_member_type_alias,none,
-      "typealias %0 is too complex to be used as a generic constraint; "
-      "use an associatedtype instead", (Identifier))
 ERROR(ambiguous_member_type,none,
       "ambiguous type name %0 in %1", (Identifier, Type))
 ERROR(no_module_type,none,

lib/AST/ArchetypeBuilder.cpp

@@ -426,51 +426,18 @@ auto ArchetypeBuilder::PotentialArchetype::getNestedType(
 
         auto type = alias->getUnderlyingType();
         SmallVector<Identifier, 4> identifiers;
-        
-        if (auto archetype = type->getAs<ArchetypeType>()) {
-          auto containingProtocol = dyn_cast<ProtocolDecl>(alias->getParent());
-          if (!containingProtocol) continue;
-          
-          // Go up archetype parents until we find our containing protocol.
-          while (archetype->getParent()) {
-            identifiers.push_back(archetype->getName());
-            archetype = archetype->getParent();
-          }
-          if (!archetype->isEqual(containingProtocol->getSelfTypeInContext()))
-            continue;
-        } else if (auto dependent = type->getAs<DependentMemberType>()) {
-          do {
-            identifiers.push_back(dependent->getName());
-            dependent = dependent->getBase()->getAs<DependentMemberType>();
-          } while (dependent);
+
+        // Map the type out of its context.
+        if (auto genericEnv = alias->getGenericEnvironmentOfContext()) {
+          type = genericEnv->mapTypeOutOfContext(alias->getModuleContext(),
+                                                 type);
         }
-        
-        if (identifiers.size()) {
-          // Go down our PAs until we find the referenced PA.
-          auto existingPA = this;
-          while (identifiers.size()) {
-            auto identifier = identifiers.back();
-            // If we end up looking for ourselves, don't recurse.
-            if (existingPA == this && identifier == nestedName) {
-              existingPA = pa;
-            } else {
-              existingPA = existingPA->getNestedType(identifier, builder);
-              existingPA = existingPA->getRepresentative();
-            }
-            identifiers.pop_back();
-          }
-          if (pa != existingPA) {
-            pa->Representative = existingPA;
-            pa->Representative->EquivalenceClass.push_back(pa);
-            pa->SameTypeSource = redundantSource;
-          }
-        } else if (type->hasArchetype()) {
-          // This is a complex type involving other associatedtypes, we'll fail
-          // to resolve and get a special diagnosis in finalize.
-          continue;
+
+        if (auto existingPA = builder.resolveArchetype(type)) {
+          builder.addSameTypeRequirementBetweenArchetypes(pa, existingPA,
+                                                          redundantSource);
         } else {
-          pa->ConcreteType = type;
-          pa->SameTypeSource = redundantSource;
+          builder.addSameTypeRequirementToConcrete(pa, type, redundantSource);
         }
       } else
         continue;
@@ -488,17 +455,8 @@ auto ArchetypeBuilder::PotentialArchetype::getNestedType(
           // case we want to make sure the associatedtype is frontmost to
           // generate generics/witness lists correctly, and the alias
           // will be unused/useless for generic constraining anyway.
-          for (auto existing : nested) {
-            existing->Representative = pa;
-            existing->Representative->EquivalenceClass.push_back(existing);
-            existing->SameTypeSource = redundantSource;
-          }
           nested.insert(nested.begin(), pa);
-          NestedTypes[nestedName] = nested;
         } else {
-          pa->Representative = existing->getRepresentative();
-          pa->Representative->EquivalenceClass.push_back(pa);
-          pa->SameTypeSource = redundantSource;
           nested.push_back(pa);
         }
       } else
@@ -1847,25 +1805,10 @@ ArchetypeBuilder::finalize(SourceLoc loc, bool allowConcreteGenericParams) {
     visitPotentialArchetypes([&](PotentialArchetype *pa) {
       // We only care about nested types that haven't been resolved.
       if (pa->getParent() == nullptr || pa->getResolvedAssociatedType() ||
+          pa->getTypeAliasDecl() ||
           /* FIXME: Should be able to handle this earlier */pa->getSuperclass())
         return;
 
-      // If a typealias with this name exists in one of the parent protocols,
-      // give a special diagnosis.
-      auto parentConformances = pa->getParent()->getConformsTo();
-      for (auto &conforms : parentConformances) {
-        for (auto member : conforms.first->getMembers()) {
-          auto typealias = dyn_cast<TypeAliasDecl>(member);
-          if (!typealias || typealias->getName() != pa->getName())
-            continue;
-
-          Context.Diags.diagnose(loc, diag::invalid_member_type_alias,
-                                 pa->getName());
-          pa->setInvalid();
-          return;
-        }
-      }
-      
       // Try to typo correct to a nested type name.
       Identifier correction = typoCorrectNestedType(pa);
       if (correction.empty()) {
@@ -2202,7 +2145,8 @@ GenericEnvironment *ArchetypeBuilder::getGenericEnvironment(
                                                     /*allowUnresolved=*/false);
       auto repInContext = genericEnv->mapTypeIntoContext(&getModule(), repDepTy);
       assert((inContext->isEqual(repInContext) ||
-              (inContext->hasError() && repInContext->hasError())) &&
+              inContext->hasError() ||
+              repInContext->hasError()) &&
              "Potential archetype mapping differs from representative!");
     });
   }

lib/Sema/TypeCheckGeneric.cpp

@@ -232,8 +232,12 @@ Type CompleteGenericTypeResolver::resolveDependentMemberType(
   // If the nested type comes from a type alias, use either the alias's
   // concrete type, or resolve its components down to another dependent member.
   if (auto alias = nestedPA->getTypeAliasDecl()) {
-    return TC.substMemberTypeWithBase(DC->getParentModule(), alias,
-                                      baseTy);
+    Type result = TC.substMemberTypeWithBase(DC->getParentModule(), alias,
+                                             baseTy);
+
+    // FIXME: Introduce a SubstitutedType so availability checking can use it.
+    // This is a horrible hack.
+    return SubstitutedType::get(alias->getAliasType(), result, TC.Context);
   }
 
   Identifier name = ref->getIdentifier();

test/decl/typealias/protocol.swift

@@ -110,7 +110,7 @@ protocol P2 {
     associatedtype B
 }
 
-func go3<T : P1, U : P2>(_ x: T) -> U where T.F == U.B { // expected-error {{typealias 'F' is too complex to be used as a generic constraint; use an associatedtype instead}} expected-error {{'F' is not a member type of 'T'}}
+func go3<T : P1, U : P2>(_ x: T) -> U where T.F == U.B {
 }
 
 // Specific diagnosis for things that look like Swift 2.x typealiases
@@ -179,3 +179,12 @@ struct S7 : P7 {
     _ = Y.self
   }
 }
+
+protocol P8 {
+  associatedtype B
+
+  @available(*, unavailable, renamed: "B")
+  typealias A = B // expected-note{{'A' has been explicitly marked unavailable here}}
+}
+
+func testP8<T: P8>(_: T) where T.A == Int { } // expected-error{{'A' has been renamed to 'B'}}{{34-35=B}}

test/stdlib/Renames.swift

@@ -59,7 +59,7 @@ func _Collection() {
 }
 
 func _Collection<C : Collection>(c: C) {
-  func fn<T : Collection, U>(_: T, _: U) where T.Generator == U {} // expected-error {{'T' does not have a member type named 'Generator'; did you mean 'Iterator'?}} {{50-59=Iterator}} {{none}} 
+  func fn<T : Collection, U>(_: T, _: U) where T.Generator == U {} // expected-error {{'Generator' has been renamed to 'Iterator'}} {{50-59=Iterator}} {{none}}
   _ = c.generate() // expected-error {{'generate()' has been renamed to 'makeIterator()'}} {{9-17=makeIterator}} {{none}}
   _ = c.underestimateCount() // expected-error {{'underestimateCount()' has been replaced by 'underestimatedCount'}} {{9-27=underestimatedCount}} {{27-29=}} {{none}}
   _ = c.split(1) { _ in return true} // expected-error {{split(maxSplits:omittingEmptySubsequences:whereSeparator:) instead}} {{none}}

validation-test/compiler_crashers/28448-dist-nested-type-should-have-matched-associated-type-failed.swift renamed to validation-test/compiler_crashers_fixed/28448-dist-nested-type-should-have-matched-associated-type-failed.swift

@@ -5,6 +5,5 @@
 // See https://swift.org/LICENSE.txt for license information
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 
-// RUN: not --crash %target-swift-frontend %s -emit-ir
-// REQUIRES: asserts
+// RUN: not %target-swift-frontend %s -emit-ir
 extension A{func c:f.c:typealias e:A{}}protocol A{typealias f{}typealias e

validation-test/compiler_crashers/28468-segfault-0xd09050-0xd08dfd-0xbe9d76-0xbeb154.swift renamed to validation-test/compiler_crashers_fixed/28468-segfault-0xd09050-0xd08dfd-0xbe9d76-0xbeb154.swift

@@ -5,5 +5,5 @@
 // See https://swift.org/LICENSE.txt for license information
 // See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 
-// RUN: not --crash %target-swift-frontend %s -emit-ir
+// RUN: not %target-swift-frontend %s -emit-ir
 protocol A{typealias B>typealias B<a>:a}extension A