- tmp

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/ModulePasses/MandatoryPerformanceOptimizations.swift

@@ -45,6 +45,10 @@ let mandatoryPerformanceOptimizations = ModulePass(name: "mandatory-performance-
   }
 
   optimizeFunctionsTopDown(using: &worklist, moduleContext)
+
+  if moduleContext.options.enableEmbeddedSwift {
+    checkVTablesForGenericFunctions(moduleContext)
+  }
 }
 
 private func optimizeFunctionsTopDown(using worklist: inout FunctionWorklist,
@@ -265,21 +269,38 @@ private func specializeWitnessTables(for initExRef: InitExistentialRefInst, _ co
   let conformingType = initExRef.instance.type
   assert(conformingType.isClass)
 
-  for conformance in initExRef.conformances {
-    if conformance.isConcrete,
-       conformance.isSpecialized,
-       context.lookupWitnessTable(for: conformance) == nil
-    {
-      let wt = specializeWitnessTable(forConformance: conformance, context)
-      for entry in wt.entries where entry.kind == .method {
-        if let method = entry.methodFunction,
-           // A new witness table can still contain a generic function if the method couldn't be specialized for
-           // some reason and an error has been printed. Exclude generic functions to not run into an assert later.
-           !method.isGeneric
-        {
-          worklist.pushIfNotVisited(method)
-        }
+  for conformance in initExRef.conformances where conformance.isConcrete {
+    let origWitnessTable = context.lookupWitnessTable(for: conformance)
+    if conformance.isSpecialized {
+      if origWitnessTable == nil {
+        let wt = specializeWitnessTable(forConformance: conformance, errorLocation: initExRef.location, context)
+        worklist.addWitnessMethods(of: wt)
       }
+    } else if let origWitnessTable {
+      checkForGenericMethods(in: origWitnessTable, errorLocation: initExRef.location, context)
+    }
+  }
+}
+
+private func checkForGenericMethods(in witnessTable: WitnessTable,
+                                    errorLocation: Location,
+                                    _ context: ModulePassContext)
+{
+  for entry in witnessTable.entries where entry.kind == .method {
+    if let method = entry.methodFunction,
+       method.isGeneric
+    {
+      context.diagnosticEngine.diagnose(errorLocation.sourceLoc, .cannot_specialize_witness_method,
+                                        entry.methodRequirement)
+      return
+    }
+  }
+}
+
+private func checkVTablesForGenericFunctions(_ context: ModulePassContext) {
+  for vTable in context.vTables where !vTable.class.isGenericAtAnyLevel {
+    for entry in vTable.entries where entry.implementation.isGeneric {
+      context.diagnosticEngine.diagnose(entry.methodDecl.location.sourceLoc, .non_final_generic_class_function)
     }
   }
 }
@@ -489,6 +510,18 @@ fileprivate struct FunctionWorklist {
     }
   }
 
+  mutating func addWitnessMethods(of witnessTable: WitnessTable) {
+    for entry in witnessTable.entries where entry.kind == .method {
+      if let method = entry.methodFunction,
+         // A new witness table can still contain a generic function if the method couldn't be specialized for
+         // some reason and an error has been printed. Exclude generic functions to not run into an assert later.
+         !method.isGeneric
+      {
+        pushIfNotVisited(method)
+      }
+    }
+  }
+
   mutating func pushIfNotVisited(_ element: Function) {
     if pushedFunctions.insert(element).inserted {
       functions.append(element)

SwiftCompilerSources/Sources/Optimizer/Utilities/DiagnosticEngine.swift

@@ -35,6 +35,11 @@ extension Type: DiagnosticArgument {
     fn(bridged.asDiagnosticArgument())
   }
 }
+extension DeclRef: DiagnosticArgument {
+  public func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {
+    fn(bridged.asDiagnosticArgument())
+  }
+}
 
 public struct DiagnosticFixIt {
   public let start: SourceLoc

SwiftCompilerSources/Sources/Optimizer/Utilities/GenericSpecialization.swift

@@ -77,6 +77,7 @@ func specializeVTablesOfSuperclasses(_ moduleContext: ModulePassContext) {
 }
 
 func specializeWitnessTable(forConformance conformance: ProtocolConformance,
+                            errorLocation: Location,
                             _ context: ModulePassContext) -> WitnessTable
 {
   let genericConformance = conformance.genericConformance
@@ -88,10 +89,16 @@ func specializeWitnessTable(forConformance conformance: ProtocolConformance,
   let newEntries = witnessTable.entries.map { origEntry in
     switch origEntry.kind {
     case .method:
+      guard let origMethod = origEntry.methodFunction else {
+        return origEntry
+      }
       let methodDecl = origEntry.methodRequirement
-      guard let specializedMethod = context.specialize(function: origEntry.methodFunction!,
-                                                       for: conformance.specializedSubstitutions) else {
-        context.diagnosticEngine.diagnose(methodDecl.location.sourceLoc, .cannot_specialize_witness_method)
+      let methodSubs = conformance.specializedSubstitutions.getMethodSubstitutions(for: origMethod)
+
+      guard !methodSubs.conformances.contains(where: {!$0.isValid}),
+            let specializedMethod = context.specialize(function: origMethod, for: methodSubs) else
+      {
+        context.diagnosticEngine.diagnose(errorLocation.sourceLoc, .cannot_specialize_witness_method, methodDecl)
         return origEntry
       }
       return WitnessTable.Entry(methodRequirement: methodDecl, methodFunction: specializedMethod)

SwiftCompilerSources/Sources/SIL/Declarations.swift

@@ -60,7 +60,7 @@ public struct NominalTypeDecl : Equatable, Hashable {
 }
 
 public struct DeclRef {
-  let bridged: BridgedDeclRef
+  public let bridged: BridgedDeclRef
 
   public var location: Location { Location(bridged: bridged.getLocation()) }
 }

include/swift/AST/DiagnosticsSIL.def

@@ -378,7 +378,7 @@ ERROR(global_must_be_compile_time_const,none,
 ERROR(non_final_generic_class_function,none,
       "classes cannot have non-final generic fuctions in embedded Swift", ())
 ERROR(cannot_specialize_witness_method,none,
-      "generic method cannot be used in existential type", ())
+      "an existential type cannot contain a generic method %0 in embedded Swift", (DeclName))
 ERROR(cannot_specialize_class,none,
       "cannot specialize %0 because class definition is not available (make sure to build with -wmo)", (Type))
 ERROR(embedded_swift_existential_type,none,

include/swift/SIL/SILBridging.h

@@ -1264,8 +1264,8 @@ struct BridgedDeclRef {
     return *reinterpret_cast<const swift::SILDeclRef *>(&storage);
   }
 #endif
-
   SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedLocation getLocation() const;
+  SWIFT_IMPORT_UNSAFE BRIDGED_INLINE BridgedDiagnosticArgument asDiagnosticArgument() const;
 };
 
 struct BridgedVTableEntry {

include/swift/SIL/SILBridgingImpl.h

@@ -1660,6 +1660,10 @@ BridgedLocation BridgedDeclRef::getLocation() const {
   return swift::SILDebugLocation(unbridged().getDecl(), nullptr);
 }
 
+BridgedDiagnosticArgument BridgedDeclRef::asDiagnosticArgument() const {
+  return swift::DiagnosticArgument(unbridged().getDecl()->getName());
+}
+
 //===----------------------------------------------------------------------===//
 //                                BridgedVTable
 //===----------------------------------------------------------------------===//

lib/SILOptimizer/Mandatory/PerformanceDiagnostics.cpp

@@ -914,36 +914,8 @@ class PerformanceDiagnosticsPass : public SILModuleTransform {
       for (SILFunction *function : constructorsAndDestructors) {
         diagnoser.visitFunctionEmbeddedSwift(function);
       }
-
-      checkVTables();
     }
   }
-
-  void checkVTables() {
-    for (SILVTable *vtable : getModule()->getVTables()) {
-      if (vtable->getClass()->isGenericContext())
-        continue;
-
-      for (SILVTableEntry &entry : vtable->getMutableEntries()) {
-        SILFunction *method = entry.getImplementation();
-        if (!method->getLoweredFunctionType()->isPolymorphic())
-          continue;
-
-        ValueDecl *decl = entry.getMethod().getDecl();
-        getModule()->getASTContext().Diags.diagnose(
-            decl->getLoc(), diag::non_final_generic_class_function);
-
-        if (decl->getLoc().isInvalid()) {
-          auto demangledName = Demangle::demangleSymbolAsString(
-              method->getName(),
-              Demangle::DemangleOptions::SimplifiedUIDemangleOptions());
-          llvm::errs() << "in function " << demangledName << "\n";
-          llvm::errs() << "in class " << vtable->getClass()->getName() << "\n";
-        }
-      }
-    }
-  }
-
 };
 
 } // end anonymous namespace

test/embedded/classes-non-final-method-no-stdlib.swift

@@ -3,26 +3,26 @@
 // REQUIRES: swift_in_compiler
 
 public class MyClass {
-  public func foo<T>(t: T) { } // expected-error {{classes cannot have non-final generic fuctions in embedded Swift}}
-  public func bar() { }
+  func foo<T>(t: T) { } // expected-error {{classes cannot have non-final generic fuctions in embedded Swift}}
+  func bar() { }
 }
 
-public final class C2<Element> {
+final class C2<Element> {
   // TODO: this shouldn't be a problem because the class is final
-  public init<T>(x: T) { } // expected-error {{classes cannot have non-final generic fuctions in embedded Swift}}
+  init<T>(x: T) { } // expected-error {{classes cannot have non-final generic fuctions in embedded Swift}}
 }
 
-public struct S {}
+struct S {}
 
-public func testit2() -> C2<S> {
+func testit2() -> C2<S> {
   return C2(x: S())
 }
 
 open class C3<X> {
   public func foo<T>(t: T) {} // expected-error {{classes cannot have non-final generic fuctions in embedded Swift}}
 }
 
-public func testit3() -> C3<S> {
+func testit3() -> C3<S> {
   return C3<S>()
 }