feat(pysugar/class): suport define cls.new -> cls.__new__; ref #4

Author: litlighilit

src/pylib/pysugar/class.nim

@@ -1,5 +1,6 @@
 
 import ./stmt/class
+export class.new
 import ./parserWithCfg
 
 macro class*(obj, body: untyped): untyped = 

src/pylib/pysugar/stmt/class.nim

@@ -27,7 +27,13 @@ proc parseDeclWithType(def: NimNode): tuple[name, typ, val: NimNode] =
 
 #proc mapSuper(nCall: NimNode): NimNode = discard
 
-proc replaceSuperCall(n: var NimNode, defSupCls: NimNode): bool =
+type
+  MethKind = enum
+    mkNorm
+    mkCls
+    mkStatic
+
+proc replaceSuperCall(n: var NimNode, defSupCls: NimNode, methKind: MethKind): bool =
   template nret(cond): untyped =
     if not cond:
       return
@@ -37,24 +43,51 @@ proc replaceSuperCall(n: var NimNode, defSupCls: NimNode): bool =
   nret callSup.kind == nnkCall
   nret callSup[0].eqIdent "super"
 
-  var supCls = defSupCls
-  let cLen = callSup.len
-  if cLen > 1:
-    expectIdent callSup[2], "self"
-  if callSup.len > 2:
-    if cLen > 3: error "super(<SupCls>, self) expected, but got too many args"
-    supCls = callSup[1]
+  var cLen = callSup.len
+  let supCls =
+    if cLen > 2:
+      if cLen > 3: error "super([<cls>[, self]]) expected, but got too many args"
+      callSup[1]
+    else:
+      if cLen == 1:
+        callSup.add defSupCls
+        cLen.inc
+      defSupCls
+
+  if methKind == mkCls:
+    if cLen == 3:
+      expectIdent callSup[2], "cls"
+    else:
+      callSup.add ident"cls"
+      cLen.inc
+    n = newDotExpr(supCls, n[0][1]).newCall(callSup[2])
+  elif methKind == mkNorm:
+    if cLen > 1:
+      expectIdent callSup[2], "self"
+    n[0][0] = newCall(supCls, ident"self")
 
-  n[0][0] = newCall(supCls, ident"self")
+    #let meth = n[0][1]
+    #let args = n[1..^1]
 
-  #let meth = n[0][1]
-  #let args = n[1..^1]
+    n = newCall(ident"procCall", n)
 
-  n = newCall(ident"procCall", n)
   result = true
 
-proc recReplaceSuperCall*(n: NimNode, defSupCls: NimNode, start=0): NimNode =
-  ##[ Recursively maps `super(...).f(...)`
+template new*[T; R: RootRef](_: typedesc[R], cls: typedesc[T],
+    _: varargs[untyped]): typedesc[T] =
+  ## py's `object.__new__`
+  cls
+
+proc init_subclass*[T](cls: typedesc[ref T]): ref T =
+  ## py's `object.__init_subclass__`
+  discard
+
+proc recReplaceSuperCall*(n: NimNode, defSupCls: NimNode, start=0, methKind=mkNorm): NimNode =
+  ##[ Recursively maps
+
+### 1.
+
+`super(...).f(...)`
     to `procCall(<SuperClass>(self).f(...))`
 
 The AST map:
@@ -66,7 +99,7 @@ The AST map:
         [<SuperClass>]
         [Ident "self"]
       Ident "f"
-      <args>
+    <args>
 
       |
       |
@@ -80,7 +113,13 @@ The AST map:
           <SuperClass>
           Ident "self"
         Ident "f"
-```  ]##
+      <args>
+```
+
+### 2
+`super(...).new/init_subclass(...)`
+    to `<SuperClass>.new/init_subclass(...)`
+]##
   runnableExamples:
     import std/[macros, strutils]
     macro checkSupSub(resStr: static string; b) =
@@ -104,9 +143,9 @@ The AST map:
   result = n.copy()
   var i = start
   while i<result.len:
-    discard replaceSuperCall(result, defSupCls)
+    discard replaceSuperCall(result, defSupCls, methKind=methKind)
     if result[i].len != 0:
