fresh start

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
+    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)

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

@@ -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)
 

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}:

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,17 +186,17 @@ 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)
           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 +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

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: