diff --git a/compiler/parser.nim b/compiler/parser.nim
index 15f2187eda3c3..35beb982181f5 100644
--- a/compiler/parser.nim
+++ b/compiler/parser.nim
@@ -1898,11 +1898,7 @@ proc parseObjectCase(p: var TParser): 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/semobjconstr.nim b/compiler/semobjconstr.nim
index 0ddec1706b050..d07300f501c34 100644
--- a/compiler/semobjconstr.nim
+++ b/compiler/semobjconstr.nim
@@ -75,17 +75,7 @@ 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 =
+proc branchVals(c: PContext, caseNode: PNode, caseIdx: int): IntSet =
   if caseNode[caseIdx].kind == nkOfBranch:
     result = initIntSet()
     for val in processBranchVals(caseNode[caseIdx]):
@@ -104,15 +94,33 @@ proc findUsefulCaseContext(c: PContext, discrimator: PNode): (PNode, int) =
     if skipped.kind == nkSym and skipped.sym == discrimator.sym:
       return (caseNode, index)
 
-proc pickCaseBranch(caseExpr, matched: PNode): PNode =
-  # XXX: Perhaps this proc already exists somewhere
+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 - int(endsWithElse):
     if caseExpr[i].caseBranchMatchesExpr(matched):
-      return caseExpr[i]
-
+      return i
   if endsWithElse:
-    return caseExpr[^1]
+    return caseExpr.len - 1
+
+proc pickCaseBranches(caseExpr: PNode, c: PContext, possibleValues: IntSet): seq[int] =
+  let endsWithElse = caseExpr[^1].kind == nkElse
+  var remaining = possibleValues
+  for i in 1 ..< caseExpr.len - int(endsWithElse):
+    let b = branchVals(c, caseExpr, i)
+    if len(remaining * b) != 0:
+      result.add i
+    else:
+      discard "Nothing to do, lets see if the next one matches"
+    remaining = remaining - b
+  if (remaining.len != 0) and endsWithElse: #and result.len == 0:
+    result.add caseExpr.len - 1
 
 iterator directFieldsInRecList(recList: PNode): PNode =
   # XXX: We can remove this case by making all nkOfBranch nodes
@@ -126,206 +134,126 @@ iterator directFieldsInRecList(recList: PNode): PNode =
       if field.kind != nkSym: continue
       yield field
 
-template quoteStr(s: string): string = "'" & s & "'"
-
 proc fieldsPresentInInitExpr(c: PContext, fieldsRecList, initExpr: PNode): string =
   result = ""
   for field in directFieldsInRecList(fieldsRecList):
     let assignment = locateFieldInInitExpr(c, field.sym, initExpr)
     if assignment != nil:
       if result.len != 0: result.add ", "
-      result.add field.sym.name.s.quoteStr
+      result.add "'" & field.sym.name.s & "'"
 
-proc missingMandatoryFields(c: PContext, fieldsRecList, initExpr: PNode): string =
-  for r in directFieldsInRecList(fieldsRecList):
+proc checkForMissingFields(c: PContext, recList, initExpr: PNode, considerDefaults: bool) =
+  var missing: string
+  for r in directFieldsInRecList(recList):
     if {tfNotNil, tfNeedsInit} * r.sym.typ.flags != {}:
       let assignment = locateFieldInInitExpr(c, r.sym, initExpr)
-      if assignment == nil:
-        if result.len == 0:
-          result = r.sym.name.s
+      if assignment == nil and not(considerDefaults and r.sym.ast != nil):
+        if missing.len == 0:
+          missing = r.sym.name.s
         else:
-          result.add ", "
-          result.add r.sym.name.s
-
-proc checkForMissingFields(c: PContext, recList, initExpr: PNode) =
-  let missing = missingMandatoryFields(c, recList, initExpr)
+          missing.add ", "
+          missing.add r.sym.name.s
   if missing.len > 0:
     localError(c.config, initExpr.info, "fields not initialized: $1.", [missing])
 
