[GSB] Record unresolved potential archetypes as delayed requirements.

Whenever we form a potential archetype that is unresolved (because it
names a member wasn't known at the time the potential archetype was
formed), create a corresponding delayed requirement to resolve the
potential archetype. This ensures that all potential archetypes get a
chance to be resolve, fixing the

  nested type should have matched associated type

assertion in rdar://problem/31401161 (and others).

Author: DougGregor

include/swift/AST/GenericSignatureBuilder.h

@@ -265,6 +265,10 @@ class GenericSignatureBuilder {
   GenericSignatureBuilder(const GenericSignatureBuilder &) = delete;
   GenericSignatureBuilder &operator=(const GenericSignatureBuilder &) = delete;
 
+  /// Record that the given potential archetype is unresolved, so we know to
+  /// resolve it later.
+  void recordUnresolvedType(PotentialArchetype *unresolvedPA);
+
   /// When a particular requirement cannot be resolved due to, e.g., a
   /// currently-unresolvable or nested type, this routine should be
   /// called to cope with the unresolved requirement.
@@ -294,6 +298,9 @@ class GenericSignatureBuilder {
                                              ProtocolDecl *Proto,
                                              const RequirementSource *Source);
 
+  /// Try to resolve the given unresolved potential archetype.
+  ConstraintResult resolveUnresolvedType(PotentialArchetype *pa);
+
 public:
   /// \brief Add a new same-type requirement between two fully resolved types
   /// (output of \c GenericSignatureBuilder::resolve).
@@ -1325,13 +1332,7 @@ class GenericSignatureBuilder::PotentialArchetype {
 
   /// \brief Construct a new potential archetype for an unresolved
   /// associated type.
-  PotentialArchetype(PotentialArchetype *parent, Identifier name)
-    : parentOrBuilder(parent), identifier(name), isUnresolvedNestedType(true),
-      IsRecursive(false), Invalid(false),
-      DiagnosedRename(false)
-  { 
-    assert(parent != nullptr && "Not an associated type?");
-  }
+  PotentialArchetype(PotentialArchetype *parent, Identifier name);
 
   /// \brief Construct a new potential archetype for an associated type.
   PotentialArchetype(PotentialArchetype *parent, AssociatedTypeDecl *assocType)
@@ -1688,6 +1689,9 @@ class GenericSignatureBuilder::DelayedRequirement {
 
     /// A same-type requirement.
     SameType,
+
+    /// An unresolved potential archetype.
+    Unresolved,
   };
 
   Kind kind;

lib/AST/GenericSignatureBuilder.cpp

@@ -1025,6 +1025,16 @@ bool FloatingRequirementSource::isRecursive(
   return false;
 }
 
+PotentialArchetype::PotentialArchetype(PotentialArchetype *parent,
+                                       Identifier name)
+  : parentOrBuilder(parent), identifier(name), isUnresolvedNestedType(true),
+  IsRecursive(false), Invalid(false),
+  DiagnosedRename(false)
+{
+  assert(parent != nullptr && "Not an associated type?");
+  getBuilder()->recordUnresolvedType(this);
+}
+
 GenericSignatureBuilder::PotentialArchetype::~PotentialArchetype() {
   ++NumPotentialArchetypes;
 
@@ -1202,6 +1212,15 @@ void EquivalenceClass::dump() const {
   dump(llvm::errs());
 }
 
+void GenericSignatureBuilder::recordUnresolvedType(
+                                          PotentialArchetype *unresolvedPA) {
+  ++Impl->NumUnresolvedNestedTypes;
+
+  Impl->DelayedRequirements.push_back(
+    {DelayedRequirement::Unresolved, unresolvedPA, RequirementRHS(),
+     FloatingRequirementSource::forAbstract()});
+}
+
 ConstraintResult GenericSignatureBuilder::handleUnresolvedRequirement(
                                    RequirementKind kind,
                                    UnresolvedType lhs,
@@ -1770,7 +1789,6 @@ PotentialArchetype *PotentialArchetype::getNestedArchetypeAnchor(
   auto &nested = NestedTypes[name];
   if (nested.empty()) {
     nested.push_back(new PotentialArchetype(this, name));
-    ++builder.Impl->NumUnresolvedNestedTypes;
 
     auto rep = getRepresentative();
     if (rep != this) {
@@ -2788,6 +2806,32 @@ ConstraintResult GenericSignatureBuilder::addConformanceRequirement(
   return ConstraintResult::Resolved;
 }
 
+ConstraintResult GenericSignatureBuilder::resolveUnresolvedType(
+                                          PotentialArchetype *pa) {
+  // If something else resolved this type, we're done.
+  if (!pa->isUnresolved())
+    return ConstraintResult::Resolved;
+
+  // If the parent isn't resolved, we can't resolve this now.
+  auto parentPA = pa->getParent();
+  if (parentPA->isUnresolved())
+    return ConstraintResult::Unresolved;
+
+  // Resolve this via its parent.
+  auto resolvedPA =
+    parentPA->getNestedArchetypeAnchor(
+                        pa->getNestedName(),
+                        *this,
+                        PotentialArchetype::NestedTypeUpdate::ResolveExisting);
+  if (resolvedPA) {
+    assert(!pa->isUnresolved() && "This type must have been resolved");
+    return ConstraintResult::Resolved;
+  }
+
+  // We are unable to resolve this constraint.
+  return ConstraintResult::Unresolved;
+}
+
 ConstraintResult GenericSignatureBuilder::addLayoutRequirementDirect(
                                              PotentialArchetype *PAT,
                                              LayoutConstraint Layout,
@@ -4146,6 +4190,10 @@ void GenericSignatureBuilder::processDelayedRequirements() {
                                req.lhs, asUnresolvedType(req.rhs), req.source,
                                UnresolvedHandlingKind::ReturnUnresolved);
         break;
+
+      case DelayedRequirement::Unresolved:
+        reqResult = resolveUnresolvedType(req.lhs.get<PotentialArchetype *>());
+        break;
       }
 
       // Update our state based on what happened.

test/decl/protocol/req/where_clause.swift

@@ -0,0 +1,18 @@
+// RUN: %target-typecheck-verify-swift
+
+// rdar://problem/31401161
+class C1 {}
+
+protocol P1 {
+  associatedtype Element
+}
+
+protocol P2 : P1 {
+  associatedtype SubSequence : P1 // expected-note{{'SubSequence' declared here}}
+}
+
+protocol P3 : P2 {
+  associatedtype SubSequence : P2 // expected-warning{{redeclaration of associated type 'SubSequence' from protocol 'P2' is better expressed as a 'where' clause on the protocol}}
+}
+
+func foo<S>(_: S) where S.SubSequence.Element == C1, S : P3 {}