Swift - Compiler error - Segmentation fault 11 - Generics conform to protocol

Question

Swift 1.2 / XCode 6.4

I have the following code:

public protocol MapShape : AnyObject
{
    func isEqualTo(other : MapShape) -> Bool
}

And a Generic class that I try to conform to that protocol

public class MapMulti<T:MapShape>
{
    let items : [T]
    init(items : [T])
    {
        self.items = items
    }
}
extension MapMulti : Equatable {}
    public func ==<T:MapShape>(lhs: MapMulti<T>, rhs: MapMulti<T>) -> Bool
    {
         return true //simplify code
    }


extension MapMulti : MapShape {
    public func isEqualTo(other: MapShape) -> Bool {
        if (object_getClassName(other) == object_getClassName(self))
        {
            return self == other as! MapMulti
        }
        return false
     }
}

When I try to build fails hrribly with:

0  swift                    0x000000010a3da2b8       llvm::sys::PrintStackTrace(__sFILE*) + 40
1  swift                    0x000000010a3da794 SignalHandler(int) + 452
2  libsystem_platform.dylib 0x00007fff95704f1a _sigtramp + 26
3  libsystem_platform.dylib 0x00007fff55f3c832 _sigtramp + 3229841714
4  swift                    0x0000000109d0112b swift::irgen::emitCategoryData(swift::irgen::IRGenModule&, swift::ExtensionDecl*) + 1819
5  swift                    0x0000000109d09432 swift::irgen::IRGenModule::emitExtension(swift::ExtensionDecl*) + 514
6  swift                    0x0000000109d061a4 swift::irgen::IRGenModule::emitSourceFile(swift::SourceFile&, unsigned int) + 100
7  swift                    0x0000000109d87c77 performIRGeneration(swift::IRGenOptions&, swift::Module*, swift::SILModule*, llvm::StringRef, llvm::LLVMContext&, swift::SourceFile*, unsigned int) + 2151
8  swift                    0x0000000109d88693 swift::performIRGeneration(swift::IRGenOptions&, swift::SourceFile&, swift::SILModule*, llvm::StringRef, llvm::LLVMContext&, unsigned int) + 51
9  swift                    0x0000000109cc4087 frontend_main(llvm::ArrayRef<char const*>, char const*, void*) + 6647
10 swift                    0x0000000109cc24e6 main + 1814
11 libdyld.dylib            0x00007fff998e75c9 start + 1
12 libdyld.dylib            0x0000000000000069 start + 1718717089
Stack dump:

1.  While emitting IR for source file /<PROJECT>/MyProject/MapMulti.swift

The part that is causing the failure is the extension that tries to conform to the MapShape protocol if I comment that out it compiles.

Also I think something in my Generics understanding is wrong. When I tried this:

let multipoint : MapMulti<MapShape> = MapMulti<MapPoint>(items: [P1,P2,P3])

It says MapMulti(MapPoint) is not convertible to MapMulti(MapShape)
Even though MapPoint conforms to MapShape I can do:

let shape : MapShape = MapPoint()

Instead I have to do: which I don't like.

let multiShape : MapMulti<MapShape> = MapMulti<MapShape>(items: [P1,P2,P3])

Please, help needed!!!

Edit: Added MapPoint Implementation

public class MapPoint : MapShape{
    let lat : Double
    let long : Double

    init (lat : Double, long : Double)
    {
        self.lat = lat
        self.long = long
    }



}
extension MapPoint : Equatable{}
public func ==(lhs: MapPoint, rhs: MapPoint) -> Bool
{
    return lhs.long == rhs.long && lhs.lat == rhs.lat
}

extension MapPoint : MapShape
{
    public func isEqualTo(other: MapShape) -> Bool {
        if (object_getClassName(other) == object_getClassName(self))
        {
            return self == other as! MapPoint
        }
        return false
    }
}

Answer 1

I made small changes to your code and it compiles now

public protocol MapShape // Removed the : AnyObject
{
    func isEqualTo(other : MapShape) -> Bool
}

public class MapMulti<T:MapShape>
{
    let items : [T]
    init(items : [T])
    {
        self.items = items
    }
}

extension MapMulti : Equatable {}

public func ==<T:MapShape>(lhs: MapMulti<T>, rhs: MapMulti<T>) -> Bool
{
    return true //simplify code
}

Now, the next change works if you just want to know if both elements are instances of the same class:

extension MapMulti : MapShape {
    public func isEqualTo(other: MapShape) -> Bool {
        // You can compare against dynamic class here 
        return self.dynamicType == other.dynamicType
    }
}

There's a very good explanation and example of dynamicType in this answered question: Identifying a subclass with Swift Generics works with custom class but not with UITapGestureRecognizer

I hope it helped