-proc semConstructFields(c: PContext, recNode: PNode,
-                        initExpr: PNode, flags: TExprFlags): InitStatus =
-  result = initUnknown
-
+proc checkForNoExplicitlyDefinedFields(c: PContext, recList, initExpr: PNode) =
+  var existing: string
+  for r in directFieldsInRecList(recList):
+    let assignment = locateFieldInInitExpr(c, r.sym, initExpr)
+    if assignment != nil:
+      if existing.len == 0:
+        existing = r.sym.name.s
+      else:
+        existing.add ", "
+        existing.add r.sym.name.s
+  if existing.len > 0:
+    localError(c.config, initExpr.info, "runtime discriminator could select " &
+               "multiple branches, so you can't initialize these fields: $1", [existing])
+
+proc semConstructFields(c: PContext, recNode, initExpr: PNode,
+                        flags: TExprFlags): tuple[status: InitStatus, defaults: seq[PNode]] =
   case recNode.kind
   of nkRecList:
     for field in recNode:
-      let status = semConstructFields(c, field, initExpr, flags)
-      mergeInitStatus(result, status)
-
+      let (subSt, subDf) = semConstructFields(c, field, initExpr, flags)
+      result.status.mergeInitStatus subSt
+      result.defaults.add subDf
   of nkRecCase:
-    template fieldsPresentInBranch(branchIdx: int): string =
-      let branch = recNode[branchIdx]
-      let fields = branch[^1]
-      fieldsPresentInInitExpr(c, fields, initExpr)
-
-    template checkMissingFields(branchNode: PNode) =
-      if branchNode != nil:
-        let fields = branchNode[^1]
-        checkForMissingFields(c, fields, initExpr)
-
+    internalAssert c.config, recNode[0].kind == nkSym
     let discriminator = recNode[0]
