Sema: Make a couple of TypeResolver methods idempotent

When emitting a diagnostic, mark the TypeRepr as invalid and
return an ErrorType to ensure that the diagnostic is not
emitted again, and to muffle downstream diagnostics.

Author: slavapestov

lib/Sema/TypeCheckType.cpp

@@ -2638,6 +2638,8 @@ TypeResolver::resolveAttributedType(TypeAttributes &attrs, TypeRepr *repr,
           diagnoseInvalid(repr, loc, diag::escaping_non_function_parameter)
               .fixItRemove(attrRange);
         }
+
+        ty = ErrorType::get(getASTContext());
       }
 
       attrs.clearAttribute(TAK_escaping);
@@ -3853,6 +3855,8 @@ TypeResolver::resolveCompositionType(CompositionTypeRepr *repr,
     return false;
   };
 
+  bool IsInvalid = false;
+
   for (auto tyR : repr->getTypes()) {
     auto ty = resolveType(tyR,
         options.withContext(TypeResolverContext::GenericRequirement));
@@ -3885,6 +3889,13 @@ TypeResolver::resolveCompositionType(CompositionTypeRepr *repr,
     diagnose(tyR->getStartLoc(),
              diag::invalid_protocol_composition_member,
              ty);
+
+    IsInvalid = true;
+  }
+
+  if (IsInvalid) {
+    repr->setInvalid();
+    return ErrorType::get(getASTContext());
   }
 
   // Avoid confusing diagnostics ('MyClass' not convertible to 'MyClass',

test/Compatibility/protocol_composition.swift

@@ -34,17 +34,16 @@ typealias A1 = P1.Type & P2 // expected-error {{non-protocol, non-class type 'P1
 // BEGIN swift4.swift
 
 func foo(x: P1 & Any & P2.Type?) { // expected-error {{non-protocol, non-class type 'P2.Type?' cannot be used within a protocol-constrained type}}
-  let _: (P1 & P2).Type? = x // expected-error {{cannot convert value of type 'P1' to specified type '(P1 & P2).Type?'}}
-  let _: (P1 & P2).Type = x! // expected-error {{cannot force unwrap value of non-optional type 'P1'}}
-  // expected-error@-1 {{cannot convert value of type 'P1' to specified type '(P1 & P2).Type'}}
-  let _: Int = x!.p1() // expected-error {{cannot force unwrap value of non-optional type 'P1'}} expected-error {{static member 'p1' cannot be used on instance of type 'P1'}}
-  let _: Int? = x?.p2 // expected-error {{cannot use optional chaining on non-optional value of type 'P1'}}
-                      // expected-error@-1 {{value of type 'P1' has no member 'p2'}}
+  let _: (P1 & P2).Type? = x
+  let _: (P1 & P2).Type = x!
+
+  let _: Int = x!.p1()
+  let _: Int? = x?.p2
 }
 
 func bar() -> ((P1 & P2)?).Type {
   let x = (P1 & P2?).self // expected-error {{non-protocol, non-class type 'P2?' cannot be used within a protocol-constrained type}}
-  return x // expected-error {{cannot convert return expression}}
+  return x
 }
 
 typealias A1 = P1.Type & P2 // expected-error {{non-protocol, non-class type 'P1.Type' cannot be used within a protocol-constrained type}}

test/Constraints/same_types.swift

@@ -304,10 +304,9 @@ func testSameTypeCommutativity4<U, T>(_ t: T, _ u: U)
 func testSameTypeCommutativity5<U, T: P1>(_ t: T, _ u: U)
   where PPP & P3 == T.Assoc { } // Ok, equivalent to T.Assoc == PPP & P3
 
-// FIXME: Error emitted twice.
 func testSameTypeCommutativity6<U, T: P1>(_ t: T, _ u: U)
   where U & P3 == T.Assoc { } // Equivalent to T.Assoc == U & P3
-// expected-error@-1 2 {{non-protocol, non-class type 'U' cannot be used within a protocol-constrained type}}
+// expected-error@-1 {{non-protocol, non-class type 'U' cannot be used within a protocol-constrained type}}
 
 // rdar;//problem/46848889
 struct Foo<A: P1, B: P1, C: P1> where A.Assoc == B.Assoc, A.Assoc == C.Assoc {}

test/Generics/function_defs.swift

@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift
+// RUN: %target-typecheck-verify-swift -requirement-machine-protocol-signatures=verify -requirement-machine-inferred-signatures=verify
 
 //===----------------------------------------------------------------------===//
 // Type-check function definitions
@@ -288,13 +288,10 @@ func badTypeConformance3<T>(_: T) where (T) -> () : EqualComparable { }
 // expected-error@-1{{type '(T) -> ()' in conformance requirement does not refer to a generic parameter or associated type}}
 
 func badTypeConformance4<T>(_: T) where @escaping (inout T) throws -> () : EqualComparable { }
-// expected-error@-1{{type '(inout T) throws -> ()' in conformance requirement does not refer to a generic parameter or associated type}}
-// expected-error@-2 2 {{@escaping attribute may only be used in function parameter position}}
+// expected-error@-1 {{@escaping attribute may only be used in function parameter position}}
 
-// FIXME: Error emitted twice.
 func badTypeConformance5<T>(_: T) where T & Sequence : EqualComparable { }
-// expected-error@-1 2 {{non-protocol, non-class type 'T' cannot be used within a protocol-constrained type}}
-// expected-error@-2{{type 'Sequence' in conformance requirement does not refer to a generic parameter or associated type}}
+// expected-error@-1 {{non-protocol, non-class type 'T' cannot be used within a protocol-constrained type}}
 
 func badTypeConformance6<T>(_: T) where [T] : Collection { }
 // expected-error@-1{{type '[T]' in conformance requirement does not refer to a generic parameter or associated type}}

test/Generics/generic_types.swift

@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift
+// RUN: %target-typecheck-verify-swift -requirement-machine-protocol-signatures=verify -requirement-machine-inferred-signatures=verify
 
 protocol MyFormattedPrintable {
   func myFormat() -> String
@@ -230,7 +230,7 @@ class Top {}
 class Bottom<T : Bottom<Top>> {}
 // expected-error@-1 {{'Bottom' requires that 'Top' inherit from 'Bottom<Top>'}}
 // expected-note@-2 {{requirement specified as 'T' : 'Bottom<Top>' [with T = Top]}}
-// expected-error@-3 3{{generic class 'Bottom' has self-referential generic requirements}}
+// expected-error@-3 *{{generic class 'Bottom' has self-referential generic requirements}}
 
 // Invalid inheritance clause
 

test/IDE/complete_override.swift

@@ -442,7 +442,7 @@ class Deprecated2 : Deprecated1 {
 // DEPRECATED_1: Decl[InstanceMethod]/Super/NotRecommended: deprecated() {|};
 
 class EscapingBase {
-  func method(_ x: @escaping (@escaping ()->()) -> (()->())) -> (@escaping (@escaping ()->() )->()) { }
+  func method(_ x: @escaping (@escaping ()->()) -> (()->())) -> ((@escaping ()->() )->()) { }
   func autoclosure(arg: @autoclosure () -> Bool) {}
 }
 class Escaping : EscapingBase {

test/decl/protocol/req/associated_type_ambiguity.swift

@@ -1,18 +1,18 @@
-// RUN: %target-typecheck-verify-swift
+// RUN: %target-typecheck-verify-swift -requirement-machine-inferred-signatures=on -requirement-machine-protocol-signatures=on
 // RUN: not %target-swift-frontend -typecheck %s -debug-generic-signatures -requirement-machine-inferred-signatures=on -requirement-machine-protocol-signatures=on 2>&1 | %FileCheck %s
 
 protocol P1 {
-  typealias T = Int // expected-note 3{{found this candidate}}
+  typealias T = Int // expected-note {{found this candidate}}
 }
 
 protocol P2 {
-  associatedtype T // expected-note 3{{found this candidate}}
+  associatedtype T // expected-note {{found this candidate}}
 }
 
 // CHECK: ExtensionDecl line={{.*}} base=P1
 // CHECK-NEXT: Generic signature: <Self where Self : P1, Self : P2>
 extension P1 where Self : P2, T == Int { // expected-error {{'T' is ambiguous for type lookup in this context}}
-  func takeT11(_: T) {} // expected-error {{'T' is ambiguous for type lookup in this context}}
+  func takeT11(_: T) {}
   func takeT12(_: Self.T) {}
 }
 
@@ -24,7 +24,7 @@ extension P1 where Self : P2, Self.T == Int {
 }
 
 extension P1 where Self : P2 {
-  func takeT31(_: T) {} // expected-error {{'T' is ambiguous for type lookup in this context}}
+  func takeT31(_: T) {}
   func takeT32(_: Self.T) {}
 }
 

test/decl/typealias/generic.swift

@@ -1,4 +1,4 @@
-// RUN: %target-typecheck-verify-swift
+// RUN: %target-typecheck-verify-swift -requirement-machine-protocol-signatures=verify -requirement-machine-inferred-signatures=verify
 
 struct MyType<TyA, TyB> { // expected-note {{generic type 'MyType' declared here}}
   // expected-note @-1 {{arguments to generic parameter 'TyB' ('S' and 'Int') are expected to be equal}}

test/expr/expressions.swift

@@ -263,7 +263,7 @@ func test_lambda2() {
   { () -> protocol<Int> in
     // expected-error @-1 {{'protocol<...>' composition syntax has been removed and is not needed here}} {{11-24=Int}}
     // expected-error @-2 {{non-protocol, non-class type 'Int' cannot be used within a protocol-constrained type}}
-    // expected-warning @-3 {{result of call to closure returning 'Any' is unused}}
+    // expected-warning @-3 {{result of call to closure returning 'Int' is unused}}
     return 1
   }()
 }

test/type/parameterized_protocol.swift

@@ -148,6 +148,4 @@ protocol SomeProto {}
 
 func protocolCompositionNotSupported(_: SomeProto & Sequence<Int>) {}
 // expected-error@-1 {{non-protocol, non-class type 'Sequence<Int>' cannot be used within a protocol-constrained type}}
-// expected-warning@-2 {{protocol 'Sequence' as a type must be explicitly marked as 'any'}}
 
-// FIXME: The second diagnostic is bogus.