[Name lookup] Allow where clauses to find typealiases declared in a protocol.

Within the where clause of (e.g.) an extension, unqualified name lookup is
permitted to find associated types. Extend this to also include finding
typealiases declared within the protocol itself.

This is service of the IndexDistance change (SE-0191), and
fixes rdar://problem/35490504.

(cherry picked from commit 5431400)

Author: DougGregor

lib/AST/GenericSignatureBuilder.cpp

@@ -4131,6 +4131,19 @@ ConstraintResult GenericSignatureBuilder::addSameTypeRequirement(
                                       diagnoseMismatch);
 }
 
+/// Determine whether the given type has a type parameter or directly
+/// references a deprecated typealias.
+static bool hasTypeParameterOrIsDeprecatedTypealias(Type type){
+  if (type->hasTypeParameter()) return true;
+
+  if (auto typeAlias = dyn_cast<NameAliasType>(type.getPointer())) {
+    return typeAlias->getDecl()->getAttrs().getDeprecated(
+                                                      type->getASTContext());
+  }
+
+  return false;
+}
+
 ConstraintResult GenericSignatureBuilder::addSameTypeRequirementDirect(
     ResolvedType type1, ResolvedType type2,
     FloatingRequirementSource source,
@@ -4286,9 +4299,9 @@ ConstraintResult GenericSignatureBuilder::addRequirement(
 
   case RequirementReprKind::SameType: {
     // Require that at least one side of the requirement contain a type
-    // parameter.
-    if (!Req->getFirstType()->hasTypeParameter() &&
-        !Req->getSecondType()->hasTypeParameter()) {
+    // parameter or directly reference a deprecated declaration.
+    if (!hasTypeParameterOrIsDeprecatedTypealias(Req->getFirstType()) &&
+        !hasTypeParameterOrIsDeprecatedTypealias(Req->getSecondType())) {
       if (!Req->getFirstType()->hasError() &&
           !Req->getSecondType()->hasError()) {
         Impl->HadAnyError = true;

lib/Sema/TypeCheckType.cpp

@@ -1024,7 +1024,8 @@ resolveGenericSignatureComponent(TypeChecker &TC, DeclContext *DC,
   }
 
   // If the lookup occurs from within a trailing 'where' clause of
-  // a constrained extension, also look for associated types.
+  // a constrained extension, also look for associated types and typealiases
+  // in the protocol.
   if (genericParams->hasTrailingWhereClause() &&
       comp->getIdLoc().isValid() &&
       TC.Context.SourceMgr.rangeContainsTokenLoc(
@@ -1047,12 +1048,15 @@ resolveGenericSignatureComponent(TypeChecker &TC, DeclContext *DC,
                             decls)) {
       for (const auto decl : decls) {
         // FIXME: Better ambiguity handling.
-        if (auto assocType = dyn_cast<AssociatedTypeDecl>(decl)) {
-          comp->setValue(assocType, DC);
-          return resolveTopLevelIdentTypeComponent(TC, DC, comp, options,
-                                                   diagnoseErrors, resolver,
-                                                   unsatisfiedDependency);
-        }
+        auto typeDecl = dyn_cast<TypeDecl>(decl);
+        if (!typeDecl) continue;
+
+        if (!isa<ProtocolDecl>(typeDecl->getDeclContext())) continue;
+
+        comp->setValue(typeDecl, DC);
+        return resolveTopLevelIdentTypeComponent(TC, DC, comp, options,
+                                                 diagnoseErrors, resolver,
+                                                 unsatisfiedDependency);
       }
     }
   }

test/decl/typealias/protocol.swift

@@ -252,3 +252,28 @@ protocol P9 {
 
 func testT9a<T: P9, U>(_: T, _: U) where T.A == U { }
 func testT9b<T: P9>(_: T) where T.A == Float { } // expected-error{{'T.A' cannot be equal to both 'Float' and 'P9.A' (aka 'Int')}}
+
+
+struct X<T> { }
+
+protocol P10 {
+  associatedtype A
+  typealias T = Int
+
+  @available(*, deprecated, message: "just use Int, silly")
+  typealias V = Int
+}
+
+extension P10 {
+  typealias U = Float
+}
+
+extension P10 where T == Int { } // expected-error{{neither type in same-type refers to a generic parameter or associated type}}
+
+extension P10 where A == X<T> { }
+
+extension P10 where A == X<U> { } // expected-error{{use of undeclared type 'U'}}
+
+extension P10 where A == X<Self.U> { }
+
+extension P10 where V == Int { } // expected-warning 3{{'V' is deprecated: just use Int, silly}}