From ad67b7106ca14a26ae7a2d5fe184134c85a80d93 Mon Sep 17 00:00:00 2001
From: flywind <xzsflywind@gmail.com>
Date: Wed, 18 May 2022 10:35:25 +0800
Subject: [PATCH 1/2] fresh start

---
 compiler/ast.nim                        |  12 ++
 compiler/parser.nim                     |   6 +-
 compiler/semexprs.nim                   |  12 +-
 compiler/semmagic.nim                   | 108 +++++++++++
 compiler/semobjconstr.nim               |  70 ++++---
 compiler/semstmts.nim                   |  12 ++
 compiler/semtypes.nim                   |  21 ++-
 compiler/transf.nim                     | 160 +++++++++++++++-
 tests/objects/mobject_default_value.nim |  15 ++
 tests/objects/tobject_default_value.nim | 238 ++++++++++++++++++++++++
 10 files changed, 614 insertions(+), 40 deletions(-)
 create mode 100644 tests/objects/mobject_default_value.nim
 create mode 100644 tests/objects/tobject_default_value.nim

diff --git a/compiler/ast.nim b/compiler/ast.nim
index d1e5ae2bfe65..d0fcab9b5819 100644
--- a/compiler/ast.nim
+++ b/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
+    nfUseDefaultField
 
   TNodeFlags* = set[TNodeFlag]
   TTypeFlag* = enum   # keep below 32 for efficiency reasons (now: 45)
@@ -1453,6 +1454,17 @@ proc newIntTypeNode*(intVal: BiggestInt, typ: PType): PNode =
   result.intVal = intVal
   result.typ = typ
 
+proc newFloatTypeNode*(floatVal: BiggestFloat, typ: PType): PNode =
+  let kind = skipTypes(typ, abstractVarRange).kind
+  case kind
+  of tyFloat32:
+    result = newNode(nkFloat32Lit)
+  of tyFloat64, tyFloat:
+    result = newNode(nkFloatLit)
+  else: doAssert false, $kind
+  result.floatVal = floatVal
+  result.typ = typ
+
 proc newIntTypeNode*(intVal: Int128, typ: PType): PNode =
   # XXX: introduce range check
   newIntTypeNode(castToInt64(intVal), typ)
diff --git a/compiler/parser.nim b/compiler/parser.nim
index 52466d9fa0f0..2f89efc560d7 100644
--- a/compiler/parser.nim
+++ b/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)
diff --git a/compiler/semexprs.nim b/compiler/semexprs.nim
index 702b47929c7c..fc703ea858fc 100644
--- a/compiler/semexprs.nim
+++ b/compiler/semexprs.nim
@@ -897,8 +897,6 @@ proc semOverloadedCallAnalyseEffects(c: PContext, n: PNode, nOrig: PNode,
           rawAddSon(typ, result.typ)
           result.typ = typ
 
-proc semObjConstr(c: PContext, n: PNode, flags: TExprFlags): PNode
-
 proc resolveIndirectCall(c: PContext; n, nOrig: PNode;
                          t: PType): TCandidate =
   initCandidate(c, result, t)
@@ -2380,6 +2378,16 @@ 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})
+    if typ.skipTypes({tyGenericInst, tyAlias, tySink}).kind == tyObject:
+      var asgnExpr = newTree(nkObjConstr, newNodeIT(nkType, result[^1].info, typ))
+      asgnExpr.typ = typ
+      var hasDefault: bool
+      asgnExpr.sons.add defaultFieldsForTheUninitialized(c.graph, typ.skipTypes({tyGenericInst, tyAlias, tySink}).n, hasDefault)
+      if hasDefault:
+        result = semObjConstr(c, asgnExpr, flags)
   else:
     result = semDirectOp(c, n, flags)
 
diff --git a/compiler/semmagic.nim b/compiler/semmagic.nim
index ed1826fd4ea9..cb630edb0009 100644
--- a/compiler/semmagic.nim
+++ b/compiler/semmagic.nim
@@ -10,6 +10,8 @@
 # This include file implements the semantic checking for magics.
 # included from sem.nim
 
+proc semObjConstr(c: PContext, n: PNode, flags: TExprFlags): PNode
+
 proc semAddrArg(c: PContext; n: PNode): PNode =
   let x = semExprWithType(c, n)
   if x.kind == nkSym:
@@ -454,6 +456,95 @@ proc semPrivateAccess(c: PContext, n: PNode): PNode =
   c.currentScope.allowPrivateAccess.add t.sym
   result = newNodeIT(nkEmpty, n.info, getSysType(c.graph, n.info, tyVoid))
 
+
+# import nimsets
+
+
+
+# proc caseBranchMatchesExpr2(branch, matched: PNode): bool =
+#   for i in 0 ..< branch.len-1:
+#     if branch[i].kind == nkRange:
+#       if overlap(branch[i], matched): return true
+#     elif exprStructuralEquivalent(branch[i], matched):
+#       return true
+
+# proc pickCaseBranch2(caseExpr, matched: PNode): int =
+#   let endsWithElse = caseExpr[^1].kind == nkElse
+#   for i in 1..<caseExpr.len - endsWithElse.int:
+#     if caseExpr[i].caseBranchMatchesExpr2(matched):
+#       return i
+#   if endsWithElse:
+#     return caseExpr.len - 1
+
+# proc defaultFieldsForTheUninitialized2*(c: PContext, recNode: PNode, hasDefault: var bool): seq[PNode] =
+#   case recNode.kind
+#   of nkRecList:
+#     for field in recNode:
+#       result.add defaultFieldsForTheUninitialized2(c, field, hasDefault)
+#   of nkRecCase:
+#     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.pickCaseBranch2 newIntNode(nkIntLit#[c.graph]#, 0)
+#     else: # Try to use default value
+#       selectedBranch = recNode.pickCaseBranch2 defaultValue
+#       result.add newTree(nkExprColonExpr, discriminator, defaultValue)
+#     result.add defaultFieldsForTheUninitialized2(c, recNode[selectedBranch][^1], hasDefault)
+#   of nkSym:
+#     let field = recNode.sym
+#     let recType = recNode.typ.skipTypes({tyGenericInst, tyAlias, tySink})
+#     if field.ast != nil: #Try to use default value
+#       result.add newTree(nkExprColonExpr, recNode, field.ast)
+#       hasDefault = true
+#     elif recType.kind == tyObject:
+#       var asgnExpr = newTree(nkObjConstr, newNodeIT(nkType, recNode.info, recNode.typ))
+#       asgnExpr.typ = recNode.typ
+#       asgnExpr.flags.incl nfUseDefaultField
+#       asgnExpr.sons.add defaultFieldsForTheUninitialized2(c, recType.n, hasDefault)
+#       result.add newTree(nkExprColonExpr, recNode, asgnExpr)
+#     elif recType.kind == tyArray and recType[1].skipTypes({tyGenericInst, tyAlias, tySink}).kind == tyObject:
+#       let defaults = defaultFieldsForTheUninitialized2(c, recType[1].skipTypes({tyGenericInst, tyAlias, tySink}).n, hasDefault)
+#       var objExpr = newTree(nkObjConstr, newNodeIT(nkType, recNode.info, recType[1]))
+#       objExpr.typ = recType[1].skipTypes({tyGenericInst, tyAlias, tySink})
+#       objExpr.sons.add defaults # todo create clean?
+
+#       let node = newNode(nkIntLit)
+#       node.intVal = toInt(lengthOrd(c.graph.config, recType))
+#       var asgnExpr = newTree(nkCall, newSymNode(getSysSym(c.graph, recNode.info, "newDefaultArray"), recNode.info),
+#       # var asgnExpr = newTree(nkCall, newSymNode(getCompilerProc(c.graph, "newDefaultArray")),
+#               node,
+#               objExpr
+#               )
+#       asgnExpr.typ = recNode.typ
+#       asgnExpr.flags.incl nfUseDefaultField
+
+#       # asgnExpr.sons.setLen(toInt(lengthOrd(c, recType)))
+#       # for i in 0..<asgnExpr.sons.len:
+#       #   asgnExpr[i] = objExpr
+#       let asgnExpr2 = semExprWithType(c, asgnExpr)
+#       result.add newTree(nkExprColonExpr, recNode, asgnExpr2)
+
+#     elif recType.kind == tyTuple:
+#       # doAssert false
+#       discard
+#     elif recType.kind in {tyInt..tyInt64, tyUInt..tyUInt64}:
+#       let asgnExpr = newIntTypeNode(int64(0), recType)
+#       asgnExpr.flags.incl nfUseDefaultField
+#       result.add newTree(nkExprColonExpr, recNode,
+#               asgnExpr)
+#     elif recType.kind in tyFloat..tyFloat64:
+#       let asgnExpr = newFloatTypeNode(BiggestFloat(0.0), recType)
+#       asgnExpr.flags.incl nfUseDefaultField
+#       result.add newTree(nkExprColonExpr, recNode,
+#               asgnExpr)
+
+#   else:
+#     assert false
+
 proc magicsAfterOverloadResolution(c: PContext, n: PNode,
                                    flags: TExprFlags): PNode =
   ## This is the preferred code point to implement magics.