-    internalAssert c.config, discriminator.kind == nkSym
-    var selectedBranch = -1
-
-    for i in 1..<recNode.len:
-      let innerRecords = recNode[i][^1]
-      let status = semConstructFields(c, innerRecords, initExpr, flags)
-      if status notin {initNone, initUnknown}:
-        mergeInitStatus(result, status)
-        if selectedBranch != -1:
-          let prevFields = fieldsPresentInBranch(selectedBranch)
-          let currentFields = fieldsPresentInBranch(i)
-          localError(c.config, 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
-        else:
-          selectedBranch = i
-
-    if selectedBranch != -1:
-      template badDiscriminatorError =
-        let fields = fieldsPresentInBranch(selectedBranch)
-        localError(c.config, initExpr.info,
-          ("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)
-
-      template wrongBranchError(i) =
-        let fields = fieldsPresentInBranch(i)
-        localError(c.config, initExpr.info,
-          "a case selecting discriminator '$1' with value '$2' " &
-          "appears in the object construction, but the field(s) $3 " &
-          "are in conflict with this value.",
-          [discriminator.sym.name.s, discriminatorVal.renderTree, fields])
-
-      template valuesInConflictError(valsDiff) =
-        localError(c.config, discriminatorVal.info, ("possible values " &
-          "$2 are in conflict with discriminator values for " &
-          "selected object branch $1.") % [$selectedBranch,
-          valsDiff.renderAsType(recNode[0].typ)])
-
-      let branchNode = recNode[selectedBranch]
-      let flags = flags*{efAllowDestructor} + {efPreferStatic,
-                                               efPreferNilResult}
-      var discriminatorVal = semConstrField(c, flags,
-                                            discriminator.sym, initExpr)
-      if discriminatorVal != nil:
-        discriminatorVal = discriminatorVal.skipHidden
-        if discriminatorVal.kind notin nkLiterals and (
-            not isOrdinalType(discriminatorVal.typ, true) or
-            lengthOrd(c.config, discriminatorVal.typ) > MaxSetElements or
-            lengthOrd(c.config, recNode[0].typ) > MaxSetElements):
-          localError(c.config, discriminatorVal.info,
-            "branch initialization with a runtime discriminator only " &
-            "supports ordinal types with 2^16 elements or less.")
-
-      if discriminatorVal == nil:
-        badDiscriminatorError()
-      elif discriminatorVal.kind == nkSym:
-        let (ctorCase, ctorIdx) = findUsefulCaseContext(c, discriminatorVal)
-        if ctorCase == nil:
-          if discriminatorVal.typ.kind == tyRange:
-            let rangeVals = c.getIntSetOfType(discriminatorVal.typ)
-            let recBranchVals = branchVals(c, recNode, selectedBranch, false)
-            let diff = rangeVals - recBranchVals
-            if diff.len != 0:
-              valuesInConflictError(diff)
-          else:
-            badDiscriminatorError()
-        elif discriminatorVal.sym.kind notin {skLet, skParam} or
-            discriminatorVal.sym.typ.kind == tyVar:
-          localError(c.config, discriminatorVal.info,
-            "runtime discriminator must be immutable if branch fields are " &
-            "initialized, a 'let' binding is required.")
-        elif ctorCase[ctorIdx].kind == nkElifBranch:
-          localError(c.config, discriminatorVal.info, "branch initialization " &
-            "with a runtime discriminator is not supported inside of an " &
-            "`elif` branch.")
-        else:
-          var
-            ctorBranchVals = branchVals(c, ctorCase, ctorIdx, true)
-            recBranchVals = branchVals(c, recNode, selectedBranch, false)
-            branchValsDiff = ctorBranchVals - recBranchVals
-          if branchValsDiff.len != 0:
-            valuesInConflictError(branchValsDiff)
+    var discriminatorVal = semConstrField(c, flags + {efPreferStatic}, discriminator.sym, initExpr)
+    let defaultValue = discriminator.sym.ast
+    var selectedBranches: seq[int]
+
+    if discriminatorVal == nil:
+      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:
+        selectedBranches = @[recNode.pickCaseBranch newIntLit(c.graph, initExpr.info, 0)]
       else:
-        var failedBranch = -1
-        if branchNode.kind != nkElse:
-          if not branchNode.caseBranchMatchesExpr(discriminatorVal):
-            failedBranch = selectedBranch
-        else:
-          # With an else clause, check that all other branches don't match:
-          for i in 1..<recNode.len - 1:
-            if recNode[i].caseBranchMatchesExpr(discriminatorVal):
-              failedBranch = i
-              break
-        if failedBranch != -1:
-          if discriminatorVal.typ.kind == tyRange:
-            let rangeVals = c.getIntSetOfType(discriminatorVal.typ)
-            let recBranchVals = branchVals(c, recNode, selectedBranch, false)
-            let diff = rangeVals - recBranchVals
-            if diff.len != 0:
-              valuesInConflictError(diff)
-          else:
-            wrongBranchError(failedBranch)
-
-      # 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:
-        checkMissingFields branchNode
-
+        # Try to use default value
+        discriminatorVal = defaultValue
+        selectedBranches = @[recNode.pickCaseBranch defaultValue]
+        result.defaults.add newTree(nkExprColonExpr, discriminator, discriminatorVal)
     else:
-      result = initNone
-      let discriminatorVal = semConstrField(c, flags + {efPreferStatic},
-                                            discriminator.sym, initExpr)
-      if discriminatorVal == 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:
-        let matchedBranch = recNode.pickCaseBranch newIntLit(c.graph, initExpr.info, 0)
-        checkMissingFields matchedBranch
+      discriminatorVal = discriminatorVal.skipHidden
+      if discriminatorVal.kind == nkIntLit:
+        # Discriminator is a compile-time value, we know which branch will be selected
+        selectedBranches = @[recNode.pickCaseBranch discriminatorVal]
+        assert selectedBranches[0] != 0 #TODO: Proper error 
       else:
-        result = initPartial
-        if discriminatorVal.kind == nkIntLit:
-          # When the discriminator is a compile-time value, we also know
-          # which branch will be selected:
-          let matchedBranch = recNode.pickCaseBranch discriminatorVal
-          if matchedBranch != nil: checkMissingFields matchedBranch
-        else:
-          # All bets are off. If any of the branches has a mandatory
-          # fields we must produce an error:
-          for i in 1..<recNode.len: checkMissingFields recNode[i]
-
+        if lengthOrd(c.config, discriminatorVal.typ) > BiggestInt(MaxSetElements):
+          localError(c.config, discriminatorVal.info, "branch initialization with a runtime " &
+                     "discriminator only supports ordinal types with 2^16 elements or less.")
+        var possibleValues = c.getIntSetOfType(discriminatorVal.typ)
+        let (ctorCase, ctorIdx) = findUsefulCaseContext(c, discriminatorVal)
+        if ctorCase != nil and discriminatorVal.sym.kind in {skLet, skParam} and discriminatorVal.sym.typ.kind != tyVar:
+          possibleValues = possibleValues * branchVals(c, ctorCase, ctorIdx)
+        selectedBranches = recNode.pickCaseBranches(c, possibleValues)
+
+    assert selectedBranches.len != 0 #XXX: Proper error, does this even occur?
+    if selectedBranches.len == 1:
+      let branch = recNode[selectedBranches[0]]
+      #error for fields which require initialization and don't have a default
+      checkForMissingFields(c, branch[^1], initExpr, considerDefaults = true)
+      let (subSt, subDf) = semConstructFields(c, branch[^1], initExpr, flags)
+      result.status.mergeInitStatus subSt
+      result.defaults.add subDf
+    else:
+      for i in selectedBranches:
+        assert i != 0
+        let branch = recNode[i]
+        if branch != nil:
+          checkForNoExplicitlyDefinedFields(c, branch[^1], initExpr)
+          #error for fields which require initialization no matter wether they have a default or not
+          checkForMissingFields(c, branch[^1], initExpr, considerDefaults = false)
+          discard semConstructFields(c, branch[^1], initExpr, flags)
+          #TODO: error/warn for fields which don't require initialization but have a default
+          #if subDf.len > 0: warn "Will not initalize branch fields to their default value"
+      result.status = initNone
   of nkSym:
     let field = recNode.sym
     let e = semConstrField(c, flags, field, 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, recNode, field.ast)
+    else:
+      result.status = initNone
   else:
     internalAssert c.config, false
 
 proc semConstructType(c: PContext, initExpr: PNode,
-                      t: PType, flags: TExprFlags): InitStatus =
+                      t: PType, flags: TExprFlags): tuple[status: InitStatus, defaults: seq[PNode]] =
   var t = t
-  result = initUnknown
   while true:
-    let status = semConstructFields(c, t.n, initExpr, flags)
-    mergeInitStatus(result, status)
+    let (status, defaults) = semConstructFields(c, t.n, initExpr, flags)
+    result.status.mergeInitStatus status
+    result.defaults.add defaults
     if status in {initPartial, initNone, initUnknown}:
-      checkForMissingFields c, t.n, initExpr
+      checkForMissingFields c, t.n, initExpr, true
     let base = t[0]
     if base == nil: break
     t = skipTypes(base, skipPtrs)
@@ -333,7 +261,9 @@ proc semConstructType(c: PContext, initExpr: PNode,
 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:
     localError(c.config, n.info, errGenerated, "object constructor needs an object type")
@@ -354,7 +284,9 @@ proc semObjConstr(c: PContext, n: PNode, flags: TExprFlags): PNode =
   # Check if the object is fully initialized by recursively testing each
   # field (if this is a case object, initialized fields in two different
   # branches will be reported as an error):
-  let initResult = semConstructType(c, result, t, flags)
+  let (initResult, defaults) = semConstructType(c, result, t, flags)
+
+  result[0].sons.add defaults
 
   # It's possible that the object was not fully initialized while
   # specifying a .requiresInit. pragma.
diff --git a/compiler/semtypes.nim b/compiler/semtypes.nim
index cb6cb04f7bc8c..69e89c7fb769f 100644
--- a/compiler/semtypes.nim
+++ b/compiler/semtypes.nim
@@ -596,7 +596,7 @@ proc getIntSetOfType(c: PContext, t: PType): IntSet =
   result = initIntSet()
   if t.enumHasHoles:
     let t = t.skipTypes(abstractRange)
-    for field in t.n.sons:
+    for field in t.n:
       result.incl(field.sym.position)
   else:
     assert(lengthOrd(c.config, t) <= BiggestInt(MaxSetElements))
@@ -607,7 +607,7 @@ iterator processBranchVals(b: PNode): int =
   assert b.kind in {nkOfBranch, nkElifBranch, nkElse}
   if b.kind == nkOfBranch:
     for i in 0..<b.len-1:
-      if b[i].kind == nkIntLit:
+      if b[i].kind in {nkIntLit..nkUInt64Lit}:
         yield b[i].intVal.int
       elif b[i].kind == nkRange:
         for i in b[i][0].intVal..b[i][1].intVal:
@@ -742,11 +742,6 @@ proc semRecordNodeAux(c: PContext, n: PNode, check: var IntSet, pos: var int,
     if a != father: father.add a
   of nkIdentDefs:
     checkMinSonsLen(n, 3, c.config)
-    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:
       localError(c.config, n.info, errTypeExpected)
@@ -754,6 +749,8 @@ proc semRecordNodeAux(c: PContext, n: PNode, check: var IntSet, pos: var int,
     else:
       typ = semTypeNode(c, n[^2], nil)
       propagateToOwner(rectype, typ)
+    var a: PNode = if father.kind != nkRecList and n.len > 3: newNodeI(nkRecList, n.info)
+                   else: newNodeI(nkEmpty, n.info)
     var fieldOwner = if c.inGenericContext > 0: c.getCurrOwner
                      else: rectype.sym
     for i in 0..<n.len-2:
@@ -774,6 +771,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 & "'")
+      var fSym = newSymNode(f)
+      if n[^1].kind != nkEmpty:
+        n[^1] = semConstExpr(c, n[^1])
+        fSym.sym.ast = n[^1]
+      elif typ.kind in {tyRange, tyOrdinal}: #Node flag? Handle embedded objects?
+        fSym.sym.ast = semConstExpr(c, newIntNode(nkIntLit, firstOrd(c.config, typ)))
       if a.kind == nkEmpty: father.add newSymNode(f)
       else: a.add newSymNode(f)
       styleCheckDef(c.config, f)
diff --git a/compiler/transf.nim b/compiler/transf.nim
index 68ef464c4f23d..111f40c474a3e 100644
--- a/compiler/transf.nim
+++ b/compiler/transf.nim
@@ -17,6 +17,7 @@
 # * introduces method dispatchers
 # * performs lambda lifting for closure support
 # * transforms 'defer' into a 'try finally' statement
+# * generates default field values for objects and transforms object contructors
 
 import
   options, ast, astalgo, trees, msgs,
@@ -44,7 +45,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          # XXX
     contSyms, breakSyms: seq[PSym]  # to transform 'continue' and 'break'
     deferDetected, tooEarly: bool
     graph: ModuleGraph
@@ -383,7 +384,7 @@ proc transformYield(c: PTransf, n: PNode): PNode =
       let rhs = transform(c, e)
       result.add(asgnTo(lhs, rhs))
 
-  inc(c.transCon.yieldStmts)
+  inc c.transCon.yieldStmts
   if c.transCon.yieldStmts <= 1:
     # common case
     result.add(c.transCon.forLoopBody)
@@ -658,7 +659,7 @@ proc transformFor(c: PTransf, n: PNode): PNode =
 
   let body = transformBody(c.graph, iter, true)
   pushInfoContext(c.graph.config, n.info)
-  inc(c.inlining)
+  inc c.inlining
   stmtList.add(transform(c, body))
   #findWrongOwners(c, stmtList.pnode)
   dec(c.inlining)
@@ -743,13 +744,13 @@ proc transformCall(c: PTransf, n: PNode): PNode =
     var j = 1
     while j < n.len:
       var a = transform(c, n[j])
-      inc(j)
+      inc j
       if isConstExpr(a):
         while (j < n.len):
           let b = transform(c, n[j])
           if not isConstExpr(b): break
           a = evalOp(op.magic, n, a, b, nil, c.graph)
-          inc(j)
+          inc j
       result.add(a)
     if result.len == 2: result = result[1]
   elif magic == mAddr:
@@ -828,13 +829,13 @@ proc commonOptimizations*(g: ModuleGraph; c: PSym, n: PNode): PNode =
     var j = 0
     while j < args.len:
       var a = args[j]
-      inc(j)
+      inc j
       if isConstExpr(a):
         while j < args.len:
           let b = args[j]
           if not isConstExpr(b): break
           a = evalOp(op.magic, result, a, b, nil, g)
-          inc(j)
+          inc j
       result.add(a)
     if result.len == 2: result = result[1]
   else:
@@ -882,6 +883,47 @@ proc hoistParamsUsedInDefault(c: PTransf, call, letSection, defExpr: PNode): PNo
       let hoisted = hoistParamsUsedInDefault(c, call, letSection, defExpr[i])
       if hoisted != nil: defExpr[i] = hoisted
 
+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(c: PTransf, recNode: PNode): seq[PNode] =
+  case recNode.kind
+  of nkRecList:
+    for field in recNode:
+      result.add defaultFieldsForTheUninitialized(c, field)
+  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(c, 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
@@ -890,6 +932,18 @@ 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.kind == tyObject:
+      var asgnExpr = newTree(nkObjConstr, newNodeIT(nkType, toInit.info, toInit.typ))
+      asgnExpr.typ = toInit.typ
+      #TODO: Once the VM is ready this should be done in injectdestructors so that it can be elided properly
+      asgnExpr.sons.add defaultFieldsForTheUninitialized(c, toInit.typ.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)
@@ -947,17 +1001,26 @@ proc transform(c: PTransf, n: PNode): PNode =
     result.add(newSymNode(labl))
   of nkBreakStmt: result = transformBreak(c, n)
   of nkCallKinds:
-    result = transformCall(c, n)
-    var call = result
-    if nfDefaultRefsParam in call.flags:
-      # We've found a default value that references another param.
-      # See the notes in `hoistParamsUsedInDefault` for more details.
-      var hoistedParams = newNodeI(nkLetSection, call.info, 0)
-      for i in 1..<call.len:
-        let hoisted = hoistParamsUsedInDefault(c, call, hoistedParams, call[i])
-        if hoisted != nil: call[i] = hoisted
-      result = newTree(nkStmtListExpr, hoistedParams, call)
-      result.typ = call.typ
+    # if (n[0].kind == nkSym) and (n[0].sym.magic == mReset) and (n[1].typ.kind == tyObject):
+    #   result = newNodeIT(nkStmtList, n.info, n.typ)
+    #   result.add transformCall(c, n)
+    #   result.add initDefaultFields(n[1], n[1].typ.n)
+    # elif (n[0].kind == nkSym) and (n[0].sym.magic in {mNew, mNewFinalize}) and (n[1].typ.kind == tyRef):
+    #   result = newNodeIT(nkStmtListExpr, n.info, n.typ)
+    #   result.add transformCall(c, n)
+    #   result.add initDefaultFields(n[1], n[1].typ[0].n)
+    # else:
+      result = transformCall(c, n)
+      var call = result
+      if nfDefaultRefsParam in call.flags:
+        # We've found a default value that references another param.
+        # See the notes in `hoistParamsUsedInDefault` for more details.
+        var hoistedParams = newNodeI(nkLetSection, call.info, 0)
+        for i in 1 ..< call.len:
+          let hoisted = hoistParamsUsedInDefault(c, call, hoistedParams, call[i])
+          if hoisted != nil: call[i] = hoisted
+        result = newTree(nkStmtListExpr, hoistedParams, call)
+        result.typ = call.typ
   of nkAddr, nkHiddenAddr:
     result = transformAddrDeref(c, n, nkDerefExpr, nkHiddenDeref)
   of nkDerefExpr, nkHiddenDeref:
@@ -1013,6 +1076,13 @@ proc transform(c: PTransf, n: PNode): PNode =
     return n
   of nkExceptBranch:
     result = transformExceptBranch(c, n)
+  of nkObjConstr:
+    result = n
+    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)
   else:
     result = transformSons(c, n)
   when false:
@@ -1034,6 +1104,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/compiler/vmgen.nim b/compiler/vmgen.nim
index 987fc7864aae6..08cbee714144c 100644
--- a/compiler/vmgen.nim
+++ b/compiler/vmgen.nim
@@ -1639,7 +1639,7 @@ proc genRdVar(c: PCtx; n: PNode; dest: var TDest; flags: TGenFlags) =
   else:
     if s.kind == skForVar and c.mode == emRepl: c.setSlot(s)
     if s.position > 0 or (s.position == 0 and
-                          s.kind in {skParam, skResult}):
+                          s.kind in {skParam, skResult, skTemp}):
       if dest < 0:
         dest = s.position + ord(s.kind == skParam)
         internalAssert(c.config, c.prc.slots[dest].kind < slotSomeTemp)
diff --git a/tests/constructors/tinvalid_construction.nim b/tests/constructors/tinvalid_construction.nim
index b3e56eec6087d..7050298b80a92 100644
--- a/tests/constructors/tinvalid_construction.nim
+++ b/tests/constructors/tinvalid_construction.nim
@@ -65,7 +65,7 @@ accept TObj()
 accept TObj(choice: A)
 reject TObj(choice: A, bc: 10)  # bc is in the wrong branch
 accept TObj(choice: B, bc: 20)
-reject TObj(a: 10)              # branch selected without providing discriminator
+accept TObj(a: 10)              # branch selected with the default value "low(T)" of the discriminator
 reject TObj(choice: x, a: 10)   # the discrimantor must be a compile-time value when a branch is selected
 accept TObj(choice: x)          # it's OK to use run-time value when a branch is not selected
 accept TObj(choice: F, f: "")   # match an else clause
diff --git a/tests/objvariant/trt_discrim.nim b/tests/objvariant/trt_discrim.nim
index 95b2a9f768858..8d4c1defb2f6b 100644
--- a/tests/objvariant/trt_discrim.nim
+++ b/tests/objvariant/trt_discrim.nim
@@ -133,6 +133,12 @@ reject:
 var varkind = k4
 
 reject: # not immutable.
+  case varkind
+  of k1, k2, k3: discard KindObj(kind: varkind, i32: 1)
+  of k4: discard KindObj(kind: varkind, f32: 2.0)
+  else: discard KindObj(kind: varkind, str: "3")
+
+reject: # complete bogus
   case varkind
   of k1, k2, k3: discard KindObj(varkind: kind, i32: 1)
   of k4: discard KindObj(varkind: kind, f32: 2.0)
diff --git a/tests/objvariant/trt_discrim_err0.nim b/tests/objvariant/trt_discrim_err0.nim
index 02b551cbc4218..54e98f5b664b9 100644
--- a/tests/objvariant/trt_discrim_err0.nim
+++ b/tests/objvariant/trt_discrim_err0.nim
@@ -1,5 +1,5 @@
 discard """
-  errormsg: "possible values {k1, k3, k4} are in conflict with discriminator values for selected object branch 3"
+  errormsg: "runtime discriminator could select multiple branches, so you can't initialize these fields: str"
   line: 17
 """
 
diff --git a/tests/objvariant/trt_discrim_err1.nim b/tests/objvariant/trt_discrim_err1.nim
index de29420a2f9ec..82c8b5f9ac493 100644
--- a/tests/objvariant/trt_discrim_err1.nim
+++ b/tests/objvariant/trt_discrim_err1.nim
@@ -1,5 +1,5 @@
 discard """
-  errormsg: "branch initialization with a runtime discriminator is not supported inside of an `elif` branch."
+  errormsg: "runtime discriminator could select multiple branches, so you can't initialize these fields: green"
   line: 16
 """
 type
diff --git a/tests/objvariant/trt_discrim_err3.nim b/tests/objvariant/trt_discrim_err3.nim
index e739c3d508170..055740c46552b 100644
--- a/tests/objvariant/trt_discrim_err3.nim
+++ b/tests/objvariant/trt_discrim_err3.nim
@@ -1,5 +1,5 @@
 discard """
-  errormsg: "runtime discriminator must be immutable if branch fields are initialized, a 'let' binding is required."
+  errormsg: "runtime discriminator could select multiple branches, so you can't initialize these fields: i32"
   line: 16
 """