[Test] Update existing tests

Author: theblixguy

test/Constraints/static_members_on_protocol_in_generic_context.swift

@@ -265,24 +265,6 @@ test_combo(.genericWithReqs([42]))
 test_combo(.genericWithReqs(()))
 // expected-error@-1 {{contextual member reference to static method 'genericWithReqs' requires 'Self' constraint in the protocol extension}}
 
-protocol Z {
-  associatedtype T = Int
-
-  static var prop: T { get }
-}
-
-extension Z {
-  static func method() -> T { fatalError() }
-}
-
-_ = Z.prop
-// expected-error@-1 {{member 'prop' cannot be used on value of protocol type 'Z.Protocol'; use a generic constraint instead}}
-// expected-error@-2 {{protocol 'Z' can only be used as a generic constraint because it has Self or associated type requirements}}
-
-_ = Z.method()
-// expected-error@-1 {{member 'method' cannot be used on value of protocol type 'Z.Protocol'; use a generic constraint instead}}
-// expected-error@-2 {{protocol 'Z' can only be used as a generic constraint because it has Self or associated type requirements}}
-
 protocol TestWithAssoc {
   associatedtype U
 }

test/Generics/function_defs.swift

@@ -34,7 +34,7 @@ func min<T : MethodLessComparable>(_ x: T, y: T) -> T {
 //===----------------------------------------------------------------------===//
 
 func existential<T : EqualComparable, U : EqualComparable>(_ t1: T, t2: T, u: U) {
-  var eqComp : EqualComparable = t1 // expected-error{{protocol 'EqualComparable' can only be used as a generic constraint}}
+  var eqComp : EqualComparable = t1 // Ok
   eqComp = u
   if t1.isEqual(eqComp) {} // expected-error{{cannot convert value of type 'EqualComparable' to expected argument type 'T'}}
   if eqComp.isEqual(t2) {} // expected-error{{member 'isEqual' cannot be used on value of protocol type 'EqualComparable'; use a generic constraint instead}}
@@ -49,19 +49,19 @@ func otherExistential<T : EqualComparable>(_ t1: T) {
   otherEqComp = t1 // expected-error{{value of type 'T' does not conform to 'OtherEqualComparable' in assignment}}
   _ = otherEqComp
 
-  var otherEqComp2 : OtherEqualComparable // expected-error{{protocol 'OtherEqualComparable' can only be used as a generic constraint}}
+  var otherEqComp2 : OtherEqualComparable // Ok
   otherEqComp2 = t1 // expected-error{{value of type 'T' does not conform to 'OtherEqualComparable' in assignment}}
   _ = otherEqComp2
 
-  _ = t1 as EqualComparable & OtherEqualComparable // expected-error{{value of type 'T' does not conform to 'EqualComparable & OtherEqualComparable' in coercion}} expected-error{{protocol 'OtherEqualComparable' can only be used as a generic constraint}} expected-error{{protocol 'EqualComparable' can only be used as a generic constraint}}
+  _ = t1 as EqualComparable & OtherEqualComparable // expected-error{{value of type 'T' does not conform to 'EqualComparable & OtherEqualComparable' in coercion}}
 }
 
 protocol Runcible {
   func runce<A>(_ x: A)
   func spoon(_ x: Self)
 }
 
-func testRuncible(_ x: Runcible) { // expected-error{{protocol 'Runcible' can only be used as a generic constraint}}
+func testRuncible(_ x: Runcible) { // Ok
   x.runce(5)
 }
 

test/Sema/existential_nested_type.swift

@@ -15,7 +15,7 @@ enum MyError : Error {
 
 func checkIt(_ js: Any) throws {
   switch js {
-    case let dbl as HasAssoc: // expected-error {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
+    case let dbl as HasAssoc: // Ok
       throw MyError.bad(dbl)
 
     default:

test/decl/nested/protocol.swift

@@ -31,8 +31,7 @@ protocol OuterProtocol {
 struct ConformsToOuterProtocol : OuterProtocol {
   typealias Hen = Int
 
-  func f() { let _ = InnerProtocol.self }
-  // expected-error@-1 {{protocol 'InnerProtocol' can only be used as a generic constraint because it has Self or associated type requirements}}
+  func f() { let _ = InnerProtocol.self } // Ok
 }
 
 protocol Racoon {

test/decl/nested/type_in_function.swift

@@ -144,8 +144,7 @@ func freeFunction() {
   struct ConformingType : ProtoWithAssocType {
     typealias T = Int
 
-    func method() -> ProtoWithAssocType {}
-    // expected-error@-1 {{can only be used as a generic constraint because it has Self or associated type requirements}}
+    func method() -> ProtoWithAssocType {} // Ok
   }
 }
 

test/decl/protocol/conforms/inherited.swift

@@ -167,13 +167,13 @@ class B : A {
 }
 
 func testB(_ b: B) {
-  var _: P1 = b // expected-error{{has Self or associated type requirements}}
-  var _: P4 = b // expected-error{{has Self or associated type requirements}}
+  var _: P1 = b
+  var _: P4 = b
   var _: P5 = b
   var _: P6 = b
-  var _: P7 = b // expected-error{{has Self or associated type requirements}}
-  var _: P8 = b // okay
-  var _: P9 = b // expected-error{{has Self or associated type requirements}}
+  var _: P7 = b
+  var _: P8 = b
+  var _: P9 = b
 }
 
 // Class A5 conforms to P5 in an inheritable manner.

test/decl/protocol/protocols.swift

@@ -102,10 +102,10 @@ struct DoesNotConform : Up {
 // Circular protocols
 
 protocol CircleMiddle : CircleStart { func circle_middle() } // expected-error {{protocol 'CircleMiddle' refines itself}}
-// expected-note@-1 2 {{protocol 'CircleMiddle' declared here}}
-protocol CircleStart : CircleEnd { func circle_start() } // expected-error 2 {{protocol 'CircleStart' refines itself}}
+// expected-note@-1 {{protocol 'CircleMiddle' declared here}}
+protocol CircleStart : CircleEnd { func circle_start() } // expected-error {{protocol 'CircleStart' refines itself}}
 // expected-note@-1 {{protocol 'CircleStart' declared here}}
-protocol CircleEnd : CircleMiddle { func circle_end()} // expected-note 3 {{protocol 'CircleEnd' declared here}}
+protocol CircleEnd : CircleMiddle { func circle_end()} // expected-note 2 {{protocol 'CircleEnd' declared here}}
 
 protocol CircleEntry : CircleTrivial { }
 protocol CircleTrivial : CircleTrivial { } // expected-error {{protocol 'CircleTrivial' refines itself}}
@@ -267,7 +267,7 @@ struct WrongIsEqual : IsEqualComparable { // expected-error{{type 'WrongIsEqual'
 // Using values of existential type.
 //===----------------------------------------------------------------------===//
 
-func existentialSequence(_ e: Sequence) { // expected-error{{has Self or associated type requirements}}
+func existentialSequence(_ e: Sequence) {
   var x = e.makeIterator() // expected-error{{member 'makeIterator' cannot be used on value of protocol type 'Sequence'; use a generic constraint instead}}
   x.next()
   x.nonexistent()
@@ -278,7 +278,7 @@ protocol HasSequenceAndStream {
   func getR() -> R
 }
 
-func existentialSequenceAndStreamType(_ h: HasSequenceAndStream) { // expected-error{{has Self or associated type requirements}}
+func existentialSequenceAndStreamType(_ h: HasSequenceAndStream) {
   // FIXME: Crummy diagnostics.
   var x = h.getR() // expected-error{{member 'getR' cannot be used on value of protocol type 'HasSequenceAndStream'; use a generic constraint instead}}
   x.makeIterator()
@@ -307,7 +307,7 @@ struct DictionaryIntInt {
   }
 }
 
-func testSubscripting(_ iis: IntIntSubscriptable, i_s: IntSubscriptable) { // expected-error{{has Self or associated type requirements}}
+func testSubscripting(_ iis: IntIntSubscriptable, i_s: IntSubscriptable) { // Ok
   var i: Int = iis[17] 
   var i2 = i_s[17] // expected-error{{member 'subscript' cannot be used on value of protocol type 'IntSubscriptable'; use a generic constraint instead}}
 }
@@ -488,18 +488,18 @@ func g<T : C2>(_ x : T) {
 
 class C3 : P1 {} // expected-error{{type 'C3' does not conform to protocol 'P1'}}
 func h<T : C3>(_ x : T) {
-  _ = x as P1 // expected-error{{protocol 'P1' can only be used as a generic constraint because it has Self or associated type requirements}}
+  _ = x as P1
 }
 func i<T : C3>(_ x : T?) -> Bool {
-  return x is P1 // expected-error{{protocol 'P1' can only be used as a generic constraint because it has Self or associated type requirements}}
+  return x is P1
   // FIXME: Bogus diagnostic.  See SR-11920.
   // expected-warning@-2 {{checking a value with optional type 'T?' against dynamic type 'P1' succeeds whenever the value is non-nil; did you mean to use '!= nil'?}}
 }
 func j(_ x : C1) -> Bool {
-  return x is P1 // expected-error{{protocol 'P1' can only be used as a generic constraint because it has Self or associated type requirements}}
+  return x is P1
 }
 func k(_ x : C1?) -> Bool {
-  return x is P1 // expected-error{{protocol 'P1' can only be used as a generic constraint because it has Self or associated type requirements}}
+  return x is P1
 }
 
 

test/decl/protocol/recursive_requirement.swift

@@ -91,7 +91,7 @@ protocol AsExistentialB {
 }
 
 protocol AsExistentialAssocTypeA {
-  var delegate : AsExistentialAssocTypeB? { get } // expected-error {{protocol 'AsExistentialAssocTypeB' can only be used as a generic constraint because it has Self or associated type requirements}}
+  var delegate : AsExistentialAssocTypeB? { get }
 }
 protocol AsExistentialAssocTypeB {
   func aMethod(_ object : AsExistentialAssocTypeA)
@@ -103,7 +103,7 @@ protocol AsExistentialAssocTypeAgainA {
   associatedtype Bar
 }
 protocol AsExistentialAssocTypeAgainB {
-  func aMethod(_ object : AsExistentialAssocTypeAgainA) // expected-error {{protocol 'AsExistentialAssocTypeAgainA' can only be used as a generic constraint because it has Self or associated type requirements}}
+  func aMethod(_ object : AsExistentialAssocTypeAgainA)
 }
 
 // SR-547
@@ -124,5 +124,3 @@ protocol B {
 
     func observeChangeOfProperty(_ property: BC, observable: BA)
 }
-
-

test/decl/protocol/req/dynamic_self.swift

@@ -87,22 +87,8 @@ enum EError : P { // expected-error{{type 'EError' does not conform to protocol
   func f() -> Int { 0 } // expected-note{{candidate has non-matching type '() -> Int'}}
 }
 
-
-// Settable storage declaration requirements with a 'Self' result type may not
-// be used with an existential base.
-protocol P2 {
-  subscript() -> Self { get set }
-}
-protocol P3 {
-  var prop: Self { get set }
-}
-protocol P4 {
-  subscript<T: Sequence>() -> T where T.Element == Self { get set }
-}
-func takesP2P3P4(p2: P2, p3: P3, p4: P4) { }
-// expected-error@-1{{protocol 'P2' can only be used as a generic constraint because it has Self or associated type requirements}}
-// expected-error@-2{{protocol 'P3' can only be used as a generic constraint because it has Self or associated type requirements}}
-
+// Settable storage members with a 'Self' result type may not be used with an
+// existential base.
 protocol P5 {
 }
 extension P5 {

test/stmt/foreach.swift

@@ -175,8 +175,8 @@ func testOptionalSequence() {
   }
 }
 
-// Crash with (invalid) for each over an existential
-func testExistentialSequence(s: Sequence) { // expected-error {{protocol 'Sequence' can only be used as a generic constraint because it has Self or associated type requirements}}
+// FIXME: Should this be allowed?
+func testExistentialSequence(s: Sequence) {
   for x in s { // expected-error {{protocol 'Sequence' as a type cannot conform to the protocol itself}} expected-note {{only concrete types such as structs, enums and classes can conform to protocols}}
     _ = x
   }

test/type/protocol_types.swift

@@ -3,7 +3,7 @@
 protocol HasSelfRequirements {
   func foo(_ x: Self)
 
-  func returnsOwnProtocol() -> HasSelfRequirements // expected-error{{protocol 'HasSelfRequirements' can only be used as a generic constraint because it has Self or associated type requirements}} {{educational-notes=associated-type-requirements}}
+  func returnsOwnProtocol() -> HasSelfRequirements
 }
 protocol Bar {
   // init() methods should not prevent use as an existential.
@@ -36,10 +36,10 @@ func useCompoAsWhereRequirement<T>(_ x: T) where T: HasSelfRequirements & Bar {}
 func useCompoAliasAsWhereRequirement<T>(_ x: T) where T: Compo {}
 func useNestedCompoAliasAsWhereRequirement<T>(_ x: T) where T: CompoAssocType.Compo {}
 
-func useAsType(_ x: HasSelfRequirements) { } // expected-error{{protocol 'HasSelfRequirements' can only be used as a generic constraint}}
-func useCompoAsType(_ x: HasSelfRequirements & Bar) { } // expected-error{{protocol 'HasSelfRequirements' can only be used as a generic constraint}}
-func useCompoAliasAsType(_ x: Compo) { } // expected-error{{protocol 'HasSelfRequirements' can only be used as a generic constraint}}
-func useNestedCompoAliasAsType(_ x: CompoAssocType.Compo) { } // expected-error{{protocol 'HasSelfRequirements' can only be used as a generic constraint}}
+func useAsType(_: HasSelfRequirements,
+               _: HasSelfRequirements & Bar,
+               _: Compo,
+               _: CompoAssocType.Compo) { }
 
 struct TypeRequirement<T: HasSelfRequirements> {}
 struct CompoTypeRequirement<T: HasSelfRequirements & Bar> {}
@@ -67,29 +67,20 @@ protocol HasAssoc {
   func foo()
 }
 
-func testHasAssoc(_ x: Any) {
-  if let p = x as? HasAssoc { // expected-error {{protocol 'HasAssoc' can only be used as a generic constraint}} {{educational-notes=associated-type-requirements}}
+func testHasAssoc(_ x: Any, _: HasAssoc) {
+  if let p = x as? HasAssoc {
     p.foo() // don't crash here.
   }
 }
 
-// rdar://problem/16803384
-protocol InheritsAssoc : HasAssoc {
-  func silverSpoon()
-}
-
-func testInheritsAssoc(_ x: InheritsAssoc) { // expected-error {{protocol 'InheritsAssoc' can only be used as a generic constraint}}
-  x.silverSpoon()
-}
-
 // SR-38
-var b: HasAssoc // expected-error {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
+var b: HasAssoc
 
 // Further generic constraint error testing - typealias used inside statements
 protocol P {}
 typealias MoreHasAssoc = HasAssoc & P
 func testHasMoreAssoc(_ x: Any) {
-  if let p = x as? MoreHasAssoc { // expected-error {{protocol 'HasAssoc' can only be used as a generic constraint}}
+  if let p = x as? MoreHasAssoc {
     p.foo() // don't crash here.
   }
 }
@@ -103,43 +94,35 @@ struct Outer {
 typealias X = Struct1<Pub & Bar>
 _ = Struct1<Pub & Bar>.self
 
-typealias BadAlias<T> = T
+typealias AliasWhere<T> = T
 where T : HasAssoc, T.Assoc == HasAssoc
-// expected-error@-1 {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
 
-struct BadStruct<T>
+struct StructWhere<T>
 where T : HasAssoc,
       T.Assoc == HasAssoc {}
-// expected-error@-1 {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
 
-protocol BadProtocol where T == HasAssoc {
-  // expected-error@-1 {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
+protocol ProtocolWhere where T == HasAssoc {
   associatedtype T
 
   associatedtype U : HasAssoc
     where U.Assoc == HasAssoc
-  // expected-error@-1 {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
 }
 
 extension HasAssoc where Assoc == HasAssoc {}
-// expected-error@-1 {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
 
-func badFunction<T>(_: T)
+func FunctionWhere<T>(_: T)
 where T : HasAssoc,
       T.Assoc == HasAssoc {}
-// expected-error@-1 {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
 
-struct BadSubscript {
+struct SubscriptWhere {
   subscript<T>(_: T) -> Int
   where T : HasAssoc,
         T.Assoc == HasAssoc {
-    // expected-error@-1 {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
     get {}
     set {}
   }
 }
 
 struct OuterGeneric<T> {
   func contextuallyGenericMethod() where T == HasAssoc {}
-  // expected-error@-1 {{protocol 'HasAssoc' can only be used as a generic constraint because it has Self or associated type requirements}}
 }