sizeof(UncheckedArray) should be invalid; fixed the formating of sizealignoffsetimpl.nim to make it bearable

compiler/sizealignoffsetimpl.nim

@@ -17,7 +17,6 @@ proc computeSubObjectAlign(conf: ConfigRef; n: PNode): BiggestInt =
   of nkRecCase:
     assert(n.sons[0].kind == nkSym)
     result = computeSubObjectAlign(conf, n.sons[0])
-
     for i in 1 ..< sonsLen(n):
       let child = n.sons[i]
       case child.kind
@@ -28,28 +27,22 @@ proc computeSubObjectAlign(conf: ConfigRef; n: PNode): BiggestInt =
         result = max(result, align)
       else:
         internalError(conf, "computeSubObjectAlign")
-
   of nkRecList:
     result = 1
-
     for i, child in n.sons:
       let align = computeSubObjectAlign(conf, n.sons[i])
       if align < 0:
         return align
-
       result = max(result, align)
-
   of nkSym:
     computeSizeAlign(conf, n.sym.typ)
     result = n.sym.typ.align
-
   else:
     result = 1
 
 proc computeObjectOffsetsFoldFunction(conf: ConfigRef; n: PNode, initialOffset: BiggestInt): tuple[offset, align: BiggestInt] =
   ## ``offset`` is the offset within the object, after the node has been written, no padding bytes added
   ## ``align`` maximum alignment from all sub nodes
-
   if n.typ != nil and n.typ.size == szIllegalRecursion:
     result.offset = szIllegalRecursion
     result.align  = szIllegalRecursion
