progess default field

Author: ringabout

compiler/ast.nim

@@ -502,6 +502,7 @@ type
     nfLastRead  # this node is a last read
     nfFirstWrite# this node is a first write
     nfHasComment # node has a comment
+    nfHasDefaultField
 
   TNodeFlags* = set[TNodeFlag]
   TTypeFlag* = enum   # keep below 32 for efficiency reasons (now: 45)

compiler/ccgexprs.nim

@@ -1308,6 +1308,15 @@ proc genReset(p: BProc, n: PNode) =
             genTypeInfoV1(p.module, skipTypes(a.t, {tyVar}), n.info)])
 
 proc genDefault(p: BProc; n: PNode; d: var TLoc) =
+  # let typ = n[^1].typ.skipTypes({tyTypeDesc}).sym.ast[^1].typ
+  # if typ.skipTypes(abstractInst).kind == tyObject or
+  #   typ.skipTypes(abstractInst).kind == tyRef and
+  #   typ.skipTypes(abstractInst)[0].kind == tyObject:
+  #   var asgnExpr = newTree(nkObjConstr, newNodeIT(nkType, n[^1].info, typ))
+  #   asgnExpr.typ = typ
+  #   asgnExpr.sons.add defaultFieldsForTheUninitialized(typ.skipTypes({tyGenericInst, tyAlias, tySink}).n)
+  #   genObjConstr(p, asgnExpr, d)
+  # else:
   if d.k == locNone: getTemp(p, n.typ, d, needsInit=true)
   else: resetLoc(p, d)
 

compiler/parser.nim

@@ -1963,11 +1963,7 @@ proc parseObjectCase(p: var Parser): PNode =
   #|             | IND{=} objectBranches)
   result = newNodeP(nkRecCase, p)
   getTokNoInd(p)
-  var a = newNodeP(nkIdentDefs, p)
-  a.add(identWithPragma(p))
-  eat(p, tkColon)
-  a.add(parseTypeDesc(p))
-  a.add(p.emptyNode)
+  var a = parseIdentColonEquals(p, {withPragma})
   result.add(a)
   if p.tok.tokType == tkColon: getTok(p)
   flexComment(p, result)

compiler/semexprs.nim

@@ -2380,6 +2380,24 @@ proc semMagic(c: PContext, n: PNode, s: PSym, flags: TExprFlags): PNode =
   of mSizeOf:
     markUsed(c, n.info, s)
     result = semSizeof(c, setMs(n, s))
+  of mDefault:
+    result = semDirectOp(c, n, flags)
+
+
+    # let typ = result[^1].typ.skipTypes({tyTypeDesc}).sym.ast[^1].typ
+    let node = result[^1].typ.skipTypes({tyTypeDesc}).sym.ast[^1]
+    let typ = semTypeNode(c, node, nil)
+    if typ.skipTypes(abstractInst).kind == tyObject or
+       typ.skipTypes(abstractInst).kind == tyRef and typ.skipTypes(abstractInst)[0].kind == tyObject:
+      var asgnExpr = newTree(nkObjConstr, newNodeIT(nkType, node.info, result[^1].typ.skipTypes({tyTypeDesc})))
+      # asgnExpr[0].sons.add newNodeI(nkEmpty, result[^1].info)
+      asgnExpr.typ = result[^1].typ.skipTypes({tyTypeDesc})
+      asgnExpr.sons.add defaultFieldsForTheUninitialized(result[^1].typ.skipTypes({tyTypeDesc}).n)
+      result = semObjConstr(c, asgnExpr, flags)
+      debug "a+++++++++++++++++++++++++++++++++++++++++++++"
+      echo "here: ", result.renderTree
+      debug "x+++++++++++++++++++++++++++++++++++++++++++++"
+      # debug result
   else:
     result = semDirectOp(c, n, flags)
 

compiler/semobjconstr.nim

@@ -29,6 +29,10 @@ type
     initNone     # None of the fields have been initialized
     initConflict # Fields from different branches have been initialized
 
+
+proc semConstructFields(c: PContext, n: PNode, constrCtx: var ObjConstrContext,
+                        flags: TExprFlags): tuple[status: InitStatus, defaults: seq[PNode]]
+
 proc mergeInitStatus(existing: var InitStatus, newStatus: InitStatus) =
   case newStatus
   of initConflict:
