[embedded] Fix associated type conformances for specialized witness tables

SwiftCompilerSources/Sources/AST/Declarations.swift

@@ -76,6 +76,7 @@ final public class ClassDecl: NominalTypeDecl {
 
 final public class ProtocolDecl: NominalTypeDecl {
   public var requiresClass: Bool { bridged.ProtocolDecl_requiresClass() }
+  public var isMarkerProtocol: Bool { bridged.ProtocolDecl_isMarkerProtocol() }
 }
 
 final public class BuiltinTupleDecl: NominalTypeDecl {}

SwiftCompilerSources/Sources/Optimizer/ModulePasses/EmbeddedSwiftDiagnostics.swift

@@ -94,6 +94,11 @@ private struct FunctionChecker {
         for conf in ie.conformances {
           try checkConformance(conf, location: ie.location)
         }
+      } else if instruction is OpenExistentialAddrInst {
+          // okay in embedded with exitentials
+      } else {
+          // not supported even in embedded with exitentials
+        throw Diagnostic(.embedded_swift_existential_type, instruction.operands[0].value.type, at: instruction.location)
       }
 
     case let aeb as AllocExistentialBoxInst:

SwiftCompilerSources/Sources/Optimizer/ModulePasses/MandatoryPerformanceOptimizations.swift

@@ -143,6 +143,14 @@ private func optimize(function: Function, _ context: FunctionPassContext, _ modu
           }
         }
 
+      case let initExAddr as InitExistentialAddrInst:
+        if context.options.enableEmbeddedSwift {
+          for c in initExAddr.conformances where c.isConcrete && !c.protocol.isMarkerProtocol {
+            specializeWitnessTable(for: c, moduleContext)
+            worklist.addWitnessMethods(of: c, moduleContext)
+          }
+        }
+
       case let bi as BuiltinInst:
         switch bi.id {
         case .BuildOrdinaryTaskExecutorRef,

SwiftCompilerSources/Sources/Optimizer/Utilities/GenericSpecialization.swift

@@ -148,7 +148,7 @@ func specializeWitnessTable(for conformance: Conformance, _ context: ModulePassC
       guard !methodSubs.conformances.contains(where: {!$0.isValid}),
             context.loadFunction(function: origMethod, loadCalleesRecursively: true),
             let specializedMethod = context.specialize(function: origMethod, for: methodSubs,
-                                                       convertIndirectToDirect: true, isMandatory: true)
+                                                       convertIndirectToDirect: false, isMandatory: true)
       else {
         return origEntry
       }
@@ -215,7 +215,7 @@ private func specializeDefaultMethods(for conformance: Conformance,
       guard !methodSubs.conformances.contains(where: {!$0.isValid}),
             context.loadFunction(function: origMethod, loadCalleesRecursively: true),
             let specializedMethod = context.specialize(function: origMethod, for: methodSubs,
-                                                       convertIndirectToDirect: true, isMandatory: true)
+                                                       convertIndirectToDirect: false, isMandatory: true)
       else {
         return origEntry
       }

SwiftCompilerSources/Sources/Optimizer/Utilities/OptUtils.swift

@@ -1010,8 +1010,7 @@ func isCastSupportedInEmbeddedSwift(from sourceType: Type,
     return false
   }
 
-  // Tuple?
-  if !destType.isStruct && !destType.isClass && !destType.isEnum {
+  if !destType.isStruct && !destType.isClass && !destType.isEnum && !destType.isTuple {
     return false
   }
 

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -883,6 +883,10 @@ class InitExistentialAddrInst : SingleValueInstruction, UnaryInstruction {
   public var conformances: ConformanceArray {
     ConformanceArray(bridged: bridged.InitExistentialAddrInst_getConformances())
   }
+
+  public var formalConcreteType: CanonicalType {
+    CanonicalType(bridged: bridged.InitExistentialAddrInst_getFormalConcreteType())
+  }
 }
 
 final public

include/swift/AST/ASTBridging.h

@@ -335,6 +335,7 @@ struct BridgedDeclObj {
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedASTType Class_getSuperclass() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedDeclObj Class_getDestructor() const;
   BRIDGED_INLINE bool ProtocolDecl_requiresClass() const;
+  BRIDGED_INLINE bool ProtocolDecl_isMarkerProtocol() const;
   BRIDGED_INLINE bool AbstractFunction_isOverridden() const;
   BRIDGED_INLINE bool Destructor_isIsolated() const;
   BRIDGED_INLINE bool EnumElementDecl_hasAssociatedValues() const;

include/swift/AST/ASTBridgingImpl.h

@@ -222,6 +222,10 @@ bool BridgedDeclObj::ProtocolDecl_requiresClass() const {
   return getAs<swift::ProtocolDecl>()->requiresClass();
 }
 
+bool BridgedDeclObj::ProtocolDecl_isMarkerProtocol() const {
+  return getAs<swift::ProtocolDecl>()->isMarkerProtocol();
+}
+
 bool BridgedDeclObj::AbstractFunction_isOverridden() const {
   return getAs<swift::AbstractFunctionDecl>()->isOverridden();
 }

include/swift/SIL/SILBridging.h

@@ -798,6 +798,7 @@ struct BridgedInstruction {
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedConformanceArray InitExistentialRefInst_getConformances() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedCanType InitExistentialRefInst_getFormalConcreteType() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedConformanceArray InitExistentialAddrInst_getConformances() const;
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedCanType InitExistentialAddrInst_getFormalConcreteType() const;
   BRIDGED_INLINE bool OpenExistentialAddr_isImmutable() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedGlobalVar GlobalAccessInst_getGlobal() const;
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedGlobalVar AllocGlobalInst_getGlobal() const;

include/swift/SIL/SILBridgingImpl.h

@@ -1252,6 +1252,11 @@ BridgedCanType BridgedInstruction::InitExistentialRefInst_getFormalConcreteType(
 BridgedConformanceArray BridgedInstruction::InitExistentialAddrInst_getConformances() const {
   return {getAs<swift::InitExistentialAddrInst>()->getConformances()};
 }
+
+BridgedCanType BridgedInstruction::InitExistentialAddrInst_getFormalConcreteType() const {
+  return getAs<swift::InitExistentialAddrInst>()->getFormalConcreteType();
+}
+
 bool BridgedInstruction::OpenExistentialAddr_isImmutable() const {
   switch (getAs<swift::OpenExistentialAddrInst>()->getAccessKind()) {
     case swift::OpenedExistentialAccess::Immutable: return true;

include/swift/SILOptimizer/Utils/Generics.h

@@ -216,7 +216,9 @@ class ReabstractionInfo {
 
   ReabstractionInfo(CanSILFunctionType substitutedType,
                     SILDeclRef methodDecl,
+                    bool convertIndirectToDirect,
                     SILModule &M) :
+    ConvertIndirectToDirect(convertIndirectToDirect),
     SubstitutedType(substitutedType),
     methodDecl(methodDecl),
     M(&M), isWholeModule(M.isWholeModule()) {}

lib/IRGen/GenProto.cpp

@@ -1751,6 +1751,10 @@ class AccessorConformanceInfo : public ConformanceInfo {
 #endif
 
       auto typeWitness = Conformance.getTypeWitness(assocType);
+      if (langOpts.hasFeature(Feature::EmbeddedExistentials) &&
+          SILWT->isSpecialized()) {
+        typeWitness = entry.getAssociatedTypeWitness().Witness;
+      }
 
       if (IGM.Context.LangOpts.hasFeature(Feature::EmbeddedExistentials)) {
         // In Embedded Swift associated type witness point to the metadata.

lib/SILOptimizer/Utils/Generics.cpp

@@ -2413,7 +2413,8 @@ bool swift::specializeClassMethodInst(ClassMethodInst *cm) {
   SILType substitutedType =
       funcTy.substGenericArgs(m, subs, TypeExpansionContext::minimal());
 
-  ReabstractionInfo reInfo(substitutedType.getAs<SILFunctionType>(), cm->getMember(), m);
+  ReabstractionInfo reInfo(substitutedType.getAs<SILFunctionType>(), cm->getMember(),
+                           /*convertIndirectToDirect=*/ true, m);
   reInfo.createSubstitutedAndSpecializedTypes();
   CanSILFunctionType finalFuncTy = reInfo.getSpecializedType();
   SILType finalSILTy = SILType::getPrimitiveObjectType(finalFuncTy);
@@ -2465,7 +2466,8 @@ bool swift::specializeWitnessMethodInst(WitnessMethodInst *wm) {
   SILType substitutedType =
       funcTy.substGenericArgs(m, subs, TypeExpansionContext::minimal());
 
-  ReabstractionInfo reInfo(substitutedType.getAs<SILFunctionType>(), wm->getMember(), m);
+  ReabstractionInfo reInfo(substitutedType.getAs<SILFunctionType>(), wm->getMember(),
+                           /*convertIndirectToDirect=*/ false, m);
   reInfo.createSubstitutedAndSpecializedTypes();
   CanSILFunctionType finalFuncTy = reInfo.getSpecializedType();
   SILType finalSILTy = SILType::getPrimitiveObjectType(finalFuncTy);

test/embedded/existential.swift

@@ -216,6 +216,133 @@ func test7(_ p: any Any) {
   c.a()
 }
 
+class BaseClass {
+  func foo() { print("BaseClass.foo") }
+  deinit {
+    print("BaseClass.deinit")
+  }
+}
+
+class SubClass : BaseClass {
+  override func foo() { print("SubClass.foo") }
+}
+
+func test8(_ p: any Any) {
+  print("test any as? SubClass")
+  if let c = p as? SubClass {
+    print("success")
+    c.foo()
+  } else {
+    print("cast failed")
+  }
+}
+
+func test9(_ p: any Any) {
+  print("test any as? BaseClass")
+  if let c = p as? BaseClass {
+    print("success")
+    c.foo()
+  } else {
+    print("cast failed")
+  }
+}
+
+func test10(_ p: any Any) {
+  print("test any as! BaseClass")
+  let c = p as! BaseClass
+  c.foo()
+}
+
+func test11(_ p: any Any) {
+  print("test any as! SubClass")
+  let c = p as! SubClass
+  c.foo()
+}
+
+func test12(_ p: any Any) {
+  print("test any as! (Int, Int, Int, Int)")
+  if let c = p as? (Int, Int, Int, Int) {
+    print("success")
+    print("tuple: \(c.0)")
+  } else {
+    print("cast failed")
+  }
+}
+
+protocol Q {
+  func printit()
+}
+
+protocol P4<T> {
+  associatedtype T: Q
+
+  var t: T { get }
+}
+
+struct QConformer : Q {
+  var x = (0, 1, 2,3)
+
+  func printit() {
+      print("QConformer \(x.3)")
+  }
+}
+
+struct P4Conformer : P4 {
+  var q = QConformer()
+
+  var t : QConformer {
+    get {
+      return q
+    }
+  }
+}
+
+func test13(_ p: any P4) {
+  print("test13")
+  p.t.printit()
+}
+
+struct GenericConformer<T> : ValuePrinter {
+  var t: T?
+  var l = (0, 1, 2, 3)
+
+  init(_ t: T) { self.t = t }
+
+  func printValue() {
+    print("GenericConformer \(l.0) \(l.1) \(l.2) \(l.3)")
+  }
+
+  mutating func mutate() {
+    l = (4, 5, 6, 7)
+  }
+}
+
+struct GenericConformerWithAssoc<T> : WithAssoc {
+  var g : GenericConformer<T>
+
+  init( _ g: T) {
+    self.g = GenericConformer(g)
+  }
+
+  func a() -> GenericConformer<T> {
+    return g
+  }
+}
+
+func test14(_ p: any ValuePrinter) {
+  print("test any ValuePrinter")
+  p.printValue()
+  var p2 = p
+  p2.mutate()
+  p2.printValue()
+}
+
+func test15(_ p: any WithAssoc) {
+  print("test any WithAssoc")
+  let l = p.a()
+  l.printValue()
+}
+
 @main
 struct Main {
   static func main() {
@@ -262,7 +389,7 @@ struct Main {
 // OUTPUT:  deinit called
 // OUTPUT: cast failed
 // OUTPUT-NOT:  deinit called
-   test5(GenericStructWithClass<Int>())
+    test5(GenericStructWithClass<Int>())
 // OUTPUT: test any as? MyStruct
 // OUTPUT: cast failed
 // OUTPUT:  deinit called
@@ -289,5 +416,61 @@ struct Main {
 // OUTPUT: a LargeMyStruct 5
 // OUTPUT:  deinit called
 // OUTPUT-NOT:  deinit called
+    test8(SubClass())
+// OUTPUT:  success
+// OUTPUT:  SubClass.foo
+// OUTPUT:  BaseClass.deinit
+// OUTPUT-NOT:  deinit
+    test8(BaseClass())
+// OUTPUT: test any as? SubClass
+// OUTPUT: cast failed
+// OUTPUT: BaseClass.deinit
+// OUTPUT-NOT:  deinit
+    test9(SubClass())
+// OUTPUT: test any as? BaseClass
+// OUTPUT:  success
+// OUTPUT:  SubClass.foo
+// OUTPUT:  BaseClass.deinit
+// OUTPUT-NOT:  deinit
+    test9(BaseClass())
+// OUTPUT: test any as? BaseClass
+// OUTPUT:  success
+// OUTPUT:  BaseClass.foo
+// OUTPUT:  BaseClass.deinit
+// OUTPUT-NOT:  deinit
+    test9(C())
+// OUTPUT: test any as? BaseClass
+// OUTPUT: cast failed
+// OUTPUT-NOT:  deinit
+    test10(BaseClass())
+// OUTPUT: test any as! BaseClass
+// OUTPUT:  BaseClass.foo
+// OUTPUT:  BaseClass.deinit
+// OUTPUT-NOT:  deinit
+    test10(SubClass())
+// OUTPUT: test any as! BaseClass
+// OUTPUT:  SubClass.foo
+// OUTPUT:  BaseClass.deinit
+// OUTPUT-NOT:  deinit
+    test11(SubClass())
+// OUTPUT: test any as! SubClass
+// OUTPUT:  SubClass.foo
+// OUTPUT:  BaseClass.deinit
+// OUTPUT-NOT:  deinit
+    test12((0, 1, 2, 3))
+// OUTPUT: test any as! (Int, Int, Int, Int)
+// OUTPUT:   success
+// OUTPUT:   tuple: 0
+    test13(P4Conformer())
+// OUTPUT: test13
+// OUTPUT:  QConformer 3
+// OUTPUT-NOT:  deinit
+    test14(GenericConformer(1))
+// OUTPUT: test any ValuePrinter
+// OUTPUT:  GenericConformer 0 1 2 3
+// OUTPUT:  GenericConformer 4 5 6 7
+    test15(GenericConformerWithAssoc(1))
+// OUTPUT: test any WithAssoc
+// OUTPUT:  GenericConformer 0 1 2 3
   }
 }