Objc initialization of Swift classes

Development Compiler
1

Hi,

I'm trying to understand how +initialize works for Swift classes. I know I can't override this in Swift, and that not all Swift classes end up being initialized in the ObjC runtime even when their swift initializer is called. I'd like to get a better understanding of what kinds of classes will be initialized with the ObjC runtime when they are first referenced. To try and figure it out, I am swizzling the +initialize method from objc code in the same app, like this:

+ (void)swizzleMethodWithClassName:(NSString *)className
                        methodName:(NSString *)methodName
                  swizzledSelector:(SEL)swizzledSelector
{
    Class thisClass = [self class];
    Class aClass = NSClassFromString(className);

    SEL originalSelector = NSSelectorFromString(methodName);

    Method originalMethod;
    Method swizzledMethod;
    originalMethod = class_getClassMethod(aClass, originalSelector);
    swizzledMethod = class_getClassMethod(thisClass, swizzledSelector);
    // Need to do this to swizzle a class method
    aClass = object_getClass(aClass);
    IMP originalImp = method_getImplementation(originalMethod);
    IMP swizzledImp = method_getImplementation(swizzledMethod);
    class_replaceMethod(aClass,
            swizzledSelector,
            originalImp,
            method_getTypeEncoding(swizzledMethod));
    class_replaceMethod(aClass,
            originalSelector,
            swizzledImp,
            method_getTypeEncoding(swizzledMethod));
}

+(void)load {
    [self swizzleMethodWithClassName:@"TestApp.TestClass" methodName:@"initialize" swizzledSelector:NSSelectorFromString(@"swizzled_initialize")];
}

+(void)swizzled_initialize {
  NSLog(@"swizzled initialize");
}

Then if I define a class like this:

class TestClass { }

The first time I call TestClass() my swizzled function is hit. Based on the stack trace, I think this is happening because the type metadata accessor includes a call to objc_opt_self. However, I'm not sure when this happens and when this +initialize would not be called in Swift. I thought a basic Swift class like the one I had above would not need the +initialize, but it seems like the compiler still emits the objc_opt_self call, so I'm wondering what would it take to have a Swift class that doesn't use +initialize?

Thanks!

2

I'm a little unclear on whether you're just trying to understand how these things work, or if you think you actually need to define a Swift class that does not invoke +initialize?

If the latter, I'm curious what you're trying to do that +initialize is causing a problem?

3

Thanks for taking a look Tim! I'm mostly trying to understand how it works/what controls if a Swift class calls +initialize. I thought a good test of my understanding would be if I can define a class that doesn't invoke it.