Runtime: Clean up logic for setting Objective-C name of generic classes

We're not currently doing it, but we will soon be able to use
swift_initializeSuperclass() for class layouts which are not
dependent on generic parameters. In this case, we still need
to set the Objective-C class name.

On the other hand, if we're doing resilient layout for a
non-generic class, we don't need to set the Objective-C class
name.

NFC since this isn't hooked up completely yet.

Author: slavapestov

stdlib/public/runtime/Metadata.cpp

@@ -1406,50 +1406,6 @@ void swift::swift_initStructMetadata_UniversalStrategy(size_t numFields,
 
 /*** Classes ***************************************************************/
 
-
-
-static void _swift_initializeSuperclass(ClassMetadata *theClass,
-                                        const ClassMetadata *theSuperclass,
-                                        bool copyFieldOffsetVectors) {
-  // If any ancestors had generic parameters or field offset vectors,
-  // inherit them.
-  auto ancestor = theSuperclass;
-  auto *classWords = reinterpret_cast<uintptr_t *>(theClass);
-  auto *superWords = reinterpret_cast<const uintptr_t *>(theSuperclass);
-  while (ancestor && ancestor->isTypeMetadata()) {
-    auto description = ancestor->getDescription();
-    auto &genericParams = description->GenericParams;
-    if (genericParams.hasGenericParams()) {
-      unsigned numParamWords = 0;
-      for (unsigned i = 0; i < genericParams.NumParams; ++i) {
-        // 1 word for the type metadata, and 1 for every protocol witness
-        numParamWords +=
-            1 + genericParams.Parameters[i].NumWitnessTables;
-      }
-      memcpy(classWords + genericParams.Offset,
-             superWords + genericParams.Offset,
-             numParamWords * sizeof(uintptr_t));
-    }
-    if (copyFieldOffsetVectors &&
-        description->Class.hasFieldOffsetVector()) {
-      unsigned fieldOffsetVector = description->Class.FieldOffsetVectorOffset;
-      memcpy(classWords + fieldOffsetVector,
-             superWords + fieldOffsetVector,
-             description->Class.NumFields * sizeof(uintptr_t));
-    }
-    ancestor = ancestor->SuperClass;
-  }
-
-#if SWIFT_OBJC_INTEROP
-  // Set up the superclass of the metaclass, which is the metaclass of the
-  // superclass.
-  auto theMetaclass = (ClassMetadata *)object_getClass((id)theClass);
-  auto theSuperMetaclass
-    = (const ClassMetadata *)object_getClass((id)theSuperclass);
-  theMetaclass->SuperClass = theSuperMetaclass;
-#endif
-}
-
 namespace {
   /// The structure of ObjC class ivars as emitted by compilers.
   struct ClassIvarEntry {
@@ -1530,31 +1486,76 @@ static void _swift_initGenericClassObjCName(ClassMetadata *theClass) {
 }
 #endif
 
+static void _swift_initializeSuperclass(ClassMetadata *theClass,
+                                        bool copyFieldOffsetVectors) {
+#if SWIFT_OBJC_INTEROP
+  // If the class is generic, we need to give it a name for Objective-C.
+  if (theClass->getDescription()->GenericParams.NumParams > 0)
+    _swift_initGenericClassObjCName(theClass);
+#endif
+
+  const ClassMetadata *theSuperclass = theClass->SuperClass;
+  if (theSuperclass == nullptr)
+    return;
+
+  // If any ancestors had generic parameters or field offset vectors,
+  // inherit them.
+  auto ancestor = theSuperclass;
+  auto *classWords = reinterpret_cast<uintptr_t *>(theClass);
+  auto *superWords = reinterpret_cast<const uintptr_t *>(theSuperclass);
+  while (ancestor && ancestor->isTypeMetadata()) {
+    auto description = ancestor->getDescription();
+    auto &genericParams = description->GenericParams;
+    if (genericParams.hasGenericParams()) {
+      unsigned numParamWords = 0;
+      for (unsigned i = 0; i < genericParams.NumParams; ++i) {
+        // 1 word for the type metadata, and 1 for every protocol witness
+        numParamWords +=
+            1 + genericParams.Parameters[i].NumWitnessTables;
+      }
+      memcpy(classWords + genericParams.Offset,
+             superWords + genericParams.Offset,
+             numParamWords * sizeof(uintptr_t));
+    }
+    if (copyFieldOffsetVectors &&
+        description->Class.hasFieldOffsetVector()) {
+      unsigned fieldOffsetVector = description->Class.FieldOffsetVectorOffset;
+      memcpy(classWords + fieldOffsetVector,
+             superWords + fieldOffsetVector,
+             description->Class.NumFields * sizeof(uintptr_t));
+    }
+    ancestor = ancestor->SuperClass;
+  }
+
+#if SWIFT_OBJC_INTEROP
+  // Set up the superclass of the metaclass, which is the metaclass of the
+  // superclass.
+  auto theMetaclass = (ClassMetadata *)object_getClass((id)theClass);
+  auto theSuperMetaclass
+    = (const ClassMetadata *)object_getClass((id)theSuperclass);
+  theMetaclass->SuperClass = theSuperMetaclass;
+#endif
+}
+
 /// Initialize the field offset vector for a dependent-layout class, using the
 /// "Universal" layout strategy.
 void swift::swift_initClassMetadata_UniversalStrategy(ClassMetadata *self,
                                           size_t numFields,
                                           const ClassFieldLayout *fieldLayouts,
                                           size_t *fieldOffsets) {
-  const ClassMetadata *super = self->SuperClass;
-
-  if (super) {
-    _swift_initializeSuperclass(self, super,
-                                /*copyFieldOffsetVectors=*/true);
-  }
+  _swift_initializeSuperclass(self, /*copyFieldOffsetVectors=*/true);
 
   // Start layout by appending to a standard heap object header.
   size_t size, alignMask;
 
 #if SWIFT_OBJC_INTEROP
-  ClassROData *rodata = (ClassROData*) (self->Data & ~uintptr_t(1));
-
-  // Generate a runtime name for the class.
-  _swift_initGenericClassObjCName(self);
+  ClassROData *rodata = getROData(self);
 #endif
 
   // If we have a superclass, start from its size and alignment instead.
   if (classHasSuperclass(self)) {
+    const ClassMetadata *super = self->SuperClass;
+
     // This is straightforward if the superclass is Swift.
 #if SWIFT_OBJC_INTEROP
     if (super->isTypeMetadata()) {
@@ -2495,11 +2496,7 @@ extern "C"
 void swift_initializeSuperclass(ClassMetadata *theClass,
                                 bool copyFieldOffsetVectors) {
   // Copy generic parameters and field offset vectors from the superclass.
-  const ClassMetadata *theSuperclass = theClass->SuperClass;
-  if (theSuperclass) {
-    _swift_initializeSuperclass(theClass, theSuperclass,
-                                copyFieldOffsetVectors);
-  }
+  _swift_initializeSuperclass(theClass, copyFieldOffsetVectors);
 
 #if SWIFT_OBJC_INTEROP
   // Register the class pair with the ObjC runtime.