When diagnosing some problems with associated types, mark the decl invalid. When forming a type reference to an invalid type decl, have validateType return ErrorType instead of an apparently valid type. This silences some bogus downstream errors in code that references the decl.

This exposes some wierdness with while_parsing_as_left_angle_bracket where
one case the note is being is when resolveType returns a failure.  However,
resolveType can produce a failure without emitting a diagnostic, and this
can lead to us generating a note unattached to an error.  Just remove this
case.

Author: lattner

lib/AST/ArchetypeBuilder.cpp

@@ -1065,15 +1065,19 @@ bool ArchetypeBuilder::addAbstractTypeParamRequirements(
       Diags.diagnose(assocType->getLoc(),
                      diag::recursive_requirement_reference);
 
-      // Mark all associatedtypes in this protocol as recursive (and error-type) to avoid later
-      // crashes dealing with this invalid protocol in other contexts.
+      // Mark all associatedtypes in this protocol as recursive (and error-type)
+      // to avoid later crashes dealing with this invalid protocol in other
+      // contexts.
       auto containingProto = assocType->getDeclContext()->isProtocolOrProtocolExtensionContext();
       for (auto member : containingProto->getMembers())
         if (auto assocType = dyn_cast<AssociatedTypeDecl>(member))
           assocType->setIsRecursive();
     }
     pa->setIsRecursive();
 
+    // Silence downstream errors referencing this associated type.
+    assocType->setInvalid();
+
     // FIXME: Drop this protocol.
     pa->addConformance(proto, RequirementSource(kind, loc), *this);
   };

lib/Sema/TypeCheckConstraints.cpp

@@ -683,11 +683,8 @@ namespace {
       // Type check the type parameters in an UnresolvedSpecializeExpr.
       if (auto us = dyn_cast<UnresolvedSpecializeExpr>(expr)) {
         for (TypeLoc &type : us->getUnresolvedParams()) {
-          if (TC.validateType(type, DC)) {
-            TC.diagnose(us->getLAngleLoc(),
-                        diag::while_parsing_as_left_angle_bracket);
+          if (TC.validateType(type, DC))
             return nullptr;
-          }
         }
 
         // If this is a reference type a specialized type, form a TypeExpr.

lib/Sema/TypeCheckType.cpp

@@ -1069,6 +1069,11 @@ static Type resolveNestedIdentTypeComponent(
         TC, memberType, comp->getIdLoc(), DC, genComp,
         options.contains(TR_GenericSignature), resolver);
 
+  // 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 && member->isInvalid())
+    memberType = ErrorType::get(TC.Context);
+
   if (member)
     comp->setValue(member);
   return memberType;

test/Parse/generic_disambiguation.swift

@@ -26,9 +26,9 @@ var a, b, c, d : Int
 a < b
 (a < b, c > d)
 // Parses as generic because of lparen after '>'
-(a < b, c > (d)) // expected-error{{use of undeclared type 'b'}} expected-note{{while parsing this '<' as a type parameter bracket}}
+(a < b, c > (d)) // expected-error{{use of undeclared type 'b'}}
 // Parses as generic because of lparen after '>'
-(a<b, c>(d)) // expected-error{{use of undeclared type 'b'}} expected-note{{while parsing this '<' as a type parameter bracket}}
+(a<b, c>(d)) // expected-error{{use of undeclared type 'b'}} 
 a>(b)
 a > (b)
 

test/decl/protocol/recursive_requirement.swift

@@ -20,7 +20,7 @@ struct X<T: P> {
 }
 
 func f<T : P>(z: T) {
- _ = X<T.A>() // expected-error{{expression type 'X<T.A>' is ambiguous without more context}}
+ _ = X<T.A>()
 }
 
 // -----
@@ -60,7 +60,7 @@ struct Y3 : DeclaredP {
 struct X3<T:P4> {}
 
 func f2<T:P4>(a: T) {
- _ = X3<T.A>() // expected-error{{expression type 'X3<T.A>' is ambiguous without more context}}
+ _ = X3<T.A>()
 }
 
 f2(Y3())