attempt to make 0.19 compatible

godot/core/variants.nim

@@ -73,12 +73,9 @@ proc newVariant*(r: cdouble): Variant {.inline.} =
 
 proc newVariant*(s: string): Variant {.inline.} =
   new(result, variantFinalizer)
-  if s.isNil:
+  var godotStr = s.toGodotString()
-    initGodotVariant(result.godotVariant)
+  initGodotVariant(result.godotVariant, godotStr)
-  else:
+  godotStr.deinit()
-    var godotStr = s.toGodotString()
-    initGodotVariant(result.godotVariant, godotStr)
-    godotStr.deinit()
 
 import basis, nodepaths
 import planes, quats, rect2, aabb, rids

godot/godotapigen.nim

@@ -1,9 +1,15 @@
 # Copyright 2018 Xored Software, Inc.
 
-import streams, json, os, strutils, times, sets, tables
+import streams, json, os, strutils, times, sets, tables, options
 import sequtils, algorithm
 import compiler.ast, compiler.renderer, compiler.idents, compiler.astalgo
 
+when (NimMajor, NimMinor, NimPatch) >= (0, 19, 0):
+  var gic* = newIdentCache()
+
+  proc getIdent(ident: string): PIdent =
+    getIdent(gic, ident)
+
 proc ident(ident: string): PNode =
   result = newNode(nkIdent)
   result.ident = getIdent(ident)
@@ -139,19 +145,19 @@ proc findCommonRoot(typeRegistry: Table[string, GodotType],
 
   var idx = 0
   while true:
-    var curType: string
+    var curType = none(string)
     var allEqual = true
     for chain in chains:
       if idx >= chain.len:
         allEqual = false
         break
-      if curType.isNil:
+      if curType.isNone:
-        curType = chain[idx]
+        curType = some(chain[idx])
-      elif curType != chain[idx]:
+      elif curType.get != chain[idx]:
         allEqual = false
         break
     if allEqual:
-      result = curType
+      result = curType.get
     else:
       break
     inc idx
@@ -224,7 +230,7 @@ proc newRefTypeNode(typeSection: PNode, typ, base, doc: string,
   inherit.add(ident(base))
   objTy.add(inherit)
 
-  if not doc.isNil:
+  if doc.len > 0:
     let recList = newNode(nkRecList)
     let docNode = newNode(nkCommentStmt)
     docNode.comment = doc
@@ -275,7 +281,7 @@ type
     godotName: string
     typ: GodotType
     args: seq[MethodArg]
-    returnType: string
+    returnType: Option[string]
     isVirtual: bool
     isBase: bool
     isDiscardable: bool
@@ -428,7 +434,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
         newCStringLit(meth.godotName))
     )
     let vars = newNode(nkVarSection)
-    var varargsName: string
+    var varargsName = none(string)
     var isVarargs: bool
     var staticArgsLen: int
     var argLenNode = newIntLit(0)
@@ -436,7 +442,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
     if meth.args.len > 0:
       for idx, arg in meth.args:
         if arg.kind == ArgKind.VarArgs:
-          varargsName = arg.name
+          varargsName = some(arg.name)
           isVarargs = true
           vars.add(newIdentDefs(ident("callError"), ident("VariantCallError")))
         elif arg.kind == ArgKind.Bound:
@@ -450,13 +456,13 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
             ident("array"), ident("MAX_ARG_COUNT"),
             if isVarargs: newNode(nkPtrTy).addChain(ident("GodotVariant"))
             else: ident("pointer"))))
-      staticArgsLen = if varargsName.isNil: meth.args.len
+      staticArgsLen = if varargsName.isSome: meth.args.len
                       else: meth.args.len - 1
