MandatoryPerformanceOptimizations: handle all kind of witness-table entries when specializing witness-tables

Support associated-type and associated-conformance entries.
This enable existentials with associated types.

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/Utilities/GenericSpecialization.swift

@@ -89,6 +89,8 @@ func specializeWitnessTable(forConformance conformance: Conformance,
 
   let newEntries = witnessTable.entries.map { origEntry in
     switch origEntry {
+    case .invalid:
+      return WitnessTable.Entry.invalid
     case .method(let requirement, let witness):
       guard let origMethod = witness else {
         return origEntry
@@ -108,9 +110,14 @@ func specializeWitnessTable(forConformance conformance: Conformance,
                                                        substitutions: conformance.specializedSubstitutions)
       specializeWitnessTable(forConformance: baseConf, errorLocation: errorLocation, context, notifyNewWitnessTable)
       return .baseProtocol(requirement: requirement, witness: baseConf)
-    default:
-      // TODO: handle other witness table entry kinds
-      fatalError("unsupported witness table etnry")
+    case .associatedType(let requirement, let witness):
+      let substType = witness.subst(with: conformance.specializedSubstitutions)
+      return .associatedType(requirement: requirement, witness: substType)
+    case .associatedConformance(let requirement, let proto, let witness):
+      if witness.isSpecialized {
+        specializeWitnessTable(forConformance: witness, errorLocation: errorLocation, context, notifyNewWitnessTable)
+      }
+      return .associatedConformance(requirement: requirement, protocol: proto, witness: witness)
     }
   }
   let newWT = context.createWitnessTable(entries: newEntries,conformance: conformance,

test/embedded/existential-class-bound1.swift

@@ -29,6 +29,61 @@ func test(existential: any ClassBound) {
     existential.bar()
 }
 
+public protocol ProtoWithAssocType<T>: AnyObject {
+  associatedtype T
+  func foo(t: T)
+}
+
+final public class GenClass<T: BinaryInteger>: ProtoWithAssocType {
+  public func foo(t: T) {
+    print(t)
+  }
+}
+
+public func createExWithAssocType() -> any ProtoWithAssocType<Int> {
+  return GenClass<Int>()
+}
+
+public func callExWithAssocType(_ p: any ProtoWithAssocType<Int>) {
+  p.foo(t: 27)
+}
+
+public protocol Q: AnyObject {
+  func bar()
+}
+
+public protocol ProtoWithAssocConf: AnyObject {
+  associatedtype A: Q
+  func foo() -> A
+}
+
+public class GenClass2<T>: Q {
+  var t: T
+
+  init(t : T) { self.t = t }
+
+  public func bar() {
+    print("bar")
+  }
+}
+
+final public class GenClass3<V>: ProtoWithAssocConf {
+  public func foo() -> GenClass2<Int> {
+    print("foo")
+    return GenClass2(t: 27)
+  }
+}
+
+
+public func createExWithAssocConf() -> any ProtoWithAssocConf {
+  return GenClass3<Int>()
+}
+
+public func callExWithAssocConf(_ p: any ProtoWithAssocConf) {
+  let x = p.foo()
+  x.bar()
+}
+
 @main
 struct Main {
     static func main() {
@@ -38,6 +93,11 @@ struct Main {
         test(existential: MyOtherClass())
         // CHECK: MyOtherClass.foo()
         // CHECK: MyOtherClass.bar()
+        callExWithAssocType(createExWithAssocType())
+        // CHECK: 27
+        callExWithAssocConf(createExWithAssocConf())
+        // CHECK: foo
+        // CHECK: bar
     }
 }