Merge pull request #59271 from AnthonyLatsis/sr-2063

Add regression tests to close several fixed issues

Author: AnthonyLatsis

test/Constraints/operator.swift

@@ -296,3 +296,13 @@ postfix operator ^^^
 postfix func ^^^ (lhs: Int) -> Int! { 0 }
 
 let x: Int = 1^^^
+
+// https://github.com/apple/swift/issues/44672 - DiagnosticsQoI
+do {
+  enum TestEnum: Int {
+    case First, Second
+  }
+
+  let number = 1
+  let test = true || number == .First.rawValue // expected-error {{type 'Int' has no member 'First'}}
+}

test/Generics/unbound.swift

@@ -106,3 +106,34 @@ func nested(_: OuterStruct.InnerStruct<Int>) {}
 
 func nested(_: OuterStruct<Int>.InnerStruct) {}
 // expected-error@-1 {{reference to generic type 'OuterStruct<Int>.InnerStruct' requires arguments in <...>}}
+
+
+func assertExactType<T>(of _: T, is _: T.Type) {}
+
+// https://github.com/apple/swift/issues/51217
+protocol P {
+  associatedtype A
+  associatedtype B
+}
+do {
+  struct Concrete: P {
+    typealias A = Int
+    typealias B = Bool
+  }
+  struct Generic<A, B>: P {}
+
+  struct BinderGenericParams1<T1: P, T2: P>
+  where T1.A == T2.A, T1.B == T2.B {
+    static func bind(_: T1, _: T2) -> T2 {}
+  }
+  struct BinderGenericParams2 {
+    static func bind<T1: P, T2: P>(_: T1, _: T2) -> T2
+    where T1.A == T2.A, T1.B == T2.B {}
+  }
+
+  let x1 = BinderGenericParams1.bind(Concrete(), Generic())
+  let x2 = BinderGenericParams2.bind(Concrete(), Generic())
+
+  assertExactType(of: x1, is: Generic<Int, Bool>.self)
+  assertExactType(of: x2, is: Generic<Int, Bool>.self)
+}

test/decl/protocol/req/associated_type_inference.swift

@@ -684,6 +684,27 @@ struct S40<E: Equatable>: P40c {
   typealias B = Self
 }
 
+protocol P41a {
+  associatedtype A
+  associatedtype B
+
+  func bar(_: B) -> A?
+}
+protocol P42b: P41a {
+  associatedtype A
+  associatedtype B
+
+  func foo(_: A, _: B)
+}
+extension P42b {
+  func bar(_: B) -> A? {}
+}
+do {
+  class Conformer: P42b {
+    func foo(_: Bool, _: String) {}
+  }
+}
+
 // Fails to find the fixed type witness B == FIXME_S1<A>.
 protocol FIXME_P1a {
   associatedtype A: Equatable = Never // expected-note {{protocol requires nested type 'A'}}

test/decl/protocol/req/associated_type_inference_operator.swift

@@ -0,0 +1,12 @@
+// RUN: %target-typecheck-verify-swift
+
+struct Box<T> {}
+
+infix operator =*=
+protocol P1 {
+  associatedtype A
+  static func =*= (x: Self, y: Box<A>)
+}
+class C1<A>: P1 {
+  static func =*= (x: C1, y: Box<A>) {}
+}

test/decl/protocol/req/associated_type_inference_proto_ext.swift

@@ -1,5 +1,7 @@
 // RUN: %target-typecheck-verify-swift
 
+func assertEqualTypes<T>(_: T.Type, _: T.Type) {}
+
 struct Pair<A, B> {
     var a: A
     var b: B
@@ -28,3 +30,33 @@ extension Pair: Collection where A == B {
         return i + 1
     }
 }
+
+// https://github.com/apple/swift/issues/52024
+protocol VectorBase : RandomAccessCollection where Index == Int, Element == Elle {
+  associatedtype Elle
+
+  var data: Array<Elle> { get set }
+  init(data: Array<Elle>)
+}
+
+protocol Vector: VectorBase {}
+extension Vector where Elle: FloatingPoint {
+  // RandomAccessCollection
+  var indices: Range<Int> { get {} }
+  var startIndex: Int { get {} }
+  var endIndex: Int { get {} }
+
+  // MutableCollection
+  subscript(i: Index) -> Elle {
+    get {} set {}
+  }
+}
+
+do {
+  struct VectorF: Vector {
+    var data: Array<Float>
+    init(data: Array<Float>) {}
+  }
+
+  assertEqualTypes(VectorF.Elle.self, Float.self)
+}

validation-test/compiler_crashers_2_fixed/sr13703.swift

@@ -0,0 +1,9 @@
+// RUN: %swift-ide-test -code-completion -code-completion-token=COMPLETE -source-filename %s
+
+extension Result {
+  public init(_ value: Success?) {
+    self = value.map(#^COMPLETE^#)
+  }
+}
+
+public func materialize<T>(_ f: T) {}