Merge pull request swiftlang#1 from jrose-apple/import-lightweight-objc-generics

Convert to StdlibUnittest, fix type metadata conventions

Author: cwillmor

Diff for: lib/IRGen/Fulfillment.cpp

@@ -230,6 +230,9 @@ bool FulfillmentMap::searchBoundGenericTypeMetadata(ModuleDecl &M,
                                                     unsigned source,
                                                     MetadataPath &&path,
                                          const InterestingKeysCallback &keys) {
+  if (type->getDecl()->hasClangNode())
+    return false;
+
   auto params = type->getDecl()->getGenericParams()->getAllArchetypes();
   auto substitutions = type->getSubstitutions(&M, nullptr);
   assert(params.size() >= substitutions.size() &&

Diff for: lib/IRGen/GenMeta.cpp

@@ -1764,21 +1764,14 @@ llvm::Value *irgen::emitClassHeapMetadataRef(IRGenFunction &IGF, CanType type,
     return classPtr;
   }
 
-  // ObjC-defined classes will always be top-level non-generic classes.
-
-  if (auto classType = dyn_cast<ClassType>(type)) {
-    auto theClass = classType->getDecl();
+  if (ClassDecl *theClass = type->getClassOrBoundGenericClass()) {
     if (!hasKnownSwiftMetadata(IGF.IGM, theClass)) {
       llvm::Value *result =
         emitObjCHeapMetadataRef(IGF, theClass, allowUninitialized);
       if (desiredType == MetadataValueType::TypeMetadata)
         result = IGF.Builder.CreateBitCast(result, IGF.IGM.TypeMetadataPtrTy);
       return result;
     }
-  } else {
-    auto genericType = cast<BoundGenericClassType>(type);
-    assert(hasKnownSwiftMetadata(IGF.IGM, genericType->getDecl()));
-    (void) genericType;
   }
 
   llvm::Value *result = IGF.emitTypeMetadataRef(type);

Diff for: lib/IRGen/GenProto.cpp

@@ -1283,9 +1283,13 @@ bool irgen::hasPolymorphicParameters(CanSILFunctionType ty) {
   case SILFunctionTypeRepresentation::Thick:
   case SILFunctionTypeRepresentation::Thin:
   case SILFunctionTypeRepresentation::Method:
-  case SILFunctionTypeRepresentation::ObjCMethod:
     return ty->isPolymorphic();
 
+  case SILFunctionTypeRepresentation::ObjCMethod:
+    // May be polymorphic at the SIL level, but no type metadata is actually
+    // passed.
+    return false;
+
   case SILFunctionTypeRepresentation::WitnessMethod:
     // Always carries polymorphic parameters for the Self type.
     return true;
@@ -1482,8 +1486,6 @@ namespace {
 
   private:
     void initGenerics() {
-      assert(hasPolymorphicParameters(FnType));
-
       // The canonical mangling signature removes dependent types that are
       // equal to concrete types, but isn't necessarily parallel with
       // substitutions.

Diff for: lib/IRGen/IRGenSIL.cpp

@@ -1290,16 +1290,14 @@ static void emitEntryPointArgumentsCOrObjC(IRGenSILFunction &IGF,
 
   assert(params.empty() && "didn't claim all parameters!");
 
-  // Bind polymorphic arguments.  This can only be done after binding
-  // all the value parameters.
-  if (hasPolymorphicParameters(funcTy)) {
-    emitPolymorphicParameters(IGF, *IGF.CurSILFn, params,
-                              nullptr,
-      [&](unsigned paramIndex) -> llvm::Value* {
-        SILValue parameter = entry->getBBArgs()[paramIndex];
-        return IGF.getLoweredSingletonExplosion(parameter);
-      });
-  }
+  // Bind polymorphic arguments. This can only be done after binding
+  // all the value parameters, and must be done even for non-polymorphic
+  // functions because of imported Objective-C generics.
+  emitPolymorphicParameters(IGF, *IGF.CurSILFn, params, nullptr,
+                            [&](unsigned paramIndex) -> llvm::Value* {
+    SILValue parameter = entry->getBBArgs()[paramIndex];
+    return IGF.getLoweredSingletonExplosion(parameter);
+  });
 }
 
 /// Get metadata for the dynamic Self type if we have it.

Diff for: test/Interpreter/Inputs/ObjCClasses/ObjCClasses.h

@@ -1,7 +1,9 @@
 #ifndef SWIFT_TEST_OBJC_CLASSES_H
 #define SWIFT_TEST_OBJC_CLASSES_H
 
-#include <Foundation/NSObject.h>
+#import <Foundation/NSObject.h>
+
+NS_ASSUME_NONNULL_BEGIN
 
 /* This class has instance variables which are not apparent in the
    interface.  Subclasses will need to be slid by the ObjC runtime. */
@@ -19,10 +21,12 @@
 
 @interface Container<C> : NSObject
 - (id)initWithObject:(C)object NS_DESIGNATED_INITIALIZER;
+- (id)init NS_UNAVAILABLE;
+
 @property C object;
 
 - (void)processObjectWithBlock:(void (^)(C))block;
-- (void)getObjectWithBlock:(C (^)())block;
+- (void)updateObjectWithBlock:(C (^)())block;
 @end
 
 @interface Container<D> (Cat1)
@@ -45,7 +49,7 @@
 @end
 
 @interface Animal : NSObject
-- (void)makeNoise;
+@property (readonly) NSString *noise;
 @end
 
 @interface Dog : Animal
@@ -54,4 +58,6 @@
 @interface AnimalContainer<C: Animal *> : Container<C>
 @end
 
+NS_ASSUME_NONNULL_END
+
 #endif

Diff for: test/Interpreter/Inputs/ObjCClasses/ObjCClasses.m

@@ -26,7 +26,7 @@ - (void)processObjectWithBlock:(void (^)(id))block {
   block(self.object);
 }
 
-- (void)getObjectWithBlock:(id (^)())block {
+- (void)updateObjectWithBlock:(id (^)())block {
   self.object = block();
 }
 
@@ -67,14 +67,14 @@ @implementation CopyingContainer
 @end
 
 @implementation Animal
-- (void)makeNoise {
-  printf("eep\n");
+- (NSString *)noise {
+  return @"eep";
 }
 @end
 
 @implementation Dog
-- (void)makeNoise {
-  printf("woof\n");
+- (NSString *)noise {
+  return @"woof";
 }
 @end
 

Diff for: test/Interpreter/imported_objc_generics.swift

@@ -2,85 +2,115 @@
 // RUN: mkdir -p %t
 //
 // RUN: %target-clang -fobjc-arc %S/Inputs/ObjCClasses/ObjCClasses.m -c -o %t/ObjCClasses.o
-// RUN: %target-build-swift -Xfrontend -enable-import-objc-generics -I %S/Inputs/ObjCClasses/ -Xlinker %t/ObjCClasses.o %s -o %t/a.out
-// RUN: %target-run %t/a.out | FileCheck %s
+// RUN: %target-build-swift -Xfrontend -enable-import-objc-generics -I %S/Inputs/ObjCClasses/ %t/ObjCClasses.o %s -o %t/a.out
+// RUN: %target-run %t/a.out
 
 // REQUIRES: executable_test
+// XFAIL: interpret
 // REQUIRES: objc_interop
 
 import Foundation
+import StdlibUnittest
 import ObjCClasses
 
-let cs = Container<NSString>(object: "i-just-met-you")
-print(cs)
-// CHECK: <Container: {{.*}}>
-print(cs.object)
-// CHECK: i-just-met-you
-
-cs.processObjectWithBlock { s in print("in block: \(s)!!!") }
-// CHECK: in block: i-just-met-you!!!
-cs.getObjectWithBlock { () in NSString(string: "this-is-crazy") }
-print(cs.object)
-// CHECK: this-is-crazy
-cs.object = "so-heres-my-number"
-print(cs.object)
-// CHECK: so-heres-my-number
-
-let cs2 = Container<NSString>(object: "call-me-maybe")
-print(cs2.getCat1())
-// CHECK: call-me-maybe
-cs2.setCat1(":)")
-print(cs2.cat1Property)
-// CHECK: :)
-
-let scs = SubContainer<NSString>(object: "hey neat")
-print(scs.object)
-// CHECK: hey neat 
-
-let nestedContainer = NestedContainer<NSString>(object: Container<NSString>(object: "cat"))
-print(nestedContainer.object.object)
-// CHECK: cat
-
-let stringContainer = StringContainer(object: "stringy")
-print(stringContainer.object)
-// CHECK: stringy
+var ImportedObjCGenerics = TestSuite("ImportedObjCGenerics")
+
+ImportedObjCGenerics.test("Creation") {
+  let cs = Container<NSString>(object: "i-just-met-you")
+  expectEqual("i-just-met-you", cs.object)
+  expectTrue(cs.dynamicType === Container<NSString>.self)
+  expectTrue(cs.dynamicType === Container<AnyObject>.self)
+}
+
+ImportedObjCGenerics.test("Blocks") {
+  let cs = Container<NSString>(object: "and-this-is-crazy")
+
+  var fromBlock: NSString = ""
+  cs.processObjectWithBlock { fromBlock = $0 }
+  expectEqual("and-this-is-crazy", fromBlock)
+
+  cs.updateObjectWithBlock { "but-heres-my-number" }
+  expectEqual("but-heres-my-number", cs.object)
+}
+
+ImportedObjCGenerics.test("Categories") {
+  let cs = Container<NSString>(cat1: "so-call-me-maybe")
+  expectEqual("so-call-me-maybe", cs.getCat1())
+
+  cs.setCat1("its-hard-to-look-right")
+  expectEqual("its-hard-to-look-right", cs.cat1Property)
+}
+
+ImportedObjCGenerics.test("Subclasses") {
+  let subContainer = SubContainer<NSString>(object: "at-you-baby")
+  expectEqual("at-you-baby", subContainer.object)
+
+  let nestedContainer = NestedContainer<NSString>(object: Container(object: "but-heres-my-number"))
+  expectEqual("but-heres-my-number", nestedContainer.object.object)
+
+  let stringContainer = StringContainer(object: "so-call-me-maybe")
+  expectEqual("so-call-me-maybe", stringContainer.object)
+}
+
+ImportedObjCGenerics.test("SwiftGenerics") {
+  func openContainer<T: AnyObject>(x: Container<T>) -> T {
+    return x.object
+  }
+  func openStringContainer<T: Container<NSString>>(x: T) -> NSString {
+    return x.object
+  }
+  func openArbitraryContainer<S: AnyObject, T: Container<S>>(x: T) -> S {
+    return x.object
+  }
+
+  let scs = SubContainer<NSString>(object: "before-you-came-into-my-life")
+  expectEqual("before-you-came-into-my-life", openContainer(scs))
+  expectEqual("before-you-came-into-my-life", openStringContainer(scs))
+  expectEqual("before-you-came-into-my-life", openArbitraryContainer(scs))
+
+  let cs = Container<NSString>(object: "i-missed-you-so-bad")
+  expectEqual("i-missed-you-so-bad", openContainer(cs))
+  expectEqual("i-missed-you-so-bad", openStringContainer(cs))
+  expectEqual("i-missed-you-so-bad", openArbitraryContainer(cs))
+
+  let strContainer = SubContainer<NSString>(object: "i-missed-you-so-so-bad")
+  expectEqual("i-missed-you-so-so-bad", openContainer(strContainer))
+  expectEqual("i-missed-you-so-so-bad", openStringContainer(strContainer))
+  expectEqual("i-missed-you-so-so-bad", openArbitraryContainer(strContainer))
+
+  let numContainer = Container<NSNumber>(object: NSNumber(integer: 21))
+  expectEqual(NSNumber(integer: 21), openContainer(numContainer))
+  expectEqual(NSNumber(integer: 21), openArbitraryContainer(numContainer))
+
+  let subNumContainer = SubContainer<NSNumber>(object: NSNumber(integer: 22))
+  expectEqual(NSNumber(integer: 22), openContainer(subNumContainer))
+  expectEqual(NSNumber(integer: 22), openArbitraryContainer(subNumContainer))
+}
 
 // TODO: resolve crash in IRGen from test case below
 /*func makeContainer<T: AnyObject>(x: T) -> Container<T> {*/
   /*return Container(object: x)*/
 /*}*/
 
-func openContainer<T: AnyObject>(x: Container<T>) -> T {
-  return x.object
+ImportedObjCGenerics.test("SwiftGenerics/Creation") {
+  // TODO: Test above.
 }
-print(openContainer(Container<NSString>(object: "some string")))
-// CHECK: some string
 
-func openStringContainer<T: Container<NSString>>(x: T) -> NSString {
-  return x.object
-}
-print(openStringContainer(Container<NSString>(object: "some string")))
-// CHECK: some string
-print(openStringContainer(SubContainer<NSString>(object: "some string 2")))
-// CHECK: some string 2
-print(openStringContainer(StringContainer(object: "some string 3")))
-// CHECK: some string 3
-
-func openArbitraryContainer<S: AnyObject, T: Container<S>>(x: T) -> S {
-  return x.object
-}
-print(openArbitraryContainer(Container<NSString>(object: "some string 4")))
-// CHECK: some string 4
-print(openArbitraryContainer(Container<NSNumber>(object: NSNumber(integer: 5))) as NSNumber)
-// CHECK: 5
-
-let _ = CopyingContainer<NSString>()
-func copyContainerContents<T: NSCopying>(x: CopyingContainer<T>) -> T {
-  return x.object.copyWithZone(nil) as! T
+ImportedObjCGenerics.test("ProtocolConstraints") {
+  func copyContainerContents<T: NSCopying>(x: CopyingContainer<T>) -> T {
+    return x.object.copyWithZone(nil) as! T
+  }
+
+  let cs = CopyingContainer<NSString>(object: "Happy 2012")
+  expectEqual("Happy 2012", copyContainerContents(cs))
 }
 
-func makeContainedAnimalMakeNoise<T: Animal>(x: AnimalContainer<T>) {
-  x.object.makeNoise()
+ImportedObjCGenerics.test("ClassConstraints") {
+  func makeContainedAnimalMakeNoise<T>(x: AnimalContainer<T>) -> NSString {
+    return x.object.noise
+  }
+  let petCarrier = AnimalContainer(object: Dog())
+  expectEqual("woof", makeContainedAnimalMakeNoise(petCarrier))
 }
-makeContainedAnimalMakeNoise(AnimalContainer(object: Dog()))
-// CHECK: woof
+
+runAllTests()