@@ -58,12 +51,10 @@ proc computeObjectOffsetsFoldFunction(conf: ConfigRef; n: PNode, initialOffset:
   result.align = 1
   case n.kind
   of nkRecCase:
-
     assert(n.sons[0].kind == nkSym)
     let (kindOffset, kindAlign) = computeObjectOffsetsFoldFunction(conf, n.sons[0], initialOffset)
 
     var maxChildAlign: BiggestInt = 0
-
     for i in 1 ..< sonsLen(n):
       let child = n.sons[i]
       case child.kind
@@ -86,7 +77,6 @@ proc computeObjectOffsetsFoldFunction(conf: ConfigRef; n: PNode, initialOffset:
     if maxChildAlign == szUnknownSize:
       result.align  = szUnknownSize
       result.offset = szUnknownSize
-
     else:
       # the union neds to be aligned first, before the offsets can be assigned
       let kindUnionOffset = align(kindOffset, maxChildAlign)
@@ -101,9 +91,7 @@ proc computeObjectOffsetsFoldFunction(conf: ConfigRef; n: PNode, initialOffset:
 
 
   of nkRecList:
-
     result.align = 1 # maximum of all member alignments
-
     var offset = initialOffset
 
     for i, child in n.sons:
@@ -140,28 +128,14 @@ proc computeObjectOffsetsFoldFunction(conf: ConfigRef; n: PNode, initialOffset:
     else:
       n.sym.offset = align(initialOffset, align).int
       result.offset = n.sym.offset + n.sym.typ.size
-
   else:
     result.align = szUnknownSize
     result.offset = szUnknownSize
 
-
-var recDepth = 0
 proc computePackedObjectOffsetsFoldFunction(conf: ConfigRef; n: PNode, initialOffset: BiggestInt, debug: bool): BiggestInt =
   ## ``result`` is the offset within the object, after the node has been written, no padding bytes added
-  recDepth += 1
-  defer:
-    recDepth -= 1
-
-  if debug:
-    if n.kind == nkSym:
-      echo repeat("--", recDepth) & "> ", initialOffset, "  ", n.kind, "  ", n.sym.name.s
-    else:
-      echo repeat("--", recDepth) & "> ", initialOffset, "  ", n.kind
-
   case n.kind
   of nkRecCase:
-
     assert(n.sons[0].kind == nkSym)
     let kindOffset = computePackedObjectOffsetsFoldFunction(conf, n.sons[0], initialOffset, debug)
     # the union neds to be aligned first, before the offsets can be assigned
@@ -171,24 +145,17 @@ proc computePackedObjectOffsetsFoldFunction(conf: ConfigRef; n: PNode, initialOf
     for i in 1 ..< sonsLen(n):
       let offset = computePackedObjectOffsetsFoldFunction(conf, n.sons[i].lastSon, kindUnionOffset, debug)
       maxChildOffset = max(maxChildOffset, offset)
-
-    if debug:
-      echo repeat("  ", recDepth), "result: ", maxChildOffset
-
     result = maxChildOffset
-
   of nkRecList:
     result = initialOffset
     for i, child in n.sons:
       result = computePackedObjectOffsetsFoldFunction(conf, child, result, debug)
       if result == szIllegalRecursion:
         break
-
   of nkSym:
     computeSizeAlign(conf, n.sym.typ)
     n.sym.offset = initialOffset.int
     result = n.sym.offset + n.sym.typ.size
-
   else:
     result = szUnknownSize
 
@@ -280,8 +247,7 @@ proc computeSizeAlign(conf: ConfigRef; typ: PType) =
   of tyUncheckedArray:
     let base = typ.lastSon
     computeSizeAlign(conf, base)
-    # this should probably be szUnknownSize
+    typ.size = szUnknownSize
-    typ.size = 0
     typ.align = base.align
   of tyEnum:
     if firstOrd(conf, typ) < 0:
@@ -301,7 +267,6 @@ proc computeSizeAlign(conf: ConfigRef; typ: PType) =
       else:
         typ.size = 8
         typ.align = 8
-
   of tySet:
     if typ.sons[0].kind == tyGenericParam:
       typ.size = szUncomputedSize
@@ -321,82 +286,64 @@ proc computeSizeAlign(conf: ConfigRef; typ: PType) =
       else:
         typ.size = align(length, 8) div 8 + 1
     typ.align = int16(typ.size)
-
   of tyRange:
     computeSizeAlign(conf, typ.sons[0])
     typ.size = typ.sons[0].size
     typ.align = typ.sons[0].align
-
   of tyTuple:
     maxAlign = 1
     sizeAccum = 0
-
     for i in countup(0, sonsLen(typ) - 1):
       let child = typ.sons[i]
       computeSizeAlign(conf, child)
-
       if child.size == szIllegalRecursion:
         typ.size = szIllegalRecursion
         typ.align = szIllegalRecursion
         return
-
       maxAlign = max(maxAlign, child.align)
       sizeAccum = align(sizeAccum, child.align) + child.size
-
     typ.size = align(sizeAccum, maxAlign)
     typ.align = int16(maxAlign)
-
   of tyObject:
     var headerSize: BiggestInt
     var headerAlign: int16
-
     if typ.sons[0] != nil:
       # compute header size
       var st = typ.sons[0]
-
       while st.kind in skipPtrs:
         st = st.sons[^1]
-
       computeSizeAlign(conf, st)
       if st.size == szIllegalRecursion:
         typ.size = st.size
         typ.align = st.align
         return
-
       headerSize = st.size
       headerAlign = st.align
-
     elif isObjectWithTypeFieldPredicate(typ):
       # this branch is taken for RootObj
       headerSize = conf.target.intSize
       headerAlign = conf.target.intSize.int16
-
     else:
       headerSize = 0
       headerAlign = 1
-
     let (offset, align) =
       if tfPacked in typ.flags:
         (computePackedObjectOffsetsFoldFunction(conf, typ.n, headerSize, false), BiggestInt(1))
       else:
         computeObjectOffsetsFoldFunction(conf, typ.n, headerSize)
-
     if offset == szIllegalRecursion:
       typ.size = szIllegalRecursion
       typ.align = szIllegalRecursion
       return
-
     if offset == szUnknownSize or (
         typ.sym != nil and
-          typ.sym.flags * {sfCompilerProc, sfImportc} == {sfImportc}
+        typ.sym.flags * {sfCompilerProc, sfImportc} == {sfImportc}):
-    ):
       typ.size = szUnknownSize
       typ.align = szUnknownSize
       return
 
     # header size is already in size from computeObjectOffsetsFoldFunction
     # maxAlign is probably not changed at all from headerAlign
-
     if tfPacked in typ.flags:
       typ.size = offset
       typ.align = 1