feat(method): builtin classmethod

Author: litlighilit

Objects/descrobject.nim

@@ -9,31 +9,37 @@ import methodobject
 import ../Include/descrobject as incDescr
 export incDescr
 
+#import ../Python/getargs/vargs
 import ./typeobject/apis/subtype
 
 import ../Utils/utils
 
 # method descriptor
 
-declarePyType MethodDescr():
+declarePyType CommonMethodDescr():
   name: PyStrObject
   dType: PyTypeObject
   kind: NFunc
   meth: int # the method function pointer. Have to be int to make it generic.
 
+declarePyType MethodDescr(base(CommonMethodDescr)):
+  discard
 
-template newMethodDescrTmpl(FunType) = 
-  proc newPyMethodDescr*(t: PyTypeObject, 
+
+template newXxMethodDescrTmpl(PyType, FunType){.dirty.} =
+  proc `newPy PyType`*(t: PyTypeObject, 
                          meth: FunType,
                          name: PyStrObject,
-                         ): PyMethodDescrObject = 
-    result = newPyMethodDescrSimple()
+                         ): `Py PyType Object` = 
+    result = `newPy PyType Simple`()
     result.dType = t
     result.kind = NFunc.FunType
     assert result.kind != NFunc.BltinFunc
     result.meth = cast[int](meth)
     result.name = name
 
+template newMethodDescrTmpl(FunType) =
+  newXxMethodDescrTmpl MethodDescr, FunType
 
 newMethodDescrTmpl(UnaryMethod)
 newMethodDescrTmpl(BinaryMethod)
@@ -72,6 +78,64 @@ implMethodDescrMagic get:
     return newPyNimFunc(cast[BltinMethod](self.meth), self.name, owner)
 
 
+declarePyType ClassMethodDescr(base(CommonMethodDescr)): discard
+
+
+template newClassMethodDescrTmpl(FunType) =
+  newXxMethodDescrTmpl ClassMethodDescr, FunType
+
+# newPyClassMethodDescr
+newClassMethodDescrTmpl BltinMethod
+
+proc `$?`*(descr: PyCommonMethodDescrObject): string =
+  ## inner. unstable.
+  # PyErr_Format ... "%V" .. "?"
+  if descr.name.isNil: "?" else: $descr.name
+
+proc truncedTypeName*(descr: PyCommonMethodDescrObject): string =
+  ## inner. unstable.
+  # %.100s with `PyDescr_TYPE(descr)->tp_name`
+  descr.dType.name.substr(0, 99)
+
+proc classmethod_getImpl(descr: PyCommonMethodDescrObject, obj: PyObject, typ: PyTypeObject): PyObject =
+  assert not typ.isNil
+  if not typ.isSubtype descr.dType:
+    return newTypeError newPyStr(
+      fmt"descriptor '{$?descr}' requires a subtype of '{descr.truncedTypeName}' " &
+        fmt"but received '{typ.name:.100s}'"
+    )
+  var cls = PyTypeObject nil
+  #if descr.isMETH_METHOD:
+  cls = descr.dType
+  assert descr.kind == NFunc.BltinMethod
+  newPyNimFunc(cast[BltinMethod](descr.meth), descr.name, cls)
+
+proc classmethod_get(descr: PyCommonMethodDescrObject, obj: PyObject, typ: PyTypeObject = nil): PyObject =
+  var typ = typ
+  if typ.isNil:
+    if not obj.isNil:
+      typ = obj.pyType
+    else:
+      # Wot - no type?!
+      return newTypeError newPyStr(
+      fmt"descriptor '{$?descr}' for type '{descr.truncedTypeName}' " &
+        "needs either and object or a type")
+  classmethod_getImpl(descr, obj, typ)
+
+proc classmethod_get*(self: PyObject, obj: PyObject, typ: PyObject = nil): PyObject =
+  ## inner
+  let descr = PyCommonMethodDescrObject self
+  # Ensure a valid type.  Class methods ignore obj.
+  if not typ.isNil and not typ.ofPyTypeObject:
+    return newTypeError newPyStr(
+      fmt"descriptor '{$?descr}' for type '{descr.truncedTypeName}' " &
+        fmt"needs a type, not a '{typ.typeName:.100s}' as arg 2"
+    )
+  classmethod_get(descr, obj, PyTypeObject typ)
+
+implClassMethodDescrMagic get:
+  classmethod_get(self, nil, other)
+
 # get set descriptor
 # Nim level property decorator
 

Objects/descrobjectImpl.nim

@@ -1,8 +1,13 @@
 
-import ./pyobject
-import ./noneobject
+import std/strformat
+import ./[
+  pyobject,
+  noneobject,
+  exceptions,
+  stringobject,
+  methodobject,
+]
 import ./descrobject
-import ./exceptions
 import ../Python/[
   structmember,
 ]
@@ -37,3 +42,42 @@ implMemberDescrMagic set:
   retIfExc PyMember_SetOne(obj, self.d_member, arg2)
   pyNone
 
