Test: Find better locations for some updated tests

Author: AnthonyLatsis

test/Generics/function_defs.swift

@@ -56,15 +56,6 @@ func otherExistential<T : EqualComparable>(_ t1: T) {
   _ = 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) { // Ok
-  x.runce(5)
-}
-
 //===----------------------------------------------------------------------===//
 // Overloading
 //===----------------------------------------------------------------------===//

test/Sema/existential_nested_type.swift

@@ -135,19 +135,6 @@ func genericFunction<T>(t: T) {
   // expected-error@-2 {{'Second' inherits from itself}}
 }
 
-// Spurious "Self or associated type requirements" diagnostic.
-protocol ProtoWithAssocType {
-  associatedtype T = Int
-}
-
-func freeFunction() {
-  struct ConformingType : ProtoWithAssocType {
-    typealias T = Int
-
-    func method() -> ProtoWithAssocType {} // Ok
-  }
-}
-
 // Superclass lookup archetype vs interface type mixup
 class Generic<T> {
   struct Nested {}

test/decl/nested/type_in_function.swift

@@ -263,55 +263,6 @@ struct WrongIsEqual : IsEqualComparable { // expected-error{{type 'WrongIsEqual'
   func isEqual(other: Int) -> Bool {}  // expected-note{{candidate has non-matching type '(Int) -> Bool'}}
 }
 
-//===----------------------------------------------------------------------===//
-// Using values of existential type.
-//===----------------------------------------------------------------------===//
-
-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()
-}
-
-protocol HasSequenceAndStream {
-  associatedtype R : IteratorProtocol, Sequence
-  func getR() -> R
-}
-
-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()
-  x.next()
-
-  x.nonexistent()
-}
-
-//===----------------------------------------------------------------------===//
-// Subscripting
-//===----------------------------------------------------------------------===//
-protocol IntIntSubscriptable {
-  subscript (i: Int) -> Int { get }
-}
-
-protocol IntSubscriptable {
-  associatedtype Element
-  subscript (i: Int) -> Element { get }
-}
-
-struct DictionaryIntInt {
-  subscript (i: Int) -> Int {
-    get {
-      return i
-    }
-  }
-}
-
-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}}
-}
-
 //===----------------------------------------------------------------------===//
 // Static methods
 //===----------------------------------------------------------------------===//

test/decl/protocol/protocols.swift

@@ -470,3 +470,51 @@ do {
     instance[static_invariantSelfSubscript: ()] // expected-error {{member 'subscript' cannot be used on value of protocol type 'P1_TypeMemberOnInstanceAndViceVersa'; use a generic constraint instead}}
   }
 }
+
+// Settable storage members with a 'Self' result type may not be used with an
+// existential base.
+protocol P2 {
+  subscript() -> Self { get set }
+
+  var prop: Self { get set }
+}
+func takesP2(p2: P2) {
+  _ = p2[]
+  // expected-error@-1{{member 'subscript' cannot be used on value of protocol type 'P2'; use a generic constraint instead}}
+  _ = p2.prop
+  // expected-error@-1{{member 'prop' cannot be used on value of protocol type 'P2'; use a generic constraint instead}}
+}
+
+protocol MiscTestsProto {
+  associatedtype Assoc
+  func runce<A>(_: A)
+  func spoon(_: Self)
+
+  associatedtype R : IteratorProtocol, Sequence
+  func getR() -> R
+
+  subscript(intToAssoc _: Int) -> Assoc { get }
+  subscript(intToInt _: Int) -> Int { get }
+}
+do {
+  func miscTests(_ arg: MiscTestsProto) { // ok
+    arg.runce(5)
+
+    do {
+      // FIXME: Crummy diagnostics.
+      var x = arg.getR() // expected-error{{member 'getR' cannot be used on value of protocol type 'MiscTestsProto'; use a generic constraint instead}}
+      x.makeIterator()
+      x.next()
+      x.nonexistent()
+    }
+
+    var _: Int = arg[intToInt: 17]
+    _ = arg[intToAssoc: 17] // expected-error{{member 'subscript' cannot be used on value of protocol type 'MiscTestsProto'; use a generic constraint instead}}
+  }
+
+  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()
+  }
+}

test/decl/protocol/protocols_with_self_or_assoc_reqs.swift

@@ -86,25 +86,3 @@ enum EError : P { // expected-error{{type 'EError' does not conform to protocol
   subscript() -> Int { 0 } // expected-note{{candidate has non-matching type '() -> Int'}}
   func f() -> Int { 0 } // expected-note{{candidate has non-matching type '() -> Int'}}
 }
-
-// Settable storage members with a 'Self' result type may not be used with an
-// existential base.
-protocol P5 {
-}
-extension P5 {
-  var prop: Self {
-    get { self }
-    set { }
-  }
-
-  subscript() -> Self {
-    get { self }
-    set { }
-  }
-}
-func takesP5(p5: P5) {
-  _ = p5[]
-  // expected-error@-1{{member 'subscript' cannot be used on value of protocol type 'P5'; use a generic constraint instead}}
-  _ = p5.prop
-  // expected-error@-1{{member 'prop' cannot be used on value of protocol type 'P5'; use a generic constraint instead}}
-}

test/decl/protocol/req/dynamic_self.swift

@@ -67,10 +67,33 @@ protocol HasAssoc {
   func foo()
 }
 
+do {
+  enum MyError : Error {
+    case bad(Any)
+  }
+
+  func checkIt(_ js: Any) throws {
+    switch js {
+    case let dbl as HasAssoc:
+      throw MyError.bad(dbl)
+
+    default:
+      fatalError("wrong")
+    }
+  }
+}
+
 func testHasAssoc(_ x: Any, _: HasAssoc) {
   if let p = x as? HasAssoc {
     p.foo() // don't crash here.
   }
+
+  struct ConformingType : HasAssoc {
+    typealias Assoc = Int
+    func foo() {}
+
+    func method() -> HasAssoc {}
+  }
 }
 
 // SR-38