[GSB] Infer requirements from uses of generic typealiases.

Generic typealiases can add requirements that aren't used by their
underlying type. For example, CountableRange in the standard library:

  public typealias CountableRange<Bound: Comparable> = Range<Bound>

Perform requirement inference based on uses of generic typealiases,
such that a generic function like this:

  func f<T>(_: CountableRange<T>) { }

will infer T: Bound from the use of CountableRange.

Note that this does not yet work for extensions.

Author: DougGregor

lib/AST/GenericSignatureBuilder.cpp

@@ -5430,9 +5430,25 @@ class GenericSignatureBuilder::InferRequirementsWalker : public TypeWalker {
   }
 
   Action walkToTypePost(Type ty) override {
-    auto decl = ty->getAnyNominal();
-    if (!decl)
+    // Infer from generic typealiases.
+    if (auto boundNameAlias = dyn_cast<BoundNameAliasType>(ty.getPointer())) {
+      auto decl = boundNameAlias->getDecl();
+      auto genericSig = decl->getGenericSignature();
+      if (!genericSig)
+        return Action::Continue;
+
+      auto subMap = boundNameAlias->getSubstitutionMap();
+      for (const auto &rawReq : genericSig->getRequirements()) {
+        if (auto req = rawReq.subst(subMap))
+          Builder.addRequirement(*req, source, nullptr);
+      }
+
       return Action::Continue;
+    }
+
+    // Infer from generic nominal types.
+    auto decl = ty->getAnyNominal();
+    if (!decl) return Action::Continue;
 
     auto genericSig = decl->getGenericSignature();
     if (!genericSig)

test/Generics/requirement_inference.swift

@@ -460,3 +460,30 @@ func conditionalNested1<U>(_: [ConditionalNested<U>.Inner?]) {}
 // CHECK: Generic signature: <U where U : P35, U : P36>
 // CHECK: Canonical generic signature: <τ_0_0 where τ_0_0 : P35, τ_0_0 : P36>
 func conditionalNested2<U>(_: [ConditionalNested<U>.Inner.Inner2?]) {}
+
+//
+// Generate typalias adds requirements that can be inferred
+//
+typealias X1WithP2<T: P2> = X1<T>
+
+// Inferred requirement T: P2 from the typealias
+func testX1WithP2<T>(_: X1WithP2<T>) {
+  _ = X5<T>() // requires P2
+}
+
+// Overload based on the inferred requirement.
+func testX1WithP2Overloading<T>(_: X1<T>) {
+  _ = X5<T>() // expected-error{{type 'T' does not conform to protocol 'P2'}}
+}
+
+func testX1WithP2Overloading<T>(_: X1WithP2<T>) {
+  _ = X5<T>() // requires P2
+}
+
+// Extend using the inferred requirement.
+// FIXME: Currently broken.
+extension X1WithP2 {
+  func f() {
+    _ = X5<T>() // FIXME: expected-error{{type 'T' does not conform to protocol 'P2'}}
+  }
+}