Allow subclasses of specific instantiations of ObjC generic classes.

If a subclass grounds all the type parameters from its base class, we don't have to worry about any erasure edge cases. We should be able to support this, giving existing code that subclasses the nongeneric form of the class a migration path. Spot-fix some places in IRGen where we assume we can't emit static references to ObjC generic classes or metaclasses.

Author: jckarter

include/swift/AST/DiagnosticsSema.def

@@ -1457,8 +1457,9 @@ NOTE(class_here,none,
      "class %0 declared here", (Identifier))
 ERROR(inheritance_from_final_class,none,
       "inheritance from a final class %0", (Identifier))
-ERROR(inheritance_from_objc_generic_class,none,
-      "inheritance from a generic Objective-C class %0", (Identifier))
+ERROR(inheritance_from_unspecialized_objc_generic_class,none,
+      "inheritance from a generic Objective-C class %0 must bind "
+      "type parameters of %0 to specific concrete types", (Identifier))
 ERROR(inheritance_from_objc_runtime_visible_class,none,
       "inheritance from an Objective-C class %0 only visible via the runtime", (Identifier))
 

lib/IRGen/GenClass.cpp

@@ -857,7 +857,7 @@ namespace {
     }
 
     llvm::Constant *getMetaclassRefOrNull(ClassDecl *theClass) {
-      if (theClass->isGenericContext()) {
+      if (theClass->isGenericContext() && !theClass->hasClangNode()) {
         return llvm::ConstantPointerNull::get(IGM.ObjCClassPtrTy);
       } else {
         return IGM.getAddrOfMetaclassObject(theClass, NotForDefinition);

lib/IRGen/GenDecl.cpp

@@ -2254,7 +2254,7 @@ llvm::Constant *IRGenModule::getAddrOfSwiftMetaclassStub(ClassDecl *theClass,
 /// on whether the class is published as an ObjC class.
 llvm::Constant *IRGenModule::getAddrOfMetaclassObject(ClassDecl *decl,
                                                 ForDefinition_t forDefinition) {
-  assert(!decl->isGenericContext()
+  assert((!decl->isGenericContext() || decl->hasClangNode())
          && "generic classes do not have a static metaclass object");
   if (decl->checkObjCAncestry() != ObjCClassKind::NonObjC ||
       decl->hasClangNode()) {

lib/IRGen/GenMeta.cpp

@@ -241,6 +241,31 @@ static void emitPolymorphicParametersFromArray(IRGenFunction &IGF,
   requirements.bindFromBuffer(IGF, array, getInContext);
 }
 
+static bool isTypeErasedGenericClass(NominalTypeDecl *ntd) {
+  // ObjC classes are type erased.
+  // TODO: Unless they have magic methods...
+  if (auto clas = dyn_cast<ClassDecl>(ntd))
+    return clas->hasClangNode() && clas->isGenericContext();
+  return false;
+}
+
+static bool isTypeErasedGenericClassType(CanType type) {
+  if (auto nom = type->getAnyNominal())
+    return isTypeErasedGenericClass(nom);
+  return false;
+}
+
+// Get the type that exists at runtime to represent a compile-time type.
+static CanType
+getRuntimeReifiedType(IRGenModule &IGM, CanType type) {
+  return CanType(type.transform([&](Type t) -> Type {
+    if (isTypeErasedGenericClassType(CanType(t))) {
+      return t->getAnyNominal()->getDeclaredType()->getCanonicalType();
+    }
+    return t;
+  }));
+}
+
 /// Attempts to return a constant heap metadata reference for a
 /// class type.  This is generally only valid for specific kinds of
 /// ObjC reference, like superclasses or category references.
@@ -257,8 +282,9 @@ llvm::Constant *irgen::tryEmitConstantHeapMetadataRef(IRGenModule &IGM,
       return nullptr;
 
   // Otherwise, just respect genericity and Objective-C runtime visibility.
-  } else if (theDecl->isGenericContext() ||
-             theDecl->isOnlyObjCRuntimeVisible()) {
+  } else if ((theDecl->isGenericContext()
+              && !isTypeErasedGenericClass(theDecl))
+             || theDecl->isOnlyObjCRuntimeVisible()) {
     return nullptr;
   }
 
@@ -1324,31 +1350,6 @@ static llvm::Value *emitTypeMetadataAccessFunctionBody(IRGenFunction &IGF,
 using MetadataAccessGenerator =
   llvm::function_ref<llvm::Value*(IRGenFunction &IGF, llvm::Constant *cache)>;
 
-static bool isTypeErasedGenericClass(NominalTypeDecl *ntd) {
-  // ObjC classes are type erased.
-  // TODO: Unless they have magic methods...
-  if (auto clas = dyn_cast<ClassDecl>(ntd))
-    return clas->hasClangNode() && clas->isGenericContext();
-  return false;
-}
-
-static bool isTypeErasedGenericClassType(CanType type) {
-  if (auto nom = type->getAnyNominal())
-    return isTypeErasedGenericClass(nom);
-  return false;
-}
-
-// Get the type that exists at runtime to represent a compile-time type.
-static CanType
-getRuntimeReifiedType(IRGenModule &IGM, CanType type) {
-  return CanType(type.transform([&](Type t) -> Type {
-    if (isTypeErasedGenericClassType(CanType(t))) {
-      return t->getAnyNominal()->getDeclaredType()->getCanonicalType();
-    }
-    return t;
-  }));
-}
-
 /// Get or create an accessor function to the given non-dependent type.
 static llvm::Function *getTypeMetadataAccessFunction(IRGenModule &IGM,
                                         CanType type,

lib/Sema/TypeCheckDecl.cpp

@@ -3836,8 +3836,10 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
           return;
         }
 
-        if (Super->hasClangNode() && Super->getGenericParams()) {
-          TC.diagnose(CD, diag::inheritance_from_objc_generic_class,
+        if (Super->hasClangNode() && Super->getGenericParams()
+            && superclassTy->hasTypeParameter()) {
+          TC.diagnose(CD,
+                      diag::inheritance_from_unspecialized_objc_generic_class,
                       Super->getName());
         }
 

test/ClangModules/objc_bridging_generics.swift

@@ -129,3 +129,33 @@ extension GenericClass {
     _ = #selector(GenericClass.doesntUseGenericParam3)
   }
 }
+
+// expected-error@+1{{inheritance from a generic Objective-C class 'GenericClass' must bind type parameters of 'GenericClass' to specific concrete types}}
+class SwiftGenericSubclassA<X: AnyObject>: GenericClass<X> {}
+// expected-error@+1{{inheritance from a generic Objective-C class 'GenericClass' must bind type parameters of 'GenericClass' to specific concrete types}}
+class SwiftGenericSubclassB<X: AnyObject>: GenericClass<GenericClass<X>> {}
+// expected-error@+1{{inheritance from a generic Objective-C class 'GenericClass' must bind type parameters of 'GenericClass' to specific concrete types}}
+class SwiftGenericSubclassC<X: NSCopying>: GenericClass<X> {}
+
+class SwiftConcreteSubclassA: GenericClass<AnyObject> {
+  override init(thing: AnyObject) { }
+  override func thing() -> AnyObject? { }
+  override func count() -> Int32 { }
+  override class func classThing() -> AnyObject? { }
+  override func arrayOfThings() -> [AnyObject] {}
+}
+class SwiftConcreteSubclassB: GenericClass<NSString> {
+  override init(thing: NSString) { }
+  override func thing() -> NSString? { }
+  override func count() -> Int32 { }
+  override class func classThing() -> NSString? { }
+  override func arrayOfThings() -> [NSString] {}
+}
+class SwiftConcreteSubclassC<T>: GenericClass<NSString> {
+  override init(thing: NSString) { }
+  override func thing() -> NSString? { }
+  override func count() -> Int32 { }
+  override class func classThing() -> NSString? { }
+  override func arrayOfThings() -> [NSString] {}
+}
+

test/IRGen/objc_generic_class_metadata.sil

@@ -8,6 +8,14 @@ import Swift
 import Foundation
 import objc_generics
 
+// CHECK-LABEL: @"OBJC_METACLASS_$__TtC27objc_generic_class_metadata8Subclass" = hidden global %objc_class
+// CHECK:         %objc_class* @"OBJC_METACLASS_$_NSObject"
+// CHECK:         %objc_class* @"OBJC_METACLASS_$_GenericClass"
+// CHECK-LABEL: @_TMfC27objc_generic_class_metadata8Subclass = internal global
+// CHECK:         %objc_class* @"OBJC_METACLASS_$__TtC27objc_generic_class_metadata8Subclass"
+// CHECK:         %objc_class* @"OBJC_CLASS_$_GenericClass"
+class Subclass: GenericClass<NSString> {}
+
 sil @metatype_sink : $@convention(thin) <T> (@thick T.Type) -> ()
 sil @objc_class_sink : $@convention(thin) <T: AnyObject> (@objc_metatype T.Type) -> ()
 

test/Interpreter/imported_objc_generics.swift

@@ -146,4 +146,47 @@ ImportedObjCGenerics.test("InheritanceFromNongeneric") {
   expectTrue(Container<NSObject>.self == Container<NSString>.self)
 }
 
+public class InheritInSwift: Container<NSString> {
+  public override init(object: NSString) {
+    super.init(object: object.lowercase)
+  }
+  public override var object: NSString {
+    get {
+      return super.object.uppercase
+    }
+    set {
+      super.object = newValue.lowercase
+    }
+  }
+
+  public var superObject: NSString {
+    get {
+      return super.object
+    }
+  }
+}
+
+ImportedObjCGenerics.test("InheritInSwift") {
+  let s = InheritInSwift(object: "HEllo")
+  let sup: Container = s
+
+  expectEqual(s.superObject, "hello")
+  expectEqual(s.object, "HELLO")
+  expectEqual(sup.object, "HELLO")
+
+  s.object = "GOodbye"
+  expectEqual(s.superObject, "goodbye")
+  expectEqual(s.object, "GOODBYE")
+  expectEqual(sup.object, "GOODBYE")
+
+  s.processObject { o in
+    expectEqual(o, "GOODBYE")
+  }
+
+  s.updateObject { "Aloha" }
+  expectEqual(s.superObject, "aloha")
+  expectEqual(s.object, "ALOHA")
+  expectEqual(sup.object, "ALOHA")
+}
+
 runAllTests()