@@ -155,18 +159,14 @@ proc collectMissingFields(c: PContext, fieldsRecList: PNode,
       if assignment == nil:
         constrCtx.missingFields.add r.sym
 
-
-proc semConstructFields(c: PContext, n: PNode,
-                        constrCtx: var ObjConstrContext,
-                        flags: TExprFlags): InitStatus =
-  result = initUnknown
-
+proc semConstructFields(c: PContext, n: PNode, constrCtx: var ObjConstrContext,
+                        flags: TExprFlags): tuple[status: InitStatus, defaults: seq[PNode]] =
   case n.kind
   of nkRecList:
     for field in n:
-      let status = semConstructFields(c, field, constrCtx, flags)
-      mergeInitStatus(result, status)
-
+      let (subSt, subDf) = semConstructFields(c, field, constrCtx, flags)
+      result.status.mergeInitStatus subSt
+      result.defaults.add subDf
   of nkRecCase:
     template fieldsPresentInBranch(branchIdx: int): string =
       let branch = n[branchIdx]
@@ -184,17 +184,18 @@ proc semConstructFields(c: PContext, n: PNode,
 
     for i in 1..<n.len:
       let innerRecords = n[i][^1]
-      let status = semConstructFields(c, innerRecords, constrCtx, flags)
+      let (status, defaults) = semConstructFields(c, innerRecords, constrCtx, flags)
       if status notin {initNone, initUnknown}:
-        mergeInitStatus(result, status)
+        result.status.mergeInitStatus status
+        result.defaults.add defaults
         if selectedBranch != -1:
           let prevFields = fieldsPresentInBranch(selectedBranch)
           let currentFields = fieldsPresentInBranch(i)
           localError(c.config, constrCtx.initExpr.info,
             ("The fields '$1' and '$2' cannot be initialized together, " &
             "because they are from conflicting branches in the case object.") %
             [prevFields, currentFields])
-          result = initConflict
+          result.status = initConflict
         else:
           selectedBranch = i
 
@@ -206,7 +207,7 @@ proc semConstructFields(c: PContext, n: PNode,
             ("cannot prove that it's safe to initialize $1 with " &
             "the runtime value for the discriminator '$2' ") %
             [fields, discriminator.sym.name.s])
-        mergeInitStatus(result, initNone)
+        mergeInitStatus(result.status, initNone)
 
       template wrongBranchError(i) =
         if c.inUncheckedAssignSection == 0:
@@ -291,11 +292,11 @@ proc semConstructFields(c: PContext, n: PNode,
 
       # When a branch is selected with a partial match, some of the fields
       # that were not initialized may be mandatory. We must check for this:
-      if result == initPartial:
+      if result.status == initPartial:
         collectMissingFields branchNode
 
     else:
-      result = initNone
+      result.status = initNone
       let discriminatorVal = semConstrField(c, flags + {efPreferStatic},
                                             discriminator.sym,
                                             constrCtx.initExpr)
@@ -308,7 +309,7 @@ proc semConstructFields(c: PContext, n: PNode,
         let matchedBranch = n.pickCaseBranch defaultValue
         collectMissingFields matchedBranch
       else:
-        result = initPartial
+        result.status = initPartial
         if discriminatorVal.kind == nkIntLit:
           # When the discriminator is a compile-time value, we also know
           # which branch will be selected:
@@ -318,23 +319,28 @@ proc semConstructFields(c: PContext, n: PNode,
           # All bets are off. If any of the branches has a mandatory
           # fields we must produce an error:
           for i in 1..<n.len: collectMissingFields n[i]
-
   of nkSym:
     let field = n.sym
     let e = semConstrField(c, flags, field, constrCtx.initExpr)
-    result = if e != nil: initFull else: initNone
-
+    if e != nil:
+      result.status = initFull
+    elif field.ast != nil:
+      result.status = initUnknown
+      result.defaults.add newTree(nkExprColonExpr, n, field.ast)
+    else:
+      result.status = initNone
   else:
     internalAssert c.config, false
 
 proc semConstructTypeAux(c: PContext,
                          constrCtx: var ObjConstrContext,
-                         flags: TExprFlags): InitStatus =
-  result = initUnknown
+                         flags: TExprFlags): tuple[status: InitStatus, defaults: seq[PNode]] =
+  result.status = initUnknown
   var t = constrCtx.typ
   while true:
-    let status = semConstructFields(c, t.n, constrCtx, flags)
-    mergeInitStatus(result, status)
+    let (status, defaults) = semConstructFields(c, t.n, constrCtx, flags)
+    result.status.mergeInitStatus status
+    result.defaults.add defaults
     if status in {initPartial, initNone, initUnknown}:
       collectMissingFields c, t.n, constrCtx
     let base = t[0]
@@ -378,7 +384,9 @@ proc defaultConstructionError(c: PContext, t: PType, info: TLineInfo) =
 proc semObjConstr(c: PContext, n: PNode, flags: TExprFlags): PNode =
   var t = semTypeNode(c, n[0], nil)
   result = newNodeIT(nkObjConstr, n.info, t)
-  for child in n: result.add child
+  result.add newNodeIT(nkType, n.info, t) #This will contain the default values to be added in transf
+  for i in 1..<n.len:
+    result.add n[i]
 
   if t == nil:
     return localErrorNode(c, result, "object constructor needs an object type")
@@ -399,7 +407,8 @@ proc semObjConstr(c: PContext, n: PNode, flags: TExprFlags): PNode =
   # field (if this is a case object, initialized fields in two different
   # branches will be reported as an error):
   var constrCtx = initConstrContext(t, result)
-  let initResult = semConstructTypeAux(c, constrCtx, flags)
+  let (initResult, defaults) = semConstructTypeAux(c, constrCtx, flags)
+  result[0].sons.add defaults
   var hasError = false # needed to split error detect/report for better msgs
 
   # It's possible that the object was not fully initialized while

compiler/semstmts.nim

@@ -594,6 +594,20 @@ proc semVarOrLet(c: PContext, n: PNode, symkind: TSymKind): PNode =
     var typFlags: TTypeAllowedFlags
 
     var def: PNode = c.graph.emptyNode
+    if a[^1].kind == nkEmpty and symkind == skVar and a[^2].typ != nil:
+      let aTyp = a[^2].typ
+      if aTyp.skipTypes({tyGenericInst, tyAlias, tySink}).kind == tyObject:
+        var asgnExpr = newTree(nkObjConstr, newNodeIT(nkType, a[^2].info, aTyp))
+        asgnExpr.typ = aTyp
+        echo "a----------------------------------------------------------"
+        debug aTyp.skipTypes({tyGenericInst, tyAlias, tySink}).n
+        echo len defaultFieldsForTheUninitialized(aTyp.skipTypes({tyGenericInst, tyAlias, tySink}).n)
+        echo "x----------------------------------------------------------"
+
+        asgnExpr.sons.add defaultFieldsForTheUninitialized(aTyp.skipTypes({tyGenericInst, tyAlias, tySink}).n)
+        echo asgnExpr.renderTree
+        a[^1] = asgnExpr
+
     if a[^1].kind != nkEmpty:
       def = semExprWithType(c, a[^1], {})
 
@@ -2376,7 +2390,7 @@ proc semStmtList(c: PContext, n: PNode, flags: TExprFlags): PNode =
       of tyBool:
         if x.kind == nkInfix and
             x[0].kind == nkSym and
-            x[0].sym.name.s == "==":
+            x[0].sym.s == "==":
           if x[1].typ.isUnresolvedStatic:
             inferConceptStaticParam(c, x[1], x[2])
             continue

compiler/semtypes.nim

@@ -777,12 +777,17 @@ proc semRecordNodeAux(c: PContext, n: PNode, check: var IntSet, pos: var int,
     var a: PNode
     if father.kind != nkRecList and n.len >= 4: a = newNodeI(nkRecList, n.info)
     else: a = newNodeI(nkEmpty, n.info)
-    if n[^1].kind != nkEmpty:
-      localError(c.config, n[^1].info, errInitHereNotAllowed)
     var typ: PType
+
+    let hasDefaultField = n[^1].kind != nkEmpty
     if n[^2].kind == nkEmpty:
-      localError(c.config, n.info, errTypeExpected)
-      typ = errorType(c)
+      if hasDefaultField:
+        n[^1] = semConstExpr(c, n[^1])
+        typ = n[^1].typ
+        propagateToOwner(rectype, typ)
+      else:
+        localError(c.config, n.info, errTypeExpected)
+        typ = errorType(c)
     else:
       typ = semTypeNode(c, n[^2], nil)
       propagateToOwner(rectype, typ)
@@ -806,8 +811,11 @@ proc semRecordNodeAux(c: PContext, n: PNode, check: var IntSet, pos: var int,
       inc(pos)
       if containsOrIncl(check, f.name.id):
         localError(c.config, info, "attempt to redefine: '" & f.name.s & "'")
-      if a.kind == nkEmpty: father.add newSymNode(f)
-      else: a.add newSymNode(f)
+      let fSym = newSymNode(f)
+      if hasDefaultField:
+        fSym.sym.ast = n[^1]
+      if a.kind == nkEmpty: father.add fSym
+      else: a.add fSym
       styleCheckDef(c.config, f)
       onDef(f.info, f)
     if a.kind != nkEmpty: father.add a

compiler/transf.nim

@@ -46,7 +46,7 @@ type
     module: PSym
     transCon: PTransCon      # top of a TransCon stack
     inlining: int            # > 0 if we are in inlining context (copy vars)
-    nestedProcs: int         # > 0 if we are in a nested proc
+    genResult: bool
     contSyms, breakSyms: seq[PSym]  # to transform 'continue' and 'break'
     deferDetected, tooEarly: bool
     graph: ModuleGraph
@@ -927,6 +927,32 @@ proc commonOptimizations*(g: ModuleGraph; idgen: IdGenerator; c: PSym, n: PNode)
     else:
       result = n
 
+proc defaultFieldsForTheUninitialized*(recNode: PNode): seq[PNode] =
+  case recNode.kind
+  of nkRecList:
+    for field in recNode:
+      result.add defaultFieldsForTheUninitialized(field)
+  of nkRecCase:
+    discard
+    # let discriminator = recNode[0]
+    # var selectedBranch: int
+    # let defaultValue = discriminator.sym.ast
+    # if defaultValue == nil:
+    #   # None of the branches were explicitly selected by the user and no value
+    #   # was given to the discrimator. We can assume that it will be initialized
+    #   # to zero and this will select a particular branch as a result:
+    #   selectedBranch = recNode.pickCaseBranch newIntNode(nkIntLit#[c.graph]#, 0)
+    # else: # Try to use default value
+    #   selectedBranch = recNode.pickCaseBranch defaultValue
+    #   result.add newTree(nkExprColonExpr, discriminator, defaultValue)
+    # result.add defaultFieldsForTheUninitialized(recNode[selectedBranch][^1])
+  of nkSym:
+    let field = recNode.sym
+    if field.ast != nil: #Try to use default value
+      result.add newTree(nkExprColonExpr, recNode, field.ast)
+  else:
+    assert false
+
 proc transform(c: PTransf, n: PNode): PNode =
   when false:
     var oldDeferAnchor: PNode
@@ -935,6 +961,19 @@ proc transform(c: PTransf, n: PNode): PNode =
                   nkBlockStmt, nkBlockExpr}:
       oldDeferAnchor = c.deferAnchor
       c.deferAnchor = n
+
+  if c.genResult:
+    c.genResult = false
+    result = newNodeIT(nkStmtList, n.info, nil)
+    let toInit = c.getCurrOwner().ast[resultPos]
+    if toInit.typ != nil and toInit.typ.skipTypes({tyGenericInst, tyAlias, tySink}).kind == tyObject:
+      var asgnExpr = newTree(nkObjConstr, newNodeIT(nkType, toInit.info, toInit.typ))
+      asgnExpr.typ = toInit.typ
+      asgnExpr.sons.add defaultFieldsForTheUninitialized(toInit.typ.skipTypes({tyGenericInst, tyAlias, tySink}).n)
+      result.add transform(c, newTree(nkAsgn, toInit, asgnExpr))
+    result.add transform(c, n)
+    return result
+
   case n.kind
   of nkSym:
     result = transformSym(c, n)
@@ -1052,6 +1091,14 @@ proc transform(c: PTransf, n: PNode): PNode =
       result = n
   of nkExceptBranch:
     result = transformExceptBranch(c, n)
+  of nkObjConstr:
+    result = n
+    var flag = false
+    if result.typ.skipTypes(abstractInst).kind == tyObject or
+       result.typ.skipTypes(abstractInst).kind == tyRef and result.typ.skipTypes(abstractInst)[0].kind == tyObject:
+      result.sons.add result[0].sons
+      result[0] = newNodeIT(nkType, result.info, result.typ)
+    result = transformSons(c, result)
   of nkCheckedFieldExpr:
     result = transformSons(c, n)
     if result[0].kind != nkDotExpr:
@@ -1079,6 +1126,7 @@ proc processTransf(c: PTransf, n: PNode, owner: PSym): PNode =
   # nodes into an empty node.
   if nfTransf in n.flags: return n
   pushTransCon(c, newTransCon(owner))
+  c.genResult = c.getCurrOwner().kind in routineKinds and c.transCon.owner.ast.len > resultPos and c.transCon.owner.ast[resultPos] != nil
   result = transform(c, n)
   popTransCon(c)
   incl(result.flags, nfTransf)