Add missing $ to standard types

godot/core/arrays.nim

@@ -134,10 +134,13 @@ proc len*(self: Array): int {.inline.} =
 proc sort*(self: var Array) {.inline.} =
   self.godotArray.sort()
 
-iterator items*(arr: Array): Variant =
+iterator items*(self: Array): Variant =
-  for i in 0..<arr.len:
+  for i in 0..<self.len:
-    yield arr[i]
+    yield self[i]
 
-iterator pairs*(arr: Array): tuple[key: int, val: Variant] =
+iterator pairs*(self: Array): tuple[key: int, val: Variant] =
-  for i in 0..<arr.len:
+  for i in 0..<self.len:
-    yield (i, arr[i])
+    yield (i, self[i])
+
+proc `$`*(self: Array): string =
+  $self.godotArray

godot/core/dictionaries.nim

@@ -97,3 +97,14 @@ iterator values*(dict: Dictionary): Variant =
 iterator pairs*(dict: Dictionary): tuple[key, val: Variant] =
   for key in keys(dict):
     yield (key, dict[key])
+
+proc `$`*(self: Dictionary): string =
+  result = newStringOfCap(32)
+  result.add('{')
+  for k, v in self:
+    if result.len > 1:
+      result.add(", ")
+    result.add($k)
+    result.add(": ")
+    result.add($v)
+  result.add('}')

godot/core/rids.nim

@@ -22,6 +22,9 @@ proc idCInt(self: RID): cint {.
 proc id*(self: RID): uint32 {.inline.} =
   cast[uint32](self.idCInt())
 
+proc `$`*(self: RID): string =
+  $self.id
+
 proc `==`*(a, b: RID): bool {.
     importc: "godot_rid_operator_equal".}
 proc `<`*(a, b: RID): bool {.

godot/core/variants.nim

@@ -27,6 +27,9 @@ proc variantFinalizer*(v: Variant) =
   if not v.noDeinit:
     v.godotVariant.deinit()
 
+proc `$`*(self: Variant): string {.inline.} =
+  $self.godotVariant
+
 proc newVariant*(): Variant {.inline.} =
   new(result, variantFinalizer)
   initGodotVariant(result.godotVariant)
@@ -174,9 +177,7 @@ proc asReal*(self: Variant): cdouble =
   self.godotVariant.asReal()
 
 proc asString*(self: Variant): string =
-  var s = self.godotVariant.asGodotString()
+  $self
-  result = $s
-  s.deinit()
 
 proc asVector2*(self: Variant): Vector2 =
   self.godotVariant.asVector2()

godot/internal/godotarrays.nim

@@ -4,6 +4,10 @@ type
   GodotArray* {.byref.} = object
     data: array[sizeof(int), byte]
 
+proc len*(self: GodotArray): cint {.
+    noSideEffect,
+    importc: "godot_array_size".}
+
 import hashes
 import godotobjects, godotpoolarrays, godotvariants, godotstrings
 
@@ -94,26 +98,33 @@ proc rfind*(self: GodotArray; what: GodotVariant;
             f: cint): cint {.
     noSideEffect,
     importc: "godot_array_rfind".}
-proc len*(self: GodotArray): cint {.
-    noSideEffect,
-    importc: "godot_array_size".}
 proc sort*(self: var GodotArray) {.importc: "godot_array_sort".}
 proc sortCustom*(self: var GodotArray; obj: var GodotObject;
                  funcName: GodotString) {.
     importc: "godot_array_sort_custom".}
 
-iterator items*(arr: GodotArray): GodotVariant =
+iterator items*(self: GodotArray): GodotVariant =
-  for i in 0..<arr.len:
+  for i in 0..<self.len:
-    yield arr[i]
+    yield self[i]
 
-iterator mitems*(arr: var GodotArray): var GodotVariant =
+iterator mitems*(self: var GodotArray): var GodotVariant =
-  for i in 0..<arr.len:
+  for i in 0..<self.len:
-    yield arr.mget(i)[]
+    yield self.mget(i)[]
 
-iterator pairs*(arr: GodotArray): tuple[key: cint, val: GodotVariant] =
+iterator pairs*(self: GodotArray): tuple[key: cint, val: GodotVariant] =
-  for i in 0..<arr.len:
+  for i in 0..<self.len:
-    yield (i, arr[i])
+    yield (i, self[i])
 
-iterator mpairs*(arr: var GodotArray): tuple[key: cint, val: var GodotVariant] =
+iterator mpairs*(self: var GodotArray): tuple[key: cint,
-  for i in 0..<arr.len:
+                                              val: var GodotVariant] =
-    yield (i, arr.mget(i)[])
+  for i in 0..<self.len:
+    yield (i, self.mget(i)[])
+
+proc `$`*(self: GodotArray): string =
+  result = newStringOfCap(32)
+  result.add('[')
+  for item in self:
+    if result.len > 1:
+      result.add(", ")
+    result.add($item)
+  result.add(']')

godot/internal/godotvariants.nim

@@ -191,3 +191,8 @@ proc hashCompare*(self, other: GodotVariant): bool {.
     importc: "godot_variant_hash_compare".}
 proc booleanize*(self: GodotVariant; isValid: var bool): bool {.
     importc: "godot_variant_booleanize".}
+
+proc `$`*(self: GodotVariant): string =
+  var s = self.asGodotString()
+  result = $s
+  s.deinit()