Merge pull request #71539 from slavapestov/assoc-type-regression-fixes-2

Three more associated type inference fixes

Author: slavapestov

lib/Sema/AssociatedTypeInference.cpp

@@ -67,8 +67,6 @@ actor A2: DistributedActor {
 final class DA2: DistributedActor {
 // expected-error@-1{{non-actor type 'DA2' cannot conform to the 'AnyActor' protocol}}
 // expected-error@-2{{non-distributed actor type 'DA2' cannot conform to the 'DistributedActor' protocol}}
-// expected-error@-3{{'DistributedActor' requires the types 'ObjectIdentifier' and 'FakeActorSystem.ActorID' (aka 'ActorAddress') be equivalent}}
-// expected-note@-4{{requirement specified as 'Self.ID' == 'Self.ActorSystem.ActorID' [with Self = DA2]}}
   nonisolated var id: ID {
     fatalError()
   }

test/Distributed/actor_protocols.swift

@@ -18,3 +18,5 @@ struct S: P {
   func f(_: Float) {}
   func f(_: String) {}
 }
+
+let x: String.Type = S.A.self

test/decl/protocol/req/associated_type_inference_fixed_type_experimental_inference.swift

@@ -0,0 +1,20 @@
+// RUN: %target-typecheck-verify-swift -enable-experimental-associated-type-inference
+// RUN: %target-typecheck-verify-swift -disable-experimental-associated-type-inference
+
+public protocol LazySequenceProtocol: Sequence {
+  associatedtype Elements: Sequence = Self where Elements.Element == Element
+}
+
+public struct S<Base: Sequence>: LazySequenceProtocol {
+  public struct Iterator: IteratorProtocol {
+    public mutating func next() -> Base.Element? {
+      fatalError()
+    }
+  }
+
+  public func makeIterator() -> Iterator {
+    fatalError()
+  }
+}
+
+let x: Int.Type = S<Array<Int>>.Element.self

test/decl/protocol/req/associated_type_inference_tautology_2.swift

@@ -0,0 +1,27 @@
+// RUN: %target-typecheck-verify-swift -enable-experimental-associated-type-inference
+// RUN: %target-typecheck-verify-swift -disable-experimental-associated-type-inference
+
+public struct DefaultA {}
+
+public protocol P {
+    associatedtype A = DefaultA
+    associatedtype B
+
+    static func foo(_: A, _: B)
+    static func bar(_: B)
+}
+
+extension P {
+    public static func foo(_: A, _: B) where B == Void {}
+}
+
+// The only way C can conform to P is with 'A := DefaultA' and 'B := String'.
+// We skip C.foo() because it contains 'A', so we must not infer 'B := Void'
+// from P.foo() above.
+class C: P {
+    public static func foo(_: A, _: String) {}
+    public static func bar(_: String) {}
+}
+
+let x: DefaultA.Type = C.A.self
+let y: String.Type = C.B.self

test/decl/protocol/req/rdar122574126.swift

@@ -12,3 +12,5 @@ extension P {
     public subscript(index: Int) -> String { fatalError() }
     public func makeIterator() -> AnyIterator<String> { fatalError() }
 }
+
+let x: AnyIterator<String>.Type = S.Iterator.self

test/decl/protocol/req/rdar122584912.swift

@@ -0,0 +1,38 @@
+// RUN: %target-typecheck-verify-swift -enable-experimental-associated-type-inference
+// RUN: %target-typecheck-verify-swift -disable-experimental-associated-type-inference
+
+public protocol P1 {
+  associatedtype A
+  func f() -> A
+}
+
+public struct S1 {}
+
+extension Int: P1 {
+  public func f() -> S1 { fatalError() }
+}
+
+public protocol P2: RawRepresentable, P1 {}
+
+public struct S2 {}
+
+extension P2 where RawValue == S2, A == S2 {
+  // This is not a candidate witness, because we require A == S1.
+  public func f() -> A { fatalError() }
+}
+
+extension P2 where RawValue: P1, RawValue.A == A {
+  // This is a candidate witness.
+  public func f() -> A { fatalError() }
+}
+
+public protocol P3: P2 where A == S1, RawValue == Int {}
+
+// When checking [S3: P1], the fact that P3 has [A == S1] should completely
+// solve everything.
+public struct S3: P3 {
+  public init(rawValue: Int) { fatalError() }
+  public var rawValue: Int { fatalError() }
+}
+
+let x: S1.Type = S3.A.self

test/decl/protocol/req/rdar122586685.swift

@@ -0,0 +1,19 @@
+// RUN: %target-typecheck-verify-swift -enable-experimental-associated-type-inference
+// RUN: %target-typecheck-verify-swift -disable-experimental-associated-type-inference
+
+struct G<T> {
+  class Nested {}
+}
+
+extension G.Nested: Sequence {
+  func makeIterator() -> AnyIterator<String> { fatalError() }
+}
+
+extension G: LazySequenceProtocol, IteratorProtocol {
+  mutating func next() -> Int? { fatalError() }
+}
+
+let c: G<Float>.Type = G<Float>.Iterator.self
+let n: Int.Type = G<Float>.Element.self
+let d: AnyIterator<String>.Type = G<Float>.Nested.Iterator.self
+let s: String.Type = G<Float>.Nested.Element.self