+
+methodMacroTmpl(MethodDescr)
+
+implMethodDescrMagic call:
+  #call(bound, args, kwargs)
+  let argc = len(args);
+  if argc < 1:
+    return newTypeError newPyStr(
+      fmt"descriptor '{$?self}' of '{self.truncedTypeName}' " &
+      "object needs an argument"
+                )
+  let owner = args[0]
+  let bound = tpMagic(MethodDescr, get)(self, owner)
+  #let bound = method_get(self, owner)
+  retIfExc bound
+  tpMagic(NimFunc, call)(bound, args.toOpenArray(1, args.high), kwargs)
+
+methodMacroTmpl(ClassMethodDescr)
+implClassMethodDescrMagic call:
+  ##[Instances of classmethod_descriptor are unlikely to be called directly.
+   For one, the analogous class "classmethod" (for Python classes) is not
+   callable. Second, users are not likely to access a classmethod_descriptor
+   directly, since it means pulling it from the class __dict__.
+
+   This is just an excuse to say that this doesn't need to be optimized:
+   we implement this simply by calling __get__ and then calling the result.]##
+  let argc = len(args);
+  if argc < 1:
+    return newTypeError newPyStr(
+      fmt"descriptor '{$?self}' of '{self.truncedTypeName}' " &
+      "object needs an argument"
+                )
+  #let owner = args[0]
+  let bound = classmethod_get(self, nil, self.dType)
+  retIfExc bound
+  tpMagic(NimFunc, call)(bound, args#.toOpenArray(1, args.high)
+    , kwargs)
+
+

Objects/moduleobject.nim

@@ -43,7 +43,7 @@ proc init_dict(modu: PyModuleObject, md_dict: PyDictObject, name: PyStrObject) =
   md_dict[pyDUId spec] = pyNone
 
   # `_add_methods_to_object`
-  for name, meth in modu.pyType.bltinMethods:
+  for name, (meth, _) in modu.pyType.bltinMethods:
     let namePyStr = newPyAscii(name)
     md_dict[namePyStr] = newPyNimFunc(meth, namePyStr, modu)
 

Objects/pyobject.nim

@@ -114,11 +114,14 @@ macro tpGetter*(tp, methodName: untyped): untyped =
 macro tpSetter*(tp, methodName: untyped): untyped = 
   ident(methodName.strVal.toLowerAscii & "Py" & tp.strVal & "ObjectSetter")
 
-proc registerBltinMethod*(t: PyTypeObject, name: string, fun: BltinMethod) = 
+proc registerBltinMethod*(t: PyTypeObject, name: string, fun: BltinMethodDef) =
   if t.bltinMethods.hasKey(name):
     unreachable(fmt"Method {name} is registered twice for type {t.name}")
   t.bltinMethods[name] = fun
 
+proc registerBltinMethod*(t: PyTypeObject, name: string, fun: BltinMethod) =
+  registerBltinMethod(t, name, (fun, false))
+
 template genProperty*(T; pyname: string; nname; getter, setter){.dirty.} =
   bind `[]=`, tpGetter, tpSetter
   `impl T Getter` nname: getter
@@ -503,13 +506,19 @@ proc implMethod*(prototype, ObjectType, pragmas, body: NimNode, kind: MethodKind
   # add pragmas, the last to add is the first to execute
 
   # builtin function has no `self` to cast
-  var selfCast = params != bltinFuncParams
+  var
+    selfCast = params != bltinFuncParams
+    classmethod = false
   # custom pragms
   for p in pragmas:
     if p.eqIdent"noSelfCast":
       # no castSelf pragma
       selfCast = false
       continue
+    if p.eqIdent"classmethod":
+      selfCast = false
+      classmethod = true
+      continue
     procNode.addPragma(p)
 
   if selfCast:
@@ -544,7 +553,8 @@ proc implMethod*(prototype, ObjectType, pragmas, body: NimNode, kind: MethodKind
           newIdentNode("registerBltinMethod")
         ),
         newLit($methodName),
-        name
+        quote do:
+          (`name`, `classmethod`)
       )
   of MethodKind.Magic:
     result.add newAssignment(

Objects/pyobjectBase.nim

@@ -195,6 +195,7 @@ type
     # the values are set in typeobject.nim when the type is ready
     dict*: PyObject
 
+  BltinMethodDef* = tuple[meth: BltinMethod, classmethod: bool]  ## unstable
   PyTypeObject* = ref object of PyObjectWithDict
     #mro: PyObject ## PyTupleObject
     name*: string
@@ -204,7 +205,7 @@ type
     kind*: PyTypeToken
     members*: RtArray[PyMemberDef]
     magicMethods*: MagicMethods
-    bltinMethods*: Table[string, BltinMethod]
+    bltinMethods*: Table[string, BltinMethodDef]
     getsetDescr*: Table[string, (UnaryMethod, BinaryMethod)]
     tp_dealloc*: destructor
     tp_alloc*: proc (self: PyTypeObject, nitems: int): PyObject{.pyCFuncPragma.}  ## XXX: currently must not return exception
@@ -331,7 +332,8 @@ proc newPyTypePrivate[T: PyObject](name: string): PyTypeObject =
   when defined(js):
     result.giveId
   result.name = name
-  result.bltinMethods = initTable[string, BltinMethod]()
+  # Starting from Nim v0.20, tables are initialized by default and it is not necessary to call this function explicitly.
+  #result.bltinMethods = initTable[string, BltinMethod]()
   result.getsetDescr = initTable[string, (UnaryMethod, BinaryMethod)]()
   bltinTypes.add(result)
   result.tp_basicsize = sizeof T

Objects/typeobject/type_ready.nim

@@ -287,9 +287,11 @@ proc initTypeDict(tp: PyTypeObject) =
     d[namePyStr] = descr
 
   # bltin methods
-  for name, meth in tp.bltinMethods.pairs:
+  for name, (meth, classmethod) in tp.bltinMethods.pairs:
     let namePyStr = newPyAscii(name)
-    d[namePyStr] = newPyMethodDescr(tp, meth, namePyStr)
+    d[namePyStr] = 
+      if classmethod: newPyClassMethodDescr(tp, meth, namePyStr)
+      else: newPyMethodDescr(tp, meth, namePyStr)
 
   tp.dict = d