Changes related to WebIDL support.

Author: mjburghard

IntegrationTests/TestSuites/Sources/PrimaryTests/main.swift

@@ -281,26 +281,26 @@ Call_Function_With_This: do {
 }
 
 Object_Conversion: do {
-//    let array1 = [1, 2, 3]
-//    let jsArray1 = array1.jsValue().object!
-//    try expectEqual(jsArray1.length, .number(3))
-//    try expectEqual(jsArray1[0], .number(1))
-//    try expectEqual(jsArray1[1], .number(2))
-//    try expectEqual(jsArray1[2], .number(3))
-
-    let array2: [JSValueConvertible] = [1, "str", false]
+    let array1 = [1, 2, 3]
+    let jsArray1 = array1.jsValue().object!
+    try expectEqual(jsArray1.length, .number(3))
+    try expectEqual(jsArray1[0], .number(1))
+    try expectEqual(jsArray1[1], .number(2))
+    try expectEqual(jsArray1[2], .number(3))
+
+    let array2: [JSValueEncodable] = [1, "str", false]
     let jsArray2 = array2.jsValue().object!
     try expectEqual(jsArray2.length, .number(3))
     try expectEqual(jsArray2[0], .number(1))
     try expectEqual(jsArray2[1], .string("str"))
     try expectEqual(jsArray2[2], .boolean(false))
     _ = jsArray2.push!(5)
     try expectEqual(jsArray2.length, .number(4))
-//    _ = jsArray2.push!(jsArray1)
+    _ = jsArray2.push!(jsArray1)
 
-//    try expectEqual(jsArray2[4], .object(jsArray1))
+    try expectEqual(jsArray2[4], .object(jsArray1))
 
-    let dict1: [String: JSValueConvertible] = [
+    let dict1: [String: JSValueEncodable] = [
         "prop1": 1,
         "prop2": "foo",
     ]

Sources/JavaScriptKit/JSFunction.swift

@@ -2,7 +2,7 @@ import _CJavaScriptKit
 
 public class JSFunctionRef: JSObjectRef {
     @discardableResult
-    func callAsFunction(this: JSObjectRef? = nil, args: [JSValueConvertible]) -> JSValue {
+    func callAsFunction(this: JSObjectRef? = nil, args: [JSValueEncodable]) -> JSValue {
         let result = args.withRawJSValues { rawValues in
             rawValues.withUnsafeBufferPointer { bufferPointer -> RawJSValue in
                 let argv = bufferPointer.baseAddress
@@ -25,28 +25,25 @@ public class JSFunctionRef: JSObjectRef {
     }
 
     @discardableResult
-    public func callAsFunction(this: JSObjectRef? = nil, _ args: JSValueConvertible...) -> JSValue {
+    public func callAsFunction(this: JSObjectRef? = nil, _ args: JSValueEncodable...) -> JSValue {
         self(this: this, args: args)
     }
 
-    public func new(_ args: JSValueConvertible...) -> JSObjectRef {
+    public func new(_ args: JSValueEncodable...) -> JSObjectRef {
         new(args: args)
     }
 
     // Guaranteed to return an object because either:
     // a) the constructor explicitly returns an object, or
     // b) the constructor returns nothing, which causes JS to return the `this` value, or
     // c) the constructor returns undefined, null or a non-object, in which case JS also returns `this`.
-    public func new(args: [JSValueConvertible]) -> JSObjectRef {
+    public func new(args: [JSValueEncodable]) -> JSObjectRef {
         args.withRawJSValues { rawValues in
             rawValues.withUnsafeBufferPointer { bufferPointer in
                 let argv = bufferPointer.baseAddress
                 let argc = bufferPointer.count
                 var resultObj = JavaScriptObjectRef()
-                _call_new(
-                    self.id, argv, Int32(argc),
-                    &resultObj
-                )
+                _call_new(self.id, argv, Int32(argc), &resultObj)
                 return JSObjectRef(id: resultObj)
             }
         }
@@ -57,6 +54,19 @@ public class JSFunctionRef: JSObjectRef {
         fatalError("unavailable")
     }
 
+    override public class func canDecode(from jsValue: JSValue) -> Bool {
+        return jsValue.isFunction
+    }
+
+    public required convenience init(jsValue: JSValue) {
+        switch jsValue {
+        case let .function(value):
+            self.init(id: value.id)
+        default:
+            fatalError()
+        }
+    }
+
     override public func jsValue() -> JSValue {
         .function(self)
     }
@@ -80,6 +90,15 @@ public class JSClosure: JSFunctionRef {
         id = objectRef
     }
 
+    public required convenience init(jsValue: JSValue) {
+        switch jsValue {
+        case let .function(fun):
+            self.init { fun(args: $0) }
+        default:
+            fatalError()
+        }
+    }
+
     public func release() {
         Self.sharedFunctions[hostFuncRef] = nil
     }

Sources/JavaScriptKit/JSObject.swift

@@ -8,10 +8,10 @@ public class JSObjectRef: Equatable {
     }
 
     @_disfavoredOverload
-    public subscript(dynamicMember name: String) -> ((JSValueConvertible...) -> JSValue)? {
+    public subscript(dynamicMember name: String) -> ((JSValueEncodable...) -> JSValue)? {
         guard let function = self[name].function else { return nil }
-        return { (arguments: JSValueConvertible...) in
-            function(this: self, arguments)
+        return { (arguments: JSValueEncodable...) in
+            function(this: self, args: arguments)
         }
     }
 
@@ -43,7 +43,20 @@ public class JSObjectRef: Equatable {
         return lhs.id == rhs.id
     }
 
+    public required convenience init(jsValue: JSValue) {
+        switch jsValue {
+        case let .object(value):
+            self.init(id: value.id)
+        default:
+            fatalError()
+        }
+    }
+
     public func jsValue() -> JSValue {
         .object(self)
     }
+
+    public class func canDecode(from jsValue: JSValue) -> Bool {
+        return jsValue.isObject
+    }
 }

Sources/JavaScriptKit/JSValue.swift

@@ -41,14 +41,51 @@ public enum JSValue: Equatable {
         object.flatMap { JSArrayRef($0) }
     }
 
-    public var isNull: Bool { return self == .null }
-    public var isUndefined: Bool { return self == .undefined }
     public var function: JSFunctionRef? {
         switch self {
         case let .function(function): return function
         default: return nil
         }
     }
+
+    public var isBoolean: Bool {
+        guard case .boolean = self else { return false }
+        return true
+    }
+
+    public var isString: Bool {
+        guard case .string = self else { return false }
+        return true
+    }
+
+    public var isNumber: Bool {
+        guard case .number = self else { return false }
+        return true
+    }
+
+    public var isObject: Bool {
+        guard case .object = self else { return false }
+        return true
+    }
+
+    public var isNull: Bool {
+        return self == .null
+    }
+
+    public var isUndefined: Bool {
+        return self == .undefined
+    }
+
+    public var isFunction: Bool {
+        guard case .function = self else { return false }
+        return true
+    }
+}
+
+extension JSValue {
+    public func fromJSValue<Type>() -> Type where Type: JSValueDecodable {
+        return Type(jsValue: self)
+    }
 }
 
 extension JSValue {
@@ -64,7 +101,13 @@ extension JSValue: ExpressibleByStringLiteral {
 }
 
 extension JSValue: ExpressibleByIntegerLiteral {
-    public init(integerLiteral value: Double) {
+    public init(integerLiteral value: Int32) {
+        self = .number(Double(value))
+    }
+}
+
+extension JSValue: ExpressibleByFloatLiteral {
+    public init(floatLiteral value: Double) {
         self = .number(value)
     }
 }
@@ -98,3 +141,18 @@ public func setJSValue(this: JSObjectRef, index: Int32, value: JSValue) {
                        rawValue.payload1, rawValue.payload2, rawValue.payload3)
     }
 }
+
+extension JSValue {
+    public func isInstanceOf(_ constructor: JSFunctionRef) -> Bool {
+        switch self {
+        case .boolean, .string, .number:
+            return false
+        case let .object(ref):
+            return ref.isInstanceOf(constructor)
+        case let .function(ref):
+            return ref.isInstanceOf(constructor)
+        case .null, .undefined:
+            fatalError()
+        }
+    }
+}