GSB: Remove another call to resolveDeclSignature()

The GSB should avoid triggering declaration validation where
possible, to avoid problems resulting from circularity and as
a general performance rule-of-thumb.

This last call was there to catch self-recursive protocol
typealiases. However, we can diagnose this problem elsewhere,
which allows us to emit a more accurate diagnostic as well.

Author: slavapestov

lib/AST/GenericSignatureBuilder.cpp

@@ -2057,13 +2057,6 @@ TypeDecl *EquivalenceClass::lookupNestedType(
               != proto->getParentModule())
           continue;
 
-        // Resolve the signature of this type.
-        if (!type->hasInterfaceType()) {
-          type->getASTContext().getLazyResolver()->resolveDeclSignature(type);
-          if (!type->hasInterfaceType())
-            continue;
-        }
-
         concreteDecls.push_back(type);
         continue;
       }

lib/Sema/TypeCheckType.cpp

@@ -228,8 +228,13 @@ Type TypeResolution::resolveDependentMemberType(
   auto lazyResolver = ctx.getLazyResolver();
   if (lazyResolver)
     lazyResolver->resolveDeclSignature(concrete);
-  if (!concrete->hasInterfaceType())
+  if (!concrete->hasInterfaceType()) {
+    ctx.Diags.diagnose(ref->getIdLoc(), diag::recursive_decl_reference,
+                       concrete->getDescriptiveKind(), concrete->getName());
+    concrete->diagnose(diag::kind_declared_here,
+                       DescriptiveDeclKind::Type);
     return ErrorType::get(ctx);
+  }
 
   // Make sure that base type didn't get replaced along the way.
   assert(baseTy->isTypeParameter());

test/decl/typealias/protocol.swift

@@ -144,17 +144,15 @@ protocol P3 {
 
 // Test for not crashing on recursive aliases
 protocol Circular {
-  typealias Y = Self.Y // expected-error {{'Y' is not a member type of 'Self'}}
+  typealias Y = Self.Y // expected-error {{type alias 'Y' references itself}}
+  // expected-note@-1 {{type declared here}}
 
   typealias Y2 = Y2 // expected-error {{type alias 'Y2' references itself}}
   // expected-note@-1 {{type declared here}}
-  // expected-note@-2 {{did you mean 'Y2'?}}
 
   typealias Y3 = Y4 // expected-note {{type declared here}}
-  // expected-note@-1 {{did you mean 'Y3'?}}
 
   typealias Y4 = Y3 // expected-error {{type alias 'Y3' references itself}}
-  // expected-note@-1 {{did you mean 'Y4'?}}
 }
 
 // Qualified and unqualified references to protocol typealiases from concrete type