[Sema] Always return the typealias from a member type lookup.

An expression like Type.Member will first do a normal lookup, and, if only
associated types could be found, will then do associated type inference on
them.

Previously the types of these would be returned directly, but this loses the
sugar associated with the implicit typealias that is created. The sugar is
necessary to ensure that things like the checking of conditional requirements is
satisfied, such as:

    protocol P {
      associatedtype T
    }
    struct X<T> {}
    extension X: P where T == Int {}
    let _ = X<String>.T.self

If the underlying type 'String' (or even 'Int') of 'X<...>.T' is returned, then
the above ends up being perfectly fine, because those are always available, but
that expression itself isn't quite right because the T typealias is conditional.

With this change, once associatedtype inference runs, the typealias that it
creates is found, and the type is mapped to have all the right sugar, meaning
the above is flagged. (This hints at an extra exciting bit of the original
behaviour: if the `let ...` line was copied so that there were two, the second
one gets the expected error, because it doesn't need to run inference and just
finds the typealiases created by the first line.)

Part of https://bugs.swift.org/browse/SR-5440 and
https://bugs.swift.org/browse/SR-7976 and rdar://problem/41063870.

Author: huonw

lib/Sema/TypeCheckNameLookup.cpp

@@ -447,7 +447,7 @@ LookupTypeResult TypeChecker::lookupMemberType(DeclContext *dc,
       // Add the type to the result set, so that we can diagnose the
       // reference instead of just saying the member does not exist.
       if (types.insert(memberType->getCanonicalType()).second)
-        result.Results.push_back({typeDecl, memberType});
+        result.Results.push_back({typeDecl, memberType, nullptr});
 
       continue;
     }
@@ -492,7 +492,7 @@ LookupTypeResult TypeChecker::lookupMemberType(DeclContext *dc,
 
     // If we haven't seen this type result yet, add it to the result set.
     if (types.insert(memberType->getCanonicalType()).second)
-      result.Results.push_back({typeDecl, memberType});
+      result.Results.push_back({typeDecl, memberType, nullptr});
   }
 
   if (result.Results.empty()) {
@@ -521,19 +521,21 @@ LookupTypeResult TypeChecker::lookupMemberType(DeclContext *dc,
 
       // Use the type witness.
       auto concrete = conformance->getConcrete();
-      Type memberType = concrete->getTypeWitness(assocType, this);
 
       // This is the only case where NormalProtocolConformance::
       // getTypeWitnessAndDecl() returns a null type.
       if (concrete->getState() ==
           ProtocolConformanceState::CheckingTypeWitnesses)
         continue;
 
-      assert(memberType && "Missing type witness?");
+      auto typeDecl = concrete->getTypeWitnessAndDecl(assocType, this).second;
 
-      // If we haven't seen this type result yet, add it to the result set.
+      assert(typeDecl && "Missing type witness?");
+
+      auto memberType =
+          substMemberTypeWithBase(dc->getParentModule(), typeDecl, type);
       if (types.insert(memberType->getCanonicalType()).second)
-        result.Results.push_back({assocType, memberType});
+        result.Results.push_back({typeDecl, memberType, assocType});
     }
   }
 

lib/Sema/TypeCheckType.cpp