@@ -512,6 +603,23 @@ proc magicsAfterOverloadResolution(c: PContext, n: PNode,
       result = n
     else:
       result = plugin(c, n)
+  of mNew:
+    result = n
+    let typ = result[^1].typ
+    if typ.skipTypes({tyGenericInst, tyAlias, tySink}).kind == tyRef and typ.skipTypes({tyGenericInst, tyAlias, tySink})[0].kind == tyObject:
+      var asgnExpr = newTree(nkObjConstr, newNodeIT(nkType, result[^1].info, typ))
+      asgnExpr.typ = typ
+      var hasDefault: bool
+      var t = typ.skipTypes({tyGenericInst, tyAlias, tySink})[0]
+      while true:
+        asgnExpr.sons.add defaultFieldsForTheUninitialized(c.graph, t.n, hasDefault)
+        let base = t[0]
+        if base == nil:
+          break
+        t = skipTypes(base, skipPtrs)
+
+      if hasDefault: # todo apply default
+        result = newTree(nkAsgn, result[^1], asgnExpr)
   of mNewFinalize:
     # Make sure the finalizer procedure refers to a procedure
     if n[^1].kind == nkSym and n[^1].sym.kind notin {skProc, skFunc}:
diff --git a/compiler/semobjconstr.nim b/compiler/semobjconstr.nim
index 6d11d321ec24..88260962bd29 100644
--- a/compiler/semobjconstr.nim
+++ b/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:
@@ -72,7 +76,9 @@ proc semConstrField(c: PContext, flags: TExprFlags,
   let assignment = locateFieldInInitExpr(c, field, initExpr)
   if assignment != nil:
     if nfSem in assignment.flags: return assignment[1]
-    if not fieldVisible(c, field):
+    if nfUseDefaultField in assignment[1].flags:
+      discard
+    elif not fieldVisible(c, field):
       localError(c.config, initExpr.info,
         "the field '$1' is not accessible." % [field.name.s])
       return
@@ -155,18 +161,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,9 +186,9 @@ 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, _) = semConstructFields(c, innerRecords, constrCtx, flags) # todo
       if status notin {initNone, initUnknown}:
-        mergeInitStatus(result, status)
+        result.status.mergeInitStatus status
         if selectedBranch != -1:
           let prevFields = fieldsPresentInBranch(selectedBranch)
           let currentFields = fieldsPresentInBranch(i)
@@ -194,7 +196,7 @@ proc semConstructFields(c: PContext, n: PNode,
             ("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 +208,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:
@@ -289,13 +291,16 @@ proc semConstructFields(c: PContext, n: PNode,
           else:
             wrongBranchError(failedBranch)
 
+      let (_, defaults) = semConstructFields(c, branchNode[^1], constrCtx, flags)
+      result.defaults.add defaults
+
       # 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,33 +313,41 @@ 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:
           let matchedBranch = n.pickCaseBranch discriminatorVal
-          if matchedBranch != nil: collectMissingFields matchedBranch
+          if matchedBranch != nil:
+            let (_, defaults) = semConstructFields(c, matchedBranch[^1], constrCtx, flags)
+            result.defaults.add defaults
+            collectMissingFields matchedBranch
         else:
           # 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 +391,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 +414,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
diff --git a/compiler/semstmts.nim b/compiler/semstmts.nim
index 3513fd7672f9..2f7a6374db61 100644
--- a/compiler/semstmts.nim
+++ b/compiler/semstmts.nim
@@ -594,6 +594,15 @@ 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 m = copyTree(a[0])
+      # var v = semIdentDef(c, m, symkind, false)
+      # if {sfThread, sfNoInit} * v.flags != {}: # todo var m1, m2 {threadvar}
+      #   discard # todo init threadvar properly
+      # else:
+      let field = defaultNodeField(c.graph, a[^2])
+      if field != nil:
+        a[^1] = field
     if a[^1].kind != nkEmpty:
       def = semExprWithType(c, a[^1], {})
 
@@ -662,6 +671,9 @@ proc semVarOrLet(c: PContext, n: PNode, symkind: TSymKind): PNode =
         addToVarSection(c, result, n, a)
         continue
       var v = semIdentDef(c, a[j], symkind, false)
+      if {sfThread, sfNoInit} * v.flags != {}:
+        a[^1] = c.graph.emptyNode
+        def = c.graph.emptyNode
       styleCheckDef(c.config, v)
       onDef(a[j].info, v)
       if sfGenSym notin v.flags:
diff --git a/compiler/semtypes.nim b/compiler/semtypes.nim
index b4f385fe615f..5584b6b69990 100644
--- a/compiler/semtypes.nim
+++ b/compiler/semtypes.nim
@@ -777,14 +777,21 @@ 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
-    if n[^2].kind == nkEmpty:
+    var hasDefaultField = n[^1].kind != nkEmpty
+    if hasDefaultField:
+      n[^1] = semConstExpr(c, n[^1])
+      typ = n[^1].typ
+      propagateToOwner(rectype, typ)
+    elif n[^2].kind == nkEmpty:
       localError(c.config, n.info, errTypeExpected)
       typ = errorType(c)
     else:
       typ = semTypeNode(c, n[^2], nil)
+      if c.graph.config.isDefined("nimRangeDefault") and typ.skipTypes(abstractInst).kind in {tyRange, tyOrdinal}:
+        n[^1] = newIntNode(nkIntLit, firstOrd(c.config, typ))
+        n[^1].typ = typ
+        hasDefaultField = true
       propagateToOwner(rectype, typ)
     var fieldOwner = if c.inGenericContext > 0: c.getCurrOwner
                      else: rectype.sym
@@ -806,8 +813,12 @@ 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]
+        fSym.sym.ast.flags.incl nfUseDefaultField
+      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
diff --git a/compiler/transf.nim b/compiler/transf.nim
index bdd7c680ccd5..b53d897c2570 100644
--- a/compiler/transf.nim
+++ b/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,141 @@ proc commonOptimizations*(g: ModuleGraph; idgen: IdGenerator; c: PSym, n: PNode)
     else:
       result = n
 
+import nimsets
+
+proc caseBranchMatchesExpr(branch, matched: PNode): bool =
+  for i in 0 ..< branch.len-1:
+    if branch[i].kind == nkRange:
+      if overlap(branch[i], matched): return true
+    elif exprStructuralEquivalent(branch[i], matched):
+      return true
+
+proc pickCaseBranch(caseExpr, matched: PNode): int =
+  let endsWithElse = caseExpr[^1].kind == nkElse
+  for i in 1..<caseExpr.len - endsWithElse.int:
+    if caseExpr[i].caseBranchMatchesExpr(matched):
+      return i
+  if endsWithElse:
+    return caseExpr.len - 1
+
+proc defaultFieldsForTheUninitialized*(graph: ModuleGraph, recNode: PNode, hasDefault: var bool): seq[PNode] =
+  case recNode.kind
+  of nkRecList:
+    for field in recNode:
+      result.add defaultFieldsForTheUninitialized(graph, field, hasDefault)
+  of nkRecCase:
+    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(graph, recNode[selectedBranch][^1], hasDefault)
+  of nkSym:
+    let field = recNode.sym
+    let recType = recNode.typ.skipTypes({tyGenericInst, tyAlias, tySink})
+    if field.ast != nil: #Try to use default value
+      result.add newTree(nkExprColonExpr, recNode, field.ast)
+      hasDefault = true
+    elif recType.kind == tyObject:
+      var asgnExpr = newTree(nkObjConstr, newNodeIT(nkType, recNode.info, recNode.typ))
+      asgnExpr.typ = recNode.typ
+      asgnExpr.flags.incl nfUseDefaultField
+      asgnExpr.sons.add defaultFieldsForTheUninitialized(graph, recType.n, hasDefault)
+      result.add newTree(nkExprColonExpr, recNode, asgnExpr)
+    elif recType.kind == tyArray and recType[1].skipTypes({tyGenericInst, tyAlias, tySink}).kind == tyObject:
+      var asgnExpr = newNodeI(nkBracket, recNode.info)
+      asgnExpr.typ = recNode.typ
+      asgnExpr.flags.incl nfUseDefaultField
+      let defaults = defaultFieldsForTheUninitialized(graph, recType[1].skipTypes({tyGenericInst, tyAlias, tySink}).n, hasDefault)
+      var objExpr = newTree(nkObjConstr, newNodeIT(nkType, recNode.info, recType[1]))
+      objExpr.typ = recType[1].skipTypes({tyGenericInst, tyAlias, tySink})
+      objExpr.sons.add defaults # todo create clean?
+
+      # let node = newNode(nkIntLit)
+      # node.intVal = toInt(lengthOrd(graph.config, recType))
+      # let syms = getCompilerProc(graph, "newDefaultArray")
+      # # debug syms
+      # # debug syms.typ
+      # var asgnExpr = newTree(nkCall, newSymNode(getCompilerProc(graph, "newDefaultArray")),
+      #         node,
+      #         objExpr
+      #         )
+      # asgnExpr.typ = recNode.typ
+      # asgnExpr.flags.incl nfUseDefaultField
+
+      asgnExpr.sons.setLen(toInt(lengthOrd(graph.config, recType)))
+      for i in 0..<asgnExpr.sons.len:
+        asgnExpr[i] = objExpr
+      result.add newTree(nkExprColonExpr, recNode,
+        asgnExpr)
+    elif recType.kind == tyTuple:
+      # doAssert false
+      discard
+    elif recType.kind in {tyInt..tyInt64, tyUInt..tyUInt64}:
+      let asgnExpr = newIntTypeNode(int64(0), recType)
+      asgnExpr.flags.incl nfUseDefaultField
+      result.add newTree(nkExprColonExpr, recNode,
+              asgnExpr)
+    elif recType.kind in tyFloat..tyFloat64:
+      let asgnExpr = newFloatTypeNode(BiggestFloat(0.0), recType)
+      asgnExpr.flags.incl nfUseDefaultField
+      result.add newTree(nkExprColonExpr, recNode,
+              asgnExpr)
+
+  else:
+    assert false
+
+proc defaultNodeField*(graph: ModuleGraph, a: PNode): PNode =
+  let aTyp = a.typ
+  var hasDefault: bool
+  if aTyp.skipTypes({tyGenericInst, tyAlias, tySink}).kind == tyObject:
+    var asgnExpr = newTree(nkObjConstr, newNodeIT(nkType, a.info, aTyp))
+    asgnExpr.typ = aTyp
+    asgnExpr.sons.add defaultFieldsForTheUninitialized(graph, aTyp.skipTypes({tyGenericInst, tyAlias, tySink}).n, hasDefault)
+    if hasDefault:
+      result = asgnExpr
+  elif aTyp.kind == tyArray and aTyp[1].skipTypes({tyGenericInst, tyAlias, tySink}).kind == tyObject:
+    var asgnExpr = newNodeI(nkBracket, a.info)
+    asgnExpr.typ = aTyp
+    let defaults = defaultFieldsForTheUninitialized(graph, aTyp[1].skipTypes({tyGenericInst, tyAlias, tySink}).n, hasDefault)
+    for i in 0..<toInt(lengthOrd(graph.config, aTyp)):
+      var objExpr = newTree(nkObjConstr, newNodeIT(nkType, a.info, aTyp[1]))
+      objExpr.typ = aTyp[1]
+      objExpr.sons.add defaults # todo create clean?
+      asgnExpr.add objExpr
+    if hasDefault:
+      result = asgnExpr
+  elif aTyp.kind == tyTuple:
+    var tupleExpr = newNodeI(nkTupleConstr, a.info)
+    tupleExpr.typ = aTyp
+    for s in aTyp.sons:
+      let sType = s.skipTypes({tyGenericInst, tyAlias, tySink})
+      if sType.kind == tyObject:
+        var asgnExpr = newTree(nkObjConstr, newNodeIT(nkType, a.info, s))
+        asgnExpr.typ = s
+        asgnExpr.sons.add defaultFieldsForTheUninitialized(graph, sType.n, hasDefault)
+        tupleExpr.add asgnExpr
+      elif sType.kind in {tyInt..tyInt64, tyUInt..tyUInt64}:
+        let asgnExpr = newIntTypeNode(int64(0), sType)
+        asgnExpr.flags.incl nfUseDefaultField
+        tupleExpr.add asgnExpr
+      elif sType.kind in tyFloat..tyFloat64:
+        let asgnExpr =
+          if sType.kind == tyFloat32:
+            newFloatNode(nkFloat32Lit, BiggestFloat(0.0))
+          else:
+            newFloatNode(nkFloatLit, BiggestFloat(0.0))
+        asgnExpr.flags.incl nfUseDefaultField
+        tupleExpr.add asgnExpr
+    if hasDefault:
+      result = tupleExpr
+
 proc transform(c: PTransf, n: PNode): PNode =
   when false:
     var oldDeferAnchor: PNode
@@ -935,6 +1070,21 @@ 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:
+      let field = defaultNodeField(c.graph, toInit)
+
+      if field != nil:
+        result.add newTree(nkAsgn, toInit, field)
+
+    result.add transform(c, n)
+    return result
+
   case n.kind
   of nkSym:
     result = transformSym(c, n)
@@ -1052,6 +1202,13 @@ proc transform(c: PTransf, n: PNode): PNode =
       result = n
   of nkExceptBranch:
     result = transformExceptBranch(c, n)
+  of nkObjConstr:
+    result = n
+    if result.typ.skipTypes({tyGenericInst, tyAlias, tySink}).kind == tyObject or
+       result.typ.skipTypes({tyGenericInst, tyAlias, tySink}).kind == tyRef and result.typ.skipTypes({tyGenericInst, tyAlias, tySink})[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 +1236,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)
diff --git a/tests/objects/mobject_default_value.nim b/tests/objects/mobject_default_value.nim
new file mode 100644
index 000000000000..224549501507
--- /dev/null
+++ b/tests/objects/mobject_default_value.nim
@@ -0,0 +1,15 @@
+type
+  Clean = object
+    mem: int
+  Default* = object
+    poi: int = 12
+    clc: Clean
+    se*: range[0'i32 .. high(int32)]
+
+  NonDefault* = object
+    poi: int
+
+  PrellDeque*[T] = object
+    pendingTasks*: range[0'i32 .. high(int32)]
+    head: T
+    tail: T
diff --git a/tests/objects/tobject_default_value.nim b/tests/objects/tobject_default_value.nim
new file mode 100644
index 000000000000..2a71a4c19817
--- /dev/null
+++ b/tests/objects/tobject_default_value.nim
@@ -0,0 +1,238 @@
+discard """
+  matrix: "-d:nimRangeDefault"
+  targets: "c js"
+"""
+
+import times
+
+type
+  Guess = object
+    poi: DateTime
+
+block:
+  var x: Guess
+  discard x
+
+  discard Guess()
+
+import mobject_default_value
+
+block:
+  let x = Default()
+  doAssert x.se == 0'i32
+# echo Default(poi: 12)
+# echo Default(poi: 17)
+
+# echo NonDefault(poi: 77)
+
+block:
+  var x: Default
+  doAssert x.se == 0'i32
+
+type
+  ObjectBase = object of RootObj
+    value = 12
+
+  Object = object of ObjectBase
+    time: float = 1.2
+    date: int
+    scale: range[1..10]
+
+  Object2 = object
+    name: Object
+
+  Object3 = object
+    obj: Object2
+
+  ObjectTuple = tuple
+    base: ObjectBase
+    typ: int
+    obj: Object
+
+  Ref = ref object of ObjectBase
+
+  RefInt = ref object of Ref
+    data = 73
+
+var t {.threadvar.}: Default
+# var m1, m2 {.threadvar.}: Default
+
+block:
+  doAssert t.se == 0'i32
+
+block:
+  var x: ObjectBase
+  doAssert x.value == 12
+  let y = default(ObjectBase)
+  doAssert y.value == 12
+
+block:
+  var x: Object
+  doAssert x.value == 12
+  doAssert x.time == 1.2
+  doAssert x.scale == 1
+  let y = default(Object)
+  doAssert y.value == 12
+  doAssert y.time == 1.2
+  doAssert y.scale == 1
+
+  var x1, x2, x3: Object
+  doAssert x1.value == 12
+  doAssert x1.time == 1.2
+  doAssert x1.scale == 1
+  doAssert x2.value == 12
+  doAssert x2.time == 1.2
+  doAssert x2.scale == 1
+  doAssert x3.value == 12
+  doAssert x3.time == 1.2
+  doAssert x3.scale == 1
+
+block:
+  var x: Ref
+  new(x)
+  doAssert x.value == 12, "Ref.value = " & $x.value
+
+  var y: RefInt
+  new(y)
+  doAssert y.value == 12
+  doAssert y.data == 73
+
+# block: # object array
+#   var x: ObjectArray
+#   echo x
+
+block:
+  var x: Object2
+  doAssert x.name.value == 12
+  doAssert x.name.time == 1.2
+  doAssert x.name.scale == 1
+
+block:
+  var x: Object3
+  doAssert x.obj.name.value == 12
+  doAssert x.obj.name.time == 1.2
+  doAssert x.obj.name.scale == 1
+
+# block: #seq
+#   var x = newSeq[Object](10)
+#   echo x
+
+block: # array
+  var x: array[10, Object]
+  let y = x[0]
+  doAssert y.value == 12
+  doAssert y.time == 1.2
+  doAssert y.scale == 1
+
+block: # array
+  var x {.noinit.}: array[10, Object]
+  discard x
+
+block: # tuple
+  var x: ObjectTuple
+  doAssert x.base.value == 12
+  doAssert x.typ == 0
+  doAssert x.obj.time == 1.2
+  doAssert x.obj.date == 0
+  doAssert x.obj.scale == 1
+  doAssert x.obj.value == 12
+
+type
+  ObjectArray = object
+    data: array[10, Object]
+
+block:
+  var x: ObjectArray
+  let y = x.data[0]
+  doAssert y.value == 12
+  doAssert y.time == 1.2
+  doAssert y.scale == 1
+
+
+block:
+  var x: PrellDeque[int]
+  doAssert x.pendingTasks == 0
+
+type
+  Color = enum
+    Red, Blue, Yellow
+
+  ObjectVarint = object
+    case kind: Color
+    of Red:
+      data: int = 10
+    of Blue:
+      fill = "123"
+    of Yellow:
+      time = 1.8'f32
+
+  ObjectVarint1 = object
+    case kind: Color = Blue
+    of Red:
+      data1: int = 10
+    of Blue:
+      fill2 = "123"
+      cry: float
+    of Yellow:
+      time3 = 1.8'f32
+      him: int
+
+block:
+  var x = ObjectVarint(kind: Red)
+  doAssert x.kind == Red
+  doAssert x.data == 10
+
+block:
+  var x = ObjectVarint(kind: Blue)
+  doAssert x.kind == Blue
+  doAssert x.fill == "123"
+
+block:
+  var x = ObjectVarint(kind: Yellow)
+  doAssert x.kind == Yellow
+  doAssert typeof(x.time) is float32
+
+block:
+  var x: ObjectVarint1
+  doAssert x.kind == Blue
+  doAssert x.fill2 == "123"
+  x.cry = 326
+
+
+type
+  ObjectVarint2 = object
+    case kind: Color
+    of Red:
+      data: int = 10
+    of Blue:
+      fill = "123"
+    of Yellow:
+      time = 1.8'f32
+
+  ObjectVarint3 = object
+    case kind: Color = Blue
+    of Red:
+      data1: int = 10
+    of Blue:
+      case name: Color = Blue
+      of Blue:
+        go = 12
+      else:
+        temp = 66
+      fill2 = "123"
+      cry: float
+    of Yellow:
+      time3 = 1.8'f32
+      him: int
+
+block:
+  var x: ObjectVarint3
+  doAssert x.kind == Blue
+  doAssert x.name == Blue
+  doAssert x.go == 12
+
+block:
+  var x = ObjectVarint3(kind: Blue, name: Red, temp: 99)
+  doAssert x.kind == Blue
+  doAssert x.name == Red
+  doAssert x.temp == 99

From dc9c8daeeb7ea1160184f352d23c7de23f82d46a Mon Sep 17 00:00:00 2001
From: flywind <xzsflywind@gmail.com>
Date: Wed, 18 May 2022 15:24:10 +0800
Subject: [PATCH 2/2] add cpp target

---
 compiler/sem.nim                        | 158 ++++++++++++++++++++++++
 compiler/semexprs.nim                   |   2 +-
 compiler/semmagic.nim                   |  91 +-------------
 compiler/semobjconstr.nim               |   9 --
 compiler/semstmts.nim                   |   2 +-
 compiler/transf.nim                     | 155 ++---------------------
 lib/system.nim                          |   5 +
 tests/objects/tobject_default_value.nim |  18 +--
 8 files changed, 185 insertions(+), 255 deletions(-)

diff --git a/compiler/sem.nim b/compiler/sem.nim
index 70c57864c5d0..3ecadf3fc5c6 100644
--- a/compiler/sem.nim
+++ b/compiler/sem.nim
@@ -535,6 +535,164 @@ proc setGenericParamsMisc(c: PContext; n: PNode) =
   else:
     n[miscPos][1] = orig
 
+proc caseBranchMatchesExpr(branch, matched: PNode): bool =
+  for i in 0 ..< branch.len-1:
+    if branch[i].kind == nkRange:
+      if overlap(branch[i], matched): return true
+    elif exprStructuralEquivalent(branch[i], matched):
+      return true
+
+proc pickCaseBranchIndex(caseExpr, matched: PNode): int =
+  let endsWithElse = caseExpr[^1].kind == nkElse
+  for i in 1..<caseExpr.len - endsWithElse.int:
+    if caseExpr[i].caseBranchMatchesExpr(matched):
+      return i
+  if endsWithElse:
+    return caseExpr.len - 1
+
+proc defaultFieldsForTheUninitialized(c: PContext, recNode: PNode, hasDefault: var bool): seq[PNode] =
+  case recNode.kind
+  of nkRecList:
+    for field in recNode:
+      result.add defaultFieldsForTheUninitialized(c, field, hasDefault)
+  of nkRecCase:
+    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.pickCaseBranchIndex newIntNode(nkIntLit#[c.graph]#, 0)
+    else: # Try to use default value
+      selectedBranch = recNode.pickCaseBranchIndex defaultValue
+      result.add newTree(nkExprColonExpr, discriminator, defaultValue)
+    result.add defaultFieldsForTheUninitialized(c, recNode[selectedBranch][^1], hasDefault)
+  of nkSym:
+    let field = recNode.sym
+    let recType = recNode.typ.skipTypes({tyGenericInst, tyAlias, tySink})
+    if field.ast != nil: #Try to use default value
+      result.add newTree(nkExprColonExpr, recNode, field.ast)
+      hasDefault = true
+    elif recType.kind == tyObject:
+      var asgnExpr = newTree(nkObjConstr, newNodeIT(nkType, recNode.info, recNode.typ))
+      asgnExpr.typ = recNode.typ
+      asgnExpr.flags.incl nfUseDefaultField
+      asgnExpr.sons.add defaultFieldsForTheUninitialized(c, recType.n, hasDefault)
+      result.add newTree(nkExprColonExpr, recNode, asgnExpr)
+    elif recType.kind == tyArray and recType[1].skipTypes({tyGenericInst, tyAlias, tySink}).kind == tyObject:
+      var objExpr = newTree(nkObjConstr, newNodeIT(nkType, recNode.info, recType[1]))
+      objExpr.typ = recType[1].skipTypes({tyGenericInst, tyAlias, tySink})
+      var t = objExpr.typ
+      while true:
+        objExpr.sons.add defaultFieldsForTheUninitialized(c, t.n, hasDefault)
+        let base = t[0]
+        if base == nil:
+          break
+        t = skipTypes(base, skipPtrs)
+
+
+      let node = newNode(nkIntLit)
+      node.intVal = toInt(lengthOrd(c.graph.config, recType))
+      var asgnExpr = newTree(nkCall, newSymNode(getSysSym(c.graph, recNode.info, "newDefaultArray"), recNode.info),
+      # var asgnExpr = newTree(nkCall, newSymNode(getCompilerProc(c.graph, "newDefaultArray")),
+              node,
+              objExpr
+              )
+      asgnExpr.typ = recNode.typ
+      asgnExpr.flags.incl nfUseDefaultField
+
+      # asgnExpr.sons.setLen(toInt(lengthOrd(c, recType)))
+      # for i in 0..<asgnExpr.sons.len:
+      #   asgnExpr[i] = objExpr
+      let asgnExpr2 = semExprWithType(c, asgnExpr)
+      result.add newTree(nkExprColonExpr, recNode, asgnExpr2)
+
+      # asgnExpr.sons.setLen(toInt(lengthOrd(c.graph.config, recType)))
+      # for i in 0..<asgnExpr.sons.len:
+      #   asgnExpr[i] = objExpr
+      # result.add newTree(nkExprColonExpr, recNode,
+      #   asgnExpr)
+    elif recType.kind == tyTuple:
+      # doAssert false
+      discard
+    elif recType.kind in {tyInt..tyInt64, tyUInt..tyUInt64}:
+      let asgnExpr = newIntTypeNode(int64(0), recType)
+      asgnExpr.flags.incl nfUseDefaultField
+      result.add newTree(nkExprColonExpr, recNode,
+              asgnExpr)
+    elif recType.kind in tyFloat..tyFloat64:
+      let asgnExpr = newFloatTypeNode(BiggestFloat(0.0), recType)
+      asgnExpr.flags.incl nfUseDefaultField
+      result.add newTree(nkExprColonExpr, recNode,
+              asgnExpr)
+
+  else:
+    assert false
+
+proc defaultNodeField(c: PContext, a: PNode): PNode =
+  let aTyp = a.typ
+  var hasDefault: bool
+  if aTyp.skipTypes({tyGenericInst, tyAlias, tySink}).kind == tyObject:
+    var asgnExpr = newTree(nkObjConstr, newNodeIT(nkType, a.info, aTyp))
+    asgnExpr.typ = aTyp
+    asgnExpr.sons.add defaultFieldsForTheUninitialized(c, aTyp.skipTypes({tyGenericInst, tyAlias, tySink}).n, hasDefault)
+    if hasDefault:
+      result = asgnExpr
+  elif aTyp.kind == tyArray and aTyp[1].skipTypes({tyGenericInst, tyAlias, tySink}).kind == tyObject:
+    var objExpr = newTree(nkObjConstr, newNodeIT(nkType, a.info, aTyp[1]))
+    objExpr.typ = aTyp[1].skipTypes({tyGenericInst, tyAlias, tySink})
+    # objExpr.sons.add defaults # todo create clean?
+
+    var t = objExpr.typ
+    while true:
+      objExpr.sons.add defaultFieldsForTheUninitialized(c, t.n, hasDefault)
+      let base = t[0]
+      if base == nil:
+        break
+      t = skipTypes(base, skipPtrs)
+
+    let node = newNode(nkIntLit)
+    node.intVal = toInt(lengthOrd(c.graph.config, aTyp))
+    var asgnExpr = newTree(nkCall, newSymNode(getSysSym(c.graph, a.info, "newDefaultArray"), a.info),
+    # var asgnExpr = newTree(nkCall, newSymNode(getCompilerProc(c.graph, "newDefaultArray")),
+            node,
+            objExpr
+            )
+    asgnExpr.typ = a.typ
+    asgnExpr.flags.incl nfUseDefaultField
+
+    # asgnExpr.sons.setLen(toInt(lengthOrd(c, recType)))
+    # for i in 0..<asgnExpr.sons.len:
+    #   asgnExpr[i] = objExpr
+    let asgnExpr2 = semExprWithType(c, asgnExpr)
+    if hasDefault:
+      result = asgnExpr2
+  elif aTyp.kind == tyTuple:
+    var tupleExpr = newNodeI(nkTupleConstr, a.info)
+    tupleExpr.typ = aTyp
+    for s in aTyp.sons:
+      let sType = s.skipTypes({tyGenericInst, tyAlias, tySink})
+      if sType.kind == tyObject:
+        var asgnExpr = newTree(nkObjConstr, newNodeIT(nkType, a.info, s))
+        asgnExpr.typ = s
+        asgnExpr.sons.add defaultFieldsForTheUninitialized(c, sType.n, hasDefault)
+        tupleExpr.add asgnExpr
+      elif sType.kind in {tyInt..tyInt64, tyUInt..tyUInt64}:
+        let asgnExpr = newIntTypeNode(int64(0), sType)
+        asgnExpr.flags.incl nfUseDefaultField
+        tupleExpr.add asgnExpr
+      elif sType.kind in tyFloat..tyFloat64:
+        let asgnExpr =
+          if sType.kind == tyFloat32:
+            newFloatNode(nkFloat32Lit, BiggestFloat(0.0))
+          else:
+            newFloatNode(nkFloatLit, BiggestFloat(0.0))
+        asgnExpr.flags.incl nfUseDefaultField
+        tupleExpr.add asgnExpr
+    if hasDefault:
+      result = tupleExpr
+
 include semtempl, semgnrc, semstmts, semexprs
 
 proc addCodeForGenerics(c: PContext, n: PNode) =
diff --git a/compiler/semexprs.nim b/compiler/semexprs.nim
index e73f9bcd0fca..bdd1cf70baef 100644
--- a/compiler/semexprs.nim
+++ b/compiler/semexprs.nim
@@ -2387,7 +2387,7 @@ proc semMagic(c: PContext, n: PNode, s: PSym, flags: TExprFlags): PNode =
       var asgnExpr = newTree(nkObjConstr, newNodeIT(nkType, result[^1].info, typ))
       asgnExpr.typ = typ
       var hasDefault: bool
-      asgnExpr.sons.add defaultFieldsForTheUninitialized(c.graph, typ.skipTypes({tyGenericInst, tyAlias, tySink}).n, hasDefault)
+      asgnExpr.sons.add defaultFieldsForTheUninitialized(c, typ.skipTypes({tyGenericInst, tyAlias, tySink}).n, hasDefault)
       if hasDefault:
         result = semObjConstr(c, asgnExpr, flags)
   else:
diff --git a/compiler/semmagic.nim b/compiler/semmagic.nim
index cb630edb0009..af105e33852f 100644
--- a/compiler/semmagic.nim
+++ b/compiler/semmagic.nim
@@ -456,95 +456,6 @@ proc semPrivateAccess(c: PContext, n: PNode): PNode =
   c.currentScope.allowPrivateAccess.add t.sym
   result = newNodeIT(nkEmpty, n.info, getSysType(c.graph, n.info, tyVoid))
 
-
-# import nimsets
-
-
-
-# proc caseBranchMatchesExpr2(branch, matched: PNode): bool =
-#   for i in 0 ..< branch.len-1:
-#     if branch[i].kind == nkRange:
-#       if overlap(branch[i], matched): return true
-#     elif exprStructuralEquivalent(branch[i], matched):
-#       return true
-
-# proc pickCaseBranch2(caseExpr, matched: PNode): int =
-#   let endsWithElse = caseExpr[^1].kind == nkElse
-#   for i in 1..<caseExpr.len - endsWithElse.int:
-#     if caseExpr[i].caseBranchMatchesExpr2(matched):
-#       return i
-#   if endsWithElse:
-#     return caseExpr.len - 1
-
-# proc defaultFieldsForTheUninitialized2*(c: PContext, recNode: PNode, hasDefault: var bool): seq[PNode] =
-#   case recNode.kind
-#   of nkRecList:
-#     for field in recNode:
-#       result.add defaultFieldsForTheUninitialized2(c, field, hasDefault)
-#   of nkRecCase:
-#     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.pickCaseBranch2 newIntNode(nkIntLit#[c.graph]#, 0)
-#     else: # Try to use default value
-#       selectedBranch = recNode.pickCaseBranch2 defaultValue
-#       result.add newTree(nkExprColonExpr, discriminator, defaultValue)
-#     result.add defaultFieldsForTheUninitialized2(c, recNode[selectedBranch][^1], hasDefault)
-#   of nkSym:
-#     let field = recNode.sym
-#     let recType = recNode.typ.skipTypes({tyGenericInst, tyAlias, tySink})
-#     if field.ast != nil: #Try to use default value
-#       result.add newTree(nkExprColonExpr, recNode, field.ast)
-#       hasDefault = true
-#     elif recType.kind == tyObject:
-#       var asgnExpr = newTree(nkObjConstr, newNodeIT(nkType, recNode.info, recNode.typ))
-#       asgnExpr.typ = recNode.typ
-#       asgnExpr.flags.incl nfUseDefaultField
-#       asgnExpr.sons.add defaultFieldsForTheUninitialized2(c, recType.n, hasDefault)
-#       result.add newTree(nkExprColonExpr, recNode, asgnExpr)
-#     elif recType.kind == tyArray and recType[1].skipTypes({tyGenericInst, tyAlias, tySink}).kind == tyObject:
-#       let defaults = defaultFieldsForTheUninitialized2(c, recType[1].skipTypes({tyGenericInst, tyAlias, tySink}).n, hasDefault)
-#       var objExpr = newTree(nkObjConstr, newNodeIT(nkType, recNode.info, recType[1]))
-#       objExpr.typ = recType[1].skipTypes({tyGenericInst, tyAlias, tySink})
-#       objExpr.sons.add defaults # todo create clean?
-
-#       let node = newNode(nkIntLit)
-#       node.intVal = toInt(lengthOrd(c.graph.config, recType))
-#       var asgnExpr = newTree(nkCall, newSymNode(getSysSym(c.graph, recNode.info, "newDefaultArray"), recNode.info),
-#       # var asgnExpr = newTree(nkCall, newSymNode(getCompilerProc(c.graph, "newDefaultArray")),
-#               node,
-#               objExpr
-#               )
-#       asgnExpr.typ = recNode.typ
-#       asgnExpr.flags.incl nfUseDefaultField
-
-#       # asgnExpr.sons.setLen(toInt(lengthOrd(c, recType)))
-#       # for i in 0..<asgnExpr.sons.len:
-#       #   asgnExpr[i] = objExpr
-#       let asgnExpr2 = semExprWithType(c, asgnExpr)
-#       result.add newTree(nkExprColonExpr, recNode, asgnExpr2)
-
-#     elif recType.kind == tyTuple:
-#       # doAssert false
-#       discard
-#     elif recType.kind in {tyInt..tyInt64, tyUInt..tyUInt64}:
-#       let asgnExpr = newIntTypeNode(int64(0), recType)
-#       asgnExpr.flags.incl nfUseDefaultField
-#       result.add newTree(nkExprColonExpr, recNode,
-#               asgnExpr)
-#     elif recType.kind in tyFloat..tyFloat64:
-#       let asgnExpr = newFloatTypeNode(BiggestFloat(0.0), recType)
-#       asgnExpr.flags.incl nfUseDefaultField
-#       result.add newTree(nkExprColonExpr, recNode,
-#               asgnExpr)
-
-#   else:
-#     assert false
-
 proc magicsAfterOverloadResolution(c: PContext, n: PNode,
                                    flags: TExprFlags): PNode =
   ## This is the preferred code point to implement magics.
@@ -612,7 +523,7 @@ proc magicsAfterOverloadResolution(c: PContext, n: PNode,
       var hasDefault: bool
       var t = typ.skipTypes({tyGenericInst, tyAlias, tySink})[0]
       while true:
-        asgnExpr.sons.add defaultFieldsForTheUninitialized(c.graph, t.n, hasDefault)
+        asgnExpr.sons.add defaultFieldsForTheUninitialized(c, t.n, hasDefault)
         let base = t[0]
         if base == nil:
           break
diff --git a/compiler/semobjconstr.nim b/compiler/semobjconstr.nim
index 88260962bd29..c518c1134522 100644
--- a/compiler/semobjconstr.nim
+++ b/compiler/semobjconstr.nim
@@ -91,15 +91,6 @@ proc semConstrField(c: PContext, flags: TExprFlags,
     assignment.flags.incl nfSem
     return initValue
 
-proc caseBranchMatchesExpr(branch, matched: PNode): bool =
-  for i in 0..<branch.len-1:
-    if branch[i].kind == nkRange:
-      if overlap(branch[i], matched): return true
-    elif exprStructuralEquivalent(branch[i], matched):
-      return true
-
-  return false
-
 proc branchVals(c: PContext, caseNode: PNode, caseIdx: int,
                 isStmtBranch: bool): IntSet =
   if caseNode[caseIdx].kind == nkOfBranch:
diff --git a/compiler/semstmts.nim b/compiler/semstmts.nim
index 2f7a6374db61..3a6fc9dec0ed 100644
--- a/compiler/semstmts.nim
+++ b/compiler/semstmts.nim
@@ -600,7 +600,7 @@ proc semVarOrLet(c: PContext, n: PNode, symkind: TSymKind): PNode =
       # if {sfThread, sfNoInit} * v.flags != {}: # todo var m1, m2 {threadvar}
       #   discard # todo init threadvar properly
       # else:
-      let field = defaultNodeField(c.graph, a[^2])
+      let field = defaultNodeField(c, a[^2])
       if field != nil:
         a[^1] = field
     if a[^1].kind != nkEmpty:
diff --git a/compiler/transf.nim b/compiler/transf.nim
index b53d897c2570..b44c45a6b659 100644
--- a/compiler/transf.nim
+++ b/compiler/transf.nim
@@ -927,141 +927,6 @@ proc commonOptimizations*(g: ModuleGraph; idgen: IdGenerator; c: PSym, n: PNode)
     else:
       result = n
 
-import nimsets
-
-proc caseBranchMatchesExpr(branch, matched: PNode): bool =
-  for i in 0 ..< branch.len-1:
-    if branch[i].kind == nkRange:
-      if overlap(branch[i], matched): return true
-    elif exprStructuralEquivalent(branch[i], matched):
-      return true
-
-proc pickCaseBranch(caseExpr, matched: PNode): int =
-  let endsWithElse = caseExpr[^1].kind == nkElse
-  for i in 1..<caseExpr.len - endsWithElse.int:
-    if caseExpr[i].caseBranchMatchesExpr(matched):
-      return i
-  if endsWithElse:
-    return caseExpr.len - 1
-
-proc defaultFieldsForTheUninitialized*(graph: ModuleGraph, recNode: PNode, hasDefault: var bool): seq[PNode] =
-  case recNode.kind
-  of nkRecList:
-    for field in recNode:
-      result.add defaultFieldsForTheUninitialized(graph, field, hasDefault)
-  of nkRecCase:
-    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(graph, recNode[selectedBranch][^1], hasDefault)
-  of nkSym:
-    let field = recNode.sym
-    let recType = recNode.typ.skipTypes({tyGenericInst, tyAlias, tySink})
-    if field.ast != nil: #Try to use default value
-      result.add newTree(nkExprColonExpr, recNode, field.ast)
-      hasDefault = true
-    elif recType.kind == tyObject:
-      var asgnExpr = newTree(nkObjConstr, newNodeIT(nkType, recNode.info, recNode.typ))
-      asgnExpr.typ = recNode.typ
-      asgnExpr.flags.incl nfUseDefaultField
-      asgnExpr.sons.add defaultFieldsForTheUninitialized(graph, recType.n, hasDefault)
-      result.add newTree(nkExprColonExpr, recNode, asgnExpr)
-    elif recType.kind == tyArray and recType[1].skipTypes({tyGenericInst, tyAlias, tySink}).kind == tyObject:
-      var asgnExpr = newNodeI(nkBracket, recNode.info)
-      asgnExpr.typ = recNode.typ
-      asgnExpr.flags.incl nfUseDefaultField
-      let defaults = defaultFieldsForTheUninitialized(graph, recType[1].skipTypes({tyGenericInst, tyAlias, tySink}).n, hasDefault)
-      var objExpr = newTree(nkObjConstr, newNodeIT(nkType, recNode.info, recType[1]))
-      objExpr.typ = recType[1].skipTypes({tyGenericInst, tyAlias, tySink})
-      objExpr.sons.add defaults # todo create clean?
-
-      # let node = newNode(nkIntLit)
-      # node.intVal = toInt(lengthOrd(graph.config, recType))
-      # let syms = getCompilerProc(graph, "newDefaultArray")
-      # # debug syms
-      # # debug syms.typ
-      # var asgnExpr = newTree(nkCall, newSymNode(getCompilerProc(graph, "newDefaultArray")),
-      #         node,
-      #         objExpr
-      #         )
-      # asgnExpr.typ = recNode.typ
-      # asgnExpr.flags.incl nfUseDefaultField
-
-      asgnExpr.sons.setLen(toInt(lengthOrd(graph.config, recType)))
-      for i in 0..<asgnExpr.sons.len:
-        asgnExpr[i] = objExpr
-      result.add newTree(nkExprColonExpr, recNode,
-        asgnExpr)
-    elif recType.kind == tyTuple:
-      # doAssert false
-      discard
-    elif recType.kind in {tyInt..tyInt64, tyUInt..tyUInt64}:
-      let asgnExpr = newIntTypeNode(int64(0), recType)
-      asgnExpr.flags.incl nfUseDefaultField
-      result.add newTree(nkExprColonExpr, recNode,
-              asgnExpr)
-    elif recType.kind in tyFloat..tyFloat64:
-      let asgnExpr = newFloatTypeNode(BiggestFloat(0.0), recType)
-      asgnExpr.flags.incl nfUseDefaultField
-      result.add newTree(nkExprColonExpr, recNode,
-              asgnExpr)
-
-  else:
-    assert false
-
-proc defaultNodeField*(graph: ModuleGraph, a: PNode): PNode =
-  let aTyp = a.typ
-  var hasDefault: bool
-  if aTyp.skipTypes({tyGenericInst, tyAlias, tySink}).kind == tyObject:
-    var asgnExpr = newTree(nkObjConstr, newNodeIT(nkType, a.info, aTyp))
-    asgnExpr.typ = aTyp
-    asgnExpr.sons.add defaultFieldsForTheUninitialized(graph, aTyp.skipTypes({tyGenericInst, tyAlias, tySink}).n, hasDefault)
-    if hasDefault:
-      result = asgnExpr
-  elif aTyp.kind == tyArray and aTyp[1].skipTypes({tyGenericInst, tyAlias, tySink}).kind == tyObject:
-    var asgnExpr = newNodeI(nkBracket, a.info)
-    asgnExpr.typ = aTyp
-    let defaults = defaultFieldsForTheUninitialized(graph, aTyp[1].skipTypes({tyGenericInst, tyAlias, tySink}).n, hasDefault)
-    for i in 0..<toInt(lengthOrd(graph.config, aTyp)):
-      var objExpr = newTree(nkObjConstr, newNodeIT(nkType, a.info, aTyp[1]))
-      objExpr.typ = aTyp[1]
-      objExpr.sons.add defaults # todo create clean?
-      asgnExpr.add objExpr
-    if hasDefault:
-      result = asgnExpr
-  elif aTyp.kind == tyTuple:
-    var tupleExpr = newNodeI(nkTupleConstr, a.info)
-    tupleExpr.typ = aTyp
-    for s in aTyp.sons:
-      let sType = s.skipTypes({tyGenericInst, tyAlias, tySink})
-      if sType.kind == tyObject:
-        var asgnExpr = newTree(nkObjConstr, newNodeIT(nkType, a.info, s))
-        asgnExpr.typ = s
-        asgnExpr.sons.add defaultFieldsForTheUninitialized(graph, sType.n, hasDefault)
-        tupleExpr.add asgnExpr
-      elif sType.kind in {tyInt..tyInt64, tyUInt..tyUInt64}:
-        let asgnExpr = newIntTypeNode(int64(0), sType)
-        asgnExpr.flags.incl nfUseDefaultField
-        tupleExpr.add asgnExpr
-      elif sType.kind in tyFloat..tyFloat64:
-        let asgnExpr =
-          if sType.kind == tyFloat32:
-            newFloatNode(nkFloat32Lit, BiggestFloat(0.0))
-          else:
-            newFloatNode(nkFloatLit, BiggestFloat(0.0))
-        asgnExpr.flags.incl nfUseDefaultField
-        tupleExpr.add asgnExpr
-    if hasDefault:
-      result = tupleExpr
-
 proc transform(c: PTransf, n: PNode): PNode =
   when false:
     var oldDeferAnchor: PNode
@@ -1071,19 +936,19 @@ proc transform(c: PTransf, n: PNode): PNode =
       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 c.genResult:
+  #   c.genResult = false
+  #   result = newNodeIT(nkStmtList, n.info, nil)
+  #   let toInit = c.getCurrOwner().ast[resultPos]
 
-    if toInit.typ != nil:
-      let field = defaultNodeField(c.graph, toInit)
+  #   if toInit.typ != nil:
+  #     let field = defaultNodeField(c.graph, toInit)
 
-      if field != nil:
-        result.add newTree(nkAsgn, toInit, field)
+  #     if field != nil:
+  #       result.add newTree(nkAsgn, toInit, field)
 
-    result.add transform(c, n)
-    return result
+  #   result.add transform(c, n)
+  #   return result
 
   case n.kind
   of nkSym:
diff --git a/lib/system.nim b/lib/system.nim
index 4080fee06470..bdad8c06d810 100644
--- a/lib/system.nim
+++ b/lib/system.nim
@@ -569,6 +569,11 @@ when notJSnotNims and not defined(nimSeqsV2):
   template space(s: PGenericSeq): int {.dirty.} =
     s.reserved and not (seqShallowFlag or strlitFlag)
 
+
+proc newDefaultArray*[T](N: static int, y: T): array[N, T] =
+  for i in 0..N-1:
+    result[i] = y
+
 when notJSnotNims:
   include "system/hti"
 
diff --git a/tests/objects/tobject_default_value.nim b/tests/objects/tobject_default_value.nim
index 2a71a4c19817..82e1275edacd 100644
--- a/tests/objects/tobject_default_value.nim
+++ b/tests/objects/tobject_default_value.nim
@@ -1,6 +1,6 @@
 discard """
   matrix: "-d:nimRangeDefault"
-  targets: "c js"
+  targets: "c cpp js"
 """
 
 import times
@@ -128,14 +128,14 @@ block: # array
   var x {.noinit.}: array[10, Object]
   discard x
 
-block: # tuple
-  var x: ObjectTuple
-  doAssert x.base.value == 12
-  doAssert x.typ == 0
-  doAssert x.obj.time == 1.2
-  doAssert x.obj.date == 0
-  doAssert x.obj.scale == 1
-  doAssert x.obj.value == 12
+# block: # tuple
+#   var x: ObjectTuple
+#   doAssert x.base.value == 12
+#   doAssert x.typ == 0
+#   doAssert x.obj.time == 1.2
+#   doAssert x.obj.date == 0
+#   doAssert x.obj.scale == 1
+#   doAssert x.obj.value == 12
 
 type
   ObjectArray = object