fixes #24666; Compilation error when formatting a complex number (#24667)

fixes #24666

ref https://github.com/nim-lang/Nim/pull/22924

(cherry picked from commit 485b414fce)

compiler/cbuilder.nim

@@ -0,0 +1,121 @@
+type
+  Snippet = string
+  Builder = string
+
+template newBuilder(s: string): Builder =
+  s
+
+proc addField(obj: var Builder; name, typ: Snippet) =
+  obj.add('\t')
+  obj.add(typ)
+  obj.add(" ")
+  obj.add(name)
+  obj.add(";\n")
+
+proc addField(obj: var Builder; field: PSym; name, typ: Snippet; isFlexArray: bool; initializer: Snippet) =
+  obj.add('\t')
+  if field.alignment > 0:
+    obj.add("NIM_ALIGN(")
+    obj.addInt(field.alignment)
+    obj.add(") ")
+  obj.add(typ)
+  if sfNoalias in field.flags:
+    obj.add(" NIM_NOALIAS")
+  obj.add(" ")
+  obj.add(name)
+  if isFlexArray:
+    obj.add("[SEQ_DECL_SIZE]")
+  if field.bitsize != 0:
+    obj.add(":")
+    obj.addInt(field.bitsize)
+  if initializer.len != 0:
+    obj.add(initializer)
+  obj.add(";\n")
+
+proc structOrUnion(t: PType): Snippet =
+  let t = t.skipTypes({tyAlias, tySink})
+  if tfUnion in t.flags: "union"
+  else: "struct"
+
+proc ptrType(t: Snippet): Snippet =
+  t & "*"
+
+template addStruct(obj: var Builder; m: BModule; typ: PType; name: string; baseType: string; body: typed) =
+  if tfPacked in typ.flags:
+    if hasAttribute in CC[m.config.cCompiler].props:
+      obj.add(structOrUnion(typ))
+      obj.add(" __attribute__((__packed__))")
+    else:
+      obj.add("#pragma pack(push, 1)\n")
+      obj.add(structOrUnion(typ))
+  else:
+    obj.add(structOrUnion(typ))
+  obj.add(" ")
+  obj.add(name)
+  type BaseClassKind = enum
+    bcNone, bcCppInherit, bcSupField, bcNoneRtti, bcNoneTinyRtti
+  var baseKind = bcNone
+  if typ.kind == tyObject:
+    if typ.baseClass == nil:
+      if lacksMTypeField(typ):
+        baseKind = bcNone
+      elif optTinyRtti in m.config.globalOptions:
+        baseKind = bcNoneTinyRtti
+      else:
+        baseKind = bcNoneRtti
+    elif m.compileToCpp:
+      baseKind = bcCppInherit
+    else:
+      baseKind = bcSupField
+  if baseKind == bcCppInherit:
+    obj.add(" : public ")
+    obj.add(baseType)
+  obj.add(" ")
+  obj.add("{\n")
+  let currLen = obj.len
+  case baseKind
+  of bcNone:
+    # rest of the options add a field or don't need it due to inheritance,
+    # we need to add the dummy field for uncheckedarray ahead of time
+    # so that it remains trailing
+    if typ.itemId notin m.g.graph.memberProcsPerType and
+        typ.n != nil and typ.n.len == 1 and typ.n[0].kind == nkSym and
+        typ.n[0].sym.typ.skipTypes(abstractInst).kind == tyUncheckedArray:
+      # only consists of flexible array field, add *initial* dummy field
+      obj.addField(name = "dummy", typ = "char")
+  of bcCppInherit: discard
+  of bcNoneRtti:
+    obj.addField(name = "m_type", typ = ptrType(cgsymValue(m, "TNimType")))
+  of bcNoneTinyRtti:
+    obj.addField(name = "m_type", typ = ptrType(cgsymValue(m, "TNimTypeV2")))
+  of bcSupField:
+    obj.addField(name = "Sup", typ = baseType)
+  body
+  if baseKind == bcNone and currLen == obj.len and typ.itemId notin m.g.graph.memberProcsPerType:
+    # no fields were added, add dummy field
+    obj.addField(name = "dummy", typ = "char")
+  obj.add("};\n")
+  if tfPacked in typ.flags and hasAttribute notin CC[m.config.cCompiler].props:
+    result.add("#pragma pack(pop)\n")
+
+template addFieldWithStructType(obj: var Builder; m: BModule; parentTyp: PType; fieldName: string, body: typed) =
+  ## adds a field with a `struct { ... }` type, building it according to `body`
+  obj.add('\t')
+  if tfPacked in parentTyp.flags:
+    if hasAttribute in CC[m.config.cCompiler].props:
+      obj.add("struct __attribute__((__packed__)) {\n")
+    else:
+      obj.add("#pragma pack(push, 1)\nstruct {")
+  else:
+    obj.add("struct {\n")
+  body
+  obj.add("} ")
+  obj.add(fieldName)
+  obj.add(";\n")
+  if tfPacked in parentTyp.flags and hasAttribute notin CC[m.config.cCompiler].props:
+    result.add("#pragma pack(pop)\n")
+
+template addAnonUnion(obj: var Builder; body: typed) =
+  obj.add "union{\n"
+  body
+  obj.add("};\n")

compiler/cbuilderbase.nim

@@ -1,164 +0,0 @@
-import ropes, int128
-
-type
-  Snippet* = string
-  Builder* = object
-    buf*: string
-    indents*: int
-
-template newBuilder*(s: string): Builder =
-  Builder(buf: s)
-
-proc extract*(builder: Builder): Snippet =
-  builder.buf
-
-proc add*(builder: var Builder, s: string) =
-  builder.buf.add(s)
-
-proc add*(builder: var Builder, s: char) =
-  builder.buf.add(s)
-
-proc addNewline*(builder: var Builder) =
-  builder.add('\n')
-  for i in 0 ..< builder.indents:
-    builder.add('\t')
-
-proc addLineEnd*(builder: var Builder, s: string) =
-  builder.add(s)
-  builder.addNewline()
-
-proc addLineEndIndent*(builder: var Builder, s: string) =
-  inc builder.indents
-  builder.add(s)
-  builder.addNewline()
-
-proc addDedent*(builder: var Builder, s: string) =
-  if builder.buf.len > 0 and builder.buf[^1] == '\t':
-    builder.buf.setLen(builder.buf.len - 1)
-  builder.add(s)
-  dec builder.indents
-
-proc addLineEndDedent*(builder: var Builder, s: string) =
-  builder.addDedent(s)
-  builder.addNewline()
-
-proc addLineComment*(builder: var Builder, comment: string) =
-  # probably no-op on nifc
-  builder.add("// ")
-  builder.add(comment)
-  builder.addNewline()
-
-proc addIntValue*(builder: var Builder, val: int) =
-  builder.buf.addInt(val)
-
-proc addIntValue*(builder: var Builder, val: int64) =
-  builder.buf.addInt(val)
-
-proc addIntValue*(builder: var Builder, val: uint64) =
-  builder.buf.addInt(val)
-
-proc addIntValue*(builder: var Builder, val: Int128) =
-  builder.buf.addInt128(val)
-
-template cIntValue*(val: int): Snippet = $val
-template cIntValue*(val: int64): Snippet = $val
-template cIntValue*(val: uint64): Snippet = $val
-template cIntValue*(val: Int128): Snippet = $val
-
-template cUintValue*(val: uint): Snippet = $val & "U"
-
-import std/formatfloat
-
-proc addFloatValue*(builder: var Builder, val: float) =
-  builder.buf.addFloat(val)
-
-template cFloatValue*(val: float): Snippet = $val
-
-proc addInt64Literal*(result: var Builder; i: BiggestInt) =
-  if i > low(int64):
-    result.add "IL64($1)" % [rope(i)]
-  else:
-    result.add "(IL64(-9223372036854775807) - IL64(1))"
-
-proc addUint64Literal*(result: var Builder; i: uint64) =
-  result.add rope($i & "ULL")
-
-proc addIntLiteral*(result: var Builder; i: BiggestInt) =
-  if i > low(int32) and i <= high(int32):
-    result.addIntValue(i)
-  elif i == low(int32):
-    # Nim has the same bug for the same reasons :-)
-    result.add "(-2147483647 -1)"
-  elif i > low(int64):
-    result.add "IL64($1)" % [rope(i)]
-  else:
-    result.add "(IL64(-9223372036854775807) - IL64(1))"
-
-proc addIntLiteral*(result: var Builder; i: Int128) =
-  addIntLiteral(result, toInt64(i))
-
-proc cInt64Literal*(i: BiggestInt): Snippet =
-  if i > low(int64):
-    result = "IL64($1)" % [rope(i)]
-  else:
-    result = "(IL64(-9223372036854775807) - IL64(1))"
-
-proc cUint64Literal*(i: uint64): Snippet =
-  result = $i & "ULL"
-
-proc cIntLiteral*(i: BiggestInt): Snippet =
-  if i > low(int32) and i <= high(int32):
-    result = rope(i)
-  elif i == low(int32):
-    # Nim has the same bug for the same reasons :-)
-    result = "(-2147483647 -1)"
-  elif i > low(int64):
-    result = "IL64($1)" % [rope(i)]
-  else:
-    result = "(IL64(-9223372036854775807) - IL64(1))"
-
-proc cIntLiteral*(i: Int128): Snippet =
-  result = cIntLiteral(toInt64(i))
-
-const
-  NimInt* = "NI"
-  NimInt8* = "NI8"
-  NimInt16* = "NI16"
-  NimInt32* = "NI32"
-  NimInt64* = "NI64"
-  CInt* = "int"
-  NimUint* = "NU"
-  NimUint8* = "NU8"
-  NimUint16* = "NU16"
-  NimUint32* = "NU32"
-  NimUint64* = "NU64"
-  NimFloat* = "NF"
-  NimFloat32* = "NF32"
-  NimFloat64* = "NF64"
-  NimFloat128* = "NF128" # not actually defined
-  NimNan* = "NAN"
-  NimInf* = "INF"
-  NimBool* = "NIM_BOOL"
-  NimTrue* = "NIM_TRUE"
-  NimFalse* = "NIM_FALSE"
-  NimChar* = "NIM_CHAR"
-  CChar* = "char"
-  NimCstring* = "NCSTRING"
-  NimNil* = "NIM_NIL"
-  CNil* = "NULL"
-  NimStrlitFlag* = "NIM_STRLIT_FLAG"
-  CVoid* = "void"
-  CPointer* = "void*"
-  CConstPointer* = "NIM_CONST void*"
-
-proc cIntType*(bits: BiggestInt): Snippet =
-  "NI" & $bits
-
-proc cUintType*(bits: BiggestInt): Snippet =
-  "NU" & $bits
-
-type
-  IfBuilderState* = enum
-    WaitingIf, WaitingElseIf, InBlock
-  IfBuilder* = object
-    state*: IfBuilderState

compiler/cbuilderdecls.nim

@@ -1,668 +0,0 @@
-type VarKind = enum
-  Local
-  Global
-  Threadvar
-  Const
-  AlwaysConst ## const even on C++
-
-proc addVarHeader(builder: var Builder, kind: VarKind) =
-  ## adds modifiers for given var kind:
-  ## Local has no modifier
-  ## Global has `static` modifier
-  ## Const has `static NIM_CONST` modifier
-  ## AlwaysConst has `static const` modifier (NIM_CONST is no-op on C++)
-  ## Threadvar is unimplemented
-  case kind
-  of Local: discard
-  of Global:
-    builder.add("static ")
-  of Const:
-    builder.add("static NIM_CONST ")
-  of AlwaysConst:
-    builder.add("static const ")
-  of Threadvar:
-    doAssert false, "unimplemented"
-
-proc addVar(builder: var Builder, kind: VarKind = Local, name: string, typ: Snippet, initializer: Snippet = "") =
-  ## adds a variable declaration to the builder
-  builder.addVarHeader(kind)
-  builder.add(typ)
-  builder.add(" ")
-  builder.add(name)
-  if initializer.len != 0:
-    builder.add(" = ")
-    builder.add(initializer)
-  builder.addLineEnd(";")
-
-template addVarWithType(builder: var Builder, kind: VarKind = Local, name: string, body: typed) =
-  ## adds a variable declaration to the builder, with the `body` building the type
-  builder.addVarHeader(kind)
-  body
-  builder.add(" ")
-  builder.add(name)
-  builder.addLineEnd(";")
-
-template addVarWithInitializer(builder: var Builder, kind: VarKind = Local, name: string,
-                               typ: Snippet, initializerBody: typed) =
-  ## adds a variable declaration to the builder, with
-  ## `initializerBody` building the initializer. initializer must be provided
-  builder.addVarHeader(kind)
-  builder.add(typ)
-  builder.add(" ")
-  builder.add(name)
-  builder.add(" = ")
-  initializerBody
-  builder.addLineEnd(";")
-
-template addVarWithTypeAndInitializer(builder: var Builder, kind: VarKind = Local, name: string,
-                                      typeBody, initializerBody: typed) =
-  ## adds a variable declaration to the builder, with `typeBody` building the type, and
-  ## `initializerBody` building the initializer. initializer must be provided
-  builder.addVarHeader(kind)
-  typeBody
-  builder.add(" ")
-  builder.add(name)
-  builder.add(" = ")
-  initializerBody
-  builder.addLineEnd(";")
-
-proc addArrayVar(builder: var Builder, kind: VarKind = Local, name: string, elementType: Snippet, len: int, initializer: Snippet = "") =
-  ## adds an array variable declaration to the builder
-  builder.addVarHeader(kind)
-  builder.add(elementType)
-  builder.add(" ")
-  builder.add(name)
-  builder.add("[")
-  builder.addIntValue(len)
-  builder.add("]")
-  if initializer.len != 0:
-    builder.add(" = ")
-    builder.add(initializer)
-  builder.addLineEnd(";")
-
-template addArrayVarWithInitializer(builder: var Builder, kind: VarKind = Local, name: string, elementType: Snippet, len: int, body: typed) =
-  ## adds an array variable declaration to the builder with the initializer built according to `body`
-  builder.addVarHeader(kind)
-  builder.add(elementType)
-  builder.add(" ")
-  builder.add(name)
-  builder.add("[")
-  builder.addIntValue(len)
-  builder.add("] = ")
-  body
-  builder.addLineEnd(";")
-
-template addTypedef(builder: var Builder, name: string, typeBody: typed) =
-  ## adds a typedef declaration to the builder with name `name` and type as
-  ## built in `typeBody`
-  builder.add("typedef ")
-  typeBody
-  builder.add(" ")
-  builder.add(name)
-  builder.addLineEnd(";")
-
-proc addProcTypedef(builder: var Builder, callConv: TCallingConvention, name: string, rettype, params: Snippet) =
-  builder.add("typedef ")
-  builder.add(CallingConvToStr[callConv])
-  builder.add("_PTR(")
-  builder.add(rettype)
-  builder.add(", ")
-  builder.add(name)
-  builder.add(")")
-  builder.add(params)
-  builder.addLineEnd(";")
-
-template addArrayTypedef(builder: var Builder, name: string, len: BiggestInt, typeBody: typed) =
-  ## adds an array typedef declaration to the builder with name `name`,
-  ## length `len`, and element type as built in `typeBody`
-  builder.add("typedef ")
-  typeBody
-  builder.add(" ")
-  builder.add(name)
-  builder.add("[")
-  builder.addIntValue(len)
-  builder.addLineEnd("];")
-
-type
-  StructInitializerKind = enum
-    siOrderedStruct ## struct constructor, but without named fields on C
-    siNamedStruct ## struct constructor, with named fields i.e. C99 designated initializer
-    siArray ## array constructor
-    siWrapper ## wrapper for a single field, generates it verbatim
-
-  StructInitializer = object
-    ## context for building struct initializers, i.e. `{ field1, field2 }`
-    kind: StructInitializerKind
-      ## if true, fields will not be named, instead values are placed in order
-    needsComma: bool
-
-proc initStructInitializer(builder: var Builder, kind: StructInitializerKind): StructInitializer =
-  ## starts building a struct initializer, i.e. braced initializer list
-  result = StructInitializer(kind: kind, needsComma: false)
-  if kind != siWrapper:
-    builder.add("{")
-
-template addField(builder: var Builder, constr: var StructInitializer, name: string, valueBody: typed) =
-  ## adds a field to a struct initializer, with the value built in `valueBody`
-  if constr.needsComma:
-    assert constr.kind != siWrapper, "wrapper constructor cannot have multiple fields"
-    builder.add(", ")
-  else:
-    constr.needsComma = true
-  case constr.kind
-  of siArray, siWrapper:
-    # no name, can just add value
-    valueBody
-  of siOrderedStruct:
-    # no name, can just add value on C
-    assert name.len != 0, "name has to be given for struct initializer field"
-    valueBody
-  of siNamedStruct:
-    assert name.len != 0, "name has to be given for struct initializer field"
-    builder.add(".")
-    builder.add(name)
-    builder.add(" = ")
-    valueBody
-
-proc finishStructInitializer(builder: var Builder, constr: StructInitializer) =
-  ## finishes building a struct initializer
-  if constr.kind != siWrapper:
-    builder.add("}")
-
-template addStructInitializer(builder: var Builder, constr: out StructInitializer, kind: StructInitializerKind, body: typed) =
-  ## builds a struct initializer, i.e. `{ field1, field2 }`
-  ## a `var StructInitializer` must be declared and passed as a parameter so
-  ## that it can be used with `addField`
-  constr = builder.initStructInitializer(kind)
-  body
-  builder.finishStructInitializer(constr)
-
-proc addField(obj: var Builder; name, typ: Snippet; isFlexArray: bool = false; initializer: Snippet = "") =
-  ## adds a field inside a struct/union type
-  obj.add('\t')
-  obj.add(typ)
-  obj.add(" ")
-  obj.add(name)
-  if isFlexArray:
-    obj.add("[SEQ_DECL_SIZE]")
-  if initializer.len != 0:
-    obj.add(initializer)
-  obj.add(";\n")
-
-proc addArrayField(obj: var Builder; name, elementType: Snippet; len: int; initializer: Snippet = "") =
-  ## adds an array field inside a struct/union type
-  obj.add('\t')
-  obj.add(elementType)
-  obj.add(" ")
-  obj.add(name)
-  obj.add("[")
-  obj.addIntValue(len)
-  obj.add("]")
-  if initializer.len != 0:
-    obj.add(initializer)
-  obj.add(";\n")
-
-proc addField(obj: var Builder; field: PSym; name, typ: Snippet; isFlexArray: bool = false; initializer: Snippet = "") =
-  ## adds an field inside a struct/union type, based on an `skField` symbol
-  obj.add('\t')
-  if field.alignment > 0:
-    obj.add("NIM_ALIGN(")
-    obj.addIntValue(field.alignment)
-    obj.add(") ")
-  obj.add(typ)
-  if sfNoalias in field.flags:
-    obj.add(" NIM_NOALIAS")
-  obj.add(" ")
-  obj.add(name)
-  if isFlexArray:
-    obj.add("[SEQ_DECL_SIZE]")
-  if field.bitsize != 0:
-    obj.add(":")
-    obj.addIntValue(field.bitsize)
-  if initializer.len != 0:
-    obj.add(initializer)
-  obj.add(";\n")
-
-proc addProcField(obj: var Builder, callConv: TCallingConvention, name: string, rettype, params: Snippet) =
-  obj.add(CallingConvToStr[callConv])
-  obj.add("_PTR(")
-  obj.add(rettype)
-  obj.add(", ")
-  obj.add(name)
-  obj.add(")")
-  obj.add(params)
-  obj.add(";\n")
-
-type
-  BaseClassKind = enum
-    ## denotes how and whether or not the base class/RTTI should be stored
-    bcNone, bcCppInherit, bcSupField, bcNoneRtti, bcNoneTinyRtti
-  StructBuilderInfo = object
-    ## context for building `struct` types
-    baseKind: BaseClassKind
-    named: bool
-    preFieldsLen: int
-
-proc structOrUnion(t: PType): Snippet =
-  let t = t.skipTypes({tyAlias, tySink})
-  if tfUnion in t.flags: "union"
-  else: "struct"
-
-proc startSimpleStruct(obj: var Builder; m: BModule; name: string; baseType: Snippet): StructBuilderInfo =
-  result = StructBuilderInfo(baseKind: bcNone, named: name.len != 0)
-  obj.add("struct")
-  if result.named:
-    obj.add(" ")
-    obj.add(name)
-  if baseType.len != 0:
-    if m.compileToCpp:
-      result.baseKind = bcCppInherit
-    else:
-      result.baseKind = bcSupField
-  if result.baseKind == bcCppInherit:
-    obj.add(" : public ")
-    obj.add(baseType)
-  obj.add(" ")
-  obj.add("{\n")
-  result.preFieldsLen = obj.buf.len
-  if result.baseKind == bcSupField:
-    obj.addField(name = "Sup", typ = baseType)
-
-proc finishSimpleStruct(obj: var Builder; m: BModule; info: StructBuilderInfo) =
-  if info.baseKind == bcNone and info.preFieldsLen == obj.buf.len:
-    # no fields were added, add dummy field
-    obj.addField(name = "dummy", typ = CChar)
-  if info.named:
-    obj.add("};\n")
-  else:
-    obj.add("}")
-
-template addSimpleStruct(obj: var Builder; m: BModule; name: string; baseType: Snippet; body: typed) =
-  ## builds a struct type not based on a Nim type with fields according to `body`,
-  ## `name` can be empty to build as a type expression and not a statement
-  let info = startSimpleStruct(obj, m, name, baseType)
-  body
-  finishSimpleStruct(obj, m, info)
-
-proc startStruct(obj: var Builder; m: BModule; t: PType; name: string; baseType: Snippet): StructBuilderInfo =
-  result = StructBuilderInfo(baseKind: bcNone, named: name.len != 0)
-  if tfPacked in t.flags:
-    if hasAttribute in CC[m.config.cCompiler].props:
-      obj.add(structOrUnion(t))
-      obj.add(" __attribute__((__packed__))")
-    else:
-      obj.add("#pragma pack(push, 1)\n")
-      obj.add(structOrUnion(t))
-  else:
-    obj.add(structOrUnion(t))
-  if result.named:
-    obj.add(" ")
-    obj.add(name)
-  if t.kind == tyObject:
-    if t.baseClass == nil:
-      if lacksMTypeField(t):
-        result.baseKind = bcNone
-      elif optTinyRtti in m.config.globalOptions:
-        result.baseKind = bcNoneTinyRtti
-      else:
-        result.baseKind = bcNoneRtti
-    elif m.compileToCpp:
-      result.baseKind = bcCppInherit
-    else:
-      result.baseKind = bcSupField
-  elif baseType.len != 0:
-    if m.compileToCpp:
-      result.baseKind = bcCppInherit
-    else:
-      result.baseKind = bcSupField
-  if result.baseKind == bcCppInherit:
-    obj.add(" : public ")
-    obj.add(baseType)
-  obj.add(" ")
-  obj.add("{\n")
-  result.preFieldsLen = obj.buf.len
-  case result.baseKind
-  of bcNone:
-    # rest of the options add a field or don't need it due to inheritance,
-    # we need to add the dummy field for uncheckedarray ahead of time
-    # so that it remains trailing
-    if t.itemId notin m.g.graph.memberProcsPerType and
-        t.n != nil and t.n.len == 1 and t.n[0].kind == nkSym and
-        t.n[0].sym.typ.skipTypes(abstractInst).kind == tyUncheckedArray:
-      # only consists of flexible array field, add *initial* dummy field
-      obj.addField(name = "dummy", typ = CChar)
-  of bcCppInherit: discard
-  of bcNoneRtti:
-    obj.addField(name = "m_type", typ = ptrType(cgsymValue(m, "TNimType")))
-  of bcNoneTinyRtti:
-    obj.addField(name = "m_type", typ = ptrType(cgsymValue(m, "TNimTypeV2")))
-  of bcSupField:
-    obj.addField(name = "Sup", typ = baseType)
-
-proc finishStruct(obj: var Builder; m: BModule; t: PType; info: StructBuilderInfo) =
-  if info.baseKind == bcNone and info.preFieldsLen == obj.buf.len and
-      t.itemId notin m.g.graph.memberProcsPerType:
-    # no fields were added, add dummy field
-    obj.addField(name = "dummy", typ = CChar)
-  if info.named:
-    obj.add("};\n")
-  else:
-    obj.add("}")
-  if tfPacked in t.flags and hasAttribute notin CC[m.config.cCompiler].props:
-    obj.add("#pragma pack(pop)\n")
-
-template addStruct(obj: var Builder; m: BModule; typ: PType; name: string; baseType: Snippet; body: typed) =
-  ## builds a struct type directly based on `typ` with fields according to `body`,
-  ## `name` can be empty to build as a type expression and not a statement
-  let info = startStruct(obj, m, typ, name, baseType)
-  body
-  finishStruct(obj, m, typ, info)
-
-template addFieldWithStructType(obj: var Builder; m: BModule; parentTyp: PType; fieldName: string, body: typed) =
-  ## adds a field with a `struct { ... }` type, building the fields according to `body`
-  obj.add('\t')
-  if tfPacked in parentTyp.flags:
-    if hasAttribute in CC[m.config.cCompiler].props:
-      obj.add("struct __attribute__((__packed__)) {\n")
-    else:
-      obj.add("#pragma pack(push, 1)\nstruct {")
-  else:
-    obj.add("struct {\n")
-  body
-  obj.add("} ")
-  obj.add(fieldName)
-  obj.add(";\n")
-  if tfPacked in parentTyp.flags and hasAttribute notin CC[m.config.cCompiler].props:
-    obj.add("#pragma pack(pop)\n")
-
-template addAnonUnion(obj: var Builder; body: typed) =
-  ## adds an anonymous union i.e. `union { ... };` with fields according to `body`
-  obj.add "union{\n"
-  body
-  obj.add("};\n")
-
-template addUnionType(obj: var Builder; body: typed) =
-  ## adds a union type i.e. `union { ... }` with fields according to `body`
-  obj.add "union{\n"
-  body
-  obj.add("}")
-
-type DeclVisibility = enum
-  None
-  Extern
-  ExternC
-  ImportLib
-  ExportLib
-  ExportLibVar
-  Private
-  StaticProc
-
-proc addVisibilityPrefix(builder: var Builder, visibility: DeclVisibility) =
-  # internal proc
-  case visibility
-  of None: discard
-  of Extern:
-    builder.add("extern ")
-  of ExternC:
-    builder.add("NIM_EXTERNC ")
-  of ImportLib:
-    builder.add("N_LIB_IMPORT ")
-  of ExportLib:
-    builder.add("N_LIB_EXPORT ")
-  of ExportLibVar:
-    builder.add("N_LIB_EXPORT_VAR ")
-  of Private:
-    builder.add("N_LIB_PRIVATE ")
-  of StaticProc:
-    builder.add("static ")
-
-template addDeclWithVisibility(builder: var Builder, visibility: DeclVisibility, declBody: typed) =
-  ## adds a declaration as in `declBody` with the given visibility
-  builder.addVisibilityPrefix(visibility)
-  declBody
-
-type ProcParamBuilder = object
-  needsComma: bool
-
-proc initProcParamBuilder(builder: var Builder): ProcParamBuilder =
-  result = ProcParamBuilder(needsComma: false)
-  builder.add("(")
-
-proc finishProcParamBuilder(builder: var Builder, params: ProcParamBuilder) =
-  if params.needsComma:
-    builder.add(")")
-  else:
-    builder.add("void)")
-
-template cgDeclFrmt*(s: PSym): string =
-  s.constraint.strVal
-
-proc addParam(builder: var Builder, params: var ProcParamBuilder, name: string, typ: Snippet) =
-  if params.needsComma:
-    builder.add(", ")
-  else:
-    params.needsComma = true
-  builder.add(typ)
-  builder.add(" ")
-  builder.add(name)
-
-proc addParam(builder: var Builder, params: var ProcParamBuilder, param: PSym, typ: Snippet) =
-  if params.needsComma:
-    builder.add(", ")
-  else:
-    params.needsComma = true
-  var modifiedTyp = typ
-  if sfNoalias in param.flags:
-    modifiedTyp.add(" NIM_NOALIAS")
-  if sfCodegenDecl notin param.flags:
-    builder.add(modifiedTyp)
-    builder.add(" ")
-    builder.add(param.loc.snippet)
-  else:
-    builder.add runtimeFormat(param.cgDeclFrmt, [modifiedTyp, param.loc.snippet])
-
-proc addUnnamedParam(builder: var Builder, params: var ProcParamBuilder, typ: Snippet) =
-  if params.needsComma:
-    builder.add(", ")
-  else:
-    params.needsComma = true
-  builder.add(typ)
-
-proc addProcTypedParam(builder: var Builder, paramBuilder: var ProcParamBuilder, callConv: TCallingConvention, name: string, rettype, params: Snippet) =
-  if paramBuilder.needsComma:
-    builder.add(", ")
-  else:
-    paramBuilder.needsComma = true
-  builder.add(CallingConvToStr[callConv])
-  builder.add("_PTR(")
-  builder.add(rettype)
-  builder.add(", ")
-  builder.add(name)
-  builder.add(")")
-  builder.add(params)
-
-proc addVarargsParam(builder: var Builder, params: var ProcParamBuilder) =
-  # does not exist in NIFC, needs to be proc pragma
-  if params.needsComma:
-    builder.add(", ")
-  else:
-    params.needsComma = true
-  builder.add("...")
-
-template addProcParams(builder: var Builder, params: out ProcParamBuilder, body: typed) =
-  params = initProcParamBuilder(builder)
-  body
-  finishProcParamBuilder(builder, params)
-
-type SimpleProcParam = tuple
-  name, typ: string
-
-proc cProcParams(params: varargs[SimpleProcParam]): Snippet =
-  if params.len == 0: return "(void)"
-  result = "("
-  for i in 0 ..< params.len:
-    if i != 0: result.add(", ")
-    result.add(params[i].typ)
-    if params[i].name.len != 0:
-      result.add(" ")
-      result.add(params[i].name)
-  result.add(")")
-
-template addProcHeaderWithParams(builder: var Builder, callConv: TCallingConvention,
-                                 name: string, rettype: Snippet, paramBuilder: typed) =
-  # on nifc should build something like (proc name params type pragmas
-  # with no body given
-  # or enforce this with secondary builder object
-  builder.add(CallingConvToStr[callConv])
-  builder.add("(")
-  builder.add(rettype)
-  builder.add(", ")
-  builder.add(name)
-  builder.add(")")
-  paramBuilder
-
-proc addProcHeader(builder: var Builder, callConv: TCallingConvention,
-                   name: string, rettype, params: Snippet) =
-  # on nifc should build something like (proc name params type pragmas
-  # with no body given
-  # or enforce this with secondary builder object
-  addProcHeaderWithParams(builder, callConv, name, rettype):
-    builder.add(params)
-
-proc addProcHeader(builder: var Builder, name: string, rettype, params: Snippet, isConstructor = false) =
-  # no callconv
-  builder.add(rettype)
-  builder.add(" ")
-  if isConstructor:
-    builder.add("__attribute__((constructor)) ")
-  builder.add(name)
-  builder.add(params)
-
-proc addProcHeader(builder: var Builder, m: BModule, prc: PSym, name: string, params, rettype: Snippet, addAttributes: bool) =
-  # on nifc should build something like (proc name params type pragmas
-  # with no body given
-  # or enforce this with secondary builder object
-  let noreturn = isNoReturn(m, prc)
-  if sfPure in prc.flags and hasDeclspec in extccomp.CC[m.config.cCompiler].props:
-    builder.add("__declspec(naked) ")
-  if noreturn and hasDeclspec in extccomp.CC[m.config.cCompiler].props:
-    builder.add("__declspec(noreturn) ")
-  builder.add(CallingConvToStr[prc.typ.callConv])
-  builder.add("(")
-  builder.add(rettype)
-  builder.add(", ")
-  builder.add(name)
-  builder.add(")")
-  builder.add(params)
-  if addAttributes:
-    if sfPure in prc.flags and hasAttribute in extccomp.CC[m.config.cCompiler].props:
-      builder.add(" __attribute__((naked))")
-    if noreturn and hasAttribute in extccomp.CC[m.config.cCompiler].props:
-      builder.add(" __attribute__((noreturn))")
-
-proc finishProcHeaderAsProto(builder: var Builder) =
-  builder.addLineEnd(";")
-
-template finishProcHeaderWithBody(builder: var Builder, body: typed) =
-  builder.addLineEndIndent(" {")
-  body
-  builder.addLineEndDedent("}")
-  builder.addNewline
-
-proc addProcVar(builder: var Builder, m: BModule, prc: PSym, name: string, params, rettype: Snippet,
-                isStatic = false, ignoreAttributes = false) =
-  # on nifc, builds full variable
-  if isStatic:
-    builder.add("static ")
-  let noreturn = isNoReturn(m, prc)
-  if not ignoreAttributes:
-    if sfPure in prc.flags and hasDeclspec in extccomp.CC[m.config.cCompiler].props:
-      builder.add("__declspec(naked) ")
-    if noreturn and hasDeclspec in extccomp.CC[m.config.cCompiler].props:
-      builder.add("__declspec(noreturn) ")
-  builder.add(CallingConvToStr[prc.typ.callConv])
-  builder.add("_PTR(")
-  builder.add(rettype)
-  builder.add(", ")
-  builder.add(name)
-  builder.add(")")
-  builder.add(params)
-  if not ignoreAttributes:
-    if sfPure in prc.flags and hasAttribute in extccomp.CC[m.config.cCompiler].props:
-      builder.add(" __attribute__((naked))")
-    if noreturn and hasAttribute in extccomp.CC[m.config.cCompiler].props:
-      builder.add(" __attribute__((noreturn))")
-  # ensure we are just adding a variable:
-  builder.addLineEnd(";")
-
-proc addProcVar(builder: var Builder, callConv: TCallingConvention,
-                name: string, params, rettype: Snippet,
-                isStatic = false, isVolatile = false) =
-  # on nifc, builds full variable
-  if isStatic:
-    builder.add("static ")
-  builder.add(CallingConvToStr[callConv])
-  builder.add("_PTR(")
-  builder.add(rettype)
-  builder.add(", ")
-  if isVolatile:
-    builder.add("volatile ")
-  builder.add(name)
-  builder.add(")")
-  builder.add(params)
-  # ensure we are just adding a variable:
-  builder.addLineEnd(";")
-
-proc addProcVar(builder: var Builder,
-                name: string, params, rettype: Snippet,
-                isStatic = false, isVolatile = false) =
-  # no callconv
-  if isStatic:
-    builder.add("static ")
-  builder.add(rettype)
-  builder.add(" (*")
-  if isVolatile:
-    builder.add("volatile ")
-  builder.add(name)
-  builder.add(")")
-  builder.add(params)
-  # ensure we are just adding a variable:
-  builder.addLineEnd(";")
-
-type VarInitializerKind = enum
-  Assignment, CppConstructor
-
-proc addVar(builder: var Builder, m: BModule, s: PSym, name: string, typ: Snippet, kind = Local, visibility: DeclVisibility = None, initializer: Snippet = "", initializerKind: VarInitializerKind = Assignment) =
-  if sfCodegenDecl in s.flags:
-    builder.add(runtimeFormat(s.cgDeclFrmt, [typ, name]))
-    if initializer.len != 0:
-      if initializerKind == Assignment:
-        builder.add(" = ")
-      builder.add(initializer)
-    builder.addLineEnd(";")
-    return
-  if s.kind in {skLet, skVar, skField, skForVar} and s.alignment > 0:
-    builder.add("NIM_ALIGN(" & $s.alignment & ") ")
-  builder.addVisibilityPrefix(visibility)
-  if kind == Threadvar:
-    if optThreads in m.config.globalOptions:
-      let sym = s.typ.sym
-      if sym != nil and sfCppNonPod in sym.flags:
-        builder.add("NIM_THREAD_LOCAL ")
-      else: builder.add("NIM_THREADVAR ")
-  else:
-    builder.addVarHeader(kind)
-  builder.add(typ)
-  if sfRegister in s.flags: builder.add(" register")
-  if sfVolatile in s.flags: builder.add(" volatile")
-  if sfNoalias in s.flags: builder.add(" NIM_NOALIAS")
-  builder.add(" ")
-  builder.add(name)
-  if initializer.len != 0:
-    if initializerKind == Assignment:
-      builder.add(" = ")
-    builder.add(initializer)
-  builder.addLineEnd(";")
-
-proc addInclude(builder: var Builder, value: Snippet) =
-  builder.addLineEnd("#include " & value)