-      result[i] = recReplaceSuperCall(result[i], defSupCls, 0)
+      result[i] = recReplaceSuperCall(result[i], defSupCls, 0, methKind=methKind)
     i.inc
 
 func remove1[T](s: var seq[T], x: T) =
@@ -122,7 +161,7 @@ func remove1[T](s: var seq[T], x: T) =
 
 proc tryPreClsBltinDecorater(mparser: var PyAsgnRewriter,
   args: var seq[NimNode], procType: var NimNodeKind,
-  pragmas: var seq[NimNode],
+  pragmas: var seq[NimNode], methKind: var MethKind
 ): bool =
   #[
     @staticmethod
@@ -177,9 +216,11 @@ then you will find it compile but `O.f()` gives `0` instead of `3`
     return false
   case $decor.name
   of "staticmethod":
+    methKind = mkStatic
     purgeBase()
     args.insert(newIdentDefs(ident"_", clsType), 1)
   of "classmethod":
+    methKind = mkCls
     purgeBase()
     args[1][1] = clsType
   else:
@@ -191,6 +232,31 @@ template mkPragma(pragmas: seq[NimNode]): NimNode =
   if pragmas.len == 0: emptyn
   else: nnkPragma.newNimNode.add pragmas
 
+proc genNewCls(classId, generics: NimNode, initArgs, initPragmas: seq[NimNode]): NimNode =
+  ## returns decl of `newXxx`
+  let classNewName = ident("new" & classId.strVal)
+  var newArgs = @[classId]
+  var body = newStmtList()
+  let resId = ident"result"
+  var callNew = newCall(newDotExpr(classId, ident"new"), newCall("typeof", classId))
+  let defInit = initArgs.len > 0
+  var callInit: NimNode
+  if defInit:
+    #var init = newCall(ident"init", resId)
+    callInit = newCall(resId.newDotExpr(ident"init"))
+    for i in 2..<initArgs.len:  # skip `resType` and `self: Cls`
+      let argDef = initArgs[i].copyNimTree  # we cannot use the old, as it's a symbol
+      # or there will be a error: positional param was already given as named param
+      newArgs.add argDef
+      callNew.add argDef[0]
+      callInit.add argDef[0]
+  body.add newAssignment(resId, nnkObjConstr.newTree(callNew))
+  if defInit:
+    body.add callInit
+  var pragmas = initPragmas
+  pragmas.remove1 ident"base"
+  newProc(classNewName, generics, newArgs, body, pragmas=pragmas.mkPragma)
+
 proc classImpl*(parser: var PySyntaxProcesser; obj, body: NimNode): NimNode = 
   ##[ minic Python's `class`.
 
@@ -292,8 +358,25 @@ so if wantting the attr inherited from SupCls, just write it as-is (e.g. `self.a
   template addAttr(name; typ=emptyn, defVal=emptyn) =
     typDefLs.add nnkIdentDefs.newTree(name, typ, defVal)
   var defs = newStmtList()
+  var decls = newStmtList()
+  template addMeth(def: NimNode) = defs.add def
+  #[ return type 'auto' cannot be used in forward declarations
+  template addMethWithDecl(def: NimNode) =
+    defs.add def
+    var decl = def.copyNimNode
+    let lastI = def.len - 1
+    for i in 0..<lastI:
+      decl.add def[i].copyNimTree
+    decl.add newEmptyNode()
+    decls.add decl
+  ]#
+  var noNew = true
+  var
+    initArgs: seq[NimNode]
+    initGenerics = newNimNode nnkGenericParams
+    initPragmas: seq[NimNode]
   for def in items(body):
-    var pragmas = defPragmas  # will be set as empty if `isConstruct` or not base
+    var pragmas = defPragmas  # will be set as empty if `isConstructor` or not base
     case def.kind
     of nnkCall:
       # - attr define, e.g. a: int / a: int = 1
@@ -317,51 +400,68 @@ so if wantting the attr inherited from SupCls, just write it as-is (e.g. `self.a
       let tup = parser.parseSignatureMayGenerics(generics_cpy, signature, deftype)
       var procName = tup.name
       dunderDirVal.add newLit procName.strVal
-      let isConstructor = procName.eqIdent "init"
-      if isConstructor:
-        procName = newIdentNode("new" & className)
+      let
+        isConstructor = procName.eqIdent "init"
+        isNew = procName.eqIdent "new"
+      var methKind: MethKind
+      if isNew or procName.eqIdent "init_subclass":
+        methKind = mkCls
+      if isNew:
+        noNew = false
         pragmas = @[]
       # First argument is the return type of the procedure
       var args = tup.params
       # push a new stack frame
       parser.push()
-      # Statements which will occur before proc body
-      var beforeBody = newStmtList()
+      var body = newStmtList()
+      template markSelfType =
+        args[1][1] = genericsClassId
+      template chk1ArgCls =
+        if not args[1][0].eqIdent "cls":
+          warning "the 1st arg of __new__ is not cls, but " & args[1][0].repr,
+            args[1]
+        args[1][1] = classId
       if isConstructor:
+        if args[0].strVal in ["None", "auto"]:
+          args[0] = newEmptyNode()
         expectIdent args[1][0], "self"
-        args.delete 1
-        args[0] = genericsClassId
-        template construct(): untyped {.dirty.} = 
-          var self: type(result)
-          new(self)
-        beforeBody.add getAst(construct())
+        markSelfType
+        initArgs = args
+      elif methKind == mkCls:
+        if isNew:
+          args[0] = nnkBracketExpr.newTree(bindSym"typedesc", genericsClassId)
+        chk1ArgCls
+      elif methKind == mkStatic:
+        discard
       else:
         if args.len > 1 and args[1][0].eqIdent "self":
-          args[1][1] = genericsClassId
+          markSelfType
       # Function body
       var docNode: NimNode
-      var parsedbody = recReplaceSuperCall(parser.parsePyBodyWithDoc(def[2], docNode), supCls)
-      # If we're generating a constructor proc - we need to return self
-      # after we've created it
-      if isConstructor:
-        parsedbody.add nnkReturnStmt.newTree ident"self"
-      # Add statement which will occur before function body
-      beforeBody.add parsedBody
+      var parsedbody = recReplaceSuperCall(
+        parser.parsePyBodyWithDoc(def[2], docNode), supCls,
+        methKind=methKind)
       if docNode.len != 0:
-        beforeBody.insert(0, docNode)
+        body.insert(0, docNode)
+      # Add statement which will occur before function body
+      body.add parsedBody
       parser.pop()
 
       # Finally create a procedure and add it to result!
       var procType: NimNodeKind
       discard parser.tryPreClsBltinDecorater(
-        args, procType, pragmas=pragmas
+        args, procType, pragmas=pragmas, methKind=methKind
       )
-      if isConstructor: procType = nnkProcDef
+      if methKind != mkNorm:
+        procType = nnkProcDef
+      elif isConstructor:
+        initPragmas = pragmas
+        initGenerics = generics_cpy
       let nDef = parser.consumeDecorator(
-          newProc(procName, generics_cpy, args, beforeBody, 
+          newProc(procName, generics_cpy, args, body, 
             procType, pragmas=pragmas.mkPragma)
         )
-      defs.add nDef
+      addMeth nDef
 
     of nnkStrLit, nnkRStrLit, nnkTripleStrLit:
       result.add newCommentStmtNode $def
@@ -370,6 +470,9 @@ so if wantting the attr inherited from SupCls, just write it as-is (e.g. `self.a
         result.add def
     else:
       result.add def  # AS-IS
+
+  addMeth genNewCls(classId, initGenerics, initArgs, initPragmas)
+
   let ty = nnkRefTy.newTree nnkObjectTy.newTree(emptyn, supClsNode, typDefLs)
   let typDef = nnkTypeSection.newTree nnkTypeDef.newTree(classId, generics, ty)
   result.add:
@@ -383,6 +486,8 @@ so if wantting the attr inherited from SupCls, just write it as-is (e.g. `self.a
   # result.add quote do:
   #     when not declaredInScope `classId`:
   #       `typDef`
+
+  result.add decls
   result.add defs
 
   result.add newConstStmt(