@milseman, @slavapestov, essentially the same case as the Dispatch ones, but also happens in Release? Though SILGen just goes off the rails here.

Assertion failed: (memberStatus.isInstance() && "static method with non-metatype self?!"), function getLoweredASTFunctionType, file /Volumes/Data/swift-public/swift/lib/SIL/SILFunctionType.cpp, line 2486.

1.  While silgen constructor initializer SIL function @_TFE4mainCSo13CGMutablePathcfT7svgPathSS_GSqS0__ for 'init' at <stdin>:10:24

Yes, this seems related, and is a good reason to try to prioritize the fix for Swift 3.0, if we can fit it in.

It's not a regression, so I'm fine with it landing later.

(Most CF types don't have initializers at all. CG is special because of the import-as-member proposal.)

So, previously if instead this code was:

public convenience init?(svgPath: String) { 
    self = CGPathCreateMutable()
    self.addSVGPath(svgPath: svgPath) 
} 

It also wouldn't work? Then I agree.

Yep, it's a class type, so you can't assign to self.

I'll fix the SILGen crash, but is this supposed to work at all?

It would be nice to be able to assign to self in class convenience initializers also, as long as the class is final. We can't subclass foreign classes, can we?

Comment by Glenn Howes (JIRA)

@slavapestov are you asking if the following is supposed to be valid code? Why shouldn't it be?

extension CGMutablePath 
{ 
       public func addSVGPath(svgPath: String) -> Bool 
       { 
              return true 
       } 
     
        public convenience init?(svgPath: String) 
        { 
               self.init() 
               if !self.addSVGPath(svgPath: svgPath) 
               {
                    return nil 
               } 
       }
} 

Doing this for non-foreign classes (and allowing self-assignment) requires deciding what factory initializers mean in Swift. Just doing it for foreign classes (only with self.init syntax) means we get to kick that discussion a bit further down the road.

Actually @belkadan, this is similar to what the dispatch overlay does, so the fact that it crashes must be a bug.

I opened: #4335

This fixes the SILGen assert (by fixing how we import the init). There may be other bugs deeper down, though. I'll investigate further.

While that PR will fix the provided code, actually trying to use it triggers an IRGen assert:

Assertion failed: (!theClass->isForeign()), function emitObjCHeapMetadataRef, file ...swift/lib/IRGen/GenMeta.cpp, line 339.

When trying to IRGen this:
%0 = alloc_ref [objc] $CGMutablePath, scope 0 // users: %3, %4

So, there's more layers here. I'll see how this differs from Dispatch

This is the "we need to not even try to allocate foreign classes" bit. I think Slava worked around this for Dispatch by special-casing RuntimeOnly foreign classes, whose metadata you can get by run-time lookup, but I don't think that's the correct answer even there.

So CGMutablePath does not have Objective-C metadata at all? Interesting...

CF types do not have public class symbols, no.

(or guaranteed runtime names)

We could emit a fake allocation of some kind. The only thing that's done to it is alloc, dealloc, and possibly retain and release.

There's no reason to do any allocation at all. We have a mechanism for this already: factory initializers.

Right, I agree we should do it properly if possible. Do you think it would be hard to teach SILGen to emit user-defined convenience inits as factory inits, in the case where they delegate to another factory init? Does this create any issues for PrintAsObjC and such?

This will not be supported in Swift 3, because we don't have the concept of user factory inits. This will emit an error in Swift-3, and hopefully we'll get support soon after. #4419

Slava's approach is what I was thinking, except I was going to make it based on whether the type was an AST-foreign type rather than whether the thing it delegated to was a factory init. (Normal convenience initializers are still inherited, while factory inits are not.)

This properly emits error: convenience initializers are not supported in extensions of CF types