-      if not varargsName.isNil:
+      if varargsName.isSome:
         argLenNode = newCall("cint",
                       infix(newIntLit(staticArgsLen),
                             ident("+"),
-                            newDotExpr(ident(varargsName), ident("len"))))
+                            newDotExpr(ident(varargsName.get), ident("len"))))
         argsAlloc.add(newCall("godotAlloc", newCall("cint", infix(
           newCall("sizeof", ident("Variant")), ident("*"),
           newNode(nkPar).addChain(argLenNode))))
@@ -477,12 +483,12 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
                     else: ident(arg.name)
       if arg.kind == ArgKind.VarArgs:
         argName = newNode(nkBracketExpr).addChain(
-          ident(varargsName),
+          ident(varargsName.get),
           infix(ident("idx"), ident("-"), newIntLit(staticArgsLen)))
       let argIdx = if arg.kind == ArgKind.VarArgs: ident("idx") else: newIntLit(idx)
       let isStandardType = arg.typ in standardTypes
       let isWrappedType = arg.typ in wrapperTypes
-      let convArg = if not varargsName.isNil:
+      let convArg = if varargsName.isSome:
                       getInternalPtr(newCall("toVariant", argName), "Variant")
                     elif isWrappedType: getInternalPtr(argName, arg.typ)
                     elif isStandardType: newCall("unsafeAddr", argName)
@@ -493,7 +499,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
         raise newException(ValueError,
           "Non-standard type $# for varargs params of method $# of type $#" %
             [arg.typ, meth.godotName, meth.typ.godotName])
-      if not isStandardType and varargsName.isNil:
+      if not isStandardType and varargsName.isNone:
         if arg.typ == "string":
           argConversions.add(newNode(nkVarSection).addChain(
             newIdentDefs(ident("argToPassToGodot" & $idx), newEmptyNode(),
@@ -560,31 +566,32 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
     var isStringRet: bool
     var isWrapperRet: bool
     let retValIdent = if not isVarargs: ident("ptrCallVal") else: ident(retName)
-    if not meth.returnType.isNil and not isVarargs:
+    if meth.returnType.isSome and not isVarargs:
+      let returnType = meth.returnType.get
       var addrToAssign = newCall("addr", retValIdent)
-      if meth.returnType in smallIntTypes:
+      if returnType in smallIntTypes:
         isConversionRet = true
         body.add(newNode(nkVarSection).addChain(newIdentDefs(
           retValIdent, ident("int64"),
         )))
-      elif meth.returnType in float32Types:
+      elif returnType in float32Types:
         isConversionRet = true
         body.add(newNode(nkVarSection).addChain(newIdentDefs(
           retValIdent, ident("float64"),
         )))
-      elif meth.returnType in wrapperTypes:
+      elif returnType in wrapperTypes:
         isWrapperRet = true
         body.add(newNode(nkVarSection).addChain(newIdentDefs(
-          retValIdent, ident("Godot" & meth.returnType),
+          retValIdent, ident("Godot" & returnType),
         )))
-      elif meth.returnType in standardTypes:
+      elif returnType in standardTypes:
         addrToAssign = newCall("addr", ident("result"))
-      elif meth.returnType == "string":
+      elif returnType == "string":
         isStringRet = true
         body.add(newNode(nkVarSection).addChain(newIdentDefs(
           retValIdent, ident("GodotString"),
         )))
-      elif meth.returnType != "void":
+      elif returnType != "void":
         isObjRet = true
         body.add(newNode(nkVarSection).addChain(newIdentDefs(
           retValIdent, newNode(nkPtrTy).addChain(ident("GodotObject")),
@@ -594,7 +601,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
     if not isVarargs:
       body.add(theCall)
     else:
-      if not meth.returnType.isNil:
+      if meth.returnType.isSome:
         isVariantRet = true
       let callStmt = newNode(nkLetSection).addChain(
         newIdentDefs(
@@ -603,14 +610,14 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
           newNode(nkEmpty), theCall))
       body.add(callStmt)
 
-    if varargsName.isNil:
+    if varargsName.isNone:
       for idx, arg in meth.args:
         if arg.typ == "string":
           body.add(newCall("deinit", ident("argToPassToGodot" & $idx)))
 
-    if meth.args.len > 0 and not varargsName.isNil:
+    if meth.args.len > 0 and varargsName.isSome:
       body.add(freeCall)
-    if not varargsName.isNil:
+    if varargsName.isSome:
       let errCheck = newIfStmt(
         infix(newDotExpr(ident("callError"), ident("error")), ident("!="),
                  newDotExpr(ident("VariantCallErrorType"), ident("OK"))),
@@ -638,11 +645,11 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
     elif isConversionRet:
       body.add(newNode(nkAsgn).addChain(
         ident("result"),
-        newCall(meth.returnType, retValIdent)))
+        newCall(meth.returnType.get, retValIdent)))
     elif isWrapperRet:
       body.add(newNode(nkAsgn).addChain(
         ident("result"),
-        newCall("new" & meth.returnType, retValIdent)))
+        newCall("new" & meth.returnType.get, retValIdent)))
     elif isObjRet:
       body.add(newNode(nkAsgn).addChain(ident("result"),
                newCall(newBracketExpr(ident("asNimGodotObject"),
@@ -655,8 +662,8 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
   let procType = if meth.isVirtual: nkMethodDef
                  else: nkProcDef
   var params = newSeqOfCap[PNode](meth.args.len + 2)
-  if not meth.returnType.isNil:
+  if meth.returnType.isSome:
-    params.add(ident(meth.returnType))
+    params.add(ident(meth.returnType.get))
   else:
     params.add(newNode(nkEmpty))
   if not meth.typ.isSingleton:
@@ -684,7 +691,7 @@ proc doGenerateMethod(tree: PNode, methodBindRegistry: var HashSet[string],
     if meth.isVirtual and meth.isBase and meth.typ.name != "PhysicsBody":
       # Nim doesn't like `base` on PhysicsBody methods - wtf
       pragma.add(ident("base"))
-    if meth.isDiscardable and not meth.returnType.isNil:
+    if meth.isDiscardable and meth.returnType.isSome:
       pragma.add(ident("discardable"))
     procDecl.sons[4] = pragma
   tree.add(procDecl)
@@ -729,8 +736,8 @@ proc getMethodInfo(methodObj: JsonNode, types: Table[string, GodotType],
         nimName = nimName & "Impl"
 
   let returnType = if methodObj["return_type"].str != "void":
-                      toNimType(types, methodObj["return_type"].str)
+                      some(toNimType(types, methodObj["return_type"].str))
-                   else: nil
+                   else: none(string)
   const discardableMethods = toSet(["emit_signal"])
   result = MethodInfo(
     name: ident(nimName),
@@ -764,13 +771,13 @@ proc makeProperty(types: Table[string, GodotType], tree: PNode,
 
   let getter = findMethod(obj, propertyObj["getter"].str)
   let nimType = if getter.isNil: toNimType(types, propertyObj["type"].str)
-                else: getMethodInfo(getter, types, typ).returnType
+                else: getMethodInfo(getter, types, typ).returnType.get("void")
   let getterInfo = MethodInfo(
     name: getterName,
     typ: typ,
     godotName: propertyObj["getter"].str,
-    args: @[],
+    args: newSeq[MethodArg](),
-    returnType: nimType
+    returnType: some(nimType)
   )
   let setterInfo = MethodInfo(
     name: setterName,
@@ -779,10 +786,12 @@ proc makeProperty(types: Table[string, GodotType], tree: PNode,
     args: @[MethodArg(name: "val", typ: nimType)]
   )
   if "index" in propertyObj and propertyObj["index"] != newJInt(-1):
-    getterInfo.args = @[MethodArg(defaultVal: newJString($propertyObj["index"]),
+    getterInfo.args =
-                                  typ: "int", kind: ArgKind.Bound)] & getterInfo.args
+      @[MethodArg(defaultVal: newJString($propertyObj["index"]),
-    setterInfo.args = @[MethodArg(defaultVal: newJString($propertyObj["index"]),
+                  typ: "int", kind: ArgKind.Bound)] & getterInfo.args
-                                  typ: "int", kind: ArgKind.Bound)] & setterInfo.args
+    setterInfo.args =
+      @[MethodArg(defaultVal: newJString($propertyObj["index"]),
+                  typ: "int", kind: ArgKind.Bound)] & setterInfo.args
   generateMethod(tree, methodBindRegistry, getterInfo, withImplementation)
   generateMethod(tree, methodBindRegistry, setterInfo, withImplementation)
 
@@ -920,7 +929,7 @@ proc genApi*(targetDir: string, apiJsonFile: string) =
     let className = godotClassName.replace("_", "")
     var baseClassName = obj["base_class"].str
     baseClassName = toNimType(baseClassName.replace("_", ""))
-    if baseClassName.isNil or baseClassName.len == 0:
+    if baseClassName.len == 0:
       baseClassName = "NimGodotObject"
     var doc = ""
     for attr in classAttributes:

godot/internal/godotstrings.nim

@@ -38,10 +38,7 @@ proc `$`*(self: GodotString): string =
 
 proc toGodotString*(s: string): GodotString {.inline.} =
   ## Converts the Nim string into ``GodotString``
-  if s.isNil:
+  initGodotString(result, cstring(s), cint(s.len + 1))
-    initGodotString(result)
-  else:
-    initGodotString(result, cstring(s), cint(s.len + 1))
 
 proc toGodotString*(s: cstring): GodotString {.inline.} =
   ## Converts the cstring into ``GodotString``

godot/nim/godotmacros.nim

@@ -1,6 +1,6 @@
 # Copyright 2018 Xored Software, Inc.
 
-import macros, tables, typetraits
+import macros, tables, typetraits, strutils, sets, sequtils, options
 import godotinternal, internal.godotvariants
 import godotnim, core.variants
 
@@ -10,8 +10,8 @@ type
     typ: NimNode
     defaultValue: NimNode
     isNoGodot: bool
-    hint: string
+    hint: Option[string]
-    hintStr: string
+    hintStr: Option[string]
     usage: NimNode
     isExported: bool
 
@@ -111,12 +111,12 @@ proc removePragma(statement: NimNode, pname: string): bool =
       return true
 
 proc removeStrPragma(statement: NimNode,
-                     pname: string): string {.compileTime.} =
+                     pname: string): Option[string] {.compileTime.} =
   ## Removes the pragma from the node and returns value of the pragma
   ## Works for routine nodes or nnkPragmaExpr
   let node = removePragmaNode(statement, pname)
-  result = if node.isNil: nil
+  result = if node.isNil: none(string)
-           else: $node
+           else: some($node)
 
 proc isExported(node: NimNode): bool {.compileTime.} =
   if node.kind == nnkPragmaExpr:
@@ -197,7 +197,7 @@ proc parseType(definition, callSite: NimNode): ObjectDecl =
       parseError(option, "valid type specifier expected")
   result.isTool = isTool
 
-  if result.parentName.isNil: result.parentName = "Object"
+  if result.parentName == "": result.parentName = "Object"
   for statement in body:
     case statement.kind:
       of nnkVarSection:
@@ -424,9 +424,6 @@ template registerGodotField(classNameLit, classNameIdent, propNameLit,
                                unsafeAddr attr, setFunc, getFunc)
   hintStrGodot.deinit()
 
-static:
-  import strutils, sets, sequtils
-
 proc toGodotStyle(s: string): string {.compileTime.} =
   result = newStringOfCap(s.len + 10)
   for c in s:
@@ -447,7 +444,7 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} =
   let objTy = newNimNode(nnkObjectTy)
   typeDef.add(newNimNode(nnkRefTy).add(objTy))
   objTy.add(newEmptyNode())
-  if obj.parentName.isNil:
+  if obj.parentName == "":
     objTy.add(newEmptyNode())
   else:
     objTy.add(newNimNode(nnkOfInherit).add(ident(obj.parentName)))
@@ -506,11 +503,11 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} =
     result.add(meth.nimNode)
 
   # Register Godot object
-  let parentName = if obj.parentName.isNil: newStrLitNode("Object")
+  let parentName = if obj.parentName == "": newStrLitNode("Object")
                    else: newStrLitNode(obj.parentName)
   let classNameLit = newStrLitNode(obj.name)
   let classNameIdent = ident(obj.name)
-  let isRef: bool = if obj.parentName.isNil: false
+  let isRef: bool = if obj.parentName == "": false
                     else: obj.parentName in refClasses
   result.add(getAst(
     registerGodotClass(classNameIdent, classNameLit, isRef, parentName,
@@ -519,10 +516,10 @@ proc genType(obj: ObjectDecl): NimNode {.compileTime.} =
   # Register fields (properties)
   for field in obj.fields:
     if field.isNoGodot: continue
-    let hintStr = if field.hintStr.isNil: "NIM"
+    let hintStr = if field.hintStr.isNone: "NIM"
-                  else: field.hintStr
+                  else: field.hintStr.get
-    let hint = if field.hint.isNil: "NIM"
+    let hint = if field.hint.isNone: "NIM"
-               else: field.hint
+               else: field.hint.get
     let usage =
       if field.usage.isNil:
         newLit(ord(GodotPropertyUsage.Default) or

godot/nim/godotnim.nim

@@ -1,6 +1,6 @@
 # Copyright 2018 Xored Software, Inc.
 
-import tables, typetraits, macros, unicode
+import tables, typetraits, macros, unicode, strutils, sets
 import gdnativeapi
 import core.godotcoretypes, core.godotbase
 import core.vector2, core.rect2,
@@ -101,8 +101,6 @@ var classRegistryStatic* {.compileTime.}: TableRef[FNV1Hash, ObjectInfo]
 static:
   classRegistryStatic = newTable[FNV1Hash, ObjectInfo]()
 
-static:
-  import sets, strutils
 var nativeClasses {.compileTime.} = newSeq[string]()
 var refClasses* {.compileTime.} = newSeq[string]()
 
@@ -204,7 +202,7 @@ macro baseNativeType(T: typedesc): cstring =
     if typeName == "NimGodotObject":
       break
     t = getType(t[1][1])
-  if baseT.isNil:
+  if baseT == "":
     result = newNilLit()
   else:
     let rStr = newNimNode(nnkRStrLit)
@@ -345,24 +343,21 @@ proc newRStrLit(s: string): NimNode {.compileTime.} =
   result = newNimNode(nnkRStrLit)
   result.strVal = s
 
-static:
-  import strutils
-
 macro toGodotName(T: typedesc): string =
-  var godotName: string
+  var godotName =
-  if T is GodotString or T is string:
+    if T is GodotString or T is string:
-    godotName = "String"
+      "String"
-  elif T is SomeFloat:
+    elif T is SomeFloat:
-    godotName = "float"
+      "float"
-  elif T is SomeUnsignedInt or T is SomeSignedInt:
+    elif T is SomeUnsignedInt or T is SomeSignedInt:
-    godotName = "int"
+      "int"
-  if godotName.isNil or godotName.len == 0:
-    let nameStr = (($T.getType()[1][1].symbol).split(':')[0])
-    godotName = case nameStr:
-    of "File", "Directory", "Thread", "Mutex", "Semaphore":
-      "_" & nameStr
     else:
-      nameStr
+      let nameStr = (($T.getType()[1][1].symbol).split(':')[0])
+      case nameStr:
+        of "File", "Directory", "Thread", "Mutex", "Semaphore":
+          "_" & nameStr
+        else:
+          nameStr
 
   result = newLit(godotName)
 
@@ -717,7 +712,7 @@ proc fromVariant*(s: var string, val: Variant): ConversionResult =
   if val.getType() == VariantType.String:
     s = val.asString()
   elif val.getType() == VariantType.Nil:
-    s = nil
+    s = ""
   else:
     result = ConversionResult.TypeError