compiler/cbuilderexprs.nim

@@ -1,259 +0,0 @@
-proc constType(t: Snippet): Snippet =
-  # needs manipulation of `t` in nifc
-  "NIM_CONST " & t
-
-proc constPtrType(t: Snippet): Snippet =
-  t & "* NIM_CONST"
-
-proc ptrConstType(t: Snippet): Snippet =
-  "NIM_CONST " & t & "*"
-
-proc ptrType(t: Snippet): Snippet =
-  t & "*"
-
-proc cppRefType(t: Snippet): Snippet =
-  t & "&"
-
-const
-  CallingConvToStr: array[TCallingConvention, string] = ["N_NIMCALL",
-    "N_STDCALL", "N_CDECL", "N_SAFECALL",
-    "N_SYSCALL", # this is probably not correct for all platforms,
-                 # but one can #define it to what one wants
-    "N_INLINE", "N_NOINLINE", "N_FASTCALL", "N_THISCALL", "N_CLOSURE", "N_NOCONV",
-    "N_NOCONV" #ccMember is N_NOCONV
-    ]
-
-proc procPtrTypeUnnamed(rettype, params: Snippet): Snippet =
-  rettype & "(*)" & params
-
-proc procPtrTypeUnnamedNimCall(rettype, params: Snippet): Snippet =
-  rettype & "(N_RAW_NIMCALL*)" & params
-
-proc procPtrTypeUnnamed(callConv: TCallingConvention, rettype, params: Snippet): Snippet =
-  CallingConvToStr[callConv] & "_PTR(" & rettype & ", )" & params
-
-type CppCaptureKind = enum None, ByReference, ByCopy
-
-template addCppLambda(builder: var Builder, captures: CppCaptureKind, params: Snippet, body: typed) =
-  builder.add("[")
-  case captures
-  of None: discard
-  of ByReference: builder.add("&")
-  of ByCopy: builder.add("=")
-  builder.add("] ")
-  builder.add(params)
-  builder.addLineEndIndent(" {")
-  body
-  builder.addLineEndDedent("}")
-
-proc cCast(typ, value: Snippet): Snippet =
-  "((" & typ & ") " & value & ")"
-
-proc wrapPar(value: Snippet): Snippet =
-  # used for expression group, no-op on sexp
-  "(" & value & ")"
-
-proc removeSinglePar(value: Snippet): Snippet =
-  # removes a single paren layer expected to exist, to silence Wparentheses-equality
-  assert value[0] == '(' and value[^1] == ')'
-  value[1..^2]
-
-template addCast(builder: var Builder, typ: Snippet, valueBody: typed) =
-  ## adds a cast to `typ` with value built by `valueBody`
-  builder.add "(("
-  builder.add typ
-  builder.add ") "
-  valueBody
-  builder.add ")"
-
-proc cAddr(value: Snippet): Snippet =
-  "(&" & value & ")"
-
-proc cLabelAddr(value: TLabel): Snippet =
-  "&&" & value
-
-proc cDeref(value: Snippet): Snippet =
-  "(*" & value & ")"
-
-proc subscript(a, b: Snippet): Snippet =
-  a & "[" & b & "]"
-
-proc dotField(a, b: Snippet): Snippet =
-  a & "." & b
-
-proc derefField(a, b: Snippet): Snippet =
-  a & "->" & b
-
-type CallBuilder = object
-  needsComma: bool
-
-proc initCallBuilder(builder: var Builder, callee: Snippet): CallBuilder =
-  result = CallBuilder(needsComma: false)
-  builder.add(callee)
-  builder.add("(")
-
-const cArgumentSeparator = ", "
-
-proc addArgumentSeparator(builder: var Builder) =
-  # no-op on NIFC
-  # used by "single argument" builders
-  builder.add(cArgumentSeparator)
-
-template addArgument(builder: var Builder, call: var CallBuilder, valueBody: typed) =
-  if call.needsComma:
-    builder.addArgumentSeparator()
-  else:
-    call.needsComma = true
-  valueBody
-
-proc finishCallBuilder(builder: var Builder, call: CallBuilder) =
-  builder.add(")")
-
-template addCall(builder: var Builder, call: out CallBuilder, callee: Snippet, body: typed) =
-  call = initCallBuilder(builder, callee)
-  body
-  finishCallBuilder(builder, call)
-
-proc addCall(builder: var Builder, callee: Snippet, args: varargs[Snippet]) =
-  builder.add(callee)
-  builder.add("(")
-  if args.len != 0:
-    builder.add(args[0])
-    for i in 1 ..< args.len:
-      builder.add(", ")
-      builder.add(args[i])
-  builder.add(")")
-
-proc cCall(callee: Snippet, args: varargs[Snippet]): Snippet =
-  result = callee
-  result.add("(")
-  if args.len != 0:
-    result.add(args[0])
-    for i in 1 ..< args.len:
-      result.add(", ")
-      result.add(args[i])
-  result.add(")")
-
-proc addSizeof(builder: var Builder, val: Snippet) =
-  builder.add("sizeof(")
-  builder.add(val)
-  builder.add(")")
-
-proc addAlignof(builder: var Builder, val: Snippet) =
-  builder.add("NIM_ALIGNOF(")
-  builder.add(val)
-  builder.add(")")
-
-proc addOffsetof(builder: var Builder, val, member: Snippet) =
-  builder.add("offsetof(")
-  builder.add(val)
-  builder.add(", ")
-  builder.add(member)
-  builder.add(")")
-
-template cSizeof(val: Snippet): Snippet =
-  "sizeof(" & val & ")"
-
-template cAlignof(val: Snippet): Snippet =
-  "NIM_ALIGNOF(" & val & ")"
-
-template cOffsetof(val, member: Snippet): Snippet =
-  "offsetof(" & val & ", " & member & ")"
-
-type TypedBinaryOp = enum
-  Add, Sub, Mul, Div, Mod
-  Shr, Shl, BitAnd, BitOr, BitXor
-
-const typedBinaryOperators: array[TypedBinaryOp, string] = [
-  Add: "+",
-  Sub: "-",
-  Mul: "*",
-  Div: "/",
-  Mod: "%",
-  Shr: ">>",
-  Shl: "<<",
-  BitAnd: "&",
-  BitOr: "|",
-  BitXor: "^"
-]
-
-type TypedUnaryOp = enum
-  Neg, BitNot
-
-const typedUnaryOperators: array[TypedUnaryOp, string] = [
-  Neg: "-",
-  BitNot: "~",
-]
-
-type UntypedBinaryOp = enum
-  LessEqual, LessThan, GreaterEqual, GreaterThan, Equal, NotEqual
-  And, Or
-
-const untypedBinaryOperators: array[UntypedBinaryOp, string] = [
-  LessEqual: "<=",
-  LessThan: "<",
-  GreaterEqual: ">=",
-  GreaterThan: ">",
-  Equal: "==",
-  NotEqual: "!=",
-  And: "&&",
-  Or: "||"
-]
-
-type UntypedUnaryOp = enum
-  Not
-
-const untypedUnaryOperators: array[UntypedUnaryOp, string] = [
-  Not: "!"
-]
-
-proc addOp(builder: var Builder, binOp: TypedBinaryOp, t: Snippet, a, b: Snippet) =
-  builder.add('(')
-  builder.add(a)
-  builder.add(' ')
-  builder.add(typedBinaryOperators[binOp])
-  builder.add(' ')
-  builder.add(b)
-  builder.add(')')
-
-proc addOp(builder: var Builder, unOp: TypedUnaryOp, t: Snippet, a: Snippet) =
-  builder.add('(')
-  builder.add(typedUnaryOperators[unOp])
-  builder.add('(')
-  builder.add(a)
-  builder.add("))")
-
-proc addOp(builder: var Builder, binOp: UntypedBinaryOp, a, b: Snippet) =
-  builder.add('(')
-  builder.add(a)
-  builder.add(' ')
-  builder.add(untypedBinaryOperators[binOp])
-  builder.add(' ')
-  builder.add(b)
-  builder.add(')')
-
-proc addOp(builder: var Builder, unOp: UntypedUnaryOp, a: Snippet) =
-  builder.add('(')
-  builder.add(untypedUnaryOperators[unOp])
-  builder.add('(')
-  builder.add(a)
-  builder.add("))")
-
-template cOp(binOp: TypedBinaryOp, t: Snippet, a, b: Snippet): Snippet =
-  '(' & a & ' ' & typedBinaryOperators[binOp] & ' ' & b & ')'
-
-template cOp(binOp: TypedUnaryOp, t: Snippet, a: Snippet): Snippet =
-  '(' & typedUnaryOperators[binOp] & '(' & a & "))"
-
-template cOp(binOp: UntypedBinaryOp, a, b: Snippet): Snippet =
-  '(' & a & ' ' & untypedBinaryOperators[binOp] & ' ' & b & ')'
-
-template cOp(binOp: UntypedUnaryOp, a: Snippet): Snippet =
-  '(' & untypedUnaryOperators[binOp] & '(' & a & "))"
-
-template cIfExpr(cond, a, b: Snippet): Snippet =
-  # XXX used for `min` and `max`, maybe add nifc primitives for these
-  "(" & cond & " ? " & a & " : " & b & ")"
-
-template cUnlikely(val: Snippet): Snippet =
-  "NIM_UNLIKELY(" & val & ")"

compiler/cbuilderstmts.nim

@@ -1,329 +0,0 @@
-template addAssignmentWithValue(builder: var Builder, lhs: Snippet, valueBody: typed) =
-  builder.add(lhs)
-  builder.add(" = ")
-  valueBody
-  builder.addLineEnd(";")
-
-template addFieldAssignmentWithValue(builder: var Builder, lhs: Snippet, name: string, valueBody: typed) =
-  builder.add(lhs)
-  builder.add("." & name & " = ")
-  valueBody
-  builder.addLineEnd(";")
-
-template addAssignment(builder: var Builder, lhs, rhs: Snippet) =
-  builder.addAssignmentWithValue(lhs):
-    builder.add(rhs)
-
-template addFieldAssignment(builder: var Builder, lhs: Snippet, name: string, rhs: Snippet) =
-  builder.addFieldAssignmentWithValue(lhs, name):
-    builder.add(rhs)
-
-template addMutualFieldAssignment(builder: var Builder, lhs, rhs: Snippet, name: string) =
-  builder.addFieldAssignmentWithValue(lhs, name):
-    builder.add(rhs)
-    builder.add("." & name)
-
-template addAssignment(builder: var Builder, lhs: Snippet, rhs: int | int64 | uint64 | Int128) =
-  builder.addAssignmentWithValue(lhs):
-    builder.addIntValue(rhs)
-
-template addFieldAssignment(builder: var Builder, lhs: Snippet, name: string, rhs: int | int64 | uint64 | Int128) =
-  builder.addFieldAssignmentWithValue(lhs, name):
-    builder.addIntValue(rhs)
-
-template addDerefFieldAssignment(builder: var Builder, lhs: Snippet, name: string, rhs: Snippet) =
-  builder.add(lhs)
-  builder.add("->" & name & " = ")
-  builder.add(rhs)
-  builder.addLineEnd(";")
-
-template addSubscriptAssignment(builder: var Builder, lhs: Snippet, index: Snippet, rhs: Snippet) =
-  builder.add(lhs)
-  builder.add("[" & index & "] = ")
-  builder.add(rhs)
-  builder.addLineEnd(";")
-
-template addStmt(builder: var Builder, stmtBody: typed) =
-  ## makes an expression built by `stmtBody` into a statement
-  stmtBody
-  builder.addLineEnd(";")
-
-proc addCallStmt(builder: var Builder, callee: Snippet, args: varargs[Snippet]) =
-  builder.addStmt():
-    builder.addCall(callee, args)
-
-# XXX blocks need indent tracker in `Builder` object
-
-template addSingleIfStmt(builder: var Builder, cond: Snippet, body: typed) =
-  builder.add("if (")
-  builder.add(cond)
-  builder.addLineEndIndent(") {")
-  body
-  builder.addLineEndDedent("}")
-
-template addSingleIfStmtWithCond(builder: var Builder, condBody: typed, body: typed) =
-  builder.add("if (")
-  condBody
-  builder.addLineEndIndent(") {")
-  body
-  builder.addLineEndDedent("}")
-
-proc initIfStmt(builder: var Builder): IfBuilder =
-  IfBuilder(state: WaitingIf)
-
-proc finishIfStmt(builder: var Builder, stmt: IfBuilder) =
-  assert stmt.state != InBlock
-  builder.addNewline()
-
-template addIfStmt(builder: var Builder, stmt: out IfBuilder, body: typed) =
-  stmt = initIfStmt(builder)
-  body
-  finishIfStmt(builder, stmt)
-
-proc initElifBranch(builder: var Builder, stmt: var IfBuilder, cond: Snippet) =
-  case stmt.state
-  of WaitingIf:
-    builder.add("if (")
-  of WaitingElseIf:
-    builder.add(" else if (")
-  else: assert false, $stmt.state
-  builder.add(cond)
-  builder.addLineEndIndent(") {")
-  stmt.state = InBlock
-
-proc initElseBranch(builder: var Builder, stmt: var IfBuilder) =
-  assert stmt.state == WaitingElseIf, $stmt.state
-  builder.addLineEndIndent(" else {")
-  stmt.state = InBlock
-
-proc finishBranch(builder: var Builder, stmt: var IfBuilder) =
-  builder.addDedent("}")
-  stmt.state = WaitingElseIf
-
-template addElifBranch(builder: var Builder, stmt: var IfBuilder, cond: Snippet, body: typed) =
-  initElifBranch(builder, stmt, cond)
-  body
-  finishBranch(builder, stmt)
-
-template addElseBranch(builder: var Builder, stmt: var IfBuilder, body: typed) =
-  initElseBranch(builder, stmt)
-  body
-  finishBranch(builder, stmt)
-
-proc initForRange(builder: var Builder, i, start, bound: Snippet, inclusive: bool = false) =
-  builder.add("for (")
-  builder.add(i)
-  builder.add(" = ")
-  builder.add(start)
-  builder.add("; ")
-  builder.add(i)
-  if inclusive:
-    builder.add(" <= ")
-  else:
-    builder.add(" < ")
-  builder.add(bound)
-  builder.add("; ")
-  builder.add(i)
-  builder.addLineEndIndent("++) {")
-
-proc initForStep(builder: var Builder, i, start, bound, step: Snippet, inclusive: bool = false) =
-  builder.add("for (")
-  builder.add(i)
-  builder.add(" = ")
-  builder.add(start)
-  builder.add("; ")
-  builder.add(i)
-  if inclusive:
-    builder.add(" <= ")
-  else:
-    builder.add(" < ")
-  builder.add(bound)
-  builder.add("; ")
-  builder.add(i)
-  builder.add(" += ")
-  builder.add(step)
-  builder.addLineEndIndent(") {")
-
-proc finishFor(builder: var Builder) {.inline.} =
-  builder.addLineEndDedent("}")
-
-template addForRangeExclusive(builder: var Builder, i, start, bound: Snippet, body: typed) =
-  initForRange(builder, i, start, bound, false)
-  body
-  finishFor(builder)
-
-template addForRangeInclusive(builder: var Builder, i, start, bound: Snippet, body: typed) =
-  initForRange(builder, i, start, bound, true)
-  body
-  finishFor(builder)
-
-template addSwitchStmt(builder: var Builder, val: Snippet, body: typed) =
-  builder.add("switch (")
-  builder.add(val)
-  builder.addLineEnd(") {") # no indent
-  body
-  builder.addLineEnd("}")
-
-template addSingleSwitchCase(builder: var Builder, val: Snippet, body: typed) =
-  builder.add("case ")
-  builder.add(val)
-  builder.addLineEndIndent(":")
-  body
-  builder.addLineEndDedent("")
-
-type
-  SwitchCaseState = enum
-    None, Of, Else, Finished
-  SwitchCaseBuilder = object
-    state: SwitchCaseState
-
-proc addCase(builder: var Builder, info: var SwitchCaseBuilder, val: Snippet) =
-  if info.state != Of:
-    assert info.state == None
-    info.state = Of
-  builder.add("case ")
-  builder.add(val)
-  builder.addLineEndIndent(":")
-
-proc addCaseRange(builder: var Builder, info: var SwitchCaseBuilder, first, last: Snippet) =
-  if info.state != Of:
-    assert info.state == None
-    info.state = Of
-  builder.add("case ")
-  builder.add(first)
-  builder.add(" ... ")
-  builder.add(last)
-  builder.addLineEndIndent(":")
-
-proc addCaseElse(builder: var Builder, info: var SwitchCaseBuilder) =
-  assert info.state == None
-  info.state = Else
-  builder.addLineEndIndent("default:")
-
-template addSwitchCase(builder: var Builder, info: out SwitchCaseBuilder, caseBody, body: typed) =
-  info = SwitchCaseBuilder(state: None)
-  caseBody
-  info.state = Finished
-  body
-  builder.addLineEndDedent("")
-
-template addSwitchElse(builder: var Builder, body: typed) =
-  builder.addLineEndIndent("default:")
-  body
-  builder.addLineEndDedent("")
-
-proc addBreak(builder: var Builder) =
-  builder.addLineEnd("break;")
-
-type ScopeBuilder = object
-  inside: bool
-
-proc initScope(builder: var Builder): ScopeBuilder =
-  builder.addLineEndIndent("{")
-  result = ScopeBuilder(inside: true)
-
-proc finishScope(builder: var Builder, scope: var ScopeBuilder) =
-  assert scope.inside, "scope not inited"
-  builder.addLineEndDedent("}")
-  scope.inside = false
-
-template addScope(builder: var Builder, body: typed) =
-  builder.addLineEndIndent("{")
-  body
-  builder.addLineEndDedent("}")
-
-type WhileBuilder = object
-  inside: bool
-
-proc initWhileStmt(builder: var Builder, cond: Snippet): WhileBuilder =
-  builder.add("while (")
-  builder.add(cond)
-  builder.addLineEndIndent(") {")
-  result = WhileBuilder(inside: true)
-
-proc finishWhileStmt(builder: var Builder, stmt: var WhileBuilder) =
-  assert stmt.inside, "while stmt not inited"
-  builder.addLineEndDedent("}")
-  stmt.inside = false
-
-template addWhileStmt(builder: var Builder, cond: Snippet, body: typed) =
-  builder.add("while (")
-  builder.add(cond)
-  builder.addLineEndIndent(") {")
-  body
-  builder.addLineEndDedent("}")
-
-proc addLabel(builder: var Builder, name: TLabel) =
-  builder.add(name)
-  builder.addLineEnd(": ;")
-
-proc addReturn(builder: var Builder) =
-  builder.addLineEnd("return;")
-
-proc addReturn(builder: var Builder, value: Snippet) =
-  builder.add("return ")
-  builder.add(value)
-  builder.addLineEnd(";")
-
-proc addGoto(builder: var Builder, label: TLabel) =
-  builder.add("goto ")
-  builder.add(label)
-  builder.addLineEnd(";")
-
-proc addComputedGoto(builder: var Builder, value: Snippet) =
-  builder.add("goto *")
-  builder.add(value)
-  builder.addLineEnd(";")
-
-proc addIncr(builder: var Builder, val: Snippet) =
-  builder.add(val)
-  builder.addLineEnd("++;")
-
-proc addDecr(builder: var Builder, val: Snippet) =
-  builder.add(val)
-  builder.addLineEnd("--;")
-
-proc addInPlaceOp(builder: var Builder, binOp: TypedBinaryOp, t: Snippet, a, b: Snippet) =
-  builder.add(a)
-  builder.add(' ')
-  builder.add(typedBinaryOperators[binOp])
-  builder.add("= ")
-  builder.add(b)
-  builder.addLineEnd(";")
-
-proc addInPlaceOp(builder: var Builder, binOp: UntypedBinaryOp, a, b: Snippet) =
-  builder.add(a)
-  builder.add(' ')
-  builder.add(untypedBinaryOperators[binOp])
-  builder.add("= ")
-  builder.add(b)
-  builder.addLineEnd(";")
-
-proc cInPlaceOp(binOp: TypedBinaryOp, t: Snippet, a, b: Snippet): Snippet =
-  result = ""
-  result.add(a)
-  result.add(' ')
-  result.add(typedBinaryOperators[binOp])
-  result.add("= ")
-  result.add(b)
-  result.add(";\n")
-
-proc cInPlaceOp(binOp: UntypedBinaryOp, a, b: Snippet): Snippet =
-  result = ""
-  result.add(a)
-  result.add(' ')
-  result.add(untypedBinaryOperators[binOp])
-  result.add("= ")
-  result.add(b)
-  result.add(";\n")
-
-template addCPragma(builder: var Builder, val: Snippet) =
-  builder.addNewline()
-  builder.add("#pragma ")
-  builder.add(val)
-  builder.addNewline()
-
-proc addDiscard(builder: var Builder, val: Snippet) =
-  builder.add("(void)")
-  builder.add(val)
-  builder.addLineEnd(";")

