Switch to using Any instead of AnyObject

In Swift 3 AnyObject is rarely what you want to use. Objective-C API gets imported as Any and while types like Array and Dictionary can be coerced to AnyObject, they prefer Any, which doesn’t require a manual cast.
2016-08-23 10:10:33 -07:00 · 2016-08-23 10:10:33 -07:00 · 536367392f
commit 536367392f
parent 0233f383bb
22 changed files with 140 additions and 151 deletions
--- a/Socket.IO-Client-Swift.xcodeproj/project.pbxproj
+++ b/Socket.IO-Client-Swift.xcodeproj/project.pbxproj
@ -819,6 +819,7 @@
 				ONLY_ACTIVE_ARCH = YES;
 				PRODUCT_NAME = SocketIOClientSwift;
 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
+				SWIFT_VERSION = 3.0;
 				TVOS_DEPLOYMENT_TARGET = 9.0;
 				WATCHOS_DEPLOYMENT_TARGET = 2.0;
 			};
@ -849,6 +850,7 @@
 				MACOSX_DEPLOYMENT_TARGET = 10.10;
 				PRODUCT_NAME = SocketIOClientSwift;
 				SWIFT_OPTIMIZATION_LEVEL = "-Owholemodule";
+				SWIFT_VERSION = 3.0;
 				TVOS_DEPLOYMENT_TARGET = 9.0;
 				WATCHOS_DEPLOYMENT_TARGET = 2.0;
 			};