@@ -1254,7 +1254,8 @@ static Type resolveNestedIdentTypeComponent(
               bool diagnoseErrors,
               GenericTypeResolver *resolver,
               UnsatisfiedDependency *unsatisfiedDependency) {
-  auto maybeDiagnoseBadMemberType = [&](TypeDecl *member, Type memberType) {
+  auto maybeDiagnoseBadMemberType = [&](TypeDecl *member, Type memberType,
+                                        AssociatedTypeDecl *inferredAssocType) {
     // Diagnose invalid cases.
     if (TC.isUnsupportedMemberTypeAccess(parentTy, member)) {
       if (diagnoseErrors) {
@@ -1285,20 +1286,21 @@ static Type resolveNestedIdentTypeComponent(
       }
     }
 
+    // Diagnose a bad conformance reference if we need to.
+    if (inferredAssocType && diagnoseErrors && memberType &&
+        memberType->hasError()) {
+      maybeDiagnoseBadConformanceRef(TC, DC, parentTy, comp->getLoc(),
+                                     inferredAssocType);
+    }
+
     // If we found a reference to an associated type or other member type that
     // was marked invalid, just return ErrorType to silence downstream errors.
     if (member->isInvalid())
       return ErrorType::get(TC.Context);
 
-    // Diagnose a bad conformance reference if we need to.
-    if (isa<AssociatedTypeDecl>(member) && diagnoseErrors &&
-        memberType && memberType->hasError()) {
-      maybeDiagnoseBadConformanceRef(TC, DC, parentTy, comp->getLoc(),
-                                     cast<AssociatedTypeDecl>(member));
-    }
-
     // At this point, we need to have resolved the type of the member.
-    if (!memberType || memberType->hasError()) return memberType;
+    if (!memberType || memberType->hasError())
+      return memberType;
 
     // If there are generic arguments, apply them now.
     if (!options.contains(TypeResolutionFlags::ResolveStructure)) {
@@ -1335,7 +1337,7 @@ static Type resolveNestedIdentTypeComponent(
   if (auto *typeDecl = comp->getBoundDecl()) {
     auto memberType = TC.substMemberTypeWithBase(DC->getParentModule(),
                                                  typeDecl, parentTy);
-    return maybeDiagnoseBadMemberType(typeDecl, memberType);
+    return maybeDiagnoseBadMemberType(typeDecl, memberType, nullptr);
   }
 
   // Phase 1: Find and bind the component decl.
@@ -1390,6 +1392,7 @@ static Type resolveNestedIdentTypeComponent(
   // If we didn't find anything, complain.
   Type memberType;
   TypeDecl *member = nullptr;
+  AssociatedTypeDecl *inferredAssocType = nullptr;
   if (!memberTypes) {
     // If we're not allowed to complain or we couldn't fix the
     // source, bail out.
@@ -1405,10 +1408,11 @@ static Type resolveNestedIdentTypeComponent(
   } else {
     memberType = memberTypes.back().MemberType;
     member = memberTypes.back().Member;
+    inferredAssocType = memberTypes.back().InferredAssociatedType;
     comp->setValue(member, nullptr);
   }
 
-  return maybeDiagnoseBadMemberType(member, memberType);
+  return maybeDiagnoseBadMemberType(member, memberType, inferredAssocType);
 }
 
 static Type resolveIdentTypeComponent(

lib/Sema/TypeChecker.h

@@ -155,6 +155,9 @@ class LookupResult {
 struct LookupTypeResultEntry {
   TypeDecl *Member;
   Type MemberType;
+  /// The associated type that the Member/MemberType were inferred for, but only
+  /// if inference happened when creating this entry.
+  AssociatedTypeDecl *InferredAssociatedType;
 };
 
 /// The result of name lookup for types.

test/Constraints/conditionally_defined_types.swift

@@ -45,6 +45,14 @@ let _ = SameType<Y>.Decl3.self // expected-error {{'SameType<Y>.Decl3.Type' requ
 let _ = SameType<Y>.Decl4<X>.self // expected-error {{'SameType<Y>.Decl4' requires the types 'Y' and 'X' be equivalent}}
 let _ = SameType<Y>.Decl5<X>.self // expected-error {{'SameType<Y>.Decl5' requires the types 'Y' and 'X' be equivalent}}
 
+extension SameType: AssociatedType where T == X {}
+
+// (Y first here, because there were issues caused by running associated type
+// inference for the first time)
+let _ = SameType<Y>.T.self // expected-error {{'SameType<Y>.T.Type' (aka 'X.Type') requires the types 'Y' and 'X' be equivalent}}
+
+let _ = SameType<X>.T.self
+
 struct Conforms<T> {}
 extension Conforms where T: P {
     typealias TypeAlias1 = T
@@ -76,6 +84,12 @@ let _ = Conforms<Y>.Decl3.self // expected-error {{type 'Y' does not conform to
 let _ = Conforms<Y>.Decl4<X>.self // expected-error {{type 'Y' does not conform to protocol 'P'}}
 let _ = Conforms<Y>.Decl5<X>.self // expected-error {{type 'Y' does not conform to protocol 'P'}}
 
+extension Conforms: AssociatedType where T: P {}
+
+let _ = Conforms<Y>.T.self // expected-error {{type 'Y' does not conform to protocol 'P'}}
+
+let _ = Conforms<X>.T.self
+
 // Now, even more nesting!
 
 extension SameType.Decl1 {