MandatoryPerformanceOptimizations: support default methods for class existentials

For example: ``` protocol P: AnyObject { func foo() } extension P { func foo() {} } class C: P {} let e: any P = C() ``` Such default methods are SILGen'd with a generic self argument. Therefore we need to specialize such witness methods, even if the conforming type is not generic. rdar://145855851

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/ModulePasses/MandatoryPerformanceOptimizations.swift

@@ -10,6 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+import AST
 import SIL
 
 /// Performs mandatory optimizations for performance-annotated functions, and global
@@ -39,11 +40,6 @@ let mandatoryPerformanceOptimizations = ModulePass(name: "mandatory-performance-
 }
 
 optimizeFunctionsTopDown(using:&worklist, moduleContext)
-
-if moduleContext.options.enableEmbeddedSwift {
- // Print errors for generic functions in vtables, which is not allowed in embedded Swift.
-checkVTablesForGenericFunctions(moduleContext)
-}
 }
 
 privatefunc optimizeFunctionsTopDown(using worklist:inoutFunctionWorklist,
@@ -131,9 +127,27 @@ private func optimize(function: Function, _ context: FunctionPassContext, _ modu
 
 caseletinitExRef as InitExistentialRefInst:
 if context.options.enableEmbeddedSwift {
-specializeWitnessTables(for: initExRef, moduleContext,&worklist)
+forcin initExRef.conformances where c.isConcrete {
+specializeWitnessTable(for: c, moduleContext){
+ worklist.addWitnessMethods(of: $0)
+}
+}
 }
 
+caseletbi as BuiltinInst:
+switch bi.id {
+case.BuildOrdinaryTaskExecutorRef,
+.BuildOrdinarySerialExecutorRef,
+.BuildComplexEqualitySerialExecutorRef:
+specializeWitnessTable(for: bi.substitutionMap.conformances[0], moduleContext){
+ worklist.addWitnessMethods(of: $0)
+}
+
+default:
+break
+}
+
+
  // We need to de-virtualize deinits of non-copyable types to be able to specialize the deinitializers.
 caseletdestroyValue as DestroyValueInst:
 if !devirtualizeDeinits(of: destroyValue, simplifyCtxt){
@@ -282,47 +296,6 @@ private func shouldInline(apply: FullApplySite, callee: Function, alreadyInlined
 returnfalse
 }
 
-privatefunc specializeWitnessTables(for initExRef:InitExistentialRefInst, _ context:ModulePassContext,
- _ worklist:inoutFunctionWorklist)
-{
-forcin initExRef.conformances where c.isConcrete {
-letconformance= c.isInherited ? c.inheritedConformance : c
-letorigWitnessTable= context.lookupWitnessTable(for: conformance)
-if conformance.isSpecialized {
-if origWitnessTable ==nil{
-specializeWitnessTable(forConformance: conformance, errorLocation: initExRef.location, context){
- worklist.addWitnessMethods(of: $0)
-}
-}
-}elseiflet origWitnessTable {
-checkForGenericMethods(in: origWitnessTable, errorLocation: initExRef.location, context)
-}
-}
-}
-
-privatefunc checkForGenericMethods(in witnessTable:WitnessTable,
- errorLocation:Location,
- _ context:ModulePassContext)
-{
-forentryin witnessTable.entries {
-if case .method(let requirement,let witness)= entry,
-let witness,
- witness.isGeneric
-{
- context.diagnosticEngine.diagnose(.cannot_specialize_witness_method, requirement, at: errorLocation)
-return
-}
-}
-}
-
-privatefunc checkVTablesForGenericFunctions(_ context:ModulePassContext){
-forvTablein context.vTables where !vTable.class.isGenericAtAnyLevel {
-forentryin vTable.entries where entry.implementation.isGeneric {
- context.diagnosticEngine.diagnose(.non_final_generic_class_function, at: entry.methodDecl.location)
-}
-}
-}
-
 privateextensionFullApplySite{
 func resultIsUsedInGlobalInitialization()->SmallProjectionPath?{
 guard parentFunction.isGlobalInitOnceFunction,

SwiftCompilerSources/Sources/Optimizer/PassManager/ModulePassContext.swift

@@ -144,14 +144,14 @@ struct ModulePassContext : Context, CustomStringConvertible {
 }
 
 @discardableResult
-funccreateWitnessTable(entries:[WitnessTable.Entry],
+funccreateSpecializedWitnessTable(entries:[WitnessTable.Entry],
  conformance:Conformance,
  linkage:Linkage,
  serialized:Bool)->WitnessTable
 {
 letbridgedEntries= entries.map{ $0.bridged }
 letbridgedWitnessTable= bridgedEntries.withBridgedArrayRef{
- _bridged.createWitnessTable(linkage.bridged, serialized, conformance.bridged, $0)
+ _bridged.createSpecializedWitnessTable(linkage.bridged, serialized, conformance.bridged, $0)
 }
 returnWitnessTable(bridged: bridgedWitnessTable)
 }

SwiftCompilerSources/Sources/Optimizer/Utilities/GenericSpecialization.swift

@@ -79,7 +79,7 @@ private struct VTableSpecializer {
 }
 
 privatefunc specializeEntries(of vTable:VTable, _ notifyNewFunction:(Function)->())->[VTable.Entry]{
-return vTable.entries.compactMap{ entry in
+return vTable.entries.map{ entry in
 if !entry.implementation.isGeneric {
 return entry
 }
@@ -91,8 +91,7 @@ private struct VTableSpecializer {
  context.loadFunction(function: entry.implementation, loadCalleesRecursively:true),
 let specializedMethod = context.specialize(function: entry.implementation, for: methodSubs)else
 {
- context.diagnosticEngine.diagnose(.non_final_generic_class_function, at: entry.methodDecl.location)
-returnnil
+return entry
 }
 notifyNewFunction(specializedMethod)
 
@@ -106,16 +105,29 @@ private struct VTableSpecializer {
 }
 }
 
-func specializeWitnessTable(forConformance conformance:Conformance,
- errorLocation:Location,
+/// Specializes a witness table of `conformance` for the concrete type of the conformance.
+func specializeWitnessTable(for conformance:Conformance,
  _ context:ModulePassContext,
  _ notifyNewWitnessTable:(WitnessTable)->())
 {
-letgenericConformance= conformance.genericConformance
-guardlet witnessTable = context.lookupWitnessTable(for: genericConformance)else{
+iflet existingSpecialization = context.lookupWitnessTable(for: conformance),
+ existingSpecialization.isSpecialized
+{
+return
+}
+
+letbaseConf= conformance.isInherited ? conformance.inheritedConformance: conformance
+if !baseConf.isSpecialized {
+varvisited=Set<Conformance>()
+specializeDefaultMethods(for: conformance, visited:&visited, context, notifyNewWitnessTable)
+return
+}
+
+guardlet witnessTable = context.lookupWitnessTable(for: baseConf.genericConformance)else{
 fatalError("no witness table found")
 }
 assert(witnessTable.isDefinition,"No witness table available")
+letsubstitutions= baseConf.specializedSubstitutions
 
 letnewEntries= witnessTable.entries.map{ origEntry in
 switch origEntry {
@@ -125,21 +137,22 @@ func specializeWitnessTable(forConformance conformance: Conformance,
 guardlet origMethod = witness else{
 return origEntry
 }
-letmethodSubs= conformance.specializedSubstitutions.getMethodSubstitutions(for: origMethod)
+letmethodSubs= substitutions.getMethodSubstitutions(for: origMethod,
+ // Generic self types need to be handled specially (see `getMethodSubstitutions`)
+ selfType: origMethod.hasGenericSelf(context)? conformance.type.canonical :nil)
 
 guard !methodSubs.conformances.contains(where:{!$0.isValid}),
  context.loadFunction(function: origMethod, loadCalleesRecursively:true),
 let specializedMethod = context.specialize(function: origMethod, for: methodSubs)else
 {
- context.diagnosticEngine.diagnose(.cannot_specialize_witness_method, requirement, at: errorLocation)
 return origEntry
 }
 return.method(requirement: requirement, witness: specializedMethod)
 case.baseProtocol(let requirement,let witness):
 letbaseConf= context.getSpecializedConformance(of: witness,
  for: conformance.type,
  substitutions: conformance.specializedSubstitutions)
-specializeWitnessTable(forConformance: baseConf, errorLocation: errorLocation, context, notifyNewWitnessTable)
+specializeWitnessTable(for: baseConf, context, notifyNewWitnessTable)
 return.baseProtocol(requirement: requirement, witness: baseConf)
 case.associatedType(let requirement,let witness):
 letsubstType= witness.subst(with: conformance.specializedSubstitutions)
@@ -150,15 +163,104 @@ func specializeWitnessTable(forConformance conformance: Conformance,
 letconcreteAssociateConf= conformance.getAssociatedConformance(ofAssociatedType: requirement.rawType,
  to: assocConf.protocol)
 if concreteAssociateConf.isSpecialized {
-specializeWitnessTable(forConformance: concreteAssociateConf,
- errorLocation: errorLocation,
- context, notifyNewWitnessTable)
+specializeWitnessTable(for: concreteAssociateConf, context, notifyNewWitnessTable)
 }
 return.associatedConformance(requirement: requirement,
  witness: concreteAssociateConf)
 }
 }
-letnewWT= context.createWitnessTable(entries: newEntries,conformance: conformance,
- linkage:.shared, serialized:false)
+letnewWT= context.createSpecializedWitnessTable(entries: newEntries,conformance: conformance,
+linkage:.shared, serialized:false)
 notifyNewWitnessTable(newWT)
 }
+
+/// Specializes the default methods of a non-generic witness table.
+/// Default implementations (in protocol extentions) of non-generic protocol methods have a generic
+/// self argument. Specialize such methods with the concrete type. Note that it is important to also
+/// specialize inherited conformances so that the concrete self type is correct, even for derived classes.
+privatefunc specializeDefaultMethods(for conformance:Conformance,
+ visited:inoutSet<Conformance>,
+ _ context:ModulePassContext,
+ _ notifyNewWitnessTable:(WitnessTable)->())
+{
+ // Avoid infinite recursion, which may happen if an associated conformance is the conformance itself.
+guard visited.insert(conformance).inserted,
+let witnessTable = context.lookupWitnessTable(for: conformance.rootConformance)
+else{
+return
+}
+
+assert(witnessTable.isDefinition,"No witness table available")
+
+varspecialized=false
+
+letnewEntries= witnessTable.entries.map{ origEntry in
+switch origEntry {
+case.invalid:
+returnWitnessTable.Entry.invalid
+case.method(let requirement,let witness):
+guardlet origMethod = witness,
+ // Is it a generic method where only self is generic (= a default witness method)?
+ origMethod.isGeneric, origMethod.isNonGenericWitnessMethod(context)
+else{
+return origEntry
+}
+ // Replace the generic self type with the concrete type.
+letmethodSubs=SubstitutionMap(genericSignature: origMethod.genericSignature,
+ replacementTypes:[conformance.type])
+
+guard !methodSubs.conformances.contains(where:{!$0.isValid}),
+ context.loadFunction(function: origMethod, loadCalleesRecursively:true),
+let specializedMethod = context.specialize(function: origMethod, for: methodSubs)else
+{
+return origEntry
+}
+ specialized =true
+return.method(requirement: requirement, witness: specializedMethod)
+case.baseProtocol(_,let witness):
+specializeDefaultMethods(for: witness, visited:&visited, context, notifyNewWitnessTable)
+return origEntry
+case.associatedType:
+return origEntry
+case.associatedConformance(_,let assocConf):
+specializeDefaultMethods(for: assocConf, visited:&visited, context, notifyNewWitnessTable)
+return origEntry
+}
+}
+ // If the witness table does not contain any default methods, there is no need to create a
+ // specialized witness table.
+if specialized {
+letnewWT= context.createSpecializedWitnessTable(entries: newEntries,conformance: conformance,
+ linkage:.shared, serialized:false)
+notifyNewWitnessTable(newWT)
+}
+}
+
+privateextensionFunction{
+ // True, if this is a non-generic method which might have a generic self argument.
+ // Default implementations (in protocol extentions) of non-generic protocol methods have a generic
+ // self argument.
+func isNonGenericWitnessMethod(_ context:someContext)->Bool{
+switch loweredFunctionType.invocationGenericSignatureOfFunction.genericParameters.count {
+case0:
+returntrue
+case1:
+returnhasGenericSelf(context)
+default:
+returnfalse
+}
+}
+
+ // True, if the self argument is a generic parameter.
+func hasGenericSelf(_ context:someContext)->Bool{
+letconvention=FunctionConvention(for: loweredFunctionType,
+ hasLoweredAddresses: context.moduleHasLoweredAddresses)
+if convention.hasSelfParameter,
+let selfParam = convention.parameters.last,
+ selfParam.type.isGenericTypeParameter
+{
+returntrue
+}
+returnfalse
+}
+}

include/swift/SILOptimizer/OptimizerBridging.h

@@ -328,7 +328,7 @@ struct BridgedPassContext {
  BridgedSubstitutionMap substitutions) const;
  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE
  OptionalBridgedWitnessTable lookupWitnessTable(BridgedConformance conformance) const;
- SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedWitnessTable createWitnessTable(BridgedLinkage linkage,
+ SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedWitnessTable createSpecializedWitnessTable(BridgedLinkage linkage,
 bool serialized,
  BridgedConformance conformance,
  BridgedArrayRef bridgedEntries) const;

include/swift/SILOptimizer/OptimizerBridgingImpl.h

@@ -445,7 +445,7 @@ OptionalBridgedWitnessTable BridgedPassContext::lookupWitnessTable(BridgedConfor
 return {mod->lookUpWitnessTable(ref.getConcrete())};
 }
 
-BridgedWitnessTable BridgedPassContext::createWitnessTable(BridgedLinkage linkage,
+BridgedWitnessTable BridgedPassContext::createSpecializedWitnessTable(BridgedLinkage linkage,
 bool serialized,
  BridgedConformance conformance,
  BridgedArrayRef bridgedEntries) const {