--- a/SocketIO-MacTests/SocketAckManagerTest.swift
+++ b/SocketIO-MacTests/SocketAckManagerTest.swift
@ -15,11 +15,11 @@ class SocketAckManagerTest: XCTestCase {
    func testAddAcks() {
        let callbackExpection = self.expectation(description: "callbackExpection")
        let itemsArray = ["Hi", "ho"]
-        func callback(_ items: [AnyObject]) {
+        func callback(_ items: [Any]) {
            callbackExpection.fulfill()
        }
        ackManager.addAck(1, callback: callback)
-        ackManager.executeAck(1, with: itemsArray as [AnyObject], onQueue: DispatchQueue.main)
+        ackManager.executeAck(1, with: itemsArray, onQueue: DispatchQueue.main)
        
        waitForExpectations(timeout: 3.0, handler: nil)
    }
--- a/SocketIO-MacTests/SocketBasicPacketTest.swift
+++ b/SocketIO-MacTests/SocketBasicPacketTest.swift
@ -16,15 +16,15 @@ class SocketBasicPacketTest: XCTestCase {
    func testEmpyEmit() {
        let expectedSendString = "2[\"test\"]"
        let sendData = ["test"]
-        let packet = SocketPacket.packetFromEmit(sendData as [AnyObject], id: -1, nsp: "/", ack: false)
+        let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)

        XCTAssertEqual(packet.packetString, expectedSendString)
    }
    
    func testNullEmit() {
        let expectedSendString = "2[\"test\",null]"
-        let sendData = ["test", NSNull()] as [Any]
-        let packet = SocketPacket.packetFromEmit(sendData as [AnyObject], id: -1, nsp: "/", ack: false)
+		let sendData: [Any] = ["test", NSNull()]
+        let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
        
        XCTAssertEqual(packet.packetString, expectedSendString)
    }
@ -32,7 +32,7 @@ class SocketBasicPacketTest: XCTestCase {
    func testStringEmit() {
        let expectedSendString = "2[\"test\",\"foo bar\"]"
        let sendData = ["test", "foo bar"]
-        let packet = SocketPacket.packetFromEmit(sendData as [AnyObject], id: -1, nsp: "/", ack: false)
+        let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
        
        XCTAssertEqual(packet.packetString, expectedSendString)
    }
@ -40,31 +40,31 @@ class SocketBasicPacketTest: XCTestCase {
    func testStringEmitWithQuotes() {
        let expectedSendString = "2[\"test\",\"\\\"he\\\"llo world\\\"\"]"
        let sendData = ["test", "\"he\"llo world\""]
-        let packet = SocketPacket.packetFromEmit(sendData as [AnyObject], id: -1, nsp: "/", ack: false)
+        let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
        
        XCTAssertEqual(packet.packetString, expectedSendString)
    }
    
    func testJSONEmit() {
        let expectedSendString = "2[\"test\",{\"test\":\"hello\",\"hello\":1,\"foobar\":1,\"null\":null}]"
-        let sendData = ["test" as AnyObject, ["foobar": true, "hello": 1, "test": "hello", "null": NSNull()] as NSDictionary] as [AnyObject]
-        let packet = SocketPacket.packetFromEmit(sendData as [AnyObject], id: -1, nsp: "/", ack: false)
+        let sendData: [Any] = ["test", ["foobar": true, "hello": 1, "test": "hello", "null": NSNull()]]
+        let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
        
        XCTAssertEqual(packet.packetString, expectedSendString)
    }
    
    func testArrayEmit() {
        let expectedSendString = "2[\"test\",[\"hello\",1,{\"test\":\"test\"}]]"
-        let sendData = ["test", ["hello", 1, ["test": "test"]]] as [Any]
-        let packet = SocketPacket.packetFromEmit(sendData as [AnyObject], id: -1, nsp: "/", ack: false)
+        let sendData: [Any] = ["test", ["hello", 1, ["test": "test"]]]
+        let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
        
        XCTAssertEqual(packet.packetString, expectedSendString)
    }
    
    func testBinaryEmit() {
        let expectedSendString = "51-[\"test\",{\"_placeholder\":1,\"num\":0}]"
-        let sendData = ["test", data] as [Any]
-        let packet = SocketPacket.packetFromEmit(sendData as [AnyObject], id: -1, nsp: "/", ack: false)
+        let sendData: [Any] = ["test", data]
+        let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
        
        XCTAssertEqual(packet.packetString, expectedSendString)
        XCTAssertEqual(packet.binary, [data])
@ -72,8 +72,8 @@ class SocketBasicPacketTest: XCTestCase {
    
    func testMultipleBinaryEmit() {
        let expectedSendString = "52-[\"test\",{\"data1\":{\"_placeholder\":1,\"num\":0},\"data2\":{\"_placeholder\":1,\"num\":1}}]"
-        let sendData = ["test" as AnyObject, ["data1": data, "data2": data2] as NSDictionary] as [AnyObject]
-        let packet = SocketPacket.packetFromEmit(sendData as [AnyObject], id: -1, nsp: "/", ack: false)
+        let sendData: [Any] = ["test", ["data1": data, "data2": data2] as NSDictionary]
+        let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/", ack: false)
        
        XCTAssertEqual(packet.packetString, expectedSendString)
        XCTAssertEqual(packet.binary, [data, data2])
@ -82,7 +82,7 @@ class SocketBasicPacketTest: XCTestCase {
    func testEmitWithAck() {
        let expectedSendString = "20[\"test\"]"
        let sendData = ["test"]
-        let packet = SocketPacket.packetFromEmit(sendData as [AnyObject], id: 0, nsp: "/", ack: false)
+        let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: false)
        
        XCTAssertEqual(packet.packetString,
                       
@ -91,8 +91,8 @@ class SocketBasicPacketTest: XCTestCase {
    
    func testEmitDataWithAck() {
        let expectedSendString = "51-0[\"test\",{\"_placeholder\":1,\"num\":0}]"
-        let sendData = ["test" as AnyObject, data as AnyObject] as [AnyObject]
-        let packet = SocketPacket.packetFromEmit(sendData as [AnyObject], id: 0, nsp: "/", ack: false)
+        let sendData: [Any] = ["test", data]
+        let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: false)

        XCTAssertEqual(packet.packetString, expectedSendString)
        XCTAssertEqual(packet.binary, [data])
@ -117,7 +117,7 @@ class SocketBasicPacketTest: XCTestCase {
    func testStringAck() {
        let expectedSendString = "30[\"test\"]"
        let sendData = ["test"]
-        let packet = SocketPacket.packetFromEmit(sendData as [AnyObject], id: 0, nsp: "/", ack: true)
+        let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true)
        
        XCTAssertEqual(packet.packetString, expectedSendString)
    }
@ -125,7 +125,7 @@ class SocketBasicPacketTest: XCTestCase {
    func testJSONAck() {
        let expectedSendString = "30[{\"test\":\"hello\",\"hello\":1,\"foobar\":1,\"null\":null}]"
        let sendData = [["foobar": true, "hello": 1, "test": "hello", "null": NSNull()]]
-        let packet = SocketPacket.packetFromEmit(sendData as [AnyObject], id: 0, nsp: "/", ack: true)
+        let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true)
        
        XCTAssertEqual(packet.packetString, expectedSendString)
    }
@ -133,7 +133,7 @@ class SocketBasicPacketTest: XCTestCase {
    func testBinaryAck() {
        let expectedSendString = "61-0[{\"_placeholder\":1,\"num\":0}]"
        let sendData = [data]
-        let packet = SocketPacket.packetFromEmit(sendData as [AnyObject], id: 0, nsp: "/", ack: true)
+        let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true)
        
        XCTAssertEqual(packet.packetString, expectedSendString)
        XCTAssertEqual(packet.binary, [data])
@ -142,7 +142,7 @@ class SocketBasicPacketTest: XCTestCase {
    func testMultipleBinaryAck() {
        let expectedSendString = "62-0[{\"data2\":{\"_placeholder\":1,\"num\":0},\"data1\":{\"_placeholder\":1,\"num\":1}}]"
        let sendData = [["data1": data, "data2": data2]]
-        let packet = SocketPacket.packetFromEmit(sendData as [AnyObject], id: 0, nsp: "/", ack: true)
+        let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/", ack: true)
        
        XCTAssertEqual(packet.packetString, expectedSendString)
        XCTAssertEqual(packet.binary, [data2, data])
--- a/SocketIO-MacTests/SocketEngineTest.swift
+++ b/SocketIO-MacTests/SocketEngineTest.swift
@ -89,14 +89,14 @@ class SocketEngineTest: XCTestCase {

    func testEncodeURLProperly() {
        engine.connectParams = [
-            "created": "2016-05-04T18:31:15+0200" as AnyObject
+            "created": "2016-05-04T18:31:15+0200"
        ]

        XCTAssertEqual(engine.urlPolling.query, "transport=polling&b64=1&created=2016-05-04T18%3A31%3A15%2B0200")
        XCTAssertEqual(engine.urlWebSocket.query, "transport=websocket&created=2016-05-04T18%3A31%3A15%2B0200")

        engine.connectParams = [
-            "forbidden": "!*'();:@&=+$,/?%#[]\" {}" as AnyObject
+            "forbidden": "!*'();:@&=+$,/?%#[]\" {}"
        ]

        XCTAssertEqual(engine.urlPolling.query, "transport=polling&b64=1&forbidden=%21%2A%27%28%29%3B%3A%40%26%3D%2B%24%2C%2F%3F%25%23%5B%5D%22%20%7B%7D")
--- a/SocketIO-MacTests/SocketNamespacePacketTest.swift
+++ b/SocketIO-MacTests/SocketNamespacePacketTest.swift
@ -15,40 +15,40 @@ class SocketNamespacePacketTest: XCTestCase {
    
    func testEmpyEmit() {
        let expectedSendString = "2/swift,[\"test\"]"
-        let sendData = ["test"]
-        let packet = SocketPacket.packetFromEmit(sendData as [AnyObject], id: -1, nsp: "/swift", ack: false)
+        let sendData: [Any] = ["test"]
+        let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/swift", ack: false)
        
        XCTAssertEqual(packet.packetString, expectedSendString)
    }
    
    func testNullEmit() {
        let expectedSendString = "2/swift,[\"test\",null]"
-        let sendData = ["test", NSNull()] as [Any]
-        let packet = SocketPacket.packetFromEmit(sendData as [AnyObject], id: -1, nsp: "/swift", ack: false)
+        let sendData: [Any] = ["test", NSNull()]
+        let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/swift", ack: false)
        
        XCTAssertEqual(packet.packetString, expectedSendString)
    }
    
    func testStringEmit() {
        let expectedSendString = "2/swift,[\"test\",\"foo bar\"]"
-        let sendData = ["test", "foo bar"]
-        let packet = SocketPacket.packetFromEmit(sendData as [AnyObject], id: -1, nsp: "/swift", ack: false)
+        let sendData: [Any] = ["test", "foo bar"]
+        let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/swift", ack: false)
        
        XCTAssertEqual(packet.packetString, expectedSendString)
    }
    
    func testJSONEmit() {
        let expectedSendString = "2/swift,[\"test\",{\"test\":\"hello\",\"hello\":1,\"foobar\":1,\"null\":null}]"
-        let sendData = ["test" as AnyObject, ["foobar": true, "hello": 1, "test": "hello", "null": NSNull()] as NSDictionary] as [AnyObject]
-        let packet = SocketPacket.packetFromEmit(sendData as [AnyObject], id: -1, nsp: "/swift", ack: false)
+        let sendData: [Any] = ["test", ["foobar": true, "hello": 1, "test": "hello", "null": NSNull()] as NSDictionary]
+        let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/swift", ack: false)
        
        XCTAssertEqual(packet.packetString, expectedSendString)
    }
    
    func testArrayEmit() {
        let expectedSendString = "2/swift,[\"test\",[\"hello\",1,{\"test\":\"test\"}]]"
-        let sendData = ["test", ["hello", 1, ["test": "test"]]] as [Any]
-        let packet = SocketPacket.packetFromEmit(sendData as [AnyObject], id: -1, nsp: "/swift", ack: false)
+        let sendData: [Any] = ["test", ["hello", 1, ["test": "test"]]]
+        let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/swift", ack: false)
        
        
        XCTAssertEqual(packet.packetString, expectedSendString)
@ -56,8 +56,8 @@ class SocketNamespacePacketTest: XCTestCase {
    
    func testBinaryEmit() {
        let expectedSendString = "51-/swift,[\"test\",{\"_placeholder\":1,\"num\":0}]"
-        let sendData = ["test" as AnyObject, data as AnyObject] as [AnyObject]
-        let packet = SocketPacket.packetFromEmit(sendData as [AnyObject], id: -1, nsp: "/swift", ack: false)
+        let sendData: [Any] = ["test", data]
+        let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/swift", ack: false)
        
        XCTAssertEqual(packet.packetString, expectedSendString)
        XCTAssertEqual(packet.binary, [data])
@ -65,8 +65,8 @@ class SocketNamespacePacketTest: XCTestCase {
    
    func testMultipleBinaryEmit() {
        let expectedSendString = "52-/swift,[\"test\",{\"data1\":{\"_placeholder\":1,\"num\":0},\"data2\":{\"_placeholder\":1,\"num\":1}}]"
-        let sendData = ["test" as AnyObject, ["data1": data, "data2": data2] as NSDictionary] as [AnyObject]
-        let packet = SocketPacket.packetFromEmit(sendData as [AnyObject], id: -1, nsp: "/swift", ack: false)
+        let sendData: [Any] = ["test", ["data1": data, "data2": data2] as NSDictionary]
+        let packet = SocketPacket.packetFromEmit(sendData, id: -1, nsp: "/swift", ack: false)
        
        XCTAssertEqual(packet.packetString, expectedSendString)
        XCTAssertEqual(packet.binary, [data, data2])
@ -75,15 +75,15 @@ class SocketNamespacePacketTest: XCTestCase {
    func testEmitWithAck() {
        let expectedSendString = "2/swift,0[\"test\"]"
        let sendData = ["test"]
-        let packet = SocketPacket.packetFromEmit(sendData as [AnyObject], id: 0, nsp: "/swift", ack: false)
+        let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/swift", ack: false)
        
        XCTAssertEqual(packet.packetString, expectedSendString)
    }
    
    func testEmitDataWithAck() {
        let expectedSendString = "51-/swift,0[\"test\",{\"_placeholder\":1,\"num\":0}]"
-        let sendData = ["test" as AnyObject, data as AnyObject] as [AnyObject]
-        let packet = SocketPacket.packetFromEmit(sendData as [AnyObject], id: 0, nsp: "/swift", ack: false)
+        let sendData: [Any] = ["test", data]
+        let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/swift", ack: false)
        
        XCTAssertEqual(packet.packetString, expectedSendString)
        XCTAssertEqual(packet.binary, [data])
@ -108,7 +108,7 @@ class SocketNamespacePacketTest: XCTestCase {
    func testStringAck() {
        let expectedSendString = "3/swift,0[\"test\"]"
        let sendData = ["test"]
-        let packet = SocketPacket.packetFromEmit(sendData as [AnyObject], id: 0, nsp: "/swift", ack: true)
+        let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/swift", ack: true)
        
        XCTAssertEqual(packet.packetString, expectedSendString)
    }
@ -116,7 +116,7 @@ class SocketNamespacePacketTest: XCTestCase {
    func testJSONAck() {
        let expectedSendString = "3/swift,0[{\"test\":\"hello\",\"hello\":1,\"foobar\":1,\"null\":null}]"
        let sendData = [["foobar": true, "hello": 1, "test": "hello", "null": NSNull()]]
-        let packet = SocketPacket.packetFromEmit(sendData as [AnyObject], id: 0, nsp: "/swift", ack: true)
+        let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/swift", ack: true)
        
        XCTAssertEqual(packet.packetString, expectedSendString)
    }
@ -124,7 +124,7 @@ class SocketNamespacePacketTest: XCTestCase {
    func testBinaryAck() {
        let expectedSendString = "61-/swift,0[{\"_placeholder\":1,\"num\":0}]"
        let sendData = [data]
-        let packet = SocketPacket.packetFromEmit(sendData as [AnyObject], id: 0, nsp: "/swift", ack: true)
+        let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/swift", ack: true)
        
        XCTAssertEqual(packet.packetString, expectedSendString)
        XCTAssertEqual(packet.binary, [data])
@ -133,7 +133,7 @@ class SocketNamespacePacketTest: XCTestCase {
    func testMultipleBinaryAck() {
        let expectedSendString = "62-/swift,0[{\"data2\":{\"_placeholder\":1,\"num\":0},\"data1\":{\"_placeholder\":1,\"num\":1}}]"
        let sendData = [["data1": data, "data2": data2]]
-        let packet = SocketPacket.packetFromEmit(sendData as [AnyObject], id: 0, nsp: "/swift", ack: true)
+        let packet = SocketPacket.packetFromEmit(sendData, id: 0, nsp: "/swift", ack: true)
        
        XCTAssertEqual(packet.packetString, expectedSendString)
        XCTAssertEqual(packet.binary, [data2, data])
--- a/SocketIO-MacTests/SocketParserTest.swift
+++ b/SocketIO-MacTests/SocketParserTest.swift
@ -13,21 +13,21 @@ class SocketParserTest: XCTestCase {
    let testSocket = SocketIOClient(socketURL: URL(string: "http://localhost/")!)
    
    //Format key: message; namespace-data-binary-id
-    static let packetTypes: [String: (String, [AnyObject], [Data], Int)] = [
+    static let packetTypes: [String: (String, [Any], [Data], Int)] = [
        "0": ("/", [], [], -1), "1": ("/", [], [], -1),
-        "25[\"test\"]": ("/", ["test" as AnyObject], [], 5),
-        "2[\"test\",\"~~0\"]": ("/", ["test" as AnyObject, "~~0" as AnyObject], [], -1),
-        "2/swift,[\"testArrayEmitReturn\",[\"test3\",\"test4\"]]": ("/swift", ["testArrayEmitReturn" as AnyObject, ["test3" as AnyObject, "test4" as AnyObject] as NSArray], [], -1),
-        "51-/swift,[\"testMultipleItemsWithBufferEmitReturn\",[1,2],{\"test\":\"bob\"},25,\"polo\",{\"_placeholder\":true,\"num\":0}]": ("/swift", ["testMultipleItemsWithBufferEmitReturn" as AnyObject, [1, 2] as NSArray, ["test": "bob"] as NSDictionary, 25 as AnyObject, "polo" as AnyObject, ["_placeholder": true, "num": 0] as NSDictionary], [], -1),
+        "25[\"test\"]": ("/", ["test"], [], 5),
+        "2[\"test\",\"~~0\"]": ("/", ["test", "~~0"], [], -1),
+        "2/swift,[\"testArrayEmitReturn\",[\"test3\",\"test4\"]]": ("/swift", ["testArrayEmitReturn", ["test3", "test4"] as NSArray], [], -1),
+        "51-/swift,[\"testMultipleItemsWithBufferEmitReturn\",[1,2],{\"test\":\"bob\"},25,\"polo\",{\"_placeholder\":true,\"num\":0}]": ("/swift", ["testMultipleItemsWithBufferEmitReturn", [1, 2] as NSArray, ["test": "bob"] as NSDictionary, 25, "polo", ["_placeholder": true, "num": 0] as NSDictionary], [], -1),
        "3/swift,0[[\"test3\",\"test4\"]]": ("/swift", [["test3", "test4"] as NSArray], [], 0),
        "61-/swift,19[[1,2],{\"test\":\"bob\"},25,\"polo\",{\"_placeholder\":true,\"num\":0}]":
-            ("/swift", [ [1, 2] as NSArray, ["test": "bob"] as NSDictionary, 25 as AnyObject, "polo" as AnyObject, ["_placeholder": true, "num": 0] as NSDictionary], [], 19),
+            ("/swift", [ [1, 2] as NSArray, ["test": "bob"] as NSDictionary, 25, "polo", ["_placeholder": true, "num": 0] as NSDictionary], [], 19),
        "4/swift,": ("/swift", [], [], -1),
        "0/swift": ("/swift", [], [], -1),
        "1/swift": ("/swift", [], [], -1),
-        "4\"ERROR\"": ("/", ["ERROR" as AnyObject], [], -1),
+        "4\"ERROR\"": ("/", ["ERROR"], [], -1),
        "4{\"test\":2}": ("/", [["test": 2] as NSDictionary], [], -1),
-        "41": ("/", [1 as AnyObject], [], -1)]
+        "41": ("/", [1], [], -1)]
    
    func testDisconnect() {
        let message = "1"
@ -120,7 +120,7 @@ class SocketParserTest: XCTestCase {
    func validateParseResult(_ message: String) {
        let validValues = SocketParserTest.packetTypes[message]!
        let packet = testSocket.parseString(message)
-        let type = message.substring(with: Range<String.Index>(message.startIndex..<message.characters.index(message.startIndex, offsetBy: 1)))
+        let type = String(message.characters.prefix(1))
        if case let .right(packet) = packet {
            XCTAssertEqual(packet.type, SocketPacket.PacketType(rawValue: Int(type) ?? -1)!)
            XCTAssertEqual(packet.nsp, validValues.0)
--- a/SocketIO-MacTests/SocketSideEffectTest.swift
+++ b/SocketIO-MacTests/SocketSideEffectTest.swift
@ -137,12 +137,6 @@ class SocketSideEffectTest: XCTestCase {
        waitForExpectations(timeout: 3, handler: nil)
    }
    
-    func testSocketDataToAnyObject() {
-        let data = ["test", 1, 2.2, ["Hello": 2, "bob": 2.2], true, [1, 2], [1.1, 2]] as [SocketData]
-        
-        XCTAssertEqual(data.count, data.toAnyObjectArray().count)
-    }
-    
    func testHandleMultipleBinaryEvent() {
        let expect = expectation(description: "handled multiple binary event")
        socket.on("test") {data, ack in
--- a/Source/SSLSecurity.swift
+++ b/Source/SSLSecurity.swift
@ -149,9 +149,9 @@ public class SSLSecurity : NSObject {
        if self.usePublicKeys {
            if let keys = self.pubKeys {
                let serverPubKeys = publicKeyChainForTrust(trust: trust)
-                for serverKey in serverPubKeys as [AnyObject] {
-                    for key in keys as [AnyObject] {
-                        if serverKey.isEqual(key) {
+                for serverKey in serverPubKeys {
+                    for key in keys {
+                        if CFEqual(serverKey, key) {
                            return true
                        }
                    }
--- a/Source/SocketAckEmitter.swift
+++ b/Source/SocketAckEmitter.swift
@ -36,10 +36,10 @@ public final class SocketAckEmitter : NSObject {
    public func with(_ items: SocketData...) {
        guard ackNum != -1 else { return }
        
-        socket.emitAck(ackNum, with: items.toAnyObjectArray())
+        socket.emitAck(ackNum, with: items)
    }
    
-    public func with(_ items: [AnyObject]) {
+    public func with(_ items: [Any]) {
        guard ackNum != -1 else { return }
        
        socket.emitAck(ackNum, with: items)
--- a/Source/SocketAckManager.swift
+++ b/Source/SocketAckManager.swift
@ -57,7 +57,7 @@ struct SocketAckManager {
    }
    
    /// Should be called on handle queue
-    mutating func executeAck(_ ack: Int, with items: [AnyObject], onQueue: DispatchQueue) {
+    mutating func executeAck(_ ack: Int, with items: [Any], onQueue: DispatchQueue) {
        let ack = acks.remove(SocketAck(ack: ack))
        
        onQueue.async() { ack?.callback(items) }
@ -67,6 +67,6 @@ struct SocketAckManager {
    mutating func timeoutAck(_ ack: Int, onQueue: DispatchQueue) {
        let ack = acks.remove(SocketAck(ack: ack))
        
-        onQueue.async() { ack?.callback?(["NO ACK" as AnyObject]) }
+        onQueue.async() { ack?.callback?(["NO ACK"]) }
    }
 }
--- a/Source/SocketAnyEvent.swift
+++ b/Source/SocketAnyEvent.swift
@ -26,12 +26,12 @@ import Foundation

 public final class SocketAnyEvent : NSObject {
    public let event: String
-    public let items: [AnyObject]?
+    public let items: [Any]?
    override public var description: String {
        return "SocketAnyEvent: Event: \(event) items: \(items ?? nil)"
    }
    
-    init(event: String, items: [AnyObject]?) {
+    init(event: String, items: [Any]?) {
        self.event = event
        self.items = items
    }
--- a/Source/SocketEngine.swift
+++ b/Source/SocketEngine.swift
@ -29,7 +29,7 @@ public final class SocketEngine : NSObject, URLSessionDelegate, SocketEnginePoll
    public let handleQueue = DispatchQueue(label: "com.socketio.engineHandleQueue", attributes: [])
    public let parseQueue = DispatchQueue(label: "com.socketio.engineParseQueue", attributes: [])

-    public var connectParams: [String: AnyObject]? {
+    public var connectParams: [String: Any]? {
        didSet {
            (urlPolling, urlWebSocket) = createURLs()
        }
--- a/Source/SocketEngineSpec.swift
+++ b/Source/SocketEngineSpec.swift
@ -29,7 +29,7 @@ import Foundation
    weak var client: SocketEngineClient? { get set }
    var closed: Bool { get }
    var connected: Bool { get }
-    var connectParams: [String: AnyObject]? { get set }
+    var connectParams: [String: Any]? { get set }
    var doubleEncodeUTF8: Bool { get }
    var cookies: [HTTPCookie]? { get }
    var extraHeaders: [String: String]? { get }
--- a/Source/SocketEventHandler.swift
+++ b/Source/SocketEventHandler.swift
@ -29,7 +29,7 @@ struct SocketEventHandler {
    let id: UUID
    let callback: NormalCallback
    
-    func executeCallback(with items: [AnyObject], withAck ack: Int, withSocket socket: SocketIOClient) {
+    func executeCallback(with items: [Any], withAck ack: Int, withSocket socket: SocketIOClient) {
        callback(items, SocketAckEmitter(socket: socket, ackNum: ack))
    }
 }
--- a/Source/SocketExtensions.swift
+++ b/Source/SocketExtensions.swift
@ -30,13 +30,6 @@ enum JSONError : Error {
 }

 extension Array {
-    /// Because Swift 3 removes a lot of implicit briding so we have to perform more casts
-    func toAnyObjectArray() -> [AnyObject] {
-        return flatMap({$0 as? AnyObject})
-    }
-}
-
-extension Array where Element: AnyObject {
    func toJSON() throws -> Data {
        return try JSONSerialization.data(withJSONObject: self as NSArray, options: JSONSerialization.WritingOptions(rawValue: 0))
    }
@ -49,9 +42,9 @@ extension CharacterSet {
 }

 extension NSDictionary {
-    private static func keyValueToSocketIOClientOption(key: String, value: AnyObject) -> SocketIOClientOption? {
+    private static func keyValueToSocketIOClientOption(key: String, value: Any) -> SocketIOClientOption? {
        switch (key, value) {
-        case let ("connectParams", params as [String: AnyObject]):
+        case let ("connectParams", params as [String: Any]):
            return .connectParams(params)
        case let ("cookies", cookies as [HTTPCookie]):
            return .cookies(cookies)
@ -100,7 +93,7 @@ extension NSDictionary {
        var options = [] as SocketIOClientConfiguration
        
        for (rawKey, value) in self {
-            if let key = rawKey as? String, let opt = NSDictionary.keyValueToSocketIOClientOption(key: key, value: value as AnyObject) {
+            if let key = rawKey as? String, let opt = NSDictionary.keyValueToSocketIOClientOption(key: key, value: value) {
                options.insert(opt)
            }
        }
@ -110,9 +103,9 @@ extension NSDictionary {
 }

 extension String {
-    func toArray() throws -> [AnyObject] {
+    func toArray() throws -> [Any] {
        guard let stringData = data(using: .utf8, allowLossyConversion: false) else { return [] }
-        guard let array = try JSONSerialization.jsonObject(with: stringData, options: .mutableContainers) as? [AnyObject] else {
+        guard let array = try JSONSerialization.jsonObject(with: stringData, options: .mutableContainers) as? [Any] else {
             throw JSONError.notArray
        }
        
--- a/Source/SocketIOClient.swift
+++ b/Source/SocketIOClient.swift
@ -160,7 +160,7 @@ public final class SocketIOClient : NSObject, SocketEngineClient, SocketParsable
        }
    }

-    private func createOnAck(_ items: [AnyObject]) -> OnAckCallback {
+    private func createOnAck(_ items: [Any]) -> OnAckCallback {
        currentAck += 1
        
        return {[weak self, ack = currentAck] timeout, callback in
@ -201,7 +201,7 @@ public final class SocketIOClient : NSObject, SocketEngineClient, SocketParsable

        // Make sure the engine is actually dead.
        engine?.disconnect(reason: reason)
-        handleEvent("disconnect", data: [reason as AnyObject], isInternalMessage: true)
+        handleEvent("disconnect", data: [reason], isInternalMessage: true)
    }

    /// Disconnects the socket.
@ -215,34 +215,34 @@ public final class SocketIOClient : NSObject, SocketEngineClient, SocketParsable

    /// Send a message to the server
    public func emit(_ event: String, _ items: SocketData...) {
-        emit(event, with: items.toAnyObjectArray())
+        emit(event, with: items)
    }

    /// Same as emit, but meant for Objective-C
-    public func emit(_ event: String, with items: [AnyObject]) {
+    public func emit(_ event: String, with items: [Any]) {
        guard status == .connected else {
-            handleEvent("error", data: ["Tried emitting \(event) when not connected" as AnyObject], isInternalMessage: true)
+            handleEvent("error", data: ["Tried emitting \(event) when not connected"], isInternalMessage: true)
            return
        }
        
-        _emit([event as AnyObject] + items)
+        _emit([event] + items)
    }

    /// Sends a message to the server, requesting an ack. Use the onAck method of SocketAckHandler to add
    /// an ack.
    public func emitWithAck(_ event: String, _ items: SocketData...) -> OnAckCallback {
-        return emitWithAck(event, with: items.toAnyObjectArray())
+        return emitWithAck(event, with: items)
    }

    /// Same as emitWithAck, but for Objective-C
-    public func emitWithAck(_ event: String, with items: [AnyObject]) -> OnAckCallback {
-        return createOnAck([event as AnyObject] + items)
+    public func emitWithAck(_ event: String, with items: [Any]) -> OnAckCallback {
+        return createOnAck([event] + items)
    }

-    private func _emit(_ data: [AnyObject], ack: Int? = nil) {
+    private func _emit(_ data: [Any], ack: Int? = nil) {
        emitQueue.async {
            guard self.status == .connected else {
-                self.handleEvent("error", data: ["Tried emitting when not connected" as AnyObject], isInternalMessage: true)
+                self.handleEvent("error", data: ["Tried emitting when not connected"], isInternalMessage: true)
                return
            }
            
@ -256,7 +256,7 @@ public final class SocketIOClient : NSObject, SocketEngineClient, SocketParsable
    }

    // If the server wants to know that the client received data
-    func emitAck(_ ack: Int, with items: [AnyObject]) {
+    func emitAck(_ ack: Int, with items: [Any]) {
        emitQueue.async {
            if self.status == .connected {
                let packet = SocketPacket.packetFromEmit(items, id: ack, nsp: self.nsp, ack: true)
@ -288,7 +288,7 @@ public final class SocketIOClient : NSObject, SocketEngineClient, SocketParsable
    public func engineDidError(reason: String) {
        DefaultSocketLogger.Logger.error("%@", type: logType, args: reason)

-        handleEvent("error", data: [reason as AnyObject], isInternalMessage: true)
+        handleEvent("error", data: [reason], isInternalMessage: true)
    }
    
    public func engineDidOpen(reason: String) {
@ -296,7 +296,7 @@ public final class SocketIOClient : NSObject, SocketEngineClient, SocketParsable
    }

    // Called when the socket gets an ack for something it sent
-    func handleAck(_ ack: Int, data: [AnyObject]) {
+    func handleAck(_ ack: Int, data: [Any]) {
        guard status == .connected else { return }

        DefaultSocketLogger.Logger.log("Handling ack: %@ with data: %@", type: logType, args: ack, data)
@ -307,7 +307,7 @@ public final class SocketIOClient : NSObject, SocketEngineClient, SocketParsable
    }

    /// Causes an event to be handled. Only use if you know what you're doing.
-    public func handleEvent(_ event: String, data: [AnyObject], isInternalMessage: Bool, withAck ack: Int = -1) {
+    public func handleEvent(_ event: String, data: [Any], isInternalMessage: Bool, withAck ack: Int = -1) {
        guard status == .connected || isInternalMessage else { return }

        DefaultSocketLogger.Logger.log("Handling event: %@ with data: %@", type: logType, args: event, data)
@ -416,7 +416,7 @@ public final class SocketIOClient : NSObject, SocketEngineClient, SocketParsable
        guard reconnecting else { return }

        DefaultSocketLogger.Logger.log("Starting reconnect", type: logType)
-        handleEvent("reconnect", data: [reason as AnyObject], isInternalMessage: true)
+        handleEvent("reconnect", data: [reason], isInternalMessage: true)
        
        _tryReconnect()
    }
@ -429,7 +429,7 @@ public final class SocketIOClient : NSObject, SocketEngineClient, SocketParsable
        }

        DefaultSocketLogger.Logger.log("Trying to reconnect", type: logType)
-        handleEvent("reconnectAttempt", data: [(reconnectAttempts - currentReconnectAttempt) as AnyObject],
+        handleEvent("reconnectAttempt", data: [(reconnectAttempts - currentReconnectAttempt)],
            isInternalMessage: true)

        currentReconnectAttempt += 1
@ -454,7 +454,7 @@ public final class SocketIOClient : NSObject, SocketEngineClient, SocketParsable
        self.engine = engine
    }
    
-    func emitTest(event: String, _ data: AnyObject...) {
-        _emit([event as AnyObject] + data)
+    func emitTest(event: String, _ data: Any...) {
+        _emit([event] + data)
    }
 }
--- a/Source/SocketIOClientOption.swift
+++ b/Source/SocketIOClientOption.swift
@ -25,11 +25,11 @@
 import Foundation

 protocol ClientOption : CustomStringConvertible, Equatable {
-    func getSocketIOOptionValue() -> AnyObject
+    func getSocketIOOptionValue() -> Any
 }

 public enum SocketIOClientOption : ClientOption {
-    case connectParams([String: AnyObject])
+    case connectParams([String: Any])
    case cookies([HTTPCookie])
    case doubleEncodeUTF8(Bool)
    case extraHeaders([String: String])
@ -99,50 +99,50 @@ public enum SocketIOClientOption : ClientOption {
        return description
    }
    
-    func getSocketIOOptionValue() -> AnyObject {
-        let value: AnyObject
+    func getSocketIOOptionValue() -> Any {
+        let value: Any
        
        switch self {
        case let .connectParams(params):
-            value = params as AnyObject
+            value = params
        case let .cookies(cookies):
-            value = cookies as AnyObject
+            value = cookies
        case let .doubleEncodeUTF8(encode):
-            value = encode as AnyObject
+            value = encode
        case let .extraHeaders(headers):
-            value = headers as AnyObject
+            value = headers
        case let .forceNew(force):
-            value = force as AnyObject
+            value = force
        case let .forcePolling(force):
-            value = force as AnyObject
+            value = force
        case let .forceWebsockets(force):
-            value = force as AnyObject
+            value = force
        case let .handleQueue(queue):
-            value = queue as AnyObject
+            value = queue
        case let .log(log):
-            value = log as AnyObject
+            value = log
        case let .logger(logger):
-            value = logger as AnyObject
+            value = logger
        case let .nsp(nsp):
-            value = nsp as AnyObject
+            value = nsp
        case let .path(path):
-            value = path as AnyObject
+            value = path
        case let .reconnects(reconnects):
-            value = reconnects as AnyObject
+            value = reconnects
        case let .reconnectAttempts(attempts):
-            value = attempts as AnyObject
+            value = attempts
        case let .reconnectWait(wait):
-            value = wait as AnyObject
+            value = wait
        case let .secure(secure):
-            value = secure as AnyObject
+            value = secure
        case let .security(security):
            value = security
        case let .selfSigned(signed):
-            value = signed as AnyObject
+            value = signed
        case let .sessionDelegate(delegate):
-            value = delegate as AnyObject
+            value = delegate
        case let .voipEnabled(enabled):
-            value = enabled as AnyObject
+            value = enabled
        }
        
        return value
--- a/Source/SocketIOClientSpec.swift
+++ b/Source/SocketIOClientSpec.swift
@ -29,8 +29,8 @@ protocol SocketIOClientSpec : class {
    func didConnect()
    func didDisconnect(reason: String)
    func didError(reason: String)
-    func handleAck(_ ack: Int, data: [AnyObject])
-    func handleEvent(_ event: String, data: [AnyObject], isInternalMessage: Bool, withAck ack: Int)
+    func handleAck(_ ack: Int, data: [Any])
+    func handleEvent(_ event: String, data: [Any], isInternalMessage: Bool, withAck ack: Int)
    func joinNamespace(_ namespace: String)
 }

@ -38,6 +38,6 @@ extension SocketIOClientSpec {
    func didError(reason: String) {
        DefaultSocketLogger.Logger.error("%@", type: "SocketIOClient", args: reason)
        
-        handleEvent("error", data: [reason as AnyObject], isInternalMessage: true, withAck: -1)
+        handleEvent("error", data: [reason], isInternalMessage: true, withAck: -1)
    }
 }
--- a/Source/SocketPacket.swift
+++ b/Source/SocketPacket.swift
@ -39,9 +39,9 @@ struct SocketPacket {
    let type: PacketType
    
    var binary: [Data]
-    var data: [AnyObject]
+    var data: [Any]
    
-    var args: [AnyObject] {
+    var args: [Any] {
        if type == .event || type == .binaryEvent && data.count != 0 {
            return Array(data.dropFirst())
        } else {
@ -62,7 +62,7 @@ struct SocketPacket {
        return createPacketString()
    }
    
-    init(type: PacketType, data: [AnyObject] = [AnyObject](), id: Int = -1,
+    init(type: PacketType, data: [Any] = [Any](), id: Int = -1,
        nsp: String, placeholders: Int = 0, binary: [Data] = [Data]()) {
        self.data = data
        self.id = id
@ -132,19 +132,19 @@ struct SocketPacket {
    // If object is a collection it will recurse
    // Returns the object if it is not a placeholder or the corresponding
    // binary data
-    private func _fillInPlaceholders(_ object: AnyObject) -> AnyObject {
+    private func _fillInPlaceholders(_ object: Any) -> Any {
        switch object {
        case let dict as NSDictionary:
            if dict["_placeholder"] as? Bool ?? false {
-                return binary[dict["num"] as! Int] as AnyObject
+                return binary[dict["num"] as! Int]
            } else {
                return dict.reduce(NSMutableDictionary(), {cur, keyValue in
-                    cur[keyValue.0 as! NSCopying] = _fillInPlaceholders(keyValue.1 as AnyObject)
+                    cur[keyValue.0 as! NSCopying] = _fillInPlaceholders(keyValue.1)
                    return cur
                })
            }
-        case let arr as [AnyObject]:
-            return arr.map(_fillInPlaceholders) as AnyObject
+        case let arr as [Any]:
+            return arr.map(_fillInPlaceholders)
        default:
            return object
        }
@ -167,7 +167,7 @@ extension SocketPacket {
        }
    }
    
-    static func packetFromEmit(_ items: [AnyObject], id: Int, nsp: String, ack: Bool) -> SocketPacket {
+    static func packetFromEmit(_ items: [Any], id: Int, nsp: String, ack: Bool) -> SocketPacket {
        let (parsedData, binary) = deconstructData(items)
        let packet = SocketPacket(type: findType(binary.count, ack: ack), data: parsedData,
            id: id, nsp: nsp, binary: binary)
@ -178,18 +178,18 @@ extension SocketPacket {

 private extension SocketPacket {
    // Recursive function that looks for NSData in collections
-    static func shred(_ data: AnyObject, binary: inout [Data]) -> AnyObject {
-        let placeholder = ["_placeholder": true, "num": binary.count as AnyObject] as [String : Any]
+    static func shred(_ data: Any, binary: inout [Data]) -> Any {
+        let placeholder = ["_placeholder": true, "num": binary.count] as [String : Any]
        
        switch data {
        case let bin as Data:
            binary.append(bin)
-            return placeholder as AnyObject
-        case let arr as [AnyObject]:
-            return arr.map({shred($0, binary: &binary)}) as AnyObject
+            return placeholder
+        case let arr as [Any]:
+            return arr.map({shred($0, binary: &binary)})
        case let dict as NSDictionary:
            return dict.reduce(NSMutableDictionary(), {cur, keyValue in
-                cur[keyValue.0 as! NSCopying] = shred(keyValue.1 as AnyObject, binary: &binary)
+                cur[keyValue.0 as! NSCopying] = shred(keyValue.1, binary: &binary)
                return cur
            })
        default:
@ -199,7 +199,7 @@ private extension SocketPacket {
    
    // Removes binary data from emit data
    // Returns a type containing the de-binaryed data and the binary
-    static func deconstructData(_ data: [AnyObject]) -> ([AnyObject], [Data]) {
+    static func deconstructData(_ data: [Any]) -> ([Any], [Data]) {
        var binary = [Data]()
        
        return (data.map({shred($0, binary: &binary)}), binary)
--- a/Source/SocketParsable.swift
+++ b/Source/SocketParsable.swift
@ -65,7 +65,7 @@ extension SocketParsable {
    func parseString(_ message: String) -> Either<String, SocketPacket> {
        var reader = SocketStringReader(message: message)
        
-        guard let type = SocketPacket.PacketType(rawValue: Int(reader.read(count: 1)) ?? -1) else {
+		guard let type = Int(reader.read(count: 1)).flatMap({ SocketPacket.PacketType(rawValue: $0) }) else {
            return .left("Invalid packet type")
        }
        
@ -112,7 +112,7 @@ extension SocketParsable {
        switch parseData(d) {
        case let .left(err):
            // Errors aren't always enclosed in an array
-            if case let .right(data) = parseData("\([d as AnyObject])") {
+            if case let .right(data) = parseData("[\(d)]") {
                return .right(SocketPacket(type: type, data: data, id: Int(idString) ?? -1,
                    nsp: namespace, placeholders: placeholders))
            } else {
@ -125,7 +125,7 @@ extension SocketParsable {
    }
    
    // Parses data for events
-    private func parseData(_ data: String) -> Either<String, [AnyObject]> {
+    private func parseData(_ data: String) -> Either<String, [Any]> {
        do {
            return .right(try data.toArray())
        } catch {
--- a/Source/SocketTypes.swift
+++ b/Source/SocketTypes.swift
@ -39,8 +39,8 @@ extension NSString : SocketData {}
 extension NSNull : SocketData {}
 extension String : SocketData {}

-public typealias AckCallback = ([AnyObject]) -> Void
-public typealias NormalCallback = ([AnyObject], SocketAckEmitter) -> Void
+public typealias AckCallback = ([Any]) -> Void
+public typealias NormalCallback = ([Any], SocketAckEmitter) -> Void
 public typealias OnAckCallback = (_ timeoutAfter: UInt64, _ callback: AckCallback) -> Void

 typealias Probe = (msg: String, type: SocketEnginePacketType, data: [Data])
--- a/Source/WebSocket.swift
+++ b/Source/WebSocket.swift
@ -368,7 +368,7 @@ public class WebSocket: NSObject, StreamDelegate {
    public func stream(aStream: Stream, handleEvent eventCode: Stream.Event) {
        
        if let sec = security , !certValidated && [.hasBytesAvailable, .hasSpaceAvailable].contains(eventCode) {
-            let possibleTrust = aStream.property(forKey: kCFStreamPropertySSLPeerTrust as Stream.PropertyKey) as AnyObject
+            let possibleTrust = aStream.property(forKey: kCFStreamPropertySSLPeerTrust as Stream.PropertyKey)
                let domain = aStream.property(forKey: kCFStreamSSLPeerName as Stream.PropertyKey) as? String
                if sec.isValid(possibleTrust as! SecTrust, domain: domain) {
                    certValidated = true