[SR-5415] Swift extension with static let accessed from objc triggers "incompatible Objective-C category definitions" linker warning

[bobergj]

Previous ID	SR-5415
Radar	None
Original Reporter	@bobergj
Type	Bug
Status	Closed
Resolution	Invalid

Environment

Xcode Version 8.3.3 (8E3004b), Swift 3
Xcode 9 beta 2, Swift 4

Additional Detail from JIRA

Votes	0
Component/s	Compiler
Labels	Bug
Assignee	None
Priority	Medium

md5: ffa2458039f895089dd9ab0b8bf7cfac

Issue Description:

Sometimes an extension on UIColor:

extension UIColor {
    static let someColor = UIColor.darkGray
}

accessed from objc:

#import "AppTargetName-Swift.h"
...
    [UIColor someColor];

Triggers a linker warning such as:

ld: warning: Some object files have incompatible Objective-C category definitions. Some category metadata may be lost. All files containing Objective-C categories should be built using the same compiler.

In this case, all code is definitely built with the same compiler, it's all built at the same time.
Both the Swift module and objective-c module is part of the application target

We can consistently reproduce this issue (on different machines) in a particular project, but in a new minimal project with only the UIColor extension and the obj-c access it doesn't occur. There seems to be another factor involved that triggers the warning.
We cannot share the code of our project, put perhaps there is a linker option to enable more verbose output related to the warning?

[belkadan]

Hm. Does your project include any prebuilt frameworks from other vendors? Or even just Carthage frameworks that haven't been rebuilt?

[bobergj]

No prebuilt frameworks but yes, a prebuilt static library, namely libGoogleAnalyticsServices.a. This library version is probably built with an earlier version of Xcode. Upgrading the library version to a newer removes the warning.

Indeed I can reproduce the issue simply by

• linking to this version of libGoogleAnalyticsServices.a

• in Swift define a category on a an objective-c class that defines type property (static let)

• adding the "-ObjC" linker flag

(do have a sample project but failed upload here as it's over the 10mb size limit)

If you don't mind to clarify one thing. I thought that Objective C 2.0 had a stable ABI, or at least a non-fragile ABI by the means of runtime backward-compatibility. I mean, many vendors do ship frameworks and static libraries as if that was the case.
Does this "All files containing Objective-C categories should be built using the same compiler." rule only apply when defining Objective-C class extensions in Swift?
It certainly seems like it happens only when defining a type property, something that is only possible in Swift, not in Obj-C.

extension UIColor {
    static let someColor = UIColor.darkGray
/or/
    static var someColor: UIColor {
        return UIColor.darkGray
    }
}

Triggers the warning, but

extension UIColor {
    func someColor() -> UIColor {
         return UIColor.darkGray
    }
}

does not.

[belkadan]

The changes that do get made to the ABI are backwards-compatible, but in some cases they rely on the ABI version being included in the linked binary (dylib or executable). With static libraries, that's not possible, so if you get a mixed set of static libraries and object files, it falls back to the oldest ABI version and gives you this warning. In most cases even that isn't a problem because all of the "core" Objective-C runtime features still work (most things to do with methods and selectors).

In this particular case I think the new feature that causes this is the use of class properties in categories. There wasn't a place to put class property metadata in the old runtime metadata for Objective-C categories, so you can't look them up at runtime. But you can still call the getter and setter and even look up those two methods, so most of the time no one will care. That's why this is only happening when you use static let; if you didn't need your constant to be visible to Objective-C you could also mark it @nonobjc (or update to Swift 4 mode and its more restricted inference of @objc).

Since this can happen with pure Objective-C as well I'm going to close this.

[belkadan]

Oh, and Objective-C totally has class properties now too! Though there's no storage synthesized, so you have to write the getter yourself.

@interface UIColor (MyColors)
@property (nonatomic, readonly, class) UIColor *someColor;
@end

[bobergj]

Thank your for the explanation! While clearly not a Swift issue, many people seem to run into this and think it's a Swift related issue.
I suppose it would be good if this was in some QA document or someone inside Apple could be poked to improve the linker warning message.
https://stackoverflow.com/questions/39665979/xcode-8-objective-c-category-warning
https://twitter.com/steipete/status/765633122465673216?lang=en

[belkadan]

That is fair. We do have bugs tracking that, so I'll poke them internally. rdar://problem/29929683&31665297