Improve nullability / initializers

Additionally:
- add initializers for types
- misc fix for GIL checking

Author: jerrymarino

Sources/Vim/Vim.swift

@@ -6,25 +6,27 @@ public struct Vim {
     }
 
     /// Run a vim command
-    @discardableResult public static func command(_ cmd: String) -> VimValue {
-        var value: VimValue!
+    @discardableResult public static func command(_ cmd: String) -> VimValue? {
+        var value: VimValue?
         cmd.withCString { cStr in
             //FIXME: handle error propagation
-            let result = swiftvim_command(
-                UnsafeMutablePointer(mutating: cStr))
-            value = VimValue(value: result)
+            if let result = swiftvim_command(
+                UnsafeMutablePointer(mutating: cStr)) {
+                value = VimValue(result)
+            }
         }
         return value
     }
 
     /// Evaluate an expression
-    @discardableResult public static func eval(_ cmd: String) -> VimValue {
-        var value: VimValue!
+    @discardableResult public static func eval(_ cmd: String) -> VimValue? {
+        var value: VimValue?
         cmd.withCString { cStr in
             //FIXME: handle error propagation
-            let result = swiftvim_eval(
-                UnsafeMutablePointer(mutating: cStr))
-            value = VimValue(value: result)
+            if let result = swiftvim_eval(
+                UnsafeMutablePointer(mutating: cStr)) {
+                value = VimValue(result)
+            }
         }
         return value
     }

Sources/Vim/VimBuffer.swift

@@ -1,21 +1,21 @@
 import VimInterface
 
 public class VimBuffer {
-    private let value: UnsafeVimValue
+    private let value: VimValue
 
-    init(value: UnsafeVimValue) {
+    init(_ value: VimValue) {
         self.value = value
     }
 
     public lazy var number: Int = {
-        return self.value.attr("number")
+        return self.value.reference.attr("number")
     }()
 
     public lazy var name: String = {
-        return self.value.attr("name")
+        return self.value.reference.attr("name")
     }()
 
     public func asList() -> VimList {
-        return VimList(value: self.value)
+        return VimList(self.value)
     }
 }

Sources/Vim/VimCurrent.swift

@@ -4,11 +4,11 @@ public class Current {
     private let value: UnsafeVimValue
 
     public lazy var buffer: VimBuffer = {
-        return VimBuffer(value: self.value.attrp("buffer")!)
+        return VimBuffer(VimValue(self.value.attrp("buffer")!))
     }()
 
     public lazy var window: VimWindow = {
-        return VimWindow(value: self.value.attrp("window")!)
+        return VimWindow(VimValue(self.value.attrp("window")!))
     }()
 
     init() {

Sources/Vim/VimValue.swift

@@ -1,109 +1,130 @@
 import VimInterface
 
+
+extension Int {
+    init?(_ value: VimValue) {
+        // Generally, eval results are returned as strings
+        // Perhaps there is a better way to express this.
+        if let strValue = value.asString(), 
+            let intValue = Int(strValue) {
+            self.init(intValue)
+        } else {
+            self.init(swiftvim_asint(value.reference))
+        }
+    }
+}
+
+extension String {
+    init?(_ value: VimValue) {
+        guard let cStr = swiftvim_asstring(value.reference) else {
+            return nil
+        }
+        self.init(cString: cStr)
+    }
+}
+
 /// Vim Value represents a value in Vim
 ///
 /// This value is generally created from vimscript function calls. It provides
 /// a "readonly" view of Vim's state.
 public final class VimValue {
-    fileprivate let value: UnsafeVimValue?
+    let reference: UnsafeVimValue
     private let doDeInit: Bool
 
-    init(value: UnsafeVimValue?, doDeInit: Bool = false) {
-        self.value = value
+    init(_ value: UnsafeVimValue, doDeInit: Bool = false) {
+        self.reference = value
         self.doDeInit = doDeInit
     }
 
+    /// Borrowed reference
+    init(borrowedReference: UnsafeVimValue) {
+        self.reference = borrowedReference
+        self.doDeInit = false
+    }
+
+    init(reference: UnsafeVimValue) {
+        // FIXME: Audit spmvim_lib.c for cases of this
+        self.reference = reference
+        self.doDeInit = true
+    }
+
     deinit {
         /// Correctly decrement when this value is done.
         if doDeInit {
-            swiftvim_decref(value)
+            swiftvim_decref(reference)
         }
     }
+}
 
-    // Mark - Casting
-
+/// Casting extensions
+extension VimValue {
     public func asString() -> String? {
-        guard let value = self.value else { return nil }
-        guard let cStr = swiftvim_asstring(value) else {
-            return nil
-        }
-        return String(cString: cStr)
+        return String(self)
     }
 
     public func asInt() -> Int? {
-        // Generally, eval results are returned as strings
-        // Perhaps there is a better way to express this.
-        if let strValue = asString(), 
-            let value = Int(strValue) {
-            return value  
-        }
-        guard let value = self.value else { return nil }
-        return Int(swiftvim_asint(value))
+        return Int(self)
     }
 
     public func asList() -> VimList? {
-        guard let value = self.value else { return nil }
-        return VimList(value: value)
+        return VimList(self)
     }
 
     public func asDictionary() -> VimDictionary? {
-        guard let value = self.value else { return nil }
-        return VimDictionary(value: value)
+        return VimDictionary(self)
     }
 }
 
 // A Dictionary
 public final class VimDictionary {
-    private let value: UnsafeVimValue
+    private let value: VimValue
 
-    fileprivate init(value: UnsafeVimValue) {
+    fileprivate init(_ value: VimValue) {
         self.value = value
     }
 
     public var count: Int {
-        return Int(swiftvim_dict_size(value))
+        return Int(swiftvim_dict_size(value.reference))
     }
 
     public var keys: VimList {
-        guard let list = VimValue(value: swiftvim_dict_keys(value),
-                  doDeInit: false).asList() else {
+        guard let list = VimValue(reference: swiftvim_dict_keys(value.reference)).asList() else {
             fatalError("Can't get keys")
          }
          return list
     }
 
     public var values: VimList {
-        guard let list =  VimValue(value: swiftvim_dict_values(value),
-                  doDeInit: false).asList() else {
+        guard let list = VimValue(reference: swiftvim_dict_values(value.reference)).asList() else {
             fatalError("Can't get values")
         }
         return list
     }
 
     public subscript(index: VimValue) -> VimValue? {
         get {
-            guard let v = swiftvim_dict_get(value, index.value) else {
+            guard let v = swiftvim_dict_get(value.reference, index.reference) else {
                 return nil
             }
-            return VimValue(value: v)
+            return VimValue(v)
         }
         set {
-            swiftvim_dict_set(value, index.value!, newValue?.value)
+            swiftvim_dict_set(value.reference, index.reference, newValue?.reference)
         }
     }
 
     public subscript(index: String) -> VimValue? {
         get {
             return index.withCString { cStrIdx in
-                guard let v = swiftvim_dict_getstr(value, cStrIdx) else {
+                guard let v = swiftvim_dict_getstr(value.reference, cStrIdx) else {
                     return nil
                 }
-                return VimValue(value: v)
+                return VimValue(v)
             }
         }
         set {
             index.withCString { cStrIdx in
-                swiftvim_dict_setstr(value, cStrIdx, newValue?.value)
+                swiftvim_dict_setstr(value.reference, cStrIdx, newValue?.reference)
             }
         }
     }
@@ -112,14 +133,10 @@ public final class VimDictionary {
 
 /// A List of VimValues
 public final class VimList: Collection {
-    private let value: UnsafeVimValue
+    private let value: VimValue
 
     /// Cast a VimValue to a VimList
-    public init(_ vimValue: VimValue) {
-        self.value = vimValue.value!
-    }
-
-    init(value: UnsafeVimValue) {
+    public init(_ value: VimValue) {
         self.value = value
     }
 
@@ -128,23 +145,23 @@ public final class VimList: Collection {
     }
 
     public var endIndex: Int {
-        return Int(swiftvim_list_size(value))
+        return Int(swiftvim_list_size(value.reference))
     }
 
     public var isEmpty: Bool {
-        return swiftvim_list_size(value) == 0 
+        return swiftvim_list_size(value.reference) == 0 
     }
 
     public var count: Int {
-        return Int(swiftvim_list_size(value))
+        return Int(swiftvim_list_size(value.reference))
     }
 
     public subscript(index: Int) -> VimValue {
         get {
-            return VimValue(value: swiftvim_list_get(value, Int32(index)))
+            return VimValue(swiftvim_list_get(value.reference, Int32(index)))
         }
         set {
-            swiftvim_list_set(value, Int32(index), newValue.value)
+            swiftvim_list_set(value.reference, Int32(index), newValue.reference)
         }
     }
 

Sources/Vim/VimWindow.swift

@@ -1,14 +1,14 @@
 import VimInterface
 
 public class VimWindow {
-    private let value: UnsafeVimValue
+    private let value: VimValue
 
-    init(value: UnsafeVimValue) {
+    init(_ value: VimValue) {
         self.value = value
     }
 
     public var cursor: (Int, Int) {
-        guard let cursor = self.value.attrp("cursor") else {
+        guard let cursor = self.value.reference.attrp("cursor") else {
             return (0, 0)
         }
         let first = swiftvim_tuple_get(cursor, 0)
@@ -17,23 +17,23 @@ public class VimWindow {
     }
 
     public var height: Int {
-        return value.attr("height")
+        return value.reference.attr("height")
     }
 
     public var col: Int {
-        return value.attr("col")
+        return value.reference.attr("col")
     }
 
     public var row: Int {
-        return value.attr("row")
+        return value.reference.attr("row")
     }
 
     public var valid: Bool {
-        return value.attr("valid") != 0
+        return value.reference.attr("valid") != 0
     }
 
     public var buffer: VimBuffer {
-        return VimBuffer(value: value.attrp("buffer")!)
+        return VimBuffer(VimValue(reference: value.reference.attrp("buffer")!))
     }
 }
 

Sources/VimInterface/include/VimInterface/swiftvim.h

@@ -40,7 +40,7 @@ void *_Nullable swiftvim_call(const char *_Nonnull module, const char *_Nonnull
 void *_Nullable swiftvim_get_module(const char *_Nonnull module);
 void *_Nullable swiftvim_get_attr(void *_Nonnull target, const char *_Nonnull attr);
 
-void *_Nullable swiftvim_call_impl(void *func, void *_Nullable arg1, void *_Nullable arg2);
+void *_Nullable swiftvim_call_impl(void *_Nonnull func, void *_Nullable arg1, void *_Nullable arg2);
 
 // Bootstrapping
 // Note: These methods are only for testing purposes

Sources/VimInterface/swiftvim_lib.c

@@ -63,8 +63,8 @@ VIM_INTEN void *swiftvim_call(const char *module, const char *method, const char
     PyObject *pFunc = PyObject_GetAttrString(pModule, method);
     void *v = swiftvim_call_impl(pFunc, arg, NULL);
     Py_DECREF(pModule);
-    PyGILState_Release(gstate);
     Py_XDECREF(pFunc);
+    PyGILState_Release(gstate);
     return v;
 }
 

Sources/VimKit/VimExtensions.swift

@@ -32,20 +32,20 @@ extension Vim {
         command("let \(variable) = \(value.toVimScript())")
     }
 
-    public static func get(variable: String) -> VimValue {
+    public static func get(variable: String) -> VimValue? {
         return eval(variable)
     }
 
-    public static func get(_ variable: String) -> VimValue {
+    public static func get(_ variable: String) -> VimValue? {
         return eval(variable)
     }
 
     public static func get(_ variable: String) -> Bool {
-        return Bool((eval(variable).asInt() ?? 0) != 0)
+        return Bool((eval(variable)?.asInt() ?? 0) != 0)
     }
 
     public static func get(_ variable: String) -> Int {
-        return eval(variable).asInt() ?? 0
+        return eval(variable)?.asInt() ?? 0
     }
 
     /// Returns the 0-based current line and 0-based current column