compiler/ccgcalls.nim

@@ -84,21 +84,20 @@ proc cleanupTemp(p: BProc; returnType: PType, tmp: TLoc): bool =
     let dtor = getAttachedOp(p.module.g.graph, returnType, attachedDestructor)
     var op = initLocExpr(p, newSymNode(dtor))
     var callee = rdLoc(op)
-    let destroyArg =
-      if dtor.typ.firstParamType.kind == tyVar:
-        cAddr(rdLoc(tmp))
+    let destroy = if dtor.typ.firstParamType.kind == tyVar:
+        callee & "(&" & rdLoc(tmp) & ")"
       else:
-        rdLoc(tmp)
-    let destroy = cCall(callee, destroyArg)
+        callee & "(" & rdLoc(tmp) & ")"
     raiseExitCleanup(p, destroy)
     result = true
   else:
     result = false
 
 proc fixupCall(p: BProc, le, ri: PNode, d: var TLoc,
-               result: var Builder, call: var CallBuilder) =
+               callee, params: Rope) =
   let canRaise = p.config.exc == excGoto and canRaiseDisp(p, ri[0])
   genLineDir(p, ri)
+  var pl = callee & "(" & params
   # getUniqueType() is too expensive here:
   var typ = skipTypes(ri[0].typ, abstractInst)
   if typ.returnType != nil:
@@ -107,6 +106,7 @@ proc fixupCall(p: BProc, le, ri: PNode, d: var TLoc,
       # perhaps generate no temp if the call doesn't have side effects
       flags.incl needTempForOpenArray
     if isInvalidReturnType(p.config, typ):
+      if params.len != 0: pl.add(", ")
       # beware of 'result = p(result)'. We may need to allocate a temporary:
       if d.k in {locTemp, locNone} or not preventNrvo(p, d.lode, le, ri):
         # Great, we can use 'd':
@@ -114,39 +114,33 @@ proc fixupCall(p: BProc, le, ri: PNode, d: var TLoc,
         elif d.k notin {locTemp} and not hasNoInit(ri):
           # reset before pass as 'result' var:
           discard "resetLoc(p, d)"
-        let rad = addrLoc(p.config, d)
-        result.addArgument(call):
-          result.add(rad)
-        result.finishCallBuilder(call)
-        p.s(cpsStmts).addStmt():
-          p.s(cpsStmts).add(extract(result))
+        pl.add(addrLoc(p.config, d))
+        pl.add(");\n")
+        line(p, cpsStmts, pl)
       else:
         var tmp: TLoc = getTemp(p, typ.returnType, needsInit=true)
-        let ratmp = addrLoc(p.config, tmp)
-        result.addArgument(call):
-          result.add(ratmp)
-        result.finishCallBuilder(call)
-        p.s(cpsStmts).addStmt():
-          p.s(cpsStmts).add(extract(result))
+        pl.add(addrLoc(p.config, tmp))
+        pl.add(");\n")
+        line(p, cpsStmts, pl)
         genAssignment(p, d, tmp, {}) # no need for deep copying
       if canRaise: raiseExit(p)
     else:
-      result.finishCallBuilder(call)
+      pl.add(")")
       if p.module.compileToCpp:
         if lfSingleUse in d.flags:
           # do not generate spurious temporaries for C++! For C we're better off
           # with them to prevent undefined behaviour and because the codegen
           # is free to emit expressions multiple times!
           d.k = locCall
-          d.snippet = extract(result)
+          d.snippet = pl
           excl d.flags, lfSingleUse
         else:
           if d.k == locNone and p.splitDecls == 0 and p.config.exc != excGoto:
-            d = getTempCpp(p, typ.returnType, extract(result))
+            d = getTempCpp(p, typ.returnType, pl)
           else:
             if d.k == locNone: d = getTemp(p, typ.returnType)
             var list = initLoc(locCall, d.lode, OnUnknown)
-            list.snippet = extract(result)
+            list.snippet = pl
             genAssignment(p, d, list, {needAssignCall}) # no need for deep copying
             if canRaise: raiseExit(p)
 
@@ -157,7 +151,7 @@ proc fixupCall(p: BProc, le, ri: PNode, d: var TLoc,
           d = getTemp(p, typ.returnType)
         assert(d.t != nil)        # generate an assignment to d:
         var list = initLoc(locCall, d.lode, OnUnknown)
-        list.snippet = extract(result)
+        list.snippet = pl
         genAssignment(p, d, list, flags+{needAssignCall}) # no need for deep copying
         if canRaise:
           if not (useTemp and cleanupTemp(p, typ.returnType, d)):
@@ -165,16 +159,15 @@ proc fixupCall(p: BProc, le, ri: PNode, d: var TLoc,
       else:
         var tmp: TLoc = getTemp(p, typ.returnType, needsInit=true)
         var list = initLoc(locCall, d.lode, OnUnknown)
-        list.snippet = extract(result)
+        list.snippet = pl
         genAssignment(p, tmp, list, flags+{needAssignCall}) # no need for deep copying
         if canRaise:
           if not cleanupTemp(p, typ.returnType, tmp):
             raiseExit(p)
         genAssignment(p, d, tmp, {})
   else:
-    finishCallBuilder(result, call)
-    p.s(cpsStmts).addStmt():
-      p.s(cpsStmts).add(extract(result))
+    pl.add(");\n")
+    line(p, cpsStmts, pl)
     if canRaise: raiseExit(p)
 
 proc genBoundsCheck(p: BProc; arr, a, b: TLoc; arrTyp: PType)
@@ -206,49 +199,49 @@ proc genOpenArraySlice(p: BProc; q: PNode; formalType, destType: PType; prepareF
   if optBoundsCheck in p.options:
     genBoundsCheck(p, a, b, c, ty)
   if prepareForMutation:
-    let bra = byRefLoc(p, a)
-    p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimPrepareStrMutationV2"),
-      bra)
+    linefmt(p, cpsStmts, "#nimPrepareStrMutationV2($1);$n", [byRefLoc(p, a)])
   let dest = getTypeDesc(p.module, destType)
-  let ra = rdLoc(a)
-  let rb = rdLoc(b)
-  let rc = rdLoc(c)
-  let lengthExpr = cOp(Add, NimInt, cOp(Sub, NimInt, rc, rb), cIntValue(1))
+  let lengthExpr = "($1)-($2)+1" % [rdLoc(c), rdLoc(b)]
   case ty.kind
   of tyArray:
     let first = toInt64(firstOrd(p.config, ty))
     if first == 0:
-      result = (cCast(ptrType(dest), cOp(Add, NimInt, ra, rb)), lengthExpr)
+      result = ("($3*)(($1)+($2))" % [rdLoc(a), rdLoc(b), dest],
+                lengthExpr)
     else:
-      let lit = cIntLiteral(first)
-      result = (cCast(ptrType(dest), cOp(Add, NimInt, ra, cOp(Sub, NimInt, rb, lit))), lengthExpr)
+      var lit = newRopeAppender()
+      intLiteral(first, lit)
+      result = ("($4*)($1)+(($2)-($3))" %
+        [rdLoc(a), rdLoc(b), lit, dest],
+        lengthExpr)
   of tyOpenArray, tyVarargs:
-    let data = if reifiedOpenArray(q[1]): dotField(ra, "Field0") else: ra
-    result = (cCast(ptrType(dest), cOp(Add, NimInt, data, rb)), lengthExpr)
+    if reifiedOpenArray(q[1]):
+      result = ("($3*)($1.Field0)+($2)" % [rdLoc(a), rdLoc(b), dest],
+                lengthExpr)
+    else:
+      result = ("($3*)($1)+($2)" % [rdLoc(a), rdLoc(b), dest],
+                lengthExpr)
   of tyUncheckedArray, tyCstring:
-    result = (cCast(ptrType(dest), cOp(Add, NimInt, ra, rb)), lengthExpr)
+    result = ("($3*)($1)+($2)" % [rdLoc(a), rdLoc(b), dest],
+              lengthExpr)
   of tyString, tySequence:
     let atyp = skipTypes(a.t, abstractInst)
     if formalType.skipTypes(abstractInst).kind in {tyVar} and atyp.kind == tyString and
         optSeqDestructors in p.config.globalOptions:
-      let bra = byRefLoc(p, a)
-      p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimPrepareStrMutationV2"),
-        bra)
-    var val: Snippet
+      linefmt(p, cpsStmts, "#nimPrepareStrMutationV2($1);$n", [byRefLoc(p, a)])
     if atyp.kind in {tyVar} and not compileToCpp(p.module):
-      val = cDeref(ra)
+      result = ("(($5) ? (($4*)(*$1)$3+($2)) : NIM_NIL)" %
+                  [rdLoc(a), rdLoc(b), dataField(p), dest, dataFieldAccessor(p, "*" & rdLoc(a))],
+                lengthExpr)
     else:
-      val = ra
-    result = (
-      cIfExpr(dataFieldAccessor(p, val),
-        cCast(ptrType(dest), cOp(Add, NimInt, dataField(p, val), rb)),
-        NimNil),
-      lengthExpr)
+      result = ("(($5) ? (($4*)$1$3+($2)) : NIM_NIL)" %
+                  [rdLoc(a), rdLoc(b), dataField(p), dest, dataFieldAccessor(p, rdLoc(a))],
+                lengthExpr)
   else:
     result = ("", "")
     internalError(p.config, "openArrayLoc: " & typeToString(a.t))
 
-proc openArrayLoc(p: BProc, formalType: PType, n: PNode; result: var Builder) =
+proc openArrayLoc(p: BProc, formalType: PType, n: PNode; result: var Rope) =
   var q = skipConv(n)
   var skipped = false
   while q.kind == nkStmtListExpr and q.len > 0:
@@ -263,66 +256,42 @@ proc openArrayLoc(p: BProc, formalType: PType, n: PNode; result: var Builder) =
           genStmts(p, q[i])
         q = q.lastSon
     let (x, y) = genOpenArraySlice(p, q, formalType, n.typ.elementType)
-    result.add(x)
-    result.addArgumentSeparator()
-    result.add(y)
+    result.add x & ", " & y
   else:
     var a = initLocExpr(p, if n.kind == nkHiddenStdConv: n[1] else: n)
     case skipTypes(a.t, abstractVar+{tyStatic}).kind
     of tyOpenArray, tyVarargs:
-      let ra = rdLoc(a)
       if reifiedOpenArray(n):
         if a.t.kind in {tyVar, tyLent}:
-          result.add(derefField(ra, "Field0"))
-          result.addArgumentSeparator()
-          result.add(derefField(ra, "Field1"))
+          result.add "$1->Field0, $1->Field1" % [rdLoc(a)]
         else:
-          result.add(dotField(ra, "Field0"))
-          result.addArgumentSeparator()
-          result.add(dotField(ra, "Field1"))
+          result.add "$1.Field0, $1.Field1" % [rdLoc(a)]
       else:
-        result.add(ra)
-        result.addArgumentSeparator()
-        result.add(ra & "Len_0")
+        result.add "$1, $1Len_0" % [rdLoc(a)]
     of tyString, tySequence:
       let ntyp = skipTypes(n.typ, abstractInst)
       if formalType.skipTypes(abstractInst).kind in {tyVar} and ntyp.kind == tyString and
           optSeqDestructors in p.config.globalOptions:
-        let bra = byRefLoc(p, a)
-        p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimPrepareStrMutationV2"),
-          bra)
+        linefmt(p, cpsStmts, "#nimPrepareStrMutationV2($1);$n", [byRefLoc(p, a)])
       if ntyp.kind in {tyVar} and not compileToCpp(p.module):
-        let ra = a.rdLoc
-        var t = TLoc(snippet: cDeref(ra))
-        let lt = lenExpr(p, t)
-        result.add(cIfExpr(dataFieldAccessor(p, t.snippet), dataField(p, t.snippet), NimNil))
-        result.addArgumentSeparator()
-        result.add(lt)
+        var t = TLoc(snippet: "(*$1)" % [a.rdLoc])
+        result.add "($4) ? ((*$1)$3) : NIM_NIL, $2" %
+                     [a.rdLoc, lenExpr(p, t), dataField(p),
+                      dataFieldAccessor(p, "*" & a.rdLoc)]
       else:
-        let ra = a.rdLoc
-        let la = lenExpr(p, a)
-        result.add(cIfExpr(dataFieldAccessor(p, ra), dataField(p, ra), NimNil))
-        result.addArgumentSeparator()
-        result.add(la)
+        result.add "($4) ? ($1$3) : NIM_NIL, $2" %
+                     [a.rdLoc, lenExpr(p, a), dataField(p), dataFieldAccessor(p, a.rdLoc)]
     of tyArray:
-      let ra = rdLoc(a)
-      result.add(ra)
-      result.addArgumentSeparator()
-      result.addIntValue(lengthOrd(p.config, a.t))
+      result.add "$1, $2" % [rdLoc(a), rope(lengthOrd(p.config, a.t))]
     of tyPtr, tyRef:
       case elementType(a.t).kind
       of tyString, tySequence:
-        let ra = a.rdLoc
-        var t = TLoc(snippet: cDeref(ra))
-        let lt = lenExpr(p, t)
-        result.add(cIfExpr(dataFieldAccessor(p, t.snippet), dataField(p, t.snippet), NimNil))
-        result.addArgumentSeparator()
-        result.add(lt)
+        var t = TLoc(snippet: "(*$1)" % [a.rdLoc])
+        result.add "($4) ? ((*$1)$3) : NIM_NIL, $2" %
+                     [a.rdLoc, lenExpr(p, t), dataField(p),
+                      dataFieldAccessor(p, "*" & a.rdLoc)]
       of tyArray:
-        let ra = rdLoc(a)
-        result.add(ra)
-        result.addArgumentSeparator()
-        result.addIntValue(lengthOrd(p.config, elementType(a.t)))
+        result.add "$1, $2" % [rdLoc(a), rope(lengthOrd(p.config, elementType(a.t)))]
       else:
         internalError(p.config, "openArrayLoc: " & typeToString(a.t))
     else: internalError(p.config, "openArrayLoc: " & typeToString(a.t))
@@ -342,12 +311,11 @@ proc literalsNeedsTmp(p: BProc, a: TLoc): TLoc =
   result = getTemp(p, a.lode.typ, needsInit=false)
   genAssignment(p, result, a, {})
 
-proc genArgStringToCString(p: BProc, n: PNode; result: var Builder; needsTmp: bool) {.inline.} =
+proc genArgStringToCString(p: BProc, n: PNode; result: var Rope; needsTmp: bool) {.inline.} =
   var a = initLocExpr(p, n[0])
-  let ra = withTmpIfNeeded(p, a, needsTmp).rdLoc
-  result.addCall(cgsymValue(p.module, "nimToCStringConv"), ra)
+  appcg(p.module, result, "#nimToCStringConv($1)", [withTmpIfNeeded(p, a, needsTmp).rdLoc])
 
-proc genArg(p: BProc, n: PNode, param: PSym; call: PNode; result: var Builder; needsTmp = false) =
+proc genArg(p: BProc, n: PNode, param: PSym; call: PNode; result: var Rope; needsTmp = false) =
   var a: TLoc
   if n.kind == nkStringToCString:
     genArgStringToCString(p, n, result, needsTmp)
@@ -388,11 +356,12 @@ proc genArg(p: BProc, n: PNode, param: PSym; call: PNode; result: var Builder; n
     if param.typ.kind in {tyVar, tyPtr, tyRef, tySink}:
       let typ = skipTypes(param.typ, abstractPtrs)
       if not sameBackendTypePickyAliases(typ, n.typ.skipTypes(abstractPtrs)):
-        a.snippet = cCast(getTypeDesc(p.module, param.typ), rdCharLoc(a))
+        a.snippet = "(($1) ($2))" %
+          [getTypeDesc(p.module, param.typ), rdCharLoc(a)]
     addRdLoc(withTmpIfNeeded(p, a, needsTmp), result)
   #assert result != nil
 
-proc genArgNoParam(p: BProc, n: PNode; result: var Builder; needsTmp = false) =
+proc genArgNoParam(p: BProc, n: PNode; result: var Rope; needsTmp = false) =
   var a: TLoc
   if n.kind == nkStringToCString:
     genArgStringToCString(p, n, result, needsTmp)
@@ -455,7 +424,7 @@ proc getPotentialReads(n: PNode; result: var seq[PNode]) =
     for s in n:
       getPotentialReads(s, result)
 
-proc genParams(p: BProc, ri: PNode, typ: PType; result: var Builder, argBuilder: var CallBuilder) =
+proc genParams(p: BProc, ri: PNode, typ: PType; result: var Rope) =
   # We must generate temporaries in cases like #14396
   # to keep the strict Left-To-Right evaluation
   var needTmp = newSeq[bool](ri.len - 1)
@@ -477,22 +446,21 @@ proc genParams(p: BProc, ri: PNode, typ: PType; result: var Builder, argBuilder:
         # Optimization: don't use a temp, if we would only take the address anyway
         needTmp[i - 1] = false
 
+  var oldLen = result.len
   for i in 1..<ri.len:
     if i < typ.n.len:
       assert(typ.n[i].kind == nkSym)
       let paramType = typ.n[i]
       if not paramType.typ.isCompileTimeOnly:
-        var arg = newBuilder("")
-        genArg(p, ri[i], paramType.sym, ri, arg, needTmp[i-1])
-        if arg.buf.len != 0:
-          result.addArgument(argBuilder):
-            result.add(extract(arg))
+        if oldLen != result.len:
+          result.add(", ")
+          oldLen = result.len
+        genArg(p, ri[i], paramType.sym, ri, result, needTmp[i-1])
     else:
-      var arg = newBuilder("")
-      genArgNoParam(p, ri[i], arg, needTmp[i-1])
-      if arg.buf.len != 0:
-        result.addArgument(argBuilder):
-          result.add(extract(arg))
+      if oldLen != result.len:
+        result.add(", ")
+        oldLen = result.len
+      genArgNoParam(p, ri[i], result, needTmp[i-1])
 
 proc addActualSuffixForHCR(res: var Rope, module: PSym, sym: PSym) =
   if sym.flags * {sfImportc, sfNonReloadable} == {} and sym.loc.k == locProc and
@@ -506,39 +474,21 @@ proc genPrefixCall(p: BProc, le, ri: PNode, d: var TLoc) =
   var typ = skipTypes(ri[0].typ, abstractInstOwned)
   assert(typ.kind == tyProc)
 
+  var params = newRopeAppender()
+  genParams(p, ri, typ, params)
+
   var callee = rdLoc(op)
   if p.hcrOn and ri[0].kind == nkSym:
     callee.addActualSuffixForHCR(p.module.module, ri[0].sym)
-
-  var res = newBuilder("")
-  var call = initCallBuilder(res, callee)
-  genParams(p, ri, typ, res, call)
-  fixupCall(p, le, ri, d, res, call)
+  fixupCall(p, le, ri, d, callee, params)
 
 proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) =
 
-  template callProc(rp, params, pTyp: Snippet): Snippet =
-    let e = dotField(rp, "ClE_0")
-    let p = dotField(rp, "ClP_0")
-    let eCall =
-      # note `params` here is actually multiple params
-      if params.len == 0:
-        cCall(p, e)
-      else:
-        cCall(p, params, e)
-    cIfExpr(e,
-      eCall, 
-      cCall(cCast(pTyp, p), params))
+  proc addComma(r: Rope): Rope =
+    if r.len == 0: r else: r & ", "
 
-  template callIter(rp, params: Snippet): Snippet =
-    # we know the env exists
-    let e = dotField(rp, "ClE_0")
-    let p = dotField(rp, "ClP_0")
-    # note `params` here is actually multiple params
-    if params.len == 0:
-      cCall(p, e)
-    else:
-      cCall(p, params, e)
+  const PatProc = "$1.ClE_0? $1.ClP_0($3$1.ClE_0):(($4)($1.ClP_0))($2)"
+  const PatIter = "$1.ClP_0($3$1.ClE_0)" # we know the env exists
 
   var op = initLocExpr(p, ri[0])
 
@@ -546,23 +496,20 @@ proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) =
   var typ = skipTypes(ri[0].typ, abstractInstOwned)
   assert(typ.kind == tyProc)
 
-  var params = newBuilder("")
-  var argBuilder = default(CallBuilder) # not initCallBuilder, we just want the params
-  genParams(p, ri, typ, params, argBuilder)
+  var pl = newRopeAppender()
+  genParams(p, ri, typ, pl)
 
   template genCallPattern {.dirty.} =
-    let rp = rdLoc(op)
-    let pars = extract(params)
-    p.s(cpsStmts).addStmt():
-      if tfIterator in typ.flags:
-        p.s(cpsStmts).add(callIter(rp, pars))
-      else:
-        p.s(cpsStmts).add(callProc(rp, pars, rawProc))
+    if tfIterator in typ.flags:
+      lineF(p, cpsStmts, PatIter & ";$n", [rdLoc(op), pl, pl.addComma, rawProc])
+    else:
+      lineF(p, cpsStmts, PatProc & ";$n", [rdLoc(op), pl, pl.addComma, rawProc])
 
   let rawProc = getClosureType(p.module, typ, clHalf)
   let canRaise = p.config.exc == excGoto and canRaiseDisp(p, ri[0])
   if typ.returnType != nil:
     if isInvalidReturnType(p.config, typ):
+      if ri.len > 1: pl.add(", ")
       # beware of 'result = p(result)'. We may need to allocate a temporary:
       if d.k in {locTemp, locNone} or not preventNrvo(p, d.lode, le, ri):
         # Great, we can use 'd':
@@ -571,14 +518,12 @@ proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) =
         elif d.k notin {locTemp} and not hasNoInit(ri):
           # reset before pass as 'result' var:
           discard "resetLoc(p, d)"
-        params.addArgument(argBuilder):
-          params.add(addrLoc(p.config, d))
+        pl.add(addrLoc(p.config, d))
         genCallPattern()
         if canRaise: raiseExit(p)
       else:
         var tmp: TLoc = getTemp(p, typ.returnType, needsInit=true)
-        params.addArgument(argBuilder):
-          params.add(addrLoc(p.config, tmp))
+        pl.add(addrLoc(p.config, tmp))
         genCallPattern()
         if canRaise: raiseExit(p)
         genAssignment(p, d, tmp, {}) # no need for deep copying
@@ -586,24 +531,20 @@ proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) =
       if d.k == locNone: d = getTemp(p, typ.returnType)
       assert(d.t != nil)        # generate an assignment to d:
       var list: TLoc = initLoc(locCall, d.lode, OnUnknown)
-      let rp = rdLoc(op)
-      let pars = extract(params)
       if tfIterator in typ.flags:
-        list.snippet = callIter(rp, pars)
+        list.snippet = PatIter % [rdLoc(op), pl, pl.addComma, rawProc]
       else:
-        list.snippet = callProc(rp, pars, rawProc)
+        list.snippet = PatProc % [rdLoc(op), pl, pl.addComma, rawProc]
       genAssignment(p, d, list, {}) # no need for deep copying
       if canRaise: raiseExit(p)
     else:
       var tmp: TLoc = getTemp(p, typ.returnType)
       assert(d.t != nil)        # generate an assignment to d:
       var list: TLoc = initLoc(locCall, d.lode, OnUnknown)
-      let rp = rdLoc(op)
-      let pars = extract(params)
       if tfIterator in typ.flags:
-        list.snippet = callIter(rp, pars)
+        list.snippet = PatIter % [rdLoc(op), pl, pl.addComma, rawProc]
       else:
-        list.snippet = callProc(rp, pars, rawProc)
+        list.snippet = PatProc % [rdLoc(op), pl, pl.addComma, rawProc]
       genAssignment(p, tmp, list, {})
       if canRaise: raiseExit(p)
       genAssignment(p, d, tmp, {})
@@ -611,8 +552,8 @@ proc genClosureCall(p: BProc, le, ri: PNode, d: var TLoc) =
     genCallPattern()
     if canRaise: raiseExit(p)
 
-proc genOtherArg(p: BProc; ri: PNode; i: int; typ: PType; result: var Builder;
-                 argBuilder: var CallBuilder) =
+proc genOtherArg(p: BProc; ri: PNode; i: int; typ: PType; result: var Rope;
+                 argsCounter: var int) =
   if i < typ.n.len:
     # 'var T' is 'T&' in C++. This means we ignore the request of
     # any nkHiddenAddr when it's a 'var T'.
@@ -621,17 +562,20 @@ proc genOtherArg(p: BProc; ri: PNode; i: int; typ: PType; result: var Builder;
     if paramType.typ.isCompileTimeOnly:
       discard
     elif paramType.typ.kind in {tyVar} and ri[i].kind == nkHiddenAddr:
-      result.addArgument(argBuilder):
-        genArgNoParam(p, ri[i][0], result)
+      if argsCounter > 0: result.add ", "
+      genArgNoParam(p, ri[i][0], result)
+      inc argsCounter
     else:
-      result.addArgument(argBuilder):
-        genArgNoParam(p, ri[i], result) #, typ.n[i].sym)
+      if argsCounter > 0: result.add ", "
+      genArgNoParam(p, ri[i], result) #, typ.n[i].sym)
+      inc argsCounter
   else:
     if tfVarargs notin typ.flags:
       localError(p.config, ri.info, "wrong argument count")
     else:
-      result.addArgument(argBuilder):
-        genArgNoParam(p, ri[i], result)
+      if argsCounter > 0: result.add ", "
+      genArgNoParam(p, ri[i], result)
+      inc argsCounter
 
 discard """
 Dot call syntax in C++
@@ -688,7 +632,7 @@ proc skipAddrDeref(node: PNode): PNode =
   else:
     result = node
 
-proc genThisArg(p: BProc; ri: PNode; i: int; typ: PType; result: var Builder) =
+proc genThisArg(p: BProc; ri: PNode; i: int; typ: PType; result: var Rope) =
   # for better or worse c2nim translates the 'this' argument to a 'var T'.
   # However manual wrappers may also use 'ptr T'. In any case we support both
   # for convenience.
@@ -723,15 +667,15 @@ proc genThisArg(p: BProc; ri: PNode; i: int; typ: PType; result: var Builder) =
     genArgNoParam(p, ri, result) #, typ.n[i].sym)
     result.add(".")
 
-proc genPatternCall(p: BProc; ri: PNode; pat: string; typ: PType; result: var Builder) =
+proc genPatternCall(p: BProc; ri: PNode; pat: string; typ: PType; result: var Rope) =
   var i = 0
   var j = 1
   while i < pat.len:
     case pat[i]
     of '@':
-      var callBuilder = default(CallBuilder) # not init call builder
+      var argsCounter = 0
       for k in j..<ri.len:
-        genOtherArg(p, ri, k, typ, result, callBuilder)
+        genOtherArg(p, ri, k, typ, result, argsCounter)
       inc i
     of '#':
       if i+1 < pat.len and pat[i+1] in {'+', '@'}:
@@ -741,11 +685,11 @@ proc genPatternCall(p: BProc; ri: PNode; pat: string; typ: PType; result: var Bu
           if pat[i+1] == '+': genArgNoParam(p, ri[0], result)
           result.add("(")
           if 1 < ri.len:
-            var callBuilder: CallBuilder = default(CallBuilder)
-            genOtherArg(p, ri, 1, typ, result, callBuilder)
+            var argsCounterB = 0
+            genOtherArg(p, ri, 1, typ, result, argsCounterB)
           for k in j+1..<ri.len:
-            var callBuilder: CallBuilder = default(CallBuilder)
-            genOtherArg(p, ri, k, typ, result, callBuilder)
+            var argsCounterB = 0
+            genOtherArg(p, ri, k, typ, result, argsCounterB)
           result.add(")")
         else:
           localError(p.config, ri.info, "call expression expected for C++ pattern")
@@ -759,15 +703,15 @@ proc genPatternCall(p: BProc; ri: PNode; pat: string; typ: PType; result: var Bu
         genArgNoParam(p, arg, result)
         #result.add debugTree(arg, 0, 10)
       else:
-        var callBuilder = default(CallBuilder) # not init call builder
-        genOtherArg(p, ri, j, typ, result, callBuilder)
+        var argsCounter = 0
+        genOtherArg(p, ri, j, typ, result, argsCounter)
       inc j
       inc i
     of '\'':
       var idx, stars: int = 0
       if scanCppGenericSlot(pat, i, idx, stars):
         var t = resolveStarsInCppType(typ, idx, stars)
-        if t == nil: result.add(CVoid)
+        if t == nil: result.add("void")
         else: result.add(getTypeDesc(p.module, t))
     else:
       let start = i
@@ -786,7 +730,7 @@ proc genInfixCall(p: BProc, le, ri: PNode, d: var TLoc) =
   let pat = $ri[0].sym.loc.snippet
   internalAssert p.config, pat.len > 0
   if pat.contains({'#', '(', '@', '\''}):
-    var pl = newBuilder("")
+    var pl = newRopeAppender()
     genPatternCall(p, ri, pat, typ, pl)
     # simpler version of 'fixupCall' that works with the pl+params combination:
     var typ = skipTypes(ri[0].typ, abstractInst)
@@ -796,32 +740,32 @@ proc genInfixCall(p: BProc, le, ri: PNode, d: var TLoc) =
         # with them to prevent undefined behaviour and because the codegen
         # is free to emit expressions multiple times!
         d.k = locCall
-        d.snippet = extract(pl)
+        d.snippet = pl
         excl d.flags, lfSingleUse
       else:
         if d.k == locNone: d = getTemp(p, typ.returnType)
         assert(d.t != nil)        # generate an assignment to d:
         var list: TLoc = initLoc(locCall, d.lode, OnUnknown)
-        list.snippet = extract(pl)
+        list.snippet = pl
         genAssignment(p, d, list, {}) # no need for deep copying
     else:
-      p.s(cpsStmts).addStmt():
-        p.s(cpsStmts).add(extract(pl))
+      pl.add(";\n")
+      line(p, cpsStmts, pl)
   else:
-    var pl = newBuilder("")
+    var pl = newRopeAppender()
+    var argsCounter = 0
     if 1 < ri.len:
       genThisArg(p, ri, 1, typ, pl)
     pl.add(op.snippet)
-    var res = newBuilder("")
-    var call = initCallBuilder(res, extract(pl))
+    var params = newRopeAppender()
     for i in 2..<ri.len:
-      genOtherArg(p, ri, i, typ, res, call)
-    fixupCall(p, le, ri, d, res, call)
+      genOtherArg(p, ri, i, typ, params, argsCounter)
+    fixupCall(p, le, ri, d, pl, params)
 
 proc genNamedParamCall(p: BProc, ri: PNode, d: var TLoc) =
   # generates a crappy ObjC call
   var op = initLocExpr(p, ri[0])
-  var pl = newBuilder("[")
+  var pl = "["
   # getUniqueType() is too expensive here:
   var typ = skipTypes(ri[0].typ, abstractInst)
   assert(typ.kind == tyProc)
@@ -863,27 +807,24 @@ proc genNamedParamCall(p: BProc, ri: PNode, d: var TLoc) =
         if d.k == locNone: d = getTemp(p, typ.returnType, needsInit=true)
         pl.add("Result: ")
         pl.add(addrLoc(p.config, d))
-        pl.add("]")
-        p.s(cpsStmts).addStmt():
-          p.s(cpsStmts).add(extract(pl))
+        pl.add("];\n")
+        line(p, cpsStmts, pl)
       else:
         var tmp: TLoc = getTemp(p, typ.returnType, needsInit=true)
         pl.add(addrLoc(p.config, tmp))
-        pl.add("]")
-        p.s(cpsStmts).addStmt():
-          p.s(cpsStmts).add(extract(pl))
+        pl.add("];\n")
+        line(p, cpsStmts, pl)
         genAssignment(p, d, tmp, {}) # no need for deep copying
     else:
       pl.add("]")
       if d.k == locNone: d = getTemp(p, typ.returnType)
       assert(d.t != nil)        # generate an assignment to d:
       var list: TLoc = initLoc(locCall, ri, OnUnknown)
-      list.snippet = extract(pl)
+      list.snippet = pl
       genAssignment(p, d, list, {}) # no need for deep copying
   else:
-    pl.add("]")
-    p.s(cpsStmts).addStmt():
-      p.s(cpsStmts).add(extract(pl))
+    pl.add("];\n")
+    line(p, cpsStmts, pl)
 
 proc notYetAlive(n: PNode): bool {.inline.} =
   let r = getRoot(n)

compiler/ccgliterals.nim

@@ -36,84 +36,52 @@ proc genStringLiteralDataOnlyV1(m: BModule, s: string; result: var Rope) =
   cgsym(m, "TGenericSeq")
   let tmp = getTempName(m)
   result.add tmp
-  var res = newBuilder("")
-  res.addVarWithTypeAndInitializer(AlwaysConst, name = tmp):
-    res.addSimpleStruct(m, name = "", baseType = ""):
-      res.addField(name = "Sup", typ = "TGenericSeq")
-      res.addArrayField(name = "data", elementType = NimChar, len = s.len + 1)
-  do:
-    var strInit: StructInitializer
-    res.addStructInitializer(strInit, kind = siOrderedStruct):
-      res.addField(strInit, name = "Sup"):
-        var seqInit: StructInitializer
-        res.addStructInitializer(seqInit, kind = siOrderedStruct):
-          res.addField(seqInit, name = "len"):
-            res.addIntValue(s.len)
-          res.addField(seqInit, name = "reserved"):
-            res.add(cCast(NimInt, cOp(BitOr, NimUint, cCast(NimUint, cIntValue(s.len)), NimStrlitFlag)))
-      res.addField(strInit, name = "data"):
-        res.add(makeCString(s))
-  m.s[cfsStrData].add(extract(res))
+  m.s[cfsStrData].addf("STRING_LITERAL($1, $2, $3);$n",
+       [tmp, makeCString(s), rope(s.len)])
 
-proc genStringLiteralV1(m: BModule; n: PNode; result: var Builder) =
+proc genStringLiteralV1(m: BModule; n: PNode; result: var Rope) =
   if s.isNil:
-    result.add(cCast(ptrType(cgsymValue(m, "NimStringDesc")), NimNil))
+    appcg(m, result, "((#NimStringDesc*) NIM_NIL)", [])
   else:
     let id = nodeTableTestOrSet(m.dataCache, n, m.labels)
-    var name: string = ""
     if id == m.labels:
       # string literal not found in the cache:
-      genStringLiteralDataOnlyV1(m, n.strVal, name)
+      appcg(m, result, "((#NimStringDesc*) &", [])
+      genStringLiteralDataOnlyV1(m, n.strVal, result)
+      result.add ")"
     else:
-      name = m.tmpBase & $id
-    result.add(cCast(ptrType(cgsymValue(m, "NimStringDesc")), cAddr(name)))
+      appcg(m, result, "((#NimStringDesc*) &$1$2)",
+                      [m.tmpBase, id])
 
 # ------ Version 2: destructor based strings and seqs -----------------------
 
 proc genStringLiteralDataOnlyV2(m: BModule, s: string; result: Rope; isConst: bool) =
-  var res = newBuilder("")
-  res.addVarWithTypeAndInitializer(
-      if isConst: AlwaysConst else: Global,
-      name = result):
-    res.addSimpleStruct(m, name = "", baseType = ""):
-      res.addField(name = "cap", typ = NimInt)
-      res.addArrayField(name = "data", elementType = NimChar, len = s.len + 1)
-  do:
-    var structInit: StructInitializer
-    res.addStructInitializer(structInit, kind = siOrderedStruct):
-      res.addField(structInit, name = "cap"):
-        res.add(cOp(BitOr, NimInt, cIntValue(s.len), NimStrlitFlag))
-      res.addField(structInit, name = "data"):
-        res.add(makeCString(s))
-  m.s[cfsStrData].add(extract(res))
+  m.s[cfsStrData].addf("static $4 struct {$n" &
+       "  NI cap; NIM_CHAR data[$2+1];$n" &
+       "} $1 = { $2 | NIM_STRLIT_FLAG, $3 };$n",
+       [result, rope(s.len), makeCString(s),
+       rope(if isConst: "const" else: "")])
 
-proc genStringLiteralV2(m: BModule; n: PNode; isConst: bool; result: var Builder) =
+proc genStringLiteralV2(m: BModule; n: PNode; isConst: bool; result: var Rope) =
   let id = nodeTableTestOrSet(m.dataCache, n, m.labels)
-  var litName: string
   if id == m.labels:
+    let pureLit = getTempName(m)
+    genStringLiteralDataOnlyV2(m, n.strVal, pureLit, isConst)
+    let tmp = getTempName(m)
+    result.add tmp
     cgsym(m, "NimStrPayload")
     cgsym(m, "NimStringV2")
     # string literal not found in the cache:
-    litName = getTempName(m)
-    genStringLiteralDataOnlyV2(m, n.strVal, litName, isConst)
+    m.s[cfsStrData].addf("static $4 NimStringV2 $1 = {$2, (NimStrPayload*)&$3};$n",
+          [tmp, rope(n.strVal.len), pureLit, rope(if isConst: "const" else: "")])
   else:
-    litName = m.tmpBase & $id
-  let tmp = getTempName(m)
-  result.add tmp
-  var res = newBuilder("")
-  res.addVarWithInitializer(
-      if isConst: AlwaysConst else: Global,
-      name = tmp,
-      typ = "NimStringV2"):
-    var strInit: StructInitializer
-    res.addStructInitializer(strInit, kind = siOrderedStruct):
-      res.addField(strInit, name = "len"):
-        res.addIntValue(n.strVal.len)
-      res.addField(strInit, name = "p"):
-        res.add(cCast(ptrType("NimStrPayload"), cAddr(litName)))
-  m.s[cfsStrData].add(extract(res))
+    let tmp = getTempName(m)
+    result.add tmp
+    m.s[cfsStrData].addf("static $4 NimStringV2 $1 = {$2, (NimStrPayload*)&$3};$n",
+          [tmp, rope(n.strVal.len), m.tmpBase & rope(id),
+          rope(if isConst: "const" else: "")])
 
-proc genStringLiteralV2Const(m: BModule; n: PNode; isConst: bool; result: var Builder) =
+proc genStringLiteralV2Const(m: BModule; n: PNode; isConst: bool; result: var Rope) =
   let id = nodeTableTestOrSet(m.dataCache, n, m.labels)
   var pureLit: Rope
   if id == m.labels:
@@ -124,12 +92,7 @@ proc genStringLiteralV2Const(m: BModule; n: PNode; isConst: bool; result: var Bu
     genStringLiteralDataOnlyV2(m, n.strVal, pureLit, isConst)
   else:
     pureLit = m.tmpBase & rope(id)
-  var strInit: StructInitializer
-  result.addStructInitializer(strInit, kind = siOrderedStruct):
-    result.addField(strInit, name = "len"):
-      result.addIntValue(n.strVal.len)
-    result.addField(strInit, name = "p"):
-      result.add(cCast(ptrType("NimStrPayload"), cAddr(pureLit)))
+  result.addf "{$1, (NimStrPayload*)&$2}", [rope(n.strVal.len), pureLit]
 
 # ------ Version selector ---------------------------------------------------
 
@@ -144,10 +107,10 @@ proc genStringLiteralDataOnly(m: BModule; s: string; info: TLineInfo;
   else:
     localError(m.config, info, "cannot determine how to produce code for string literal")
 
-proc genNilStringLiteral(m: BModule; info: TLineInfo; result: var Builder) =
-  result.add(cCast(ptrType(cgsymValue(m, "NimStringDesc")), NimNil))
+proc genNilStringLiteral(m: BModule; info: TLineInfo; result: var Rope) =
+  appcg(m, result, "((#NimStringDesc*) NIM_NIL)", [])
 
-proc genStringLiteral(m: BModule; n: PNode; result: var Builder) =
+proc genStringLiteral(m: BModule; n: PNode; result: var Rope) =
   case detectStrVersion(m)
   of 0, 1: genStringLiteralV1(m, n, result)
   of 2: genStringLiteralV2(m, n, isConst = true, result)

compiler/ccgreset.nim

@@ -27,28 +27,25 @@ proc specializeResetN(p: BProc, accessor: Rope, n: PNode;
     if disc.loc.snippet == "": fillObjectFields(p.module, typ)
     if disc.loc.t == nil:
       internalError(p.config, n.info, "specializeResetN()")
-    let discField = dotField(accessor, disc.loc.snippet)
-    p.s(cpsStmts).addSwitchStmt(discField):
-      for i in 1..<n.len:
-        let branch = n[i]
-        assert branch.kind in {nkOfBranch, nkElse}
-        var caseBuilder: SwitchCaseBuilder
-        p.s(cpsStmts).addSwitchCase(caseBuilder):
-          if branch.kind == nkOfBranch:
-            genCaseRange(p, branch, caseBuilder)
-          else:
-            p.s(cpsStmts).addCaseElse(caseBuilder)
-        do:
-          specializeResetN(p, accessor, lastSon(branch), typ)
-          p.s(cpsStmts).addBreak()
-    specializeResetT(p, discField, disc.loc.t)
+    lineF(p, cpsStmts, "switch ($1.$2) {$n", [accessor, disc.loc.snippet])
+    for i in 1..<n.len:
+      let branch = n[i]
+      assert branch.kind in {nkOfBranch, nkElse}
+      if branch.kind == nkOfBranch:
+        genCaseRange(p, branch)
+      else:
+        lineF(p, cpsStmts, "default:$n", [])
+      specializeResetN(p, accessor, lastSon(branch), typ)
+      lineF(p, cpsStmts, "break;$n", [])
+    lineF(p, cpsStmts, "} $n", [])
+    specializeResetT(p, "$1.$2" % [accessor, disc.loc.snippet], disc.loc.t)
   of nkSym:
     let field = n.sym
     if field.typ.kind == tyVoid: return
     if field.loc.snippet == "": fillObjectFields(p.module, typ)
     if field.loc.t == nil:
       internalError(p.config, n.info, "specializeResetN()")
-    specializeResetT(p, dotField(accessor, field.loc.snippet), field.loc.t)
+    specializeResetT(p, "$1.$2" % [accessor, field.loc.snippet], field.loc.t)
   else: internalError(p.config, n.info, "specializeResetN()")
 
 proc specializeResetT(p: BProc, accessor: Rope, typ: PType) =
@@ -61,8 +58,10 @@ proc specializeResetT(p: BProc, accessor: Rope, typ: PType) =
   of tyArray:
     let arraySize = lengthOrd(p.config, typ.indexType)
     var i: TLoc = getTemp(p, getSysType(p.module.g.graph, unknownLineInfo, tyInt))
-    p.s(cpsStmts).addForRangeExclusive(i.snippet, cIntValue(0), cIntValue(arraySize)):
-      specializeResetT(p, subscript(accessor, i.snippet), typ.elementType)
+    linefmt(p, cpsStmts, "for ($1 = 0; $1 < $2; $1++) {$n",
+            [i.snippet, arraySize])
+    specializeResetT(p, ropecg(p.module, "$1[$2]", [accessor, i.snippet]), typ.elementType)
+    lineF(p, cpsStmts, "}$n", [])
   of tyObject:
     var x = typ.baseClass
     if x != nil: x = x.skipTypes(skipPtrs)
@@ -71,34 +70,28 @@ proc specializeResetT(p: BProc, accessor: Rope, typ: PType) =
   of tyTuple:
     let typ = getUniqueType(typ)
     for i, a in typ.ikids:
-      specializeResetT(p, dotField(accessor, "Field" & $i), a)
+      specializeResetT(p, ropecg(p.module, "$1.Field$2", [accessor, i]), a)
 
   of tyString, tyRef, tySequence:
-    p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "unsureAsgnRef"),
-      cCast(ptrType(CPointer), cAddr(accessor)),
-      NimNil)
+    lineCg(p, cpsStmts, "#unsureAsgnRef((void**)&$1, NIM_NIL);$n", [accessor])
 
   of tyProc:
     if typ.callConv == ccClosure:
-      p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "unsureAsgnRef"),
-        cCast(ptrType(CPointer), cAddr(dotField(accessor, "ClE_0"))),
-        NimNil)
-      p.s(cpsStmts).addFieldAssignment(accessor, "ClP_0", NimNil)
+      lineCg(p, cpsStmts, "#unsureAsgnRef((void**)&$1.ClE_0, NIM_NIL);$n", [accessor])
+      lineCg(p, cpsStmts, "$1.ClP_0 = NIM_NIL;$n", [accessor])
     else:
-      p.s(cpsStmts).addAssignment(accessor, NimNil)
+      lineCg(p, cpsStmts, "$1 = NIM_NIL;$n", [accessor])
   of tyChar, tyBool, tyEnum, tyRange, tyInt..tyUInt64:
-    p.s(cpsStmts).addAssignment(accessor, cIntValue(0))
+    lineCg(p, cpsStmts, "$1 = 0;$n", [accessor])
   of tyCstring, tyPointer, tyPtr, tyVar, tyLent:
-    p.s(cpsStmts).addAssignment(accessor, NimNil)
+    lineCg(p, cpsStmts, "$1 = NIM_NIL;$n", [accessor])
   of tySet:
     case mapSetType(p.config, typ)
     of ctArray:
-      let t = getTypeDesc(p.module, typ)
-      p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimZeroMem"),
-        accessor,
-        cSizeof(t))
+      lineCg(p, cpsStmts, "#nimZeroMem($1, sizeof($2));$n",
+          [accessor, getTypeDesc(p.module, typ)])
     of ctInt8, ctInt16, ctInt32, ctInt64:
-      p.s(cpsStmts).addAssignment(accessor, cIntValue(0))
+      lineCg(p, cpsStmts, "$1 = 0;$n", [accessor])
     else:
       raiseAssert "unexpected set type kind"
   of tyNone, tyEmpty, tyNil, tyUntyped, tyTyped, tyGenericInvocation,

compiler/ccgthreadvars.nim

@@ -19,12 +19,9 @@ proc accessThreadLocalVar(p: BProc, s: PSym) =
   if emulatedThreadVars(p.config) and threadVarAccessed notin p.flags:
     p.flags.incl threadVarAccessed
     incl p.module.flags, usesThreadVars
-    p.procSec(cpsLocals).addVar(kind = Local,
-      name = "NimTV_",
-      typ = ptrType("NimThreadVars"))
-    p.procSec(cpsInit).addAssignment("NimTV_",
-      cCast(ptrType("NimThreadVars"),
-        cCall(cgsymValue(p.module, "GetThreadLocalVars"))))
+    p.procSec(cpsLocals).addf("\tNimThreadVars* NimTV_;$n", [])
+    p.procSec(cpsInit).add(
+      ropecg(p.module, "\tNimTV_ = (NimThreadVars*) #GetThreadLocalVars();$n", []))
 
 proc declareThreadVar(m: BModule, s: PSym, isExtern: bool) =
   if emulatedThreadVars(m.config):
@@ -33,32 +30,30 @@ proc declareThreadVar(m: BModule, s: PSym, isExtern: bool) =
     # allocator for it :-(
     if not containsOrIncl(m.g.nimtvDeclared, s.id):
       m.g.nimtvDeps.add(s.loc.t)
-      m.g.nimtv.addField(name = s.loc.snippet, typ = getTypeDesc(m, s.loc.t))
+      m.g.nimtv.addf("$1 $2;$n", [getTypeDesc(m, s.loc.t), s.loc.snippet])
   else:
-    let vis =
-      if isExtern: Extern
-      elif lfExportLib in s.loc.flags: ExportLibVar
-      else: Private
-    m.s[cfsVars].addVar(m, s,
-      name = s.loc.snippet,
-      typ = getTypeDesc(m, s.loc.t),
-      kind = Threadvar,
-      visibility = vis)
+    if isExtern: m.s[cfsVars].add("extern ")
+    elif lfExportLib in s.loc.flags: m.s[cfsVars].add("N_LIB_EXPORT_VAR ")
+    else: m.s[cfsVars].add("N_LIB_PRIVATE ")
+    if optThreads in m.config.globalOptions:
+      let sym = s.typ.sym
+      if sym != nil and sfCppNonPod in sym.flags:
+        m.s[cfsVars].add("NIM_THREAD_LOCAL ")
+      else: m.s[cfsVars].add("NIM_THREADVAR ")
+    m.s[cfsVars].add(getTypeDesc(m, s.loc.t))
+    m.s[cfsVars].addf(" $1;$n", [s.loc.snippet])
 
 proc generateThreadLocalStorage(m: BModule) =
-  if m.g.nimtv.buf.len != 0 and (usesThreadVars in m.flags or sfMainModule in m.module.flags):
+  if m.g.nimtv != "" and (usesThreadVars in m.flags or sfMainModule in m.module.flags):
     for t in items(m.g.nimtvDeps): discard getTypeDesc(m, t)
     finishTypeDescriptions(m)
-    m.s[cfsSeqTypes].addTypedef(name = "NimThreadVars"):
-      m.s[cfsSeqTypes].addSimpleStruct(m, name = "", baseType = ""):
-        m.s[cfsSeqTypes].add(extract(m.g.nimtv))
+    m.s[cfsSeqTypes].addf("typedef struct {$1} NimThreadVars;$n", [m.g.nimtv])
 
 proc generateThreadVarsSize(m: BModule) =
-  if m.g.nimtv.buf.len != 0:
+  if m.g.nimtv != "":
     let externc = if m.config.backend == backendCpp or
-                       sfCompileToCpp in m.module.flags: ExternC
-                  else: None
-    m.s[cfsProcs].addDeclWithVisibility(externc):
-      m.s[cfsProcs].addProcHeader("NimThreadVarsSize", NimInt, cProcParams())
-      m.s[cfsProcs].finishProcHeaderWithBody():
-        m.s[cfsProcs].addReturn(cCast(NimInt, cSizeof("NimThreadVars")))
+                       sfCompileToCpp in m.module.flags: "extern \"C\" "
+                  else: ""
+    m.s[cfsProcs].addf(
+      "$#NI NimThreadVarsSize(){return (NI)sizeof(NimThreadVars);}$n",
+      [externc.rope])

compiler/ccgtrav.nim

@@ -16,16 +16,13 @@ type
     p: BProc
     visitorFrmt: string
 
+const
+  visitorFrmt = "#nimGCvisit((void*)$1, $2);$n"
 
 proc genTraverseProc(c: TTraversalClosure, accessor: Rope, typ: PType)
-proc genCaseRange(p: BProc, branch: PNode, info: var SwitchCaseBuilder)
+proc genCaseRange(p: BProc, branch: PNode)
 proc getTemp(p: BProc, t: PType, needsInit=false): TLoc
 
-proc visit(p: BProc, data, visitor: Snippet) =
-  p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimGCvisit"),
-    cCast(CPointer, data),
-    visitor)
-
 proc genTraverseProc(c: TTraversalClosure, accessor: Rope, n: PNode;
                      typ: PType) =
   if n == nil: return
@@ -40,32 +37,29 @@ proc genTraverseProc(c: TTraversalClosure, accessor: Rope, n: PNode;
     if disc.loc.snippet == "": fillObjectFields(c.p.module, typ)
     if disc.loc.t == nil:
       internalError(c.p.config, n.info, "genTraverseProc()")
-    let discField = dotField(accessor, disc.loc.snippet)
-    p.s(cpsStmts).addSwitchStmt(discField):
-      for i in 1..<n.len:
-        let branch = n[i]
-        assert branch.kind in {nkOfBranch, nkElse}
-        var caseBuilder: SwitchCaseBuilder
-        p.s(cpsStmts).addSwitchCase(caseBuilder):
-          if branch.kind == nkOfBranch:
-            genCaseRange(c.p, branch, caseBuilder)
-          else:
-            p.s(cpsStmts).addCaseElse(caseBuilder)
-        do:
-          genTraverseProc(c, accessor, lastSon(branch), typ)
-          p.s(cpsStmts).addBreak()
+    lineF(p, cpsStmts, "switch ($1.$2) {$n", [accessor, disc.loc.snippet])
+    for i in 1..<n.len:
+      let branch = n[i]
+      assert branch.kind in {nkOfBranch, nkElse}
+      if branch.kind == nkOfBranch:
+        genCaseRange(c.p, branch)
+      else:
+        lineF(p, cpsStmts, "default:$n", [])
+      genTraverseProc(c, accessor, lastSon(branch), typ)
+      lineF(p, cpsStmts, "break;$n", [])
+    lineF(p, cpsStmts, "} $n", [])
   of nkSym:
     let field = n.sym
     if field.typ.kind == tyVoid: return
     if field.loc.snippet == "": fillObjectFields(c.p.module, typ)
     if field.loc.t == nil:
       internalError(c.p.config, n.info, "genTraverseProc()")
-    genTraverseProc(c, dotField(accessor, field.loc.snippet), field.loc.t)
+    genTraverseProc(c, "$1.$2" % [accessor, field.loc.snippet], field.loc.t)
   else: internalError(c.p.config, n.info, "genTraverseProc()")
 
 proc parentObj(accessor: Rope; m: BModule): Rope {.inline.} =
   if not m.compileToCpp:
-    result = dotField(accessor, "Sup")
+    result = "$1.Sup" % [accessor]
   else:
     result = accessor
 
@@ -82,14 +76,16 @@ proc genTraverseProc(c: TTraversalClosure, accessor: Rope, typ: PType) =
     let arraySize = lengthOrd(c.p.config, typ.indexType)
     var i: TLoc = getTemp(p, getSysType(c.p.module.g.graph, unknownLineInfo, tyInt))
     var oldCode = p.s(cpsStmts)
-    var oldLen, newLen: int
-    p.s(cpsStmts).addForRangeExclusive(i.snippet, cIntValue(0), cIntValue(arraySize)):
-      oldLen = p.s(cpsStmts).buf.len
-      genTraverseProc(c, subscript(accessor, i.snippet), typ.elementType)
-      newLen = p.s(cpsStmts).buf.len
-    if oldLen == newLen:
+    freeze oldCode
+    linefmt(p, cpsStmts, "for ($1 = 0; $1 < $2; $1++) {$n",
+            [i.snippet, arraySize])
+    let oldLen = p.s(cpsStmts).len
+    genTraverseProc(c, ropecg(c.p.module, "$1[$2]", [accessor, i.snippet]), typ.elementType)
+    if p.s(cpsStmts).len == oldLen:
       # do not emit dummy long loops for faster debug builds:
       p.s(cpsStmts) = oldCode
+    else:
+      lineF(p, cpsStmts, "}$n", [])
   of tyObject:
     var x = typ.baseClass
     if x != nil: x = x.skipTypes(skipPtrs)
@@ -98,25 +94,23 @@ proc genTraverseProc(c: TTraversalClosure, accessor: Rope, typ: PType) =
   of tyTuple:
     let typ = getUniqueType(typ)
     for i, a in typ.ikids:
-      genTraverseProc(c, dotField(accessor, "Field" & $i), a)
+      genTraverseProc(c, ropecg(c.p.module, "$1.Field$2", [accessor, i]), a)
   of tyRef:
-    visit(p, accessor, c.visitorFrmt)
+    lineCg(p, cpsStmts, visitorFrmt, [accessor, c.visitorFrmt])
   of tySequence:
     if optSeqDestructors notin c.p.module.config.globalOptions:
-      visit(p, accessor, c.visitorFrmt)
+      lineCg(p, cpsStmts, visitorFrmt, [accessor, c.visitorFrmt])
     elif containsGarbageCollectedRef(typ.elementType):
       # destructor based seqs are themselves not traced but their data is, if
       # they contain a GC'ed type:
-      p.s(cpsStmts).addCallStmt(cgsymValue(p.module, "nimGCvisitSeq"),
-        cCast(CPointer, accessor),
-        c.visitorFrmt)
+      lineCg(p, cpsStmts, "#nimGCvisitSeq((void*)$1, $2);$n", [accessor, c.visitorFrmt])
       #genTraverseProcSeq(c, accessor, typ)
   of tyString:
     if tfHasAsgn notin typ.flags:
-      visit(p, accessor, c.visitorFrmt)
+      lineCg(p, cpsStmts, visitorFrmt, [accessor, c.visitorFrmt])
   of tyProc:
     if typ.callConv == ccClosure:
-      visit(p, dotField(accessor, "ClE_0"), c.visitorFrmt)
+      lineCg(p, cpsStmts, visitorFrmt, [ropecg(c.p.module, "$1.ClE_0", [accessor]), c.visitorFrmt])
   else:
     discard
 
@@ -125,17 +119,18 @@ proc genTraverseProcSeq(c: TTraversalClosure, accessor: Rope, typ: PType) =
   assert typ.kind == tySequence
   var i = getTemp(p, getSysType(c.p.module.g.graph, unknownLineInfo, tyInt))
   var oldCode = p.s(cpsStmts)
-  var oldLen, newLen: int
+  freeze oldCode
   var a = TLoc(snippet: accessor)
-  let le = lenExpr(c.p, a)
 
-  p.s(cpsStmts).addForRangeExclusive(i.snippet, cIntValue(0), le):
-    oldLen = p.s(cpsStmts).buf.len
-    genTraverseProc(c, subscript(dataField(c.p, accessor), i.snippet), typ.elementType)
-    newLen = p.s(cpsStmts).buf.len
-  if newLen == oldLen:
+  lineF(p, cpsStmts, "for ($1 = 0; $1 < $2; $1++) {$n",
+      [i.snippet, lenExpr(c.p, a)])
+  let oldLen = p.s(cpsStmts).len
+  genTraverseProc(c, "$1$3[$2]" % [accessor, i.snippet, dataField(c.p)], typ.elementType)
+  if p.s(cpsStmts).len == oldLen:
     # do not emit dummy long loops for faster debug builds:
     p.s(cpsStmts) = oldCode
+  else:
+    lineF(p, cpsStmts, "}$n", [])
 
 proc genTraverseProc(m: BModule, origTyp: PType; sig: SigHash): Rope =
   var p = newProc(nil, m)
@@ -144,10 +139,11 @@ proc genTraverseProc(m: BModule, origTyp: PType; sig: SigHash): Rope =
     hcrOn = m.hcrOn
     typ = origTyp.skipTypes(abstractInstOwned)
     markerName = if hcrOn: result & "_actual" else: result
+    header = "static N_NIMCALL(void, $1)(void* p, NI op)" % [markerName]
     t = getTypeDesc(m, typ)
 
-  p.s(cpsLocals).addVar(kind = Local, name = "a", typ = t)
-  p.s(cpsInit).addAssignment("a", cCast(t, "p"))
+  lineF(p, cpsLocals, "$1 a;$n", [t])
+  lineF(p, cpsInit, "a = ($1)p;$n", [t])
 
   var c = TTraversalClosure(p: p,
     visitorFrmt: "op" # "#nimGCvisit((void*)$1, op);$n"
@@ -161,40 +157,18 @@ proc genTraverseProc(m: BModule, origTyp: PType; sig: SigHash): Rope =
       # C's arrays are broken beyond repair:
       genTraverseProc(c, "a".rope, typ.elementType)
     else:
-      genTraverseProc(c, cDeref("a"), typ.elementType)
+      genTraverseProc(c, "(*a)".rope, typ.elementType)
 
-  var headerBuilder = newBuilder("")
-  headerBuilder.addProcHeaderWithParams(ccNimCall, markerName, CVoid):
-    var paramBuilder: ProcParamBuilder
-    headerBuilder.addProcParams(paramBuilder):
-      headerBuilder.addParam(paramBuilder, name = "p", typ = CPointer)
-      headerBuilder.addParam(paramBuilder, name = "op", typ = NimInt)
-  let header = extract(headerBuilder)
+  let generatedProc = "$1 {$n$2$3$4}\n" %
+        [header, p.s(cpsLocals), p.s(cpsInit), p.s(cpsStmts)]
 
-  m.s[cfsProcHeaders].addDeclWithVisibility(StaticProc):
-    m.s[cfsProcHeaders].add(header)
-    m.s[cfsProcHeaders].finishProcHeaderAsProto()
-  m.s[cfsProcs].addDeclWithVisibility(StaticProc):
-    m.s[cfsProcs].add(header)
-    m.s[cfsProcs].finishProcHeaderWithBody():
-      m.s[cfsProcs].add(extract(p.s(cpsLocals)))
-      m.s[cfsProcs].add(extract(p.s(cpsInit)))
-      m.s[cfsProcs].add(extract(p.s(cpsStmts)))
+  m.s[cfsProcHeaders].addf("$1;\n", [header])
+  m.s[cfsProcs].add(generatedProc)
 
   if hcrOn:
-    var desc = newBuilder("")
-    var unnamedParamBuilder: ProcParamBuilder
-    desc.addProcParams(unnamedParamBuilder):
-      desc.addUnnamedParam(unnamedParamBuilder, CPointer)
-      desc.addUnnamedParam(unnamedParamBuilder, NimInt)
-    let unnamedParams = extract(desc)
-    m.s[cfsProcHeaders].addProcVar(ccNimCall, result, unnamedParams, CVoid)
-    m.s[cfsDynLibInit].addAssignmentWithValue(result):
-      m.s[cfsDynLibInit].addCast(procPtrTypeUnnamed(ccNimCall, CVoid, unnamedParams)):
-        m.s[cfsDynLibInit].addCall("hcrRegisterProc",
-          getModuleDllPath(m),
-          '"' & result & '"',
-          cCast(CPointer, markerName))
+    m.s[cfsProcHeaders].addf("N_NIMCALL_PTR(void, $1)(void*, NI);\n", [result])
+    m.s[cfsDynLibInit].addf("\t$1 = (N_NIMCALL_PTR(void, )(void*, NI)) hcrRegisterProc($3, \"$1\", (void*)$2);\n",
+         [result, markerName, getModuleDllPath(m)])
 
 proc genTraverseProcForGlobal(m: BModule, s: PSym; info: TLineInfo): Rope =
   discard genTypeInfoV1(m, s.loc.t, info)
@@ -205,28 +179,17 @@ proc genTraverseProcForGlobal(m: BModule, s: PSym; info: TLineInfo): Rope =
 
   if sfThread in s.flags and emulatedThreadVars(m.config):
     accessThreadLocalVar(p, s)
-    sLoc = derefField("NimTV_", sLoc)
+    sLoc = "NimTV_->" & sLoc
 
   var c = TTraversalClosure(p: p,
-    visitorFrmt: cIntValue(0) # "#nimGCvisit((void*)$1, 0);$n"
+    visitorFrmt: "0" # "#nimGCvisit((void*)$1, 0);$n"
   )
 
+  let header = "static N_NIMCALL(void, $1)(void)" % [result]
   genTraverseProc(c, sLoc, s.loc.t)
 
-  var headerBuilder = newBuilder("")
-  headerBuilder.addProcHeaderWithParams(ccNimCall, result, CVoid):
-    var paramBuilder: ProcParamBuilder
-    headerBuilder.addProcParams(paramBuilder):
-      # (void)
-      discard
-  let header = extract(headerBuilder)
+  let generatedProc = "$1 {$n$2$3$4}$n" %
+        [header, p.s(cpsLocals), p.s(cpsInit), p.s(cpsStmts)]
 
-  m.s[cfsProcHeaders].addDeclWithVisibility(StaticProc):
-    m.s[cfsProcHeaders].add(header)
-    m.s[cfsProcHeaders].finishProcHeaderAsProto()
-  m.s[cfsProcs].addDeclWithVisibility(StaticProc):
-    m.s[cfsProcs].add(header)
-    m.s[cfsProcs].finishProcHeaderWithBody():
-      m.s[cfsProcs].add(extract(p.s(cpsLocals)))
-      m.s[cfsProcs].add(extract(p.s(cpsInit)))
-      m.s[cfsProcs].add(extract(p.s(cpsStmts)))
+  m.s[cfsProcHeaders].addf("$1;$n", [header])
+  m.s[cfsProcs].add(generatedProc)

compiler/cgendata.nim

@@ -11,7 +11,7 @@
 
 import
   ast, ropes, options,
-  lineinfos, pathutils, modulegraphs, cbuilderbase
+  lineinfos, pathutils, modulegraphs
 
 import std/[intsets, tables, sets]
 
@@ -43,12 +43,12 @@ type
     ctUInt, ctUInt8, ctUInt16, ctUInt32, ctUInt64,
     ctArray, ctPtrToArray, ctStruct, ctPtr, ctNimStr, ctNimSeq, ctProc,
     ctCString
-  TCFileSections* = array[TCFileSection, Builder] # represents a generated C file
+  TCFileSections* = array[TCFileSection, Rope] # represents a generated C file
   TCProcSection* = enum       # the sections a generated C proc consists of
     cpsLocals,                # section of local variables for C proc
     cpsInit,                  # section for init of variables for C proc
     cpsStmts                  # section of local statements for C proc
-  TCProcSections* = array[TCProcSection, Builder] # represents a generated C proc
+  TCProcSections* = array[TCProcSection, Rope] # represents a generated C proc
   BModule* = ref TCGen
   BProc* = ref TCProc
   TBlock* = object
@@ -115,7 +115,7 @@ type
                         # computing alive data on our own.
 
   BModuleList* = ref object of RootObj
-    mainModProcs*, mainModInit*, otherModsInit*, mainDatInit*: Builder
+    mainModProcs*, mainModInit*, otherModsInit*, mainDatInit*: Rope
     mapping*: Rope             # the generated mapping file (if requested)
     modules*: seq[BModule]     # list of all compiled modules
     modulesClosed*: seq[BModule] # list of the same compiled modules, but in the order they were closed
@@ -127,7 +127,7 @@ type
     graph*: ModuleGraph
     strVersion*, seqVersion*: int # version of the string/seq implementation to use
 
-    nimtv*: Builder         # Nim thread vars; the struct body
+    nimtv*: Rope            # Nim thread vars; the struct body
     nimtvDeps*: seq[PType]  # type deps: every module needs whole struct
     nimtvDeclared*: IntSet  # so that every var/field exists only once
                             # in the struct
@@ -161,15 +161,14 @@ type
     typeInfoMarkerV2*: TypeCache
     initProc*: BProc          # code for init procedure
     preInitProc*: BProc       # code executed before the init proc
-    hcrCreateTypeInfosProc*: Builder # type info globals are in here when HCR=on
+    hcrCreateTypeInfosProc*: Rope # type info globals are in here when HCR=on
     inHcrInitGuard*: bool     # We are currently within a HCR reloading guard.
-    hcrInitGuard*: IfBuilder
     typeStack*: TTypeSeq      # used for type generation
     dataCache*: TNodeTable
     typeNodes*, nimTypes*: int # used for type info generation
     typeNodesName*, nimTypesName*: Rope # used for type info generation
     labels*: Natural          # for generating unique module-scope names
-    extensionLoaders*: array['0'..'9', Builder] # special procs for the
+    extensionLoaders*: array['0'..'9', Rope] # special procs for the
                                              # OpenGL wrapper
     sigConflicts*: CountTable[SigHash]
     g*: BModuleList
@@ -182,18 +181,18 @@ proc includeHeader*(this: BModule; header: string) =
   if not this.headerFiles.contains header:
     this.headerFiles.add header
 
-proc s*(p: BProc, s: TCProcSection): var Builder {.inline.} =
+proc s*(p: BProc, s: TCProcSection): var Rope {.inline.} =
   # section in the current block
   result = p.blocks[^1].sections[s]
 
-proc procSec*(p: BProc, s: TCProcSection): var Builder {.inline.} =
+proc procSec*(p: BProc, s: TCProcSection): var Rope {.inline.} =
   # top level proc sections
   result = p.blocks[0].sections[s]
 
 proc initBlock*(): TBlock =
   result = TBlock()
   for i in low(result.sections)..high(result.sections):
-    result.sections[i] = newBuilder("")
+    result.sections[i] = newRopeAppender()
 
 proc newProc*(prc: PSym, module: BModule): BProc =
   result = BProc(

compiler/condsyms.nim

@@ -159,7 +159,7 @@ proc initDefines*(symbols: StringTableRef) =
   defineSymbol("nimHasEnsureMove")
   defineSymbol("nimHasNoReturnError")
 
-  defineSymbol("nimUseStrictDefs") # deadcode
+  defineSymbol("nimUseStrictDefs")
   defineSymbol("nimHasNolineTooLong")
 
   defineSymbol("nimHasCastExtendedVm")
@@ -171,4 +171,3 @@ proc initDefines*(symbols: StringTableRef) =
   defineSymbol("nimHasJsNoLambdaLifting")
   defineSymbol("nimHasDefaultFloatRoundtrip")
   defineSymbol("nimHasXorSet")
-

compiler/liftdestructors.nim

@@ -1207,8 +1207,6 @@ proc produceSym(g: ModuleGraph; c: PContext; typ: PType; kind: TTypeAttachedOp;
     result.ast[pragmasPos].add newTree(nkExprColonExpr,
         newIdentNode(g.cache.getIdent("raises"),  info), newNodeI(nkBracket, info))
 
-  if kind == attachedDestructor:
-    incl result.options, optQuirky
   completePartialOp(g, idgen.module, typ, kind, result)
 
 

compiler/options.nim

@@ -222,7 +222,7 @@ type
     strictEffects,
     unicodeOperators, # deadcode
     flexibleOptionalParams,
-    strictDefs, # deadcode
+    strictDefs,
     strictCaseObjects,
     inferGenericTypes,
     openSym, # remove nfDisabledOpenSym when this is default

compiler/pragmas.nim

@@ -1318,12 +1318,8 @@ proc singlePragma(c: PContext, sym: PSym, n: PNode, i: var int,
         pragmaProposition(c, it)
       of wEnsures:
         pragmaEnsures(c, it)
-      of wEnforceNoRaises:
+      of wEnforceNoRaises, wQuirky:
         sym.flags.incl sfNeverRaises
-      of wQuirky:
-        sym.flags.incl sfNeverRaises
-        if sym.kind in {skProc, skMethod, skConverter, skFunc, skIterator}:
-          sym.options.incl optQuirky
       of wSystemRaisesDefect:
         sym.flags.incl sfSystemRaisesDefect
       of wVirtual:

compiler/semtypes.nim

@@ -1501,10 +1501,7 @@ proc semProcTypeNode(c: PContext, n, genericParams: PNode,
       addParamOrResult(c, arg, kind)
       styleCheckDef(c, a[j].info, arg)
       onDef(a[j].info, arg)
-      if a[j].kind == nkPragmaExpr:
-        a[j][0] = newSymNode(arg)
-      else:
-        a[j] = newSymNode(arg)
+      a[j] = newSymNode(arg)
 
   var r: PType = nil
   if n[0].kind != nkEmpty:

compiler/sigmatch.nim

@@ -1692,8 +1692,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
         if aAsObject.kind == tyObject and trIsOutParam notin flags:
           let baseType = aAsObject.base
           if baseType != nil:
-            if tfFinal notin aAsObject.flags:
-              inc c.inheritancePenalty, 1 + int(c.inheritancePenalty < 0)
+            inc c.inheritancePenalty, 1 + int(c.inheritancePenalty < 0)
             let ret = typeRel(c, f, baseType, flags)
             return if ret in {isEqual,isGeneric}: isSubtype else: ret
 
@@ -1734,10 +1733,6 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
           let tr = typeRel(c, f[i], x[i], flags)
           if tr <= isSubtype: return
         result = isGeneric
-        let impl = last(f[0])
-        if impl.kind == tyObject and tfFinal notin impl.flags:
-          # match non-invocation case
-          inc c.inheritancePenalty, 0 + int(c.inheritancePenalty < 0)
     elif x.kind == tyGenericInst and f[0] == x[0] and
           x.len - 1 == f.len:
       for i in 1..<f.len:
@@ -1794,8 +1789,7 @@ proc typeRel(c: var TCandidate, f, aOrig: PType,
           depth = -1
 
       if depth >= 0:
-        if aobj.kind == tyObject and tfFinal notin aobj.flags:
-          inc c.inheritancePenalty, depth + int(c.inheritancePenalty < 0)
+        inc c.inheritancePenalty, depth + int(c.inheritancePenalty < 0)
         # bug #4863: We still need to bind generic alias crap, so
         # we cannot return immediately:
         result = if depth == 0: isGeneric else: isSubtype

compiler/vm.nim

@@ -12,7 +12,7 @@
 
 import semmacrosanity
 import
-  std/[strutils, tables, intsets, parseutils],
+  std/[strutils, tables, parseutils],
   msgs, vmdef, vmgen, nimsets, types,
   parser, vmdeps, idents, trees, renderer, options, transf,
   gorgeimpl, lineinfos, btrees, macrocacheimpl,
@@ -2425,12 +2425,9 @@ proc evalConstExprAux(module: PSym; idgen: IdGenerator;
   setupGlobalCtx(module, g, idgen)
   var c = PCtx g.vm
   let oldMode = c.mode
-  let oldLocals = c.locals
   c.mode = mode
-  c.locals = initIntSet()
   c.cannotEval = false
   let start = genExpr(c, n, requiresValue = mode!=emStaticStmt)
-  c.locals = oldLocals
   if c.cannotEval:
     return errorNode(idgen, prc, n)
   if c.code[start].opcode == opcEof: return newNodeI(nkEmpty, n.info)

compiler/vmdef.nim

@@ -10,7 +10,7 @@
 ## This module contains the type definitions for the new evaluation engine.
 ## An instruction is 1-3 int32s in memory, it is a register based VM.
 
-import std/[tables, strutils, intsets]
+import std/[tables, strutils]
 
 import ast, idents, options, modulegraphs, lineinfos
 
@@ -272,7 +272,6 @@ type
     vmstateDiff*: seq[(PSym, PNode)] # we remember the "diff" to global state here (feature for IC)
     procToCodePos*: Table[int, int]
     cannotEval*: bool
-    locals*: IntSet
 
   PStackFrame* = ref TStackFrame
   TStackFrame* {.acyclic.} = object

compiler/vmgen.nim

@@ -1583,7 +1583,6 @@ proc checkCanEval(c: PCtx; n: PNode) =
     # are in the right scope:
     if sfGenSym in s.flags and c.prc.sym == nil: discard
     elif s.kind == skParam and s.typ.kind == tyTypeDesc: discard
-    elif s.kind in {skVar, skLet} and s.id in c.locals: discard
     else: cannotEval(c, n)
   elif s.kind in {skProc, skFunc, skConverter, skMethod,
                   skIterator} and sfForward in s.flags:
@@ -1976,7 +1975,7 @@ proc genVarSection(c: PCtx; n: PNode) =
       c.gen(lowerTupleUnpacking(c.graph, a, c.idgen, c.getOwner))
     elif a[0].kind == nkSym:
       let s = a[0].sym
-      c.locals.incl(s.id)
+      checkCanEval(c, a[0])
       if s.isGlobal:
         let runtimeAccessToCompileTime = c.mode == emRepl and
               sfCompileTime in s.flags and s.position > 0

doc/manual.md

@@ -5186,22 +5186,22 @@ caught by reference. Example:
   proc fn() =
     let a = initRuntimeError("foo")
     doAssert $a.what == "foo"
-    var b = ""
+    var b: cstring
     try: raise initRuntimeError("foo2")
     except CStdException as e:
       doAssert e is CStdException
-      b = $e.what()
-    doAssert b == "foo2"
+      b = e.what()
+    doAssert $b == "foo2"
 
     try: raise initStdException()
     except CStdException: discard
 
     try: raise initRuntimeError("foo3")
     except CRuntimeError as e:
-      b = $e.what()
+      b = e.what()
     except CStdException:
       doAssert false
-    doAssert b == "foo3"
+    doAssert $b == "foo3"
 
   fn()
   ```
@@ -9043,119 +9043,3 @@ This means the following compiles (for now) even though it really should not:
     inc i
     access a[i].v
   ```
-
-Strict definitions and `out` parameters
-=======================================
-
-*every* local variable must be initialized explicitly before it can be used:
-
-  ```nim
-  proc test =
-    var s: seq[string]
-    s.add "abc" # invalid!
-  ```
-
-Needs to be written as:
-
-  ```nim
-  proc test =
-    var s: seq[string] = @[]
-    s.add "abc" # valid!
-  ```
-
-A control flow analysis is performed in order to prove that a variable has been written to
-before it is used. Thus the following is valid:
-
-  ```nim
-  proc test(cond: bool) =
-    var s: seq[string]
-    if cond:
-      s = @["y"]
-    else:
-      s = @[]
-    s.add "abc" # valid!
-  ```
-
-In this example every path does set `s` to a value before it is used.
-
-  ```nim
-  proc test(cond: bool) =
-    let s: seq[string]
-    if cond:
-      s = @["y"]
-    else:
-      s = @[]
-  ```
-
-`let` statements are allowed to not have an initial value, but every path should set `s` to a value before it is used.
-
-
-`out` parameters
-----------------
-
-An `out` parameter is like a `var` parameter but it must be written to before it can be used:
-
-  ```nim
-  proc myopen(f: out File; name: string): bool =
-    f = default(File)
-    result = open(f, name)
-  ```
-
-While it is usually the better style to use the return type in order to return results API and ABI
-considerations might make this infeasible. Like for `var T` Nim maps `out T` to a hidden pointer.
-For example POSIX's `stat` routine can be wrapped as:
-
-  ```nim
-  proc stat*(a1: cstring, a2: out Stat): cint {.importc, header: "<sys/stat.h>".}
-  ```
-
-When the implementation of a routine with output parameters is analysed, the compiler
-checks that every path before the (implicit or explicit) return does set every output
-parameter:
-
-  ```nim
-  proc p(x: out int; y: out string; cond: bool) =
-    x = 4
-    if cond:
-      y = "abc"
-    # error: not every path initializes 'y'
-  ```
-
-
-Out parameters and exception handling
--------------------------------------
-
-The analysis should take exceptions into account (but currently does not):
-
-  ```nim
-  proc p(x: out int; y: out string; cond: bool) =
-    x = canRaise(45)
-    y = "abc" # <-- error: not every path initializes 'y'
-  ```
-
-Once the implementation takes exceptions into account it is easy enough to
-use `outParam = default(typeof(outParam))` in the beginning of the proc body.
-
-Out parameters and inheritance
-------------------------------
-
-It is not valid to pass an lvalue of a supertype to an `out T` parameter:
-
-  ```nim
-  type
-    Superclass = object of RootObj
-      a: int
-    Subclass = object of Superclass
-      s: string
-
-  proc init(x: out Superclass) =
-    x = Superclass(a: 8)
-
-  var v: Subclass
-  init v
-  use v.s # the 's' field was never initialized!
-  ```
-
-However, in the future this could be allowed and provide a better way to write object
-constructors that take inheritance into account.
-

doc/manual_experimental.md

@@ -1919,6 +1919,136 @@ restrictions / changes:
   yet performed for ordinary slices outside of a `parallel` section.
 
 
+Strict definitions and `out` parameters
+=======================================
+
+With `experimental: "strictDefs"` *every* local variable must be initialized explicitly before it can be used:
+
+  ```nim
+  {.experimental: "strictDefs".}
+
+  proc test =
+    var s: seq[string]
+    s.add "abc" # invalid!
+
+  ```
+
+Needs to be written as:
+
+  ```nim
+  {.experimental: "strictDefs".}
+
+  proc test =
+    var s: seq[string] = @[]
+    s.add "abc" # valid!
+
+  ```
+
+A control flow analysis is performed in order to prove that a variable has been written to
+before it is used. Thus the following is valid:
+
+  ```nim
+  {.experimental: "strictDefs".}
+
+  proc test(cond: bool) =
+    var s: seq[string]
+    if cond:
+      s = @["y"]
+    else:
+      s = @[]
+    s.add "abc" # valid!
+  ```
+
+In this example every path does set `s` to a value before it is used.
+
+  ```nim
+  {.experimental: "strictDefs".}
+
+  proc test(cond: bool) =
+    let s: seq[string]
+    if cond:
+      s = @["y"]
+    else:
+      s = @[]
+  ```
+
+With `experimental: "strictDefs"`, `let` statements are allowed to not have an initial value, but every path should set `s` to a value before it is used.
+
+
+`out` parameters
+----------------
+
+An `out` parameter is like a `var` parameter but it must be written to before it can be used:
+
+  ```nim
+  proc myopen(f: out File; name: string): bool =
+    f = default(File)
+    result = open(f, name)
+  ```
+
+While it is usually the better style to use the return type in order to return results API and ABI
+considerations might make this infeasible. Like for `var T` Nim maps `out T` to a hidden pointer.
+For example POSIX's `stat` routine can be wrapped as:
+
+  ```nim
+  proc stat*(a1: cstring, a2: out Stat): cint {.importc, header: "<sys/stat.h>".}
+  ```
+
+When the implementation of a routine with output parameters is analysed, the compiler
+checks that every path before the (implicit or explicit) return does set every output
+parameter:
+
+  ```nim
+  proc p(x: out int; y: out string; cond: bool) =
+    x = 4
+    if cond:
+      y = "abc"
+    # error: not every path initializes 'y'
+  ```
+
+
+Out parameters and exception handling
+-------------------------------------
+
+The analysis should take exceptions into account (but currently does not):
+
+  ```nim
+  proc p(x: out int; y: out string; cond: bool) =
+    x = canRaise(45)
+    y = "abc" # <-- error: not every path initializes 'y'
+  ```
+
+Once the implementation takes exceptions into account it is easy enough to
+use `outParam = default(typeof(outParam))` in the beginning of the proc body.
+
+Out parameters and inheritance
+------------------------------
+
+It is not valid to pass an lvalue of a supertype to an `out T` parameter:
+
+  ```nim
+  type
+    Superclass = object of RootObj
+      a: int
+    Subclass = object of Superclass
+      s: string
+
+  proc init(x: out Superclass) =
+    x = Superclass(a: 8)
+
+  var v: Subclass
+  init v
+  use v.s # the 's' field was never initialized!
+  ```
+
+However, in the future this could be allowed and provide a better way to write object
+constructors that take inheritance into account.
+
+
+**Note**: The implementation of "strict definitions" and "out parameters" is experimental but the concept
+is solid and it is expected that eventually this mode becomes the default in later versions.
+
+
 Strict case objects
 ===================
 

lib/impure/nre.nim

@@ -242,7 +242,6 @@ else:
     `=destroy`(pattern.captureNameToId)
 
 proc getinfo[T](pattern: Regex, opt: cint): T =
-  result = default(T)
   let retcode = pcre.fullinfo(pattern.pcreObj, pattern.pcreExtra, opt, addr result)
 
   if retcode < 0:
@@ -276,8 +275,8 @@ proc initRegex(pattern: string, flags: int, study = true): Regex =
     new(result, destroyRegex)
   result.pattern = pattern
 
-  var errorMsg: cstring = ""
-  var errOffset: cint = 0
+  var errorMsg: cstring
+  var errOffset: cint
 
   result.pcreObj = pcre.compile(cstring(pattern),
                                 # better hope int is at least 4 bytes..
@@ -289,7 +288,7 @@ proc initRegex(pattern: string, flags: int, study = true): Regex =
 
   if study:
     var options: cint = 0
-    var hasJit: cint = cint(0)
+    var hasJit: cint
     if pcre.config(pcre.CONFIG_JIT, addr hasJit) == 0:
       if hasJit == 1'i32:
         options = pcre.STUDY_JIT_COMPILE
@@ -314,7 +313,7 @@ proc matchesCrLf(pattern: Regex): bool =
     return true
 
   # get flags from build config
-  var confFlags: cint = cint(0)
+  var confFlags: cint
   if pcre.config(pcre.CONFIG_NEWLINE, addr confFlags) != 0:
     assert(false, "CONFIG_NEWLINE apparently got screwed up")
 
@@ -574,7 +573,7 @@ iterator findIter*(str: string, pattern: Regex, start = 0, endpos = int.high): R
     pcre.UTF8) > 0u32
   let strlen = if endpos == int.high: str.len else: endpos+1
   var offset = start
-  var match: Option[RegexMatch] = default(Option[RegexMatch])
+  var match: Option[RegexMatch]
   var neverMatched = true
 
   while true:
@@ -763,7 +762,7 @@ proc escapeRe*(str: string): string {.gcsafe.} =
   const SpecialCharMatcher = {'\\', '+', '*', '?', '[', '^', ']', '$', '(',
                               ')', '{', '}', '=', '!', '<', '>', '|', ':',
                               '-'}
-  result = ""
+
   for c in items(str):
     case c
     of SpecialCharMatcher:

lib/impure/re.nim

@@ -466,7 +466,7 @@ template `=~` *(s: string, pattern: Regex): untyped =
     doAssert parse("   # comment ... ") == """("# comment ... ",)"""
   bind MaxSubpatterns
   when not declaredInScope(matches):
-    var matches {.inject.}: array[MaxSubpatterns, string] = default(array[MaxSubpatterns, string])
+    var matches {.inject.}: array[MaxSubpatterns, string]
   match(s, pattern, matches)
 
 # ------------------------- more string handling ------------------------------

lib/nimbase.h

@@ -470,6 +470,12 @@ typedef char* NCSTRING;
 
 #define NIM_STRLIT_FLAG ((NU)(1) << ((NIM_INTBITS) - 2)) /* This has to be the same as system.strlitFlag! */
 
+#define STRING_LITERAL(name, str, length) \
+   static const struct {                   \
+     TGenericSeq Sup;                      \
+     NIM_CHAR data[(length) + 1];          \
+  } name = {{length, (NI) ((NU)length | NIM_STRLIT_FLAG)}, str}
+
 /* declared size of a sequence/variable length array: */
 #if defined(__cplusplus) && defined(__clang__)
 #  define SEQ_DECL_SIZE 1

lib/pure/algorithm.nim

@@ -143,7 +143,6 @@ proc reversed*[T](a: openArray[T]): seq[T] {.inline.} =
   runnableExamples:
     assert [10, 11, 12].reversed == @[12, 11, 10]
     assert seq[string].default.reversed == @[]
-  result = @[]
   let n = a.len
   result.setLen(n)
   for i in 0..<n: result[i] = a[n - (i + 1)]

lib/pure/asyncmacro.nim

@@ -264,9 +264,9 @@ proc asyncSingleProc(prc: NimNode): NimNode =
     procBody.insert(0): quote do:
       {.push warning[resultshadowed]: off.}
       when `subRetType` isnot void:
-        var `resultIdent`: `subRetType` = default(`subRetType`)
+        var `resultIdent`: `subRetType`
       else:
-        var `resultIdent`: Future[void] = nil
+        var `resultIdent`: Future[void]
       {.pop.}
 
       var `needsCompletionSym` = false

lib/pure/base64.nim

@@ -151,12 +151,10 @@ proc encode*[T: byte|char](s: openArray[T], safe = false): string =
     assert encode(['n', 'i', 'm']) == "bmlt"
     assert encode(@['n', 'i', 'm']) == "bmlt"
     assert encode([1'u8, 2, 3, 4, 5]) == "AQIDBAU="
-  result = ""
   encodeImpl()
 
 proc encode*[T: SomeInteger and not byte](s: openArray[T], safe = false): string
   {.deprecated: "use `byte` or `char` instead".} =
-  result = ""
   encodeImpl()
 
 proc encodeMime*(s: string, lineLen = 75.Positive, newLine = "\r\n",

lib/pure/collections/critbits.nim

@@ -67,7 +67,6 @@ func len*[T](c: CritBitTree[T]): int {.inline.} =
   result = c.count
 
 proc rawGet[T](c: CritBitTree[T], key: string): Node[T] =
-  result = nil
   var it = c.root
   while it != nil:
     if not it.isLeaf:
@@ -146,7 +145,7 @@ func exclImpl[T](c: var CritBitTree[T], key: string): int =
   var whereq: ptr Node[T] = nil
   if p == nil: return c.count
   var dir = 0
-  var q: Node[T] = nil
+  var q: Node[T]
   while not p.isLeaf:
     whereq = wherep
     q = p
@@ -395,7 +394,6 @@ iterator mpairs*[T](c: var CritBitTree[T]): tuple[key: string, val: var T] =
   for x in leaves(c.root): yield (x.key, x.val)
 
 proc allprefixedAux[T](c: CritBitTree[T], key: string): Node[T] =
-  result = nil
   var p = c.root
   var top = p
   if p != nil:

lib/pure/collections/deques.nim

@@ -92,7 +92,6 @@ proc initDeque*[T](initialSize: int = defaultInitialSize): Deque[T] =
   ##
   ## **See also:**
   ## * `toDeque proc <#toDeque,openArray[T]>`_
-  result = Deque[T]()
   result.initImpl(initialSize)
 
 func len*[T](deq: Deque[T]): int {.inline.} =
@@ -298,7 +297,7 @@ proc toDeque*[T](x: openArray[T]): Deque[T] {.since: (1, 3).} =
     let a = toDeque([7, 8, 9])
     assert len(a) == 3
     assert $a == "[7, 8, 9]"
-  result = Deque[T]()
+
   result.initImpl(x.len)
   for item in items(x):
     result.addLast(item)

lib/pure/collections/heapqueue.nim

@@ -157,7 +157,7 @@ proc toHeapQueue*[T](x: openArray[T]): HeapQueue[T] {.since: (1, 3).} =
     assert heap[0] == 8
 
   # see https://en.wikipedia.org/wiki/Binary_heap#Building_a_heap
-  result = HeapQueue[T](data: @x)
+  result.data = @x
   for i in countdown(x.len div 2 - 1, 0):
     siftdown(result, i)
 

lib/pure/collections/lists.nim

@@ -115,7 +115,7 @@ proc initSinglyLinkedList*[T](): SinglyLinkedList[T] =
   runnableExamples:
     let a = initSinglyLinkedList[int]()
 
-  result = default(SinglyLinkedList[T])
+  discard
 
 proc initDoublyLinkedList*[T](): DoublyLinkedList[T] =
   ## Creates a new doubly linked list that is empty.
@@ -125,7 +125,7 @@ proc initDoublyLinkedList*[T](): DoublyLinkedList[T] =
   runnableExamples:
     let a = initDoublyLinkedList[int]()
 
-  result = default(DoublyLinkedList[T])
+  discard
 
 proc initSinglyLinkedRing*[T](): SinglyLinkedRing[T] =
   ## Creates a new singly linked ring that is empty.
@@ -135,7 +135,7 @@ proc initSinglyLinkedRing*[T](): SinglyLinkedRing[T] =
   runnableExamples:
     let a = initSinglyLinkedRing[int]()
 
-  result = default(SinglyLinkedRing[T])
+  discard
 
 proc initDoublyLinkedRing*[T](): DoublyLinkedRing[T] =
   ## Creates a new doubly linked ring that is empty.
@@ -145,7 +145,7 @@ proc initDoublyLinkedRing*[T](): DoublyLinkedRing[T] =
   runnableExamples:
     let a = initDoublyLinkedRing[int]()
 
-  result = default(DoublyLinkedRing[T])
+  discard
 
 proc newDoublyLinkedNode*[T](value: T): DoublyLinkedNode[T] =
   ## Creates a new doubly linked node with the given `value`.
@@ -319,10 +319,6 @@ proc find*[T](L: SomeLinkedCollection[T], value: T): SomeLinkedNode[T] =
     let a = [9, 8].toSinglyLinkedList
     assert a.find(9).value == 9
     assert a.find(1) == nil
-  when typeof(nodes(L)) is SinglyLinkedNode[T]:
-    result = SinglyLinkedNode[T](nil)
-  else:
-    result = DoublyLinkedNode[T](nil)
 
   for x in nodes(L):
     if x.value == value: return x

lib/pure/collections/sequtils.nim

@@ -167,7 +167,7 @@ func count*[T](s: openArray[T], x: T): int =
     assert count(a, 2) == 4
     assert count(a, 99) == 0
     assert count(b, 'r') == 2
-  result = 0
+
   for itm in items(s):
     if itm == x:
       inc result
@@ -244,7 +244,7 @@ func minIndex*[T](s: openArray[T]): int {.since: (1, 1).} =
     assert minIndex(b) == 3
     assert minIndex(c) == 1
     assert minIndex(d) == 2
-  result = 0
+
   for i in 1..high(s):
     if s[i] < s[result]: result = i
 
@@ -261,7 +261,7 @@ func maxIndex*[T](s: openArray[T]): int {.since: (1, 1).} =
     assert maxIndex(b) == 0
     assert maxIndex(c) == 2
     assert maxIndex(d) == 0
-  result = 0
+
   for i in 1..high(s):
     if s[i] > s[result]: result = i
 

lib/pure/collections/setimpl.nim

@@ -45,7 +45,7 @@ proc enlarge[A](s: var HashSet[A]) =
 template inclImpl() {.dirty.} =
   if s.data.len == 0:
     initImpl(s, defaultInitialSize)
-  var hc: Hash = default(Hash)
+  var hc: Hash
   var index = rawGet(s, key, hc)
   if index < 0:
     if mustRehash(s):

lib/pure/collections/sets.nim

@@ -670,7 +670,7 @@ proc initOrderedSet*[A](initialSize = defaultInitialSize): OrderedSet[A] =
     var a = initOrderedSet[int]()
     a.incl(3)
     assert len(a) == 1
-  result = OrderedSet[A]()
+
   result.init(initialSize)
 
 proc toOrderedSet*[A](keys: openArray[A]): OrderedSet[A] =

lib/pure/collections/sharedtables.nim

@@ -139,15 +139,12 @@ template withValue*[A, B](t: var SharedTable[A, B], key: A,
 proc mget*[A, B](t: var SharedTable[A, B], key: A): var B =
   ## Retrieves the value at `t[key]`. The value can be modified.
   ## If `key` is not in `t`, the `KeyError` exception is raised.
-  acquire(t.lock)
-  var hc: Hash = Hash(0)
-  var index = rawGet(t, key, hc)
-  let hasKey = index >= 0
-  if hasKey:
-    result = t.data[index].val
-    release(t.lock)
-  else:
-    release(t.lock)
+  withLock t:
+    var hc: Hash
+    var index = rawGet(t, key, hc)
+    let hasKey = index >= 0
+    if hasKey: result = t.data[index].val
+  if not hasKey:
     when compiles($key):
       raise newException(KeyError, "key not found: " & $key)
     else:

lib/pure/collections/tableimpl.nim

@@ -30,7 +30,7 @@ proc rawGetDeep[X, A](t: X, key: A, hc: var Hash): int {.inline, outParamsAt: [3
   rawGetDeepImpl()
 
 proc rawInsert[X, A, B](t: var X, data: var KeyValuePairSeq[A, B],
-                     key: sink A, val: sink B, hc: Hash, h: Hash) =
+                     key: A, val: sink B, hc: Hash, h: Hash) =
   rawInsertImpl()
 
 template checkIfInitialized() =

lib/pure/collections/tables.nim

@@ -281,7 +281,7 @@ proc initTable*[A, B](initialSize = defaultInitialSize): Table[A, B] =
   result = default(Table[A, B])
   initImpl(result, initialSize)
 
-proc `[]=`*[A, B](t: var Table[A, B], key: sink A, val: sink B) =
+proc `[]=`*[A, B](t: var Table[A, B], key: A, val: sink B) =
   ## Inserts a `(key, value)` pair into `t`.
   ##
   ## See also:
@@ -313,7 +313,7 @@ proc toTable*[A, B](pairs: openArray[(A, B)]): Table[A, B] =
   result = initTable[A, B](pairs.len)
   for key, val in items(pairs): result[key] = val
 
-proc `[]`*[A, B](t: Table[A, B], key: sink A): lent B =
+proc `[]`*[A, B](t: Table[A, B], key: A): lent B =
   ## Retrieves the value at `t[key]`.
   ##
   ## If `key` is not in `t`, the `KeyError` exception is raised.
@@ -336,7 +336,7 @@ proc `[]`*[A, B](t: Table[A, B], key: sink A): lent B =
       echo a['z']
   get(t, key)
 
-proc `[]`*[A, B](t: var Table[A, B], key: sink A): var B =
+proc `[]`*[A, B](t: var Table[A, B], key: A): var B =
   ## Retrieves the value at `t[key]`. The value can be modified.
   ##
   ## If `key` is not in `t`, the `KeyError` exception is raised.
@@ -494,7 +494,7 @@ proc len*[A, B](t: Table[A, B]): int =
 
   result = t.counter
 
-proc add*[A, B](t: var Table[A, B], key: sink A, val: sink B) {.deprecated:
+proc add*[A, B](t: var Table[A, B], key: A, val: sink B) {.deprecated:
     "Deprecated since v1.4; it was more confusing than useful, use `[]=`".} =
   ## Puts a new `(key, value)` pair into `t` even if `t[key]` already exists.
   ##
@@ -628,7 +628,7 @@ template withValue*[A, B](t: var Table[A, B], key: A, value, body: untyped) =
     assert t[1].uid == 1314
 
   mixin rawGet
-  var hc: Hash = default(Hash)
+  var hc: Hash
   var index = rawGet(t, key, hc)
   let hasKey = index >= 0
   if hasKey:
@@ -677,7 +677,7 @@ template withValue*[A, B](t: var Table[A, B], key: A,
     body2
 
 
-iterator pairs*[A, B](t: Table[A, B]): (lent A, lent B) =
+iterator pairs*[A, B](t: Table[A, B]): (A, B) =
   ## Iterates over any `(key, value)` pair in the table `t`.
   ##
   ## See also:
@@ -864,7 +864,7 @@ proc newTableFrom*[A, B, C](collection: A, index: proc(x: B): C): TableRef[C, B]
     for item in collection:
       result[index(item)] = item
 
-proc `[]`*[A, B](t: TableRef[A, B], key: sink A): var B =
+proc `[]`*[A, B](t: TableRef[A, B], key: A): var B =
   ## Retrieves the value at `t[key]`.
   ##
   ## If `key` is not in `t`, the  `KeyError` exception is raised.
@@ -888,7 +888,7 @@ proc `[]`*[A, B](t: TableRef[A, B], key: sink A): var B =
 
   result = t[][key]
 
-proc `[]=`*[A, B](t: TableRef[A, B], key: sink A, val: sink B) =
+proc `[]=`*[A, B](t: TableRef[A, B], key: A, val: sink B) =
   ## Inserts a `(key, value)` pair into `t`.
   ##
   ## See also:
@@ -1045,7 +1045,7 @@ proc len*[A, B](t: TableRef[A, B]): int =
 
   result = t.counter
 
-proc add*[A, B](t: TableRef[A, B], key: sink A, val: sink B) {.deprecated:
+proc add*[A, B](t: TableRef[A, B], key: A, val: sink B) {.deprecated:
     "Deprecated since v1.4; it was more confusing than useful, use `[]=`".} =
   ## Puts a new `(key, value)` pair into `t` even if `t[key]` already exists.
   ##
@@ -1139,7 +1139,7 @@ proc `==`*[A, B](s, t: TableRef[A, B]): bool =
 
 
 
-iterator pairs*[A, B](t: TableRef[A, B]): (lent A, lent B) =
+iterator pairs*[A, B](t: TableRef[A, B]): (A, B) =
   ## Iterates over any `(key, value)` pair in the table `t`.
   ##
   ## See also:
@@ -1297,7 +1297,7 @@ proc rawGet[A, B](t: OrderedTable[A, B], key: A, hc: var Hash): int =
 
 proc rawInsert[A, B](t: var OrderedTable[A, B],
                      data: var OrderedKeyValuePairSeq[A, B],
-                     key: sink A, val: sink B, hc: Hash, h: Hash) =
+                     key: A, val: sink B, hc: Hash, h: Hash) =
   rawInsertImpl()
   data[h].next = -1
   if t.first < 0: t.first = h
@@ -1349,7 +1349,7 @@ proc initOrderedTable*[A, B](initialSize = defaultInitialSize): OrderedTable[A,
   result = default(OrderedTable[A, B])
   initImpl(result, initialSize)
 
-proc `[]=`*[A, B](t: var OrderedTable[A, B], key: sink A, val: sink B) =
+proc `[]=`*[A, B](t: var OrderedTable[A, B], key: A, val: sink B) =
   ## Inserts a `(key, value)` pair into `t`.
   ##
   ## See also:
@@ -1382,7 +1382,7 @@ proc toOrderedTable*[A, B](pairs: openArray[(A, B)]): OrderedTable[A, B] =
   result = initOrderedTable[A, B](pairs.len)
   for key, val in items(pairs): result[key] = val
 
-proc `[]`*[A, B](t: OrderedTable[A, B], key: sink A): lent B =
+proc `[]`*[A, B](t: OrderedTable[A, B], key: A): lent B =
   ## Retrieves the value at `t[key]`.
   ##
   ## If `key` is not in `t`, the  `KeyError` exception is raised.
@@ -1406,7 +1406,7 @@ proc `[]`*[A, B](t: OrderedTable[A, B], key: sink A): lent B =
 
   get(t, key)
 
-proc `[]`*[A, B](t: var OrderedTable[A, B], key: sink A): var B =
+proc `[]`*[A, B](t: var OrderedTable[A, B], key: A): var B =
   ## Retrieves the value at `t[key]`. The value can be modified.
   ##
   ## If `key` is not in `t`, the `KeyError` exception is raised.
@@ -1547,7 +1547,7 @@ proc len*[A, B](t: OrderedTable[A, B]): int {.inline.} =
 
   result = t.counter
 
-proc add*[A, B](t: var OrderedTable[A, B], key: sink A, val: sink B) {.deprecated:
+proc add*[A, B](t: var OrderedTable[A, B], key: A, val: sink B) {.deprecated:
     "Deprecated since v1.4; it was more confusing than useful, use `[]=`".} =
   ## Puts a new `(key, value)` pair into `t` even if `t[key]` already exists.
   ##
@@ -1727,7 +1727,7 @@ proc `==`*[A, B](s, t: OrderedTable[A, B]): bool =
 
 
 
-iterator pairs*[A, B](t: OrderedTable[A, B]): (lent A, lent B) =
+iterator pairs*[A, B](t: OrderedTable[A, B]): (A, B) =
   ## Iterates over any `(key, value)` pair in the table `t` in insertion
   ## order.
   ##
@@ -1884,7 +1884,7 @@ proc newOrderedTable*[A, B](pairs: openArray[(A, B)]): OrderedTableRef[A, B] =
     for key, val in items(pairs): result[key] = val
 
 
-proc `[]`*[A, B](t: OrderedTableRef[A, B], key: sink A): var B =
+proc `[]`*[A, B](t: OrderedTableRef[A, B], key: A): var B =
   ## Retrieves the value at `t[key]`.
   ##
   ## If `key` is not in `t`, the  `KeyError` exception is raised.
@@ -1907,7 +1907,7 @@ proc `[]`*[A, B](t: OrderedTableRef[A, B], key: sink A): var B =
       echo a['z']
   result = t[][key]
 
-proc `[]=`*[A, B](t: OrderedTableRef[A, B], key: sink A, val: sink B) =
+proc `[]=`*[A, B](t: OrderedTableRef[A, B], key: A, val: sink B) =
   ## Inserts a `(key, value)` pair into `t`.
   ##
   ## See also:
@@ -2048,7 +2048,7 @@ proc len*[A, B](t: OrderedTableRef[A, B]): int {.inline.} =
 
   result = t.counter
 
-proc add*[A, B](t: OrderedTableRef[A, B], key: sink A, val: sink B) {.deprecated:
+proc add*[A, B](t: OrderedTableRef[A, B], key: A, val: sink B) {.deprecated:
     "Deprecated since v1.4; it was more confusing than useful, use `[]=`".} =
   ## Puts a new `(key, value)` pair into `t` even if `t[key]` already exists.
   ##
@@ -2150,7 +2150,7 @@ proc `==`*[A, B](s, t: OrderedTableRef[A, B]): bool =
 
 
 
-iterator pairs*[A, B](t: OrderedTableRef[A, B]): (lent A, lent B) =
+iterator pairs*[A, B](t: OrderedTableRef[A, B]): (A, B) =
   ## Iterates over any `(key, value)` pair in the table `t` in insertion
   ## order.
   ##
@@ -2345,7 +2345,7 @@ proc toCountTable*[A](keys: openArray[A]): CountTable[A] =
   result = initCountTable[A](keys.len)
   for key in items(keys): result.inc(key)
 
-proc `[]`*[A](t: CountTable[A], key: sink A): int =
+proc `[]`*[A](t: CountTable[A], key: A): int =
   ## Retrieves the value at `t[key]` if `key` is in `t`.
   ## Otherwise `0` is returned.
   ##
@@ -2413,7 +2413,8 @@ proc smallest*[A](t: CountTable[A]): tuple[key: A, val: int] =
   for h in 0 .. high(t.data):
     if t.data[h].val > 0 and (minIdx == -1 or t.data[minIdx].val > t.data[h].val):
       minIdx = h
-  result = (t.data[minIdx].key, t.data[minIdx].val)
+  result.key = t.data[minIdx].key
+  result.val = t.data[minIdx].val
 
 proc largest*[A](t: CountTable[A]): tuple[key: A, val: int] =
   ## Returns the `(key, value)` pair with the largest `val`. Efficiency: O(n)
@@ -2424,7 +2425,8 @@ proc largest*[A](t: CountTable[A]): tuple[key: A, val: int] =
   var maxIdx = 0
   for h in 1 .. high(t.data):
     if t.data[maxIdx].val < t.data[h].val: maxIdx = h
-  result = (t.data[maxIdx].key, t.data[maxIdx].val)
+  result.key = t.data[maxIdx].key
+  result.val = t.data[maxIdx].val
 
 proc hasKey*[A](t: CountTable[A], key: A): bool =
   ## Returns true if `key` is in the table `t`.
@@ -2564,7 +2566,7 @@ proc `==`*[A](s, t: CountTable[A]): bool =
   equalsImpl(s, t)
 
 
-iterator pairs*[A](t: CountTable[A]): (lent A, int) =
+iterator pairs*[A](t: CountTable[A]): (A, int) =
   ## Iterates over any `(key, value)` pair in the table `t`.
   ##
   ## See also:
@@ -2703,7 +2705,7 @@ proc newCountTable*[A](keys: openArray[A]): CountTableRef[A] =
   {.noSideEffect.}:
     for key in items(keys): result.inc(key)
 
-proc `[]`*[A](t: CountTableRef[A], key: sink A): int =
+proc `[]`*[A](t: CountTableRef[A], key: A): int =
   ## Retrieves the value at `t[key]` if `key` is in `t`.
   ## Otherwise `0` is returned.
   ##
@@ -2845,7 +2847,7 @@ proc `==`*[A](s, t: CountTableRef[A]): bool =
   else: result = s[] == t[]
 
 
-iterator pairs*[A](t: CountTableRef[A]): (lent A, int) =
+iterator pairs*[A](t: CountTableRef[A]): (A, int) =
   ## Iterates over any `(key, value)` pair in the table `t`.
   ##
   ## See also:
@@ -2953,19 +2955,16 @@ iterator mvalues*[A](t: CountTableRef[A]): var int =
       assert(len(t) == L, "the length of the table changed while iterating over it")
 
 proc hash*[K,V](s: Table[K,V]): Hash =
-  result = Hash(0)
   for p in pairs(s):
     result = result xor hash(p)
   result = !$result
 
 proc hash*[K,V](s: OrderedTable[K,V]): Hash =
-  result = Hash(0)
   for p in pairs(s):
     result = result !& hash(p)
   result = !$result
 
 proc hash*[V](s: CountTable[V]): Hash =
-  result = Hash(0)
   for p in pairs(s):
     result = result xor hash(p)
   result = !$result

lib/pure/complex.nim

@@ -46,15 +46,18 @@ type
 
 func complex*[T: SomeFloat](re: T; im: T = 0.0): Complex[T] =
   ## Returns a `Complex[T]` with real part `re` and imaginary part `im`.
-  result = Complex[T](re: re, im: im)
+  result.re = re
+  result.im = im
 
 func complex32*(re: float32; im: float32 = 0.0): Complex32 =
   ## Returns a `Complex32` with real part `re` and imaginary part `im`.
-  result = Complex32(re: re, im: im)
+  result.re = re
+  result.im = im
 
 func complex64*(re: float64; im: float64 = 0.0): Complex64 =
   ## Returns a `Complex64` with real part `re` and imaginary part `im`.
-  result = Complex64(re: re, im: im)
+  result.re = re
+  result.im = im
 
 template im*(arg: typedesc[float32]): Complex32 = complex32(0, 1)
   ## Returns the imaginary unit (`complex32(0, 1)`).
@@ -82,16 +85,15 @@ func sgn*[T](z: Complex[T]): Complex[T] =
   let a = abs(z)
   if a != 0:
     result = z / a
-  else:
-    result = Complex[T]()
 
 func conjugate*[T](z: Complex[T]): Complex[T] =
   ## Returns the complex conjugate of `z` (`complex(z.re, -z.im)`).
-  result = Complex[T](re: z.re, im: -z.im)
+  result.re = z.re
+  result.im = -z.im
 
 func inv*[T](z: Complex[T]): Complex[T] =
   ## Returns the multiplicative inverse of `z` (`1/z`).
-  result = conjugate(z) / abs2(z)
+  conjugate(z) / abs2(z)
 
 func `==`*[T](x, y: Complex[T]): bool =
   ## Compares two complex numbers for equality.
@@ -99,48 +101,58 @@ func `==`*[T](x, y: Complex[T]): bool =
 
 func `+`*[T](x: T; y: Complex[T]): Complex[T] =
   ## Adds a real number to a complex number.
-  result = Complex[T](re: x + y.re, im: y.im)
+  result.re = x + y.re
+  result.im = y.im
 
 func `+`*[T](x: Complex[T]; y: T): Complex[T] =
   ## Adds a complex number to a real number.
-  result = Complex[T](re: x.re + y, im: x.im)
+  result.re = x.re + y
+  result.im = x.im
 
 func `+`*[T](x, y: Complex[T]): Complex[T] =
   ## Adds two complex numbers.
-  result = Complex[T](re: x.re + y.re, im: x.im + y.im)
+  result.re = x.re + y.re
+  result.im = x.im + y.im
 
 func `-`*[T](z: Complex[T]): Complex[T] =
   ## Unary minus for complex numbers.
-  result = Complex[T](re: -z.re, im: -z.im)
+  result.re = -z.re
+  result.im = -z.im
 
 func `-`*[T](x: T; y: Complex[T]): Complex[T] =
   ## Subtracts a complex number from a real number.
-  result = Complex[T](re: x - y.re, im: -y.im)
+  result.re = x - y.re
+  result.im = -y.im
 
 func `-`*[T](x: Complex[T]; y: T): Complex[T] =
   ## Subtracts a real number from a complex number.
-  result = Complex[T](re: x.re - y, im: x.im)
+  result.re = x.re - y
+  result.im = x.im
 
 func `-`*[T](x, y: Complex[T]): Complex[T] =
   ## Subtracts two complex numbers.
-  result = Complex[T](re: x.re - y.re, im: x.im - y.im)
+  result.re = x.re - y.re
+  result.im = x.im - y.im
 
 func `*`*[T](x: T; y: Complex[T]): Complex[T] =
   ## Multiplies a real number with a complex number.
-  result = Complex[T](re: x * y.re, im: x * y.im)
+  result.re = x * y.re
+  result.im = x * y.im
 
 func `*`*[T](x: Complex[T]; y: T): Complex[T] =
   ## Multiplies a complex number with a real number.
-  result = Complex[T](re: x.re * y, im: x.im * y)
+  result.re = x.re * y
+  result.im = x.im * y
 
 func `*`*[T](x, y: Complex[T]): Complex[T] =
   ## Multiplies two complex numbers.
-  result = Complex[T](re: x.re * y.re - x.im * y.im,
-                      im: x.im * y.re + x.re * y.im)
+  result.re = x.re * y.re - x.im * y.im
+  result.im = x.im * y.re + x.re * y.im
 
 func `/`*[T](x: Complex[T]; y: T): Complex[T] =
   ## Divides a complex number by a real number.
-  result = Complex[T](re: x.re / y, im: x.im / y)
+  result.re = x.re / y
+  result.im = x.im / y
 
 func `/`*[T](x: T; y: Complex[T]): Complex[T] =
   ## Divides a real number by a complex number.
@@ -190,9 +202,10 @@ func sqrt*[T](z: Complex[T]): Complex[T] =
       w = sqrt(y) * sqrt(0.5 * (r + sqrt(1.0 + r * r)))
 
     if z.re >= 0.0:
-      result = Complex[T](re: w, im: z.im / (w * 2.0))
+      result.re = w
+      result.im = z.im / (w * 2.0)
     else:
-      result = Complex[T](im: if z.im >= 0.0: w else: -w)
+      result.im = if z.im >= 0.0: w else: -w
       result.re = z.im / (result.im + result.im)
 
 func exp*[T](z: Complex[T]): Complex[T] =
@@ -200,13 +213,15 @@ func exp*[T](z: Complex[T]): Complex[T] =
   let
     rho = exp(z.re)
     theta = z.im
-  result = Complex[T](re: rho * cos(theta), im: rho * sin(theta))
+  result.re = rho * cos(theta)
+  result.im = rho * sin(theta)
 
 func ln*[T](z: Complex[T]): Complex[T] =
   ## Returns the
   ## ([principal value](https://en.wikipedia.org/wiki/Complex_logarithm#Principal_value)
   ## of the) natural logarithm of `z`.
-  result = Complex[T](re: ln(abs(z)), im: arctan2(z.im, z.re))
+  result.re = ln(abs(z))
+  result.im = arctan2(z.im, z.re)
 
 func log10*[T](z: Complex[T]): Complex[T] =
   ## Returns the logarithm base 10 of `z`.
@@ -226,9 +241,11 @@ func pow*[T](x, y: Complex[T]): Complex[T] =
   ## `x` raised to the power of `y`.
   if x.re == 0.0 and x.im == 0.0:
     if y.re == 0.0 and y.im == 0.0:
-      result = Complex[T](re: 1.0, im: 0.0)
+      result.re = 1.0
+      result.im = 0.0
     else:
-      result = Complex[T](re: 0.0, im: 0.0)
+      result.re = 0.0
+      result.im = 0.0
   elif y.im == 0.0:
     if y.re == 1.0:
       result = x
@@ -240,7 +257,8 @@ func pow*[T](x, y: Complex[T]): Complex[T] =
       result = sqrt(x)
     elif x.im == 0.0:
       # Revert to real pow when both base and exponent are real
-      result = Complex[T](re: pow(x.re, y.re), im: 0.0)
+      result.re = pow(x.re, y.re)
+      result.im = 0.0
     else:
       # Special case when the exponent is real
       let
@@ -248,7 +266,8 @@ func pow*[T](x, y: Complex[T]): Complex[T] =
         theta = arctan2(x.im, x.re)
         s = pow(rho, y.re)
         r = y.re * theta
-      result = Complex[T](re: s * cos(r), im: s * sin(r))
+      result.re = s * cos(r)
+      result.im = s * sin(r)
   elif x.im == 0.0 and x.re == E:
    # Special case Euler's formula
    result = exp(y)
@@ -258,15 +277,18 @@ func pow*[T](x, y: Complex[T]): Complex[T] =
       theta = arctan2(x.im, x.re)
       s = pow(rho, y.re) * exp(-y.im * theta)
       r = y.re * theta + y.im * ln(rho)
-    result = Complex[T](re: s * cos(r), im: s * sin(r))
+    result.re = s * cos(r)
+    result.im = s * sin(r)
 
 func pow*[T](x: Complex[T]; y: T): Complex[T] =
   ## The complex number `x` raised to the power of the real number `y`.
   pow(x, complex[T](y))
 
+
 func sin*[T](z: Complex[T]): Complex[T] =
   ## Returns the sine of `z`.
-  result = Complex[T](re: sin(z.re) * cosh(z.im), im: cos(z.re) * sinh(z.im))
+  result.re = sin(z.re) * cosh(z.im)
+  result.im = cos(z.re) * sinh(z.im)
 
 func arcsin*[T](z: Complex[T]): Complex[T] =
   ## Returns the inverse sine of `z`.
@@ -274,9 +296,8 @@ func arcsin*[T](z: Complex[T]): Complex[T] =
 
 func cos*[T](z: Complex[T]): Complex[T] =
   ## Returns the cosine of `z`.
-  result = Complex[T](re: cos(z.re) * cosh(z.im),
-                      im: -sin(z.re) * sinh(z.im)
-  )
+  result.re = cos(z.re) * cosh(z.im)
+  result.im = -sin(z.re) * sinh(z.im)
 
 func arccos*[T](z: Complex[T]): Complex[T] =
   ## Returns the inverse cosine of `z`.

lib/pure/httpclient.nim

@@ -1213,7 +1213,7 @@ proc request*(client: HttpClient | AsyncHttpClient, url: Uri | string,
       redirectBody = body
     else:
       # Unreachable
-      raiseAssert "unreachable"
+      doAssert(false)
 
     # Check if the redirection is to the same domain or a sub-domain (foo.com
     # -> sub.foo.com)

lib/pure/json.nim

@@ -1256,7 +1256,7 @@ proc foldObjectBody(dst, typeNode, tmpSym, jsonNode, jsonPath, originalJsonPathL
       when nimvm:
         when isRefSkipDistinct(`tmpSym`.`fieldSym`):
           # workaround #12489
-          var tmp: `fieldType` = default(typeof(`fieldType`))
+          var tmp: `fieldType`
           initFromJson(tmp, getOrDefault(`jsonNode`,`fieldNameLit`), `jsonPath`)
           `tmpSym`.`fieldSym` = tmp
         else:
@@ -1272,7 +1272,7 @@ proc foldObjectBody(dst, typeNode, tmpSym, jsonNode, jsonPath, originalJsonPathL
     let kindType = typeNode[0][1]
     let kindOffsetLit = newLit(uint(getOffset(kindSym)))
     dst.add quote do:
-      var kindTmp: `kindType` = default(typeof(`kindType`))
+      var kindTmp: `kindType`
       jsonPath.add `kindPathLit`
       initFromJson(kindTmp, `jsonNode`[`kindNameLit`], `jsonPath`)
       jsonPath.setLen `originalJsonPathLen`

lib/pure/marshal.nim

@@ -312,7 +312,7 @@ proc store*[T](s: Stream, data: sink T) =
   storeAny(s, toAny(d), stored)
 
 proc loadVM[T](typ: typedesc[T], x: T): string =
-  raiseAssert "the implementation is in the compiler/vmops"
+  discard "the implementation is in the compiler/vmops"
 
 proc `$$`*[T](x: sink T): string =
   ## Returns a string representation of `x` (serialization, marshalling).
@@ -343,7 +343,7 @@ proc `$$`*[T](x: sink T): string =
     result = s.data
 
 proc toVM[T](typ: typedesc[T], data: string): T =
-  raiseAssert "the implementation is in the compiler/vmops"
+  discard "the implementation is in the compiler/vmops"
 
 proc to*[T](data: string): T =
   ## Reads data and transforms it to a type `T` (deserialization, unmarshalling).
@@ -363,6 +363,5 @@ proc to*[T](data: string): T =
   when nimvm:
     result = toVM(T, data)
   else:
-    result = default(T)
     var tab = initTable[BiggestInt, pointer]()
     loadAny(newStringStream(data), toAny(result), tab)

lib/pure/math.nim

@@ -105,7 +105,7 @@ when not defined(js) and not defined(nimscript): # C
       when compileOption("overflowChecks"):
         if y == 0:
           raise new(DivByZeroDefect)
-        elif (x == T.low and int64(y) == -1):
+        elif (x == T.low and y == -1.T):
           raise new(OverflowDefect)
       let res = divmod_c(x, y)
       result[0] = res.quot
@@ -989,9 +989,8 @@ func frexp*[T: float32|float64](x: T): tuple[frac: T, exp: int] {.inline.} =
       doAssert frexp(Inf).frac == Inf # +- Inf preserved
       doAssert frexp(NaN).frac.isNaN
 
-  result = default(tuple[frac: T, exp: int])
   when not defined(js):
-    var exp: cint = cint(0)
+    var exp: cint
     result.frac = c_frexp2(x, exp)
     result.exp = exp
   else:
@@ -1069,8 +1068,10 @@ func splitDecimal*[T: float32|float64](x: T): tuple[intpart: T, floatpart: T] =
   runnableExamples:
     doAssert splitDecimal(5.25) == (intpart: 5.0, floatpart: 0.25)
     doAssert splitDecimal(-2.73) == (intpart: -2.0, floatpart: -0.73)
-  result = default(tuple[intpart: T, floatpart: T])
-  var absolute: T = abs(x)
+
+  var
+    absolute: T
+  absolute = abs(x)
   result.intpart = floor(absolute)
   result.floatpart = absolute - result.intpart
   if x < 0:
@@ -1127,7 +1128,7 @@ func sum*[T](x: openArray[T]): T =
   runnableExamples:
     doAssert sum([1, 2, 3, 4]) == 10
     doAssert sum([-4, 3, 5]) == 4
-  result = default(T)
+
   for i in items(x): result = result + i
 
 func prod*[T](x: openArray[T]): T =
@@ -1186,7 +1187,7 @@ func cumsummed*[T](x: openArray[T]): seq[T] =
   ## * `cumsum func <#cumsum,openArray[T]>`_ for the in-place version
   runnableExamples:
     doAssert cumsummed([1, 2, 3, 4]) == @[1, 3, 6, 10]
-  result = @[]
+
   let xLen = x.len
   if xLen == 0:
     return @[]

lib/pure/parseutils.nim

@@ -186,7 +186,6 @@ proc parseHex*[T: SomeInteger](s: openArray[char], number: var T, maxLen = 0): i
     var num64: int64
     doAssert parseHex("4E69ED4E69ED", num64) == 12
     doAssert num64 == 86216859871725
-  result = 0
   var i = 0
   var output = T(0)
   var foundDigit = false

lib/pure/pegs.nim

@@ -563,8 +563,6 @@ template matchOrParse(mopProc: untyped) =
   # are provided which just return *discard*.
 
   proc mopProc(s: string, p: Peg, start: int, c: var Captures): int {.gcsafe, raises: [].} =
-    result = 0
-
     proc matchBackRef(s: string, p: Peg, start: int, c: var Captures): int =
       # Parse handler code must run in an *of* clause of its own for each
       # *PegKind*, so we encapsulate the identical clause body for
@@ -581,7 +579,7 @@ template matchOrParse(mopProc: untyped) =
         n = Peg(kind: pkTerminalIgnoreStyle, term: s.substr(a, b))
       of pkBackRefIgnoreCase:
         n = Peg(kind: pkTerminalIgnoreCase, term: s.substr(a, b))
-      else: raiseAssert "impossible case"
+      else: assert(false, "impossible case")
       mopProc(s, n, start, c)
 
     case p.kind
@@ -697,7 +695,7 @@ template matchOrParse(mopProc: untyped) =
       enter(pkTerminalIgnoreStyle, s, p, start)
       var
         i = 0
-        a, b: Rune = default(Rune)
+        a, b: Rune
       result = start
       while i < len(p.term):
         while i < len(p.term):
@@ -1069,7 +1067,7 @@ template eventParser*(pegAst, handlers: untyped): (proc(s: string): int) =
   proc parser(s: string): int {.gensym.} =
     # the proc to be returned
     var
-      ms: array[MaxSubpatterns, (int, int)] = default(array[MaxSubpatterns, (int, int)])
+      ms: array[MaxSubpatterns, (int, int)]
       cs = Captures(matches: ms, ml: 0, origStart: 0)
     rawParse(s, pegAst, 0, cs)
   parser

lib/pure/random.nim

@@ -228,7 +228,6 @@ proc skipRandomNumbers*(s: var Rand) =
 
 proc rand[T: uint | uint64](r: var Rand; max: T): T =
   # xxx export in future work
-  result = default(T)
   if max == 0: return
   else:
     let max = uint64(max)

lib/pure/rationals.nim

@@ -57,7 +57,8 @@ func initRational*[T: SomeInteger](num, den: T): Rational[T] =
   ##
   ## **Note:** `den != 0` is not checked when assertions are turned off.
   assert(den != 0, "a denominator of zero is invalid")
-  result = Rational[T](num: num, den: den)
+  result.num = num
+  result.den = den
   reduce(result)
 
 func `//`*[T](num, den: T): Rational[T] =
@@ -79,7 +80,9 @@ func toRational*[T: SomeInteger](x: T): Rational[T] =
   ## Converts some integer `x` to a rational number.
   runnableExamples:
     doAssert toRational(42) == 42 // 1
-  result = Rational[T](num: x, den: 1)
+
+  result.num = x
+  result.den = 1
 
 func toRational*(x: float,
                  n: int = high(int) shr (sizeof(int) div 2 * 8)): Rational[int] =
@@ -122,18 +125,19 @@ func toInt*[T](x: Rational[T]): int =
 func `+`*[T](x, y: Rational[T]): Rational[T] =
   ## Adds two rational numbers.
   let common = lcm(x.den, y.den)
-  result = Rational[T](num: common div x.den * x.num + common div y.den * y.num,
-                       den: common
-  )
+  result.num = common div x.den * x.num + common div y.den * y.num
+  result.den = common
   reduce(result)
 
 func `+`*[T](x: Rational[T], y: T): Rational[T] =
   ## Adds the rational `x` to the int `y`.
-  result = Rational[T](num: x.num + y * x.den, den: x.den)
+  result.num = x.num + y * x.den
+  result.den = x.den
 
 func `+`*[T](x: T, y: Rational[T]): Rational[T] =
   ## Adds the int `x` to the rational `y`.
-  result = Rational[T](num: x * y.den + y.num, den: y.den)
+  result.num = x * y.den + y.num
+  result.den = y.den
 
 func `+=`*[T](x: var Rational[T], y: Rational[T]) =
   ## Adds the rational `y` to the rational `x` in-place.
@@ -148,23 +152,25 @@ func `+=`*[T](x: var Rational[T], y: T) =
 
 func `-`*[T](x: Rational[T]): Rational[T] =
   ## Unary minus for rational numbers.
-  result = Rational[T](num: -x.num, den: x.den)
+  result.num = -x.num
+  result.den = x.den
 
 func `-`*[T](x, y: Rational[T]): Rational[T] =
   ## Subtracts two rational numbers.
   let common = lcm(x.den, y.den)
-  result = Rational[T](num: common div x.den * x.num - common div y.den * y.num,
-                den: common
-  )
+  result.num = common div x.den * x.num - common div y.den * y.num
+  result.den = common
   reduce(result)
 
 func `-`*[T](x: Rational[T], y: T): Rational[T] =
   ## Subtracts the int `y` from the rational `x`.
-  result = Rational[T](num: x.num - y * x.den, den: x.den)
+  result.num = x.num - y * x.den
+  result.den = x.den
 
 func `-`*[T](x: T, y: Rational[T]): Rational[T] =
   ## Subtracts the rational `y` from the int `x`.
-  result = Rational[T](num: x * y.den - y.num, den: y.den)
+  result.num = x * y.den - y.num
+  result.den = y.den
 
 func `-=`*[T](x: var Rational[T], y: Rational[T]) =
   ## Subtracts the rational `y` from the rational `x` in-place.
@@ -179,17 +185,20 @@ func `-=`*[T](x: var Rational[T], y: T) =
 
 func `*`*[T](x, y: Rational[T]): Rational[T] =
   ## Multiplies two rational numbers.
-  result = Rational[T](num: x.num * y.num, den: x.den * y.den)
+  result.num = x.num * y.num
+  result.den = x.den * y.den
   reduce(result)
 
 func `*`*[T](x: Rational[T], y: T): Rational[T] =
   ## Multiplies the rational `x` with the int `y`.
-  result = Rational[T](num: x.num * y, den: x.den)
+  result.num = x.num * y
+  result.den = x.den
   reduce(result)
 
 func `*`*[T](x: T, y: Rational[T]): Rational[T] =
   ## Multiplies the int `x` with the rational `y`.
-  result = Rational[T](num: x * y.num, den: y.den)
+  result.num = x * y.num
+  result.den = y.den
   reduce(result)
 
 func `*=`*[T](x: var Rational[T], y: Rational[T]) =
@@ -207,25 +216,30 @@ func reciprocal*[T](x: Rational[T]): Rational[T] =
   ## Calculates the reciprocal of `x` (`1/x`).
   ## If `x` is 0, raises `DivByZeroDefect`.
   if x.num > 0:
-    result = Rational[T](num: x.den, den: x.num)
+    result.num = x.den
+    result.den = x.num
   elif x.num < 0:
-    result = Rational[T](num: -x.den, den: -x.num)
+    result.num = -x.den
+    result.den = -x.num
   else:
     raise newException(DivByZeroDefect, "division by zero")
 
 func `/`*[T](x, y: Rational[T]): Rational[T] =
   ## Divides the rational `x` by the rational `y`.
-  result = Rational[T](num: x.num * y.den, den: x.den * y.num)
+  result.num = x.num * y.den
+  result.den = x.den * y.num
   reduce(result)
 
 func `/`*[T](x: Rational[T], y: T): Rational[T] =
   ## Divides the rational `x` by the int `y`.
-  result = Rational[T](num: x.num, den: x.den * y)
+  result.num = x.num
+  result.den = x.den * y
   reduce(result)
 
 func `/`*[T](x: T, y: Rational[T]): Rational[T] =
   ## Divides the int `x` by the rational `y`.
-  result = Rational[T](num: x * y.den, den: y.num)
+  result.num = x * y.den
+  result.den = y.num
   reduce(result)
 
 func `/=`*[T](x: var Rational[T], y: Rational[T]) =
@@ -263,7 +277,9 @@ func abs*[T](x: Rational[T]): Rational[T] =
   runnableExamples:
     doAssert abs(1 // 2) == 1 // 2
     doAssert abs(-1 // 2) == 1 // 2
-  result = Rational[T](num: abs x.num, den: abs x.den)
+
+  result.num = abs x.num
+  result.den = abs x.den
 
 func `div`*[T: SomeInteger](x, y: Rational[T]): T =
   ## Computes the rational truncated division.
@@ -295,7 +311,6 @@ func floorMod*[T: SomeInteger](x, y: Rational[T]): Rational[T] =
 func hash*[T](x: Rational[T]): Hash =
   ## Computes the hash for the rational `x`.
   # reduce first so that hash(x) == hash(y) for x == y
-  result = Hash(0)
   var copy = x
   reduce(copy)
 
@@ -316,8 +331,10 @@ func `^`*[T: SomeInteger](x: Rational[T], y: T): Rational[T] =
     doAssert (-3 // 5) ^ -2 == (25 // 9)
 
   if y >= 0:
-    result = Rational[T](num: x.num ^ y, den: x.den ^ y)
+    result.num = x.num ^ y
+    result.den = x.den ^ y
   else:
-    result = Rational[T](num: x.den ^ -y, den: x.num ^ -y)
+    result.num = x.den ^ -y
+    result.den = x.num ^ -y
   # Note that all powers of reduced rationals are already reduced,
   # so we don't need to call reduce() here

lib/pure/selectors.nim

@@ -336,7 +336,7 @@ else:
       elif defined(zephyr) or defined(freertos):
         FD_MAX
       else:
-        var fdLim: RLimit = default(RLimit)
+        var fdLim: RLimit
         var res = int(getrlimit(RLIMIT_NOFILE, fdLim))
         if res >= 0:
           res = int(fdLim.rlim_cur) - 1

lib/pure/unittest.nim

@@ -109,7 +109,7 @@ import std/private/since
 import std/exitprocs
 
 when defined(nimPreviewSlimSystem):
-  import std/[assertions, syncio]
+  import std/assertions
 
 import std/[macros, strutils, streams, times, sets, sequtils]
 
@@ -665,7 +665,9 @@ macro check*(conditions: untyped): untyped =
       checkpoint(name & " was " & $value)
 
   proc inspectArgs(exp: NimNode): tuple[assigns, check, printOuts: NimNode] =
-    result = (newNimNode(nnkStmtList), copyNimTree(exp), newNimNode(nnkStmtList))
+    result.check = copyNimTree(exp)
+    result.assigns = newNimNode(nnkStmtList)
+    result.printOuts = newNimNode(nnkStmtList)
 
     var counter = 0
 

lib/std/formatfloat.nim

@@ -110,10 +110,6 @@ when defined(js):
       }
       if (Number.isSafeInteger(`a`))
         `result` = `a` === 0 && 1 / `a` < 0 ? "-0.0" : `a`+".0";
-      else if (isNaN(`a`)) // Number.isNaN is since ES6
-        `result` = "nan";  // or it'll be "NaN"
-      else if (!isFinite(`a`)) // Number.isFinite newer but unnecessary here
-        `result` = `a` > 0 ? "inf" : "-inf";  // or it'll be [-]Infinity
       else {
         `result` = `a`+"";
         if(nimOnlyDigitsOrMinus(`result`)){
@@ -144,5 +140,4 @@ proc addFloat*(result: var string; x: float | float32) {.inline.} =
 when defined(nimPreviewSlimSystem):
   func `$`*(x: float | float32): string =
     ## Outplace version of `addFloat`.
-    result = ""
     result.addFloat(x)

lib/std/jsonutils.nim

@@ -186,7 +186,7 @@ proc discKeyMatch[T](obj: T, json: JsonNode, key: static string): bool =
   if not json.hasKey key:
     return true
   let field = accessField(obj, key)
-  var jsonVal: typeof(field) = default(typeof(field))
+  var jsonVal: typeof(field)
   fromJson(jsonVal, json[key])
   if jsonVal != field:
     return false
@@ -295,7 +295,6 @@ proc fromJson*[T](a: var T, b: JsonNode, opt = Joptions()) =
 
 proc jsonTo*(b: JsonNode, T: typedesc, opt = Joptions()): T =
   ## reverse of `toJson`
-  result = default(T)
   fromJson(result, b, opt)
 
 proc toJson*[T](a: T, opt = initToJsonOptions()): JsonNode =

lib/std/packedsets.nim

@@ -462,7 +462,7 @@ proc union*[A](s1, s2: PackedSet[A]): PackedSet[A] =
       c = union(a, b)
     assert c.len == 5
     assert c == [1, 2, 3, 4, 5].toPackedSet
-  result = default(PackedSet[A])
+
   result.assign(s1)
   incl(result, s2)
 
@@ -509,7 +509,7 @@ proc symmetricDifference*[A](s1, s2: PackedSet[A]): PackedSet[A] =
       c = symmetricDifference(a, b)
     assert c.len == 4
     assert c == [1, 2, 4, 5].toPackedSet
-  result = default(PackedSet[A])
+
   result.assign(s1)
   for item in s2.items:
     if containsOrIncl(result, item):

lib/std/typedthreads.nim

@@ -63,7 +63,7 @@ proc threadFunc(obj: ptr seq[int]) {.thread.} =
 proc threadHandler() =
   var thr: array[0..4, Thread[ptr seq[int]]]
   var s = newSeq[int]()
-
+    
   for i in 0..high(thr):
     createThread(thr[i], threadFunc, s.addr)
   joinThreads(thr)
@@ -137,7 +137,6 @@ when defined(zephyr):
 {.push stack_trace:off.}
 when defined(windows):
   proc threadProcWrapper[TArg](closure: pointer): int32 {.stdcall.} =
-    result = 0'i32
     nimThreadProcWrapperBody(closure)
     # implicitly return 0
 elif defined(genode):
@@ -145,7 +144,6 @@ elif defined(genode):
     nimThreadProcWrapperBody(closure)
 else:
   proc threadProcWrapper[TArg](closure: pointer): pointer {.noconv.} =
-    result = nil
     nimThreadProcWrapperBody(closure)
 {.pop.}
 
@@ -166,7 +164,7 @@ when hostOS == "windows":
 
   proc joinThreads*[TArg](t: varargs[Thread[TArg]]) =
     ## Waits for every thread in `t` to finish.
-    var a: array[MAXIMUM_WAIT_OBJECTS, SysThread] = default(array[MAXIMUM_WAIT_OBJECTS, SysThread])
+    var a: array[MAXIMUM_WAIT_OBJECTS, SysThread]
     var k = 0
     while k < len(t):
       var count = min(len(t) - k, MAXIMUM_WAIT_OBJECTS)
@@ -222,7 +220,7 @@ when hostOS == "windows":
     when TArg isnot void: t.data = param
     t.dataFn = tp
     when hasSharedHeap: t.core.stackSize = ThreadStackSize
-    var dummyThreadId: int32 = 0'i32
+    var dummyThreadId: int32
     t.sys = createThread(nil, ThreadStackSize, threadProcWrapper[TArg],
                          addr(t), 0'i32, dummyThreadId)
     if t.sys <= 0:

lib/std/wrapnils.nim

@@ -58,7 +58,7 @@ proc finalize(n: NimNode, lhs: NimNode, level: int): NimNode =
   if level == 0:
     result = quote: `lhs` = `n`
   else:
-    result = quote: (var `lhs` = `n`)
+    result = quote: (let `lhs` = `n`)
 
 proc process(n: NimNode, lhs: NimNode, label: NimNode, level: int): NimNode =
   result = nil
@@ -78,7 +78,7 @@ proc process(n: NimNode, lhs: NimNode, label: NimNode, level: int): NimNode =
       let check = it[1]
       let okSet = check[1]
       let kind1 = check[2]
-      let tmp = genSym(nskVar, "tmpCase")
+      let tmp = genSym(nskLet, "tmpCase")
       let body = process(objRef, tmp, label, level + 1)
       let tmp3 = nnkDerefExpr.newTree(tmp)
       it[0][0] = tmp3
@@ -92,7 +92,7 @@ proc process(n: NimNode, lhs: NimNode, label: NimNode, level: int): NimNode =
         `assgn`
       break
     elif it.kind in {nnkHiddenDeref, nnkDerefExpr}:
-      let tmp = genSym(nskVar, "tmp")
+      let tmp = genSym(nskLet, "tmp")
       let body = process(it[0], tmp, label, level + 1)
       it[0] = tmp
       let assgn = finalize(n, lhs, level)
@@ -117,7 +117,7 @@ macro `?.`*(a: typed): auto =
   let label = genSym(nskLabel, "label")
   let body = process(a, lhs, label, 0)
   result = quote do:
-    var `lhs`: type(`a`) = default(type(`a`))
+    var `lhs`: type(`a`)
     block `label`:
       `body`
     `lhs`
@@ -149,9 +149,9 @@ macro `??.`*(a: typed): Option =
   let label = genSym(nskLabel, "label")
   let body = process(a, lhs2, label, 0)
   result = quote do:
-    var `lhs`: Option[type(`a`)] = default(Option[type(`a`)])
+    var `lhs`: Option[type(`a`)]
     block `label`:
-      var `lhs2`: type(`a`) = default(type(`a`))
+      var `lhs2`: type(`a`)
       `body`
       `lhs` = option(`lhs2`)
     `lhs`

lib/system.nim

@@ -2357,7 +2357,7 @@ when notJSnotNims:
       else:
         let c3 = cast[proc(y: int; env: pointer): int {.nimcall.}](p)
         echo c3(3, e)
-    result = nil
+
     {.emit: """
     `result` = (void*)`x`.ClP_0;
     """.}
@@ -2365,14 +2365,12 @@ when notJSnotNims:
   proc rawEnv*[T: proc {.closure.} | iterator {.closure.}](x: T): pointer {.noSideEffect, inline.} =
     ## Retrieves the raw environment pointer of the closure `x`. See also `rawProc`.
     ## This is not available for the JS target.
-    result = nil
     {.emit: """
     `result` = `x`.ClE_0;
     """.}
 
 proc finished*[T: iterator {.closure.}](x: T): bool {.noSideEffect, inline, magic: "Finished".} =
   ## It can be used to determine if a first class iterator has finished.
-  result = false
   when defined(js):
     # TODO: mangle `:state`
     {.emit: """

lib/system/arc.nim

@@ -87,9 +87,6 @@ else:
   template count(x: Cell): untyped =
     x.rc shr rcShift
 
-when not defined(nimHasQuirky):
-  {.pragma: quirky.}
-
 proc nimNewObj(size, alignment: int): pointer {.compilerRtl.} =
   let hdrSize = align(sizeof(RefHeader), alignment)
   let s = size + hdrSize
@@ -193,7 +190,7 @@ proc nimRawDispose(p: pointer, alignment: int) {.compilerRtl.} =
 template `=dispose`*[T](x: owned(ref T)) = nimRawDispose(cast[pointer](x), T.alignOf)
 #proc dispose*(x: pointer) = nimRawDispose(x)
 
-proc nimDestroyAndDispose(p: pointer) {.compilerRtl, quirky, raises: [].} =
+proc nimDestroyAndDispose(p: pointer) {.compilerRtl, raises: [].} =
   let rti = cast[ptr PNimTypeV2](p)
   if rti.destructor != nil:
     cast[DestructorProc](rti.destructor)(p)

lib/system/compilation.nim

@@ -6,11 +6,11 @@ const
     ##   ```
     # see also std/private/since
 
-  NimMinor* {.intdefine.}: int = 3
+  NimMinor* {.intdefine.}: int = 2
     ## is the minor number of Nim's version.
     ## Odd for devel, even for releases.
 
-  NimPatch* {.intdefine.}: int = 1
+  NimPatch* {.intdefine.}: int = 2
     ## is the patch number of Nim's version.
     ## Odd for devel, even for releases.
 

lib/system/strs_v2.nim

@@ -112,10 +112,9 @@ proc nimToCStringConv(s: NimStringV2): cstring {.compilerproc, nonReloadable, in
 
 proc appendString(dest: var NimStringV2; src: NimStringV2) {.compilerproc, inline.} =
   if src.len > 0:
-    # don't copy the \0 terminator:
-    copyMem(unsafeAddr dest.p.data[dest.len], unsafeAddr src.p.data[0], src.len)
+    # also copy the \0 terminator:
+    copyMem(unsafeAddr dest.p.data[dest.len], unsafeAddr src.p.data[0], src.len+1)
     inc dest.len, src.len
-    dest.p.data[dest.len] = '\0'
 
 proc appendChar(dest: var NimStringV2; c: char) {.compilerproc, inline.} =
   dest.p.data[dest.len] = c

lib/system/threadimpl.nim

@@ -68,7 +68,7 @@ else:
         when defined(nimV2):
           thrd.dataFn(thrd.data)
         else:
-          var x: TArg = default(TArg)
+          var x: TArg
           deepCopy(x, thrd.data)
           thrd.dataFn(x)
     except:

nimpretty/nimpretty.nim

@@ -16,8 +16,6 @@ import ../compiler / [idents, llstream, ast, msgs, syntaxes, options, pathutils,
 
 import parseopt, strutils, os, sequtils
 
-import std/tempfiles
-
 const
   Version = "0.2"
   Usage = "nimpretty - Nim Pretty Printer Version " & Version & """
@@ -28,7 +26,6 @@ Usage:
 Options:
   --out:file            set the output file (default: overwrite the input file)
   --outDir:dir          set the output dir (default: overwrite the input files)
-  --stdin               read input from stdin and write output to stdout
   --indent:N[=0]        set the number of spaces that is used for indentation
                         --indent:0 means autodetection (default behaviour)
   --maxLineLen:N        set the desired maximum line length (default: 80)
@@ -87,7 +84,7 @@ proc finalCheck(content: string; origAst: PNode): bool {.nimcall.} =
   closeParser(parser)
   result = conf.errorCounter == oldErrors # and goodEnough(newAst, origAst)
 
-proc prettyPrint*(infile, outfile: string; opt: PrettyOptions) =
+proc prettyPrint*(infile, outfile: string, opt: PrettyOptions) =
   var conf = newConfigRef()
   let fileIdx = fileInfoIdx(conf, AbsoluteFile infile)
   let f = splitFile(outfile.expandTilde)
@@ -102,28 +99,12 @@ proc prettyPrint*(infile, outfile: string; opt: PrettyOptions) =
     when defined(nimpretty):
       closeEmitter(parser.em, fullAst, finalCheck)
 
-proc handleStdinInput(opt: PrettyOptions) =
-  var content = readAll(stdin)
-
-  var (cfile, path) = createTempFile("nimpretty_", ".nim")
-
-  writeFile(path, content)
-
-  prettyPrint(path, path, opt)
-
-  echo(readAll(cfile))
-
-  close(cfile)
-  removeFile(path)
-
 proc main =
   var outfile, outdir: string
 
   var infiles = newSeq[string]()
   var outfiles = newSeq[string]()
 
-  var isStdin = false
-
   var backup = false
     # when `on`, create a backup file of input in case
     # `prettyPrint` could overwrite it (note that the backup may happen even
@@ -131,6 +112,7 @@ proc main =
     # --backup was un-documented (rely on git instead).
   var opt = PrettyOptions(indWidth: 0, maxLineLen: 80)
 
+
   for kind, key, val in getopt():
     case kind
     of cmdArgument:
@@ -150,15 +132,8 @@ proc main =
       of "outDir", "outdir": outdir = val
       of "indent": opt.indWidth = parseInt(val)
       of "maxlinelen": opt.maxLineLen = parseInt(val)
-      # "" is equal to '-' as input
-      of "stdin", "": isStdin = true
       else: writeHelp()
     of cmdEnd: assert(false) # cannot happen
-
-  if isStdin:
-    handleStdinInput(opt)
-    return
-
   if infiles.len == 0:
     quit "[Error] no input file."
 

testament/important_packages.nim

@@ -79,7 +79,7 @@ pkg "hts", "nim c -o:htss src/hts.nim"
 pkg "httpauth"
 pkg "httputils"
 pkg "illwill", "nimble examples"
-# pkg "inim"
+pkg "inim"
 pkg "itertools", "nim doc src/itertools.nim"
 pkg "iterutils"
 pkg "json_rpc"

testament/lib/stdtest/specialpaths.nim

@@ -38,7 +38,6 @@ proc splitTestFile*(file: string): tuple[cat: string, path: string] =
   ## At least one directory is required in the path, to use as a category name
   runnableExamples:
     doAssert splitTestFile("tests/fakedir/tfakename.nim") == ("fakedir", "tests/fakedir/tfakename.nim".unixToNativePath)
-  result = ("", "")
   for p in file.parentDirs(inclusive = false):
     let parent = p.parentDir
     if parent.lastPathPart == testsFname:

testament/lib/stdtest/unittest_light.nim

@@ -6,18 +6,13 @@ proc mismatch*[T](lhs: T, rhs: T): string =
   ## while avoiding pulling too many dependencies. On failure, diagnostic
   ## information is provided that in particular makes it easy to spot
   ## whitespace mismatches and where the mismatch is.
-  result = ""
-
   proc replaceInvisible(s: string): string =
-    result = ""
     for a in s:
       case a
       of '\n': result.add "\\n\n"
       else: result.add a
 
-  proc quoted(s: string): string =
-    result = ""
-    result.addQuoted s
+  proc quoted(s: string): string = result.addQuoted s
 
   result.add '\n'
   result.add "lhs:{" & replaceInvisible(

tests/arc/t24720.nim

@@ -1,20 +0,0 @@
-discard """
-  matrix: "--mm:orc"
-  output: '''
-found entry
-'''
-"""
-
-import std/tables
-type NoCopies = object
-
-proc `=copy`(a: var NoCopies, b: NoCopies) {.error.}
-
-# bug #24720
-proc foo() =
-  var t: Table[int, NoCopies]
-  t[3] = NoCopies() # only moves
-  for k, v in t.pairs(): # lent values, no need to copy!
-    echo "found entry"
-
-foo()

tests/arc/tnodestroyexplicithook.nim

@@ -1,7 +1,3 @@
-discard """
-  ccodecheck: "'Result[(i_1 - 0)] = eqdup'"
-"""
-
 # issue #24626
 
 proc arrayWith2[T](y: T, size: static int): array[size, T] {.noinit, nodestroy, raises: [].} =

tests/arc/tvalgrind.nim

@@ -1,16 +0,0 @@
-discard """
-  cmd: "nim c --mm:orc -d:useMalloc $file"
-  valgrind: "true"
-"""
-
-import std/streams
-
-
-proc foo() =
-  var name = newStringStream("2r2")
-  raise newException(ValueError, "sh")
-
-try:
-  foo()
-except:
- discard

tests/ccgbugs/tassign_nil_strings.nim

@@ -1,7 +1,7 @@
 discard """
   matrix: "--mm:refc"
   output: "Hello"
-  ccodecheck: "\\i@'a_1 = ((NimStringDesc*) NIM_NIL)'"
+  ccodecheck: "\\i@'a = ((NimStringDesc*) NIM_NIL)'"
 """
 
 proc main() =

tests/ccgbugs/tmissingvolatile.nim

@@ -1,7 +1,7 @@
 discard """
   output: "1"
   cmd: r"nim c --hints:on $options --mm:refc -d:release $file"
-  ccodecheck: "'NI volatile state_1;'"
+  ccodecheck: "'NI volatile state;'"
   targets: "c"
 """
 

tests/ccgbugs/tunioninit.nim

@@ -1,32 +0,0 @@
-# issue #20653
-
-type
-  EmptySeq* {.bycopy.} = object
-
-  ChoiceWithEmptySeq_d* {.bycopy.} = object
-    a*: bool
-
-  INNER_C_UNION* {.bycopy, union.} = object
-    a*: char
-    b*: EmptySeq
-    c*: byte
-    d*: ChoiceWithEmptySeq_d
-
-  ChoiceWithEmptySeq_selection* = enum
-    ChoiceWithEmptySeq_NONE, 
-    ChoiceWithEmptySeq_a_PRESENT,
-    ChoiceWithEmptySeq_b_PRESENT,  
-    ChoiceWithEmptySeq_c_PRESENT,
-    ChoiceWithEmptySeq_d_PRESENT
-
-  ChoiceWithEmptySeq* {.bycopy.} = object
-    kind*: ChoiceWithEmptySeq_selection
-    u*: INNER_C_UNION
-
-  Og_Context* {.bycopy.} = object
-    state*: int
-    init_done*: bool
-    ch*: ChoiceWithEmptySeq
-    em*: EmptySeq
-
-var context* : Og_Context = Og_Context(init_done: false)

tests/ccgbugs2/tcodegen.nim

@@ -45,14 +45,3 @@ block: # bug #22354
 
 
   main()
-
-proc main = # bug #24677
-  let NULL = 1
-  doAssert NULL == 1
-
-  var COMMA = 1
-  doAssert COMMA == 1
-
-  for NDEBUG in 0..2:
-    doAssert NDEBUG == NDEBUG
-main()

tests/cpp/tmanual_exception.nim

@@ -1,4 +1,6 @@
 discard """
+  # doesn't work on macos 13 seemingly due to libc++ linking issue https://stackoverflow.com/a/77375947
+  disabled: osx
   targets: cpp
 """
 
@@ -16,21 +18,21 @@ proc initStdException(): CStdException {.importcpp: "std::exception()", construc
 proc fn() =
   let a = initRuntimeError("foo")
   doAssert $a.what == "foo"
-  var b = ""
+  var b: cstring
   try: raise initRuntimeError("foo2")
   except CStdException as e:
     doAssert e is CStdException
-    b = $e.what()
-  doAssert b == "foo2"
+    b = e.what()
+  doAssert $b == "foo2"
 
   try: raise initStdException()
   except CStdException: discard
 
   try: raise initRuntimeError("foo3")
   except CRuntimeError as e:
-    b = $e.what()
+    b = e.what()
   except CStdException:
     doAssert false
-  doAssert b == "foo3"
+  doAssert $b == "foo3"
 
 fn()

tests/effects/tdiagnostic_messages.nim

@@ -1,7 +1,7 @@
 discard """
   nimoutFull: true
   action: "reject"
-  cmd: "nim r --hint:Conf:off --warnings:off $file"
+  cmd: "nim r --hint:Conf:off $file"
   nimout: '''
 tdiagnostic_messages.nim(36, 6) Error: 'a' can have side effects
 > tdiagnostic_messages.nim(37, 30) Hint: 'a' calls `.sideEffect` 'callWithSideEffects'

tests/nimdoc/trunnableexamples.nim

@@ -164,9 +164,7 @@ runnableExamples:
 
   # bug #13491
   block:
-    proc fun(): int =
-      result = 0
-      doAssert false
+    proc fun(): int = doAssert false
     doAssertRaises(AssertionDefect, (discard fun()))
 
   block:

tests/objects/tobject_default_value.nim

@@ -673,11 +673,11 @@ template main {.dirty.} =
         result = v
 
       proc failed(): Result[int, string] =
-        result = default(Result[int, string])
+        discard
 
       proc calling(): Result[int, string] =
         let _ = ? failed()
-        raiseAssert "false"
+        doAssert false
 
       let r = calling()
       doAssert assigned

tests/pragmas/tparamcustompragma.nim

@@ -1,16 +0,0 @@
-discard """
-  nimout: '''
-proc foo(a {.attr.}: int) =
-  discard
-
-'''
-"""
-
-# fixes #24702
-
-import macros
-template attr*() {.pragma.}
-proc foo(a {.attr.}: int) = discard
-macro showImpl(a: typed) =
-  echo repr getImpl(a)
-showImpl(foo)

tests/statictypes/tstatictypes.nim

@@ -22,7 +22,7 @@ heyho
 Val1
 Val1
 '''
-matrix: "--hints:off --warnings:off --mm:orc; --hints:off --warnings:off --mm:refc"
+matrix: "--hints:off --mm:orc; --hints:off --mm:refc"
 """
 
 import macros

tests/stdlib/config.nims

@@ -3,5 +3,3 @@ switch("styleCheck", "error")
 switch("define", "nimPreviewSlimSystem")
 switch("define", "nimPreviewCstringConversion")
 switch("define", "nimPreviewProcConversion")
-switch("warningAserror", "ProveInit")
-switch("warningAserror", "Uninit")

tests/stdlib/talgorithm.nim

@@ -124,7 +124,7 @@ proc main() =
     var x = @[1, 7, 8, 11, 21, 33, 45, 99]
     var y = @[6, 7, 9, 12, 57, 66]
 
-    var merged: seq[int] = @[]
+    var merged: seq[int]
     merged.merge(x, y)
     doAssert merged.isSorted
     doAssert merged == sorted(x & y)
@@ -133,7 +133,7 @@ proc main() =
     var x = @[111, 88, 76, 56, 45, 31, 22, 19, 11, 3]
     var y = @[99, 85, 83, 82, 69, 64, 48, 42, 33, 31, 26, 13]
 
-    var merged: seq[int] = @[]
+    var merged: seq[int]
     merged.merge(x, y, (x, y) => -system.cmp(x, y))
     doAssert merged.isSorted((x, y) => -system.cmp(x, y))
     doAssert merged == sorted(x & y, SortOrder.Descending)
@@ -142,7 +142,7 @@ proc main() =
     var x: seq[int] = @[]
     var y = @[1]
 
-    var merged: seq[int] = @[]
+    var merged: seq[int]
     merged.merge(x, y)
     doAssert merged.isSorted
     doAssert merged.isSorted(SortOrder.Descending)
@@ -152,7 +152,7 @@ proc main() =
     var x = [1, 3, 5, 5, 7]
     var y: seq[int] = @[]
 
-    var merged: seq[int] = @[]
+    var merged: seq[int]
     merged.merge(x, y)
     doAssert merged.isSorted
     doAssert merged == @x
@@ -167,26 +167,26 @@ proc main() =
 
 
   block:
-    var x = default(array[0, int])
+    var x: array[0, int]
     var y = [1, 4, 6, 7, 9]
 
-    var merged: seq[int] = @[]
+    var merged: seq[int]
     merged.merge(x, y)
     doAssert merged.isSorted
     doAssert merged == @y
 
   block:
-    var x: array[0, int] = []
-    var y: array[0, int] = []
+    var x: array[0, int]
+    var y: array[0, int]
 
-    var merged: seq[int] = @[]
+    var merged: seq[int]
     merged.merge(x, y)
     doAssert merged.isSorted
     doAssert merged.len == 0
 
   block:
-    var x: array[0, int] = []
-    var y: array[0, int] = []
+    var x: array[0, int]
+    var y: array[0, int]
 
     var merged: seq[int] = @[99, 99, 99]
     merged.setLen(0)
@@ -195,10 +195,10 @@ proc main() =
     doAssert merged.len == 0
 
   block:
-    var x: seq[int] = @[]
-    var y: seq[int] = @[]
+    var x: seq[int]
+    var y: seq[int]
 
-    var merged: seq[int] = @[]
+    var merged: seq[int]
     merged.merge(x, y)
     doAssert merged.isSorted
     doAssert merged.len == 0
@@ -245,7 +245,7 @@ proc main() =
     var x = @[r(-12), r(1), r(3), r(8), r(13), r(88)]
     var y = @[r(4), r(7), r(12), r(13), r(77), r(99)]
 
-    var merged: seq[Record] = @[]
+    var merged: seq[Record]
     merged.setLen(0)
     merged.merge(x, y, ascendingCmp)
     doAssert merged.isSorted(ascendingCmp)
@@ -267,7 +267,7 @@ proc main() =
     doAssert merged == sorted(x & y, ascendingCmp)
 
 
-  var x: seq[(int, int)] = @[]
+  var x: seq[(int, int)]
   x.merge([(1,1)], [(1,2)], (a,b) => a[0] - b[0])
   doAssert x == @[(1, 1), (1, 2)]
 

tests/stdlib/tbitops.nim

@@ -173,7 +173,7 @@ proc main() =
 
   block:
     # basic mask operations (mutating)
-    var v: uint8 = 0'u8
+    var v: uint8
     v.setMask(0b1100_0000)
     v.setMask(0b0000_1100)
     doAssert v == 0b1100_1100
@@ -254,7 +254,7 @@ proc main() =
     doAssert a.clearMasked(3 .. 6) == 0b1000_0100
   block:
     # single bit operations
-    var v: uint8 = 0'u8
+    var v: uint8
     v.setBit(0)
     doAssert v == 0x0000_0001
     v.setBit(1)
@@ -269,7 +269,7 @@ proc main() =
     doAssert not v.testBit(6)
   block:
     # multi bit operations
-    var v: uint8 = 0'u8
+    var v: uint8
     v.setBits(0, 1, 7)
     doAssert v == 0b1000_0011
     v.flipBits(2, 3)
@@ -278,11 +278,11 @@ proc main() =
     doAssert v == 0b0000_1100
   block:
     # signed
-    var v: int8 = 0'i8
+    var v: int8
     v.setBit(7)
     doAssert v == -128
   block:
-    var v: uint64 = 0'u64
+    var v: uint64
     v.setBit(63)
     doAssert v == 0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000'u64
 
@@ -335,7 +335,7 @@ proc main() =
 
 block: # not ready for vm because exception is compile error
   try:
-    var v: uint32 = 0'u32
+    var v: uint32
     var i = 32
     v.setBit(i)
     doAssert false

tests/stdlib/tdeques.nim

@@ -190,7 +190,7 @@ proc main() =
     doAssert $a == "[10, 20, 30]"
 
   block:
-    var a, b: Deque[int] = initDeque[int]()
+    var a, b: Deque[int]
     for i in 1 .. 256:
       a.addLast(i)
     for i in 1 .. 255:

tests/stdlib/tdiff.nim

@@ -8,7 +8,6 @@ import std/strutils
 import std/assertions
 
 proc testHelper(f: seq[Item]): string =
-  result = ""
   for it in f:
     result.add(
       $it.deletedA & "." & $it.insertedB & "." & $it.startA & "." & $it.startB & "*"

tests/stdlib/tfdleak.nim

@@ -25,7 +25,7 @@ proc leakCheck(f: AsyncFD | int | FileHandle | SocketHandle, msg: string,
   var args = @[$f.int, msg, $expectLeak]
 
   when defined(windows):
-    var refFd: Handle = default(Handle)
+    var refFd: Handle
     # NOTE: This function shouldn't be used to duplicate sockets,
     #       as this function may mess with the socket internal refcounting.
     #       but due to the lack of type segmentation in the stdlib for
@@ -51,7 +51,7 @@ proc leakCheck(f: AsyncFD | int | FileHandle | SocketHandle, msg: string,
 proc isValidHandle(f: int): bool =
   ## Check if a handle is valid. Requires OS-native handles.
   when defined(windows):
-    var flags: DWORD = default(DWORD)
+    var flags: DWORD
     result = getHandleInformation(f.Handle, addr flags) != 0
   else:
     result = fcntl(f.cint, F_GETFD) != -1
@@ -88,7 +88,7 @@ proc main() =
     defer: close client
     client.connect("127.0.0.1", port)
 
-    var input: Socket = default(Socket)
+    var input: Socket
     server.accept(input)
 
     leakCheck(input.getFd, "accept()")

tests/stdlib/tfrexp1.nim

@@ -12,12 +12,12 @@ when manualTest:
   import strformat
 
 proc frexp_test(lo, hi, step: float64) =
-  var exp: int = 0
+  var exp: int
   var frac: float64
 
   var eps = 1e-15.float64
 
-  var x: float64 = lo
+  var x:float64 = lo
   while x <= hi:
     frac = frexp(x.float, exp)
     let rslt = pow(2.0, float(exp)) * frac

tests/stdlib/tgenast.nim

@@ -54,7 +54,7 @@ proc main =
           x.a = val
 
     m1()
-    var x0: Foo = Foo()
+    var x0: Foo
     x0.a1 = 10
     doAssert x0 == Foo(a: 10)
 

tests/stdlib/thashes.nim

@@ -112,7 +112,7 @@ proc main() =
 
   when sizeof(int) == 8 or defined(js):
     block:
-      var s: seq[Hash] = @[]
+      var s: seq[Hash]
       for a in [0.0, 1.0, -1.0, 1000.0, -1000.0]:
         let b = hash(a)
         doAssert b notin s
@@ -197,7 +197,7 @@ proc main() =
     doAssert hash(Obj5(t: false, x: 1)) != hash(Obj5(t: true, y: 2))
 
   block: # hash(ref|ptr|pointer)
-    var a: array[10, uint8] = default(array[10, uint8])
+    var a: array[10, uint8]
     # disableVm:
     whenVMorJs:
       # pending fix proposed in https://github.com/nim-lang/Nim/issues/15952#issuecomment-786312417

tests/stdlib/thttpclient_ssl.nim

@@ -45,7 +45,7 @@ when not defined(windows) and not disableSSLTesting():
   proc runServer(port: Port): bool {.thread.} =
     ## Run a trivial HTTPS server in a {.thread.}
     ## Exit after serving one request
-    result = false
+
     var socket = newSocket()
     socket.setSockOpt(OptReusePort, true)
     socket.bindAddr(port)
@@ -55,7 +55,7 @@ when not defined(windows) and not disableSSLTesting():
     ##  Handle one connection
     socket.listen()
 
-    var client: Socket = default(Socket)
+    var client: Socket
     var address = ""
 
     log "server: ready"

tests/stdlib/tisolation.nim

@@ -125,7 +125,7 @@ proc main(moveZeroesOut: static bool) =
     doAssert data.extract.id == 12
 
   block:
-    var x: seq[Isolated[JsonNode]] = @[]
+    var x: seq[Isolated[JsonNode]]
     x.add isolate(newJString("1234"))
 
     doAssert $x == """@[(value: "1234")]"""

tests/stdlib/tjsonutils.nim

@@ -15,7 +15,7 @@ proc testRoundtrip[T](t: T, expected: string) =
   let j = t.toJson
   doAssert $j == expected, "\n" & $j & "\n" & expected
   doAssert j.jsonTo(T).toJson == j
-  var t2: T = default(T)
+  var t2: T
   t2.fromJson(j)
   doAssert t2.toJson == j
 

tests/stdlib/tmacros.nim

@@ -25,7 +25,6 @@ block: # bug #17454
 block: # unpackVarargs
   block:
     proc bar1(a: varargs[int]): string =
-      result = ""
       for ai in a: result.add " " & $ai
     proc bar2(a: varargs[int]) =
       let s1 = bar1(a)

tests/stdlib/tmath.nim

@@ -545,8 +545,3 @@ when not defined(js) and not defined(danger):
       doAssertRaises(OverflowDefect):
         discard sum(x)
 
-block: # bug #24673
-  let x: Natural = 5
-  let y: Natural = 3
-
-  doAssert divmod(x, y) == (Natural 1, Natural 2)

tests/stdlib/tnet.nim

@@ -94,10 +94,10 @@ block: # "IpAddress/Sockaddr conversion"
 
     doAssert($ipaddrstr == $ipaddr_1)
 
-    var sockaddr: Sockaddr_storage = default(Sockaddr_storage)
-    var socklen: SockLen = default(SockLen)
-    var ipaddr_2: IpAddress = default(IpAddress)
-    var port_2: Port = default(Port)
+    var sockaddr: Sockaddr_storage
+    var socklen: SockLen
+    var ipaddr_2: IpAddress
+    var port_2: Port
 
     toSockAddr(ipaddr_1, Port(0), sockaddr, socklen)
     fromSockAddr(sockaddr, socklen, ipaddr_2, port_2)
@@ -108,11 +108,11 @@ block: # "IpAddress/Sockaddr conversion"
     doAssert($ipaddr_1 == $ipaddr_2)
 
     if sockaddr.ss_family.cint == AF_INET.toInt:
-      var sockaddr4: Sockaddr_in = default(Sockaddr_in)
+      var sockaddr4: Sockaddr_in
       copyMem(addr sockaddr4, addr sockaddr, sizeof(sockaddr4))
       fromSockAddr(sockaddr4, socklen, ipaddr_2, port_2)
     elif sockaddr.ss_family.cint == AF_INET6.toInt:
-      var sockaddr6: Sockaddr_in6 = default(Sockaddr_in6)
+      var sockaddr6: Sockaddr_in6
       copyMem(addr sockaddr6, addr sockaddr, sizeof(sockaddr6))
       fromSockAddr(sockaddr6, socklen, ipaddr_2, port_2)
 

tests/stdlib/tnetdial.nim

@@ -40,7 +40,7 @@ proc testThread() {.thread.} =
 
 proc test() =
   let serverFd = initIPv6Server("::1", port)
-  var t: Thread[void] = default(Thread[void])
+  var t: Thread[void]
   createThread(t, testThread)
 
   var done = false

tests/stdlib/toptions.nim

@@ -47,7 +47,6 @@ proc main() =
 
     block example:
       proc find(haystack: string, needle: char): Option[int] =
-        result = none(int)
         for i, c in haystack:
           if c == needle:
             return some i
@@ -106,7 +105,7 @@ proc main() =
     block filter:
       doAssert(some(123).filter(proc (v: int): bool = v == 123) == some(123))
       doAssert(some(456).filter(proc (v: int): bool = v == 123).isNone)
-      doAssert(intNone.filter(proc (v: int): bool = raiseAssert "false").isNone)
+      doAssert(intNone.filter(proc (v: int): bool = doAssert false).isNone)
 
     block flatMap:
       proc addOneIfNotZero(v: int): Option[int] =
@@ -137,7 +136,7 @@ proc main() =
       doAssert(some(0).flatMap(maybeToString).flatMap(maybeExclaim) == none(string))
 
     block SomePointer:
-      var intref: ref int = nil
+      var intref: ref int
       doAssert(option(intref).isNone)
       intref.new
       doAssert(option(intref).isSome)

tests/stdlib/tparseutils.nim

@@ -44,12 +44,12 @@ proc test() =
   doAssert(parseSaturatedNatural("1_000_000", value) == 9)
   doAssert value == 1_000_000
 
-  var i64Value: int64 = 0'i64
+  var i64Value: int64
   discard parseBiggestInt("9223372036854775807", i64Value)
   doAssert i64Value == 9223372036854775807
 
   block:
-    var f: float = 0.0
+    var f: float
     let res = collect:
       for x in ["9.123456789012345+","11.123456789012345+","9.123456789012345-","8.123456789012345+","9.12345678901234-","9.123456789012345"]:
         (parseFloat(x, f, 0), $f)

tests/stdlib/tpegs.nim

@@ -192,7 +192,7 @@ block:
     expr.rule = sequence(capture(ident), *sequence(
                   nonterminal(ws), term('+'), nonterminal(ws), nonterminal(expr)))
 
-    var c: Captures = default(Captures)
+    var c: Captures
     var s = "a+b +  c +d+e+f"
     doAssert rawMatch(s, expr.rule, 0, c) == len(s)
     var a = ""
@@ -208,7 +208,7 @@ block:
     doAssert match("_______ana", peg"A <- 'ana' / . A")
     doAssert match("abcs%%%", peg"A <- ..A / .A / '%'")
 
-    var matches: array[0..MaxSubpatterns-1, string] = default(array[0..MaxSubpatterns-1, string])
+    var matches: array[0..MaxSubpatterns-1, string]
     if "abc" =~ peg"{'a'}'bc' 'xyz' / {\ident}":
       doAssert matches[0] == "abc"
     else:
@@ -325,7 +325,7 @@ block:
   call()
 call()
 """
-      var c: Captures = default(Captures)
+      var c: Captures
       doAssert program.len == program.rawMatch(grammar, 0, c)
       doAssert c.ml == 1
 

tests/stdlib/trandom.nim

@@ -11,7 +11,7 @@ when not defined(js):
 randomize(233)
 
 proc main() =
-  var occur: array[1000, int] = default(array[1000, int])
+  var occur: array[1000, int]
 
   for i in 0..100_000:
     let x = rand(high(occur))