Halfway through

Author: Clyybber

compiler/semobjconstr.nim

@@ -70,8 +70,8 @@ proc semConstrField(c: PContext, flags: TExprFlags,
     var initValue = semExprFlagDispatched(c, assignment[1], flags)
     if initValue != nil:
       initValue = fitNode(c, field.typ, initValue, assignment.info)
-    assignment.sons[0] = newSymNode(field)
-    assignment.sons[1] = initValue
+    assignment[0] = newSymNode(field)
+    assignment[1] = initValue
     assignment.flags.incl nfSem
     return initValue
 
@@ -88,7 +88,7 @@ proc allPossibleValues(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:
     for i in toInt64(firstOrd(c.config, t)) .. toInt64(lastOrd(c.config, t)):
@@ -100,13 +100,13 @@ proc branchVals(c: PContext, caseNode: PNode, caseIdx: int,
     result = initIntSet()
     processBranchVals(caseNode[caseIdx], incl)
   else:
-    result = allPossibleValues(c, caseNode.sons[0].typ)
+    result = allPossibleValues(c, caseNode[0].typ)
     for i in 1 .. caseNode.len-2:
       processBranchVals(caseNode[i], excl)
 
 proc rangeTypVals(rangeTyp: PType): IntSet =
   assert rangeTyp.kind == tyRange
-  let (a, b) = (rangeTyp.n.sons[0].intVal, rangeTyp.n.sons[1].intVal)
+  let (a, b) = (rangeTyp.n[0].intVal, rangeTyp.n[1].intVal)
   result = initIntSet()
   for it in a .. b:
     result.incl(it.int)
@@ -118,8 +118,8 @@ proc formatUnsafeBranchVals(t: PType, diffVals: IntSet): string =
     if t.kind in {tyEnum, tyBool}:
       var i = 0
       for val in diffVals:
-        while t.n.sons[i].sym.position < val: inc(i)
-        strs.add(t.n.sons[i].sym.name.s)
+        while t.n[i].sym.position < val: inc(i)
+        strs.add(t.n[i].sym.name.s)
     else:
       for val in diffVals:
         strs.add($val)
@@ -194,13 +194,11 @@ proc checkForMissingFields(c: PContext, recList, initExpr: PNode, considerDefaul
     localError(c.config, initExpr.info, "fields not initialized: $1.", [missing])
 
 proc semConstructFields(c: PContext, recNode: PNode,
-                        initExpr: PNode, flags: TExprFlags, wantsInit = true): InitStatus =
-  result = initUnknown
-
+                        initExpr: PNode, flags: TExprFlags): InitStatus =
   case recNode.kind
   of nkRecList:
     for field in recNode:
-      let status = semConstructFields(c, field, initExpr, flags, wantsInit)
+      let status = semConstructFields(c, field, initExpr, flags)
       mergeInitStatus(result, status)
 
   of nkRecCase:
@@ -209,18 +207,18 @@ proc semConstructFields(c: PContext, recNode: PNode,
       let fields = branch[branch.len - 1]
       fieldsPresentInInitExpr(c, fields, initExpr)
 
-    template checkMissingFields(branchNode: PNode, considerDefaults: bool) =
+    proc checkMissingFields(branchNode: PNode, considerDefaults: bool) =
       if branchNode != nil:
         let fields = branchNode[^1]
         checkForMissingFields(c, fields, initExpr, considerDefaults)
 
-    let discriminator = recNode.sons[0]
+    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, selectedBranch == -1)
+      let status = semConstructFields(c, innerRecords, initExpr, flags)
       if status notin {initNone, initUnknown}:
         mergeInitStatus(result, status)
         if selectedBranch != -1:
@@ -255,7 +253,7 @@ proc semConstructFields(c: PContext, recNode: PNode,
         localError(c.config, discriminatorVal.info, ("possible values " &
           "$2are in conflict with discriminator values for " &
           "selected object branch $1.") % [$selectedBranch,
-          formatUnsafeBranchVals(recNode.sons[0].typ, valsDiff)])
+          formatUnsafeBranchVals(recNode[0].typ, valsDiff)])
 
       let branchNode = recNode[selectedBranch]
       let flags = flags*{efAllowDestructor} + {efPreferStatic,
@@ -270,7 +268,7 @@ proc semConstructFields(c: PContext, recNode: PNode,
         if discriminatorVal.kind notin nkLiterals and (
             not isOrdinalType(discriminatorVal.typ, true) or
             lengthOrd(c.config, discriminatorVal.typ) > MaxSetElements or
-            lengthOrd(c.config, recNode.sons[0].typ) > MaxSetElements):
+            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.")
@@ -348,33 +346,28 @@ proc semConstructFields(c: PContext, recNode: PNode,
         checkMissingFields matchedBranch, true
       else:
         result = initPartial
+        discriminatorVal = discriminatorVal.skipHidden
+        debug discriminatorVal
         if discriminatorVal.kind == nkIntLit: #or discriminatorVal.typ.kind == tyRange:
           # When the discriminator is a compile-time value, we also know
           # which branch will be selected:
           matchedBranch = recNode.pickCaseBranch discriminatorVal
           if matchedBranch != nil: checkMissingFields matchedBranch, true
+        elif discriminatorVal.typ.kind == tyRange:
+          let matchedBranches = recNode.pickCaseBranches discriminatorVal.typ.n
+          for m in matchedBranches:
+            checkMissingFields m, matchedBranches.len == 0
         else:
-          discriminatorVal = discriminatorVal.skipHidden
-          if discriminatorVal.typ.kind == tyRange and not( #TODO: Maybe hint or warn when the type is too big to select the branch
-                discriminatorVal.kind notin nkLiterals and (
-                not isOrdinalType(discriminatorVal.typ, true) or
-                lengthOrd(c.config, discriminatorVal.typ) > MaxSetElements or
-                lengthOrd(c.config, recNode.sons[0].typ) > MaxSetElements)
-                ):
-            let matchedBranches = recNode.pickCaseBranches discriminatorVal.typ.n
-            for m in matchedBranches:
-              checkMissingFields m, matchedBranches.len == 0
-          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], false
+          # 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], false
 
   of nkSym:
     let field = recNode.sym
-    var e = semConstrField(c, flags, field, initExpr)
-    if wantsInit and e == nil: #Try to use default value
-      e = field.ast
-    result = if e != nil: initFull else: initNone
+    let e = semConstrField(c, flags, field, initExpr)
+    result = if e != nil: initFull
+             elif field.ast != nil: initUnknown
+             else: initNone
 
   else:
     internalAssert c.config, false
@@ -388,12 +381,12 @@ proc semConstructType(c: PContext, initExpr: PNode,
     mergeInitStatus(result, status)
     if status in {initPartial, initNone, initUnknown}:
       checkForMissingFields c, t.n, initExpr, true
-    let base = t.sons[0]
+    let base = t[0]
     if base == nil: break
     t = skipTypes(base, skipPtrs)
 
 proc semObjConstr(c: PContext, n: PNode, flags: TExprFlags): PNode =
-  var t = semTypeNode(c, n.sons[0], nil)
+  var t = semTypeNode(c, n[0], nil)
   result = newNodeIT(nkObjConstr, n.info, t)
   for child in n: result.add child
 
@@ -403,7 +396,7 @@ proc semObjConstr(c: PContext, n: PNode, flags: TExprFlags): PNode =
 
   t = skipTypes(t, {tyGenericInst, tyAlias, tySink, tyOwned})
   if t.kind == tyRef:
-    t = skipTypes(t.sons[0], {tyGenericInst, tyAlias, tySink, tyOwned})
+    t = skipTypes(t[0], {tyGenericInst, tyAlias, tySink, tyOwned})
     if optOwnedRefs in c.config.globalOptions:
       result.typ = makeVarType(c, result.typ, tyOwned)
       # we have to watch out, there are also 'owned proc' types that can be used

compiler/semtypes.nim

@@ -635,7 +635,7 @@ proc semRecordCase(c: PContext, n: PNode, check: var IntSet, pos: var int,
     errorUndeclaredIdentifier(c, n.sons[0].info, typ.sym.name.s)
   elif not isOrdinalType(typ):
     localError(c.config, n.sons[0].info, "selector must be of an ordinal type, float or string")
-  elif firstOrd(c.config, typ) != 0:
+  if firstOrd(c.config, typ) != 0:
     localError(c.config, n.info, "low(" & $a.sons[0].sym.name.s &
                                      ") must be 0 for discriminant")
   elif lengthOrd(c.config, typ) > 0x00007FFF:
@@ -745,6 +745,8 @@ proc semRecordNodeAux(c: PContext, n: PNode, check: var IntSet, pos: var int,
       if n[^1].kind != nkEmpty:
         n[^1] = semConstExpr(c, n[^1])
         fSym.sym.ast = n[^1]
+      elif typ.kind in {tyRange, tyOrdinal}:
+        fSym.sym.ast = newIntNode(nkIntLit, firstOrd(c.config, typ))
       if a.kind == nkEmpty: addSon(father, newSymNode(f))
       else: addSon(a, newSymNode(f))
       styleCheckDef(c.config, f)

compiler/transf.nim

@@ -930,6 +930,46 @@ proc containsResult(n: PNode): bool =
     for i in 0..<n.safeLen:
       if (n[i].kind notin procDefs) and containsResult(n[i]): return true
 
+#from semobjconstr import defaultFields
+
+# proc defaultFields(c: PContext, recNode: PNode, initExpr: PNode, flags: TExprFlags): seq[PNode] =
+#   case recNode.kind
+#   of nkRecList:
+#     for field in recNode:
+#       result.add defaultFields(c, field, initExpr, flags)
+#   of nkRecCase:
+#     let discriminator = recNode.sons[0]
+#     var matchedBranch: PNode
+
+#     var discriminatorVal = semConstrField(c, flags + {efPreferStatic}, discriminator.sym, initExpr)
+#     if discriminatorVal == nil: #Try to use default value
+#       discriminatorVal = discriminator.sym.ast
+#       if discriminatorVal != nil:
+#         result.add newTree(nkExprColonExpr, discriminator, discriminatorVal)
+
+#     if discriminatorVal == nil:
+#       matchedBranch = recNode.pickCaseBranch newIntLit(c.graph, initExpr.info, 0)
+#     else:
+#       if discriminatorVal.kind == nkIntLit:
+#         # When the discriminator is a compile-time value, we also know
+#         # which branch will be selected:
+#         matchedBranch = recNode.pickCaseBranch discriminatorVal
+#       else:
+#         echo "where does the wind take us?"
+#     if matchedBranch != nil:
+#       result.add defaultFields(c, matchedBranch[^1], initExpr, flags)
+#   of nkSym:
+#     let field = recNode.sym
+#     if semConstrField(c, flags, field, initExpr) == nil:
+#       if field.ast != nil: #Try to use default value
+#         result.add newTree(nkExprColonExpr, recNode, field.ast)
+#       else:
+#         echo "init zero"
+#   else:
+#     echo recNode.kind; debug recNode; internalAssert c.config, false
+
+
+
 proc transform(c: PTransf, n: PNode): PNode =
   when false:
     var oldDeferAnchor: PNode
@@ -1084,20 +1124,8 @@ proc transform(c: PTransf, n: PNode): PNode =
   of nkExceptBranch:
     result = transformExceptBranch(c, n)
   of nkObjConstr:
-    result = newNodeIT(nkStmtListExpr, n.info, n.typ)
-    let sym = newSym(skTemp, getIdent(c.graph.cache, ":tmpO"), c.transCon.owner, n.info)
-    sym.typ = n.typ
-    let obj = newSymNode(sym)
-    result.add newTree(nkVarSection, newTree(nkIdentDefs, obj, newNode(nkEmpty), n))
-    var providedFields: seq[PSym]
-    for i in 1..<n.len:
-      assert n[i].kind == nkExprColonExpr
-      result.add transform(c, newTree(nkAsgn, makeFieldTree(obj, n[i][0]), n[i][1]))
-      providedFields.add n[i][0].sym
-    let typ = obj.typ.skipTypes(abstractInst)
-    result.add transform(c, initDefaultFields(obj, (if typ.kind == tyRef: typ[0].n else: typ.n), providedFields))
-    n.sons.setLen(1)
-    result.add obj
+    result = n
+    #result.add defaultFields(c, result.typ.skipTypes(abstractInst).n, result, {})
   else:
     result = transformSons(c, n)
   when false: