refactoring and yak shaving.

compiler/ast.nim

@@ -1094,7 +1094,7 @@ template `[]`*(n: Indexable, i: BackwardsIndex): Indexable = n[n.len - i.int]
 template `[]=`*(n: Indexable, i: BackwardsIndex; x: Indexable) = n[n.len - i.int] = x
 
 when defined(useNodeIds):
-  const nodeIdToDebug* = -1 # 2322968
+  const nodeIdToDebug* = -1
   var gNodeId: int
 
 proc newNode*(kind: TNodeKind): PNode =

compiler/astalgo.nim

@@ -417,6 +417,7 @@ type
     currentLine: int
     firstItem: bool
     useColor: bool
+    compressBuiltinTypes: bool
     res: string
 
 proc indentMore(this: var DebugPrinter) =
@@ -541,7 +542,37 @@ proc value(this: var DebugPrinter; value: PSym) =
 
   this.closeCurly
 
+proc builtinTypeSubstitution(this: var DebugPrinter; substitution: string) =
+  if this.useColor:
+    this.res.add backrefStyle
+  this.res.add substitution
+  if this.useColor:
+    this.res.add resetStyle
+
 proc value(this: var DebugPrinter; value: PType) =
+  # these shortcuts for builtin types are done before ``earlyExit`` because they are shorter that backreference links
+  if this.compressBuiltinTypes and value != nil:
+    case value.kind
+    of tyBool:     this.builtinTypeSubstitution "<bool>";    return
+    of tyChar:     this.builtinTypeSubstitution "<char>";    return
+    of tyPointer:  this.builtinTypeSubstitution "<pointer>"; return
+    of tyString:   this.builtinTypeSubstitution "<string>";  return
+    of tyCString:  this.builtinTypeSubstitution "<cstring>"; return
+    of tyInt:      this.builtinTypeSubstitution "<int>";     return
+    of tyInt8:     this.builtinTypeSubstitution "<int8>";    return
+    of tyInt16:    this.builtinTypeSubstitution "<int16>";   return
+    of tyInt32:    this.builtinTypeSubstitution "<int32>";   return
+    of tyInt64:    this.builtinTypeSubstitution "<int64>";   return
+    of tyFloat:    this.builtinTypeSubstitution "<float>";   return
+    of tyFloat32:  this.builtinTypeSubstitution "<float32>"; return
+    of tyFloat64,: this.builtinTypeSubstitution "<float64>"; return
+    of tyUInt:     this.builtinTypeSubstitution "<uint>";    return
+    of tyUInt8:    this.builtinTypeSubstitution "<uint8>";   return
+    of tyUInt16:   this.builtinTypeSubstitution "<uint16>";  return
+    of tyUInt32:   this.builtinTypeSubstitution "<uint32>";  return
+    of tyUInt64:   this.builtinTypeSubstitution "<uint64>";  return
+    else:
+      discard
   earlyExit(this, value)
 
   this.openCurly
@@ -634,6 +665,7 @@ when declared(echo):
     this.visited = initTable[pointer, int]()
     this.renderSymType = true
     this.useColor = not defined(windows)
+    this.compressBuiltinTypes = true
     this.value(n)
     echo($this.res)
 
@@ -642,6 +674,7 @@ when declared(echo):
     this.visited = initTable[pointer, int]()
     this.renderSymType = true
     this.useColor = not defined(windows)
+    this.compressBuiltinTypes = true
     this.value(n)
     echo($this.res)
 
@@ -650,6 +683,7 @@ when declared(echo):
     this.visited = initTable[pointer, int]()
     #this.renderSymType = true
     this.useColor = not defined(windows)
+    this.compressBuiltinTypes = true
     this.value(n)
     echo($this.res)
 

compiler/condsyms.nim

@@ -105,6 +105,7 @@ proc initDefines*(symbols: StringTableRef) =
   defineSymbol("nimHasExceptionsQuery")
   defineSymbol("nimHasIsNamedTuple")
   defineSymbol("nimHashOrdinalFixed")
+  defineSymbol("nimHasTypeIsRecursive")
 
   when defined(nimHasLibFFI):
     # Renaming as we can't conflate input vs output define flags; e.g. this

compiler/extccomp.nim

@@ -990,12 +990,9 @@ template hashNimExe(): string = $secureHashFile(os.getAppFilename())
 proc writeJsonBuildInstructions*(conf: ConfigRef) =
   template lit(x: untyped) = f.write x
   template str(x: untyped) =
-    when compiles(escapeJson(x, buf)):
-      buf.setLen 0
-      escapeJson(x, buf)
-      f.write buf
-    else:
-      f.write escapeJson(x)
+    buf.setLen 0
+    escapeJson(x, buf)
+    f.write buf
 
   proc cfiles(conf: ConfigRef; f: File; buf: var string; clist: CfileList, isExternal: bool) =
     var comma = false
@@ -1031,7 +1028,7 @@ proc writeJsonBuildInstructions*(conf: ConfigRef) =
       pastStart = true
     lit "\L"
 
-  proc depfiles(conf: ConfigRef; f: File) =
+  proc depfiles(conf: ConfigRef; f: File; buf: var string) =
     var i = 0
     for it in conf.m.fileInfos:
       let path = it.fullPath.string
@@ -1071,7 +1068,7 @@ proc writeJsonBuildInstructions*(conf: ConfigRef) =
       lit ",\L\"cmdline\": "
       str conf.commandLine
       lit ",\L\"depfiles\":[\L"
-      depfiles(conf, f)
+      depfiles(conf, f, buf)
       lit "],\L\"nimexe\": \L"
       str hashNimExe()
       lit "\L"

compiler/guards.nim

@@ -788,12 +788,7 @@ macro `=~`(x: PNode, pat: untyped): bool =
 
   var conds = newTree(nnkBracket)
   m(x, pat, conds)
-  when compiles(nestList(ident"and", conds)):
-    result = nestList(ident"and", conds)
-  #elif declared(macros.toNimIdent):
-  #  result = nestList(toNimIdent"and", conds)
-  else:
-    result = nestList(!"and", conds)
+  result = nestList(ident"and", conds)
 
 proc isMinusOne(n: PNode): bool =
   n.kind in {nkCharLit..nkUInt64Lit} and n.intVal == -1

compiler/modulegraphs.nim

@@ -80,11 +80,11 @@ type
   TPassClose* = proc (graph: ModuleGraph; p: PPassContext, n: PNode): PNode {.nimcall.}
   TPassProcess* = proc (p: PPassContext, topLevelStmt: PNode): PNode {.nimcall.}
 
-  TPass* = tuple[open: TPassOpen,
-                 process: TPassProcess,
-                 close: TPassClose,
-                 isFrontend: bool]
-
+  TPass* = object
+    open*: TPassOpen
+    process*: TPassProcess
+    close*: TPassClose
+    isFrontend*: bool
 
 const
   cb64 = [
@@ -135,24 +135,14 @@ proc hash*(x: FileIndex): Hash {.borrow.}
 
 when defined(nimfind):
   template onUse*(info: TLineInfo; s: PSym) =
-    when compiles(c.c.graph):
-      if c.c.graph.onUsage != nil: c.c.graph.onUsage(c.c.graph, s, info)
-    else:
-      if c.graph.onUsage != nil: c.graph.onUsage(c.graph, s, info)
+    if c.graph.onUsage != nil: c.graph.onUsage(c.graph, s, info)
 
   template onDef*(info: TLineInfo; s: PSym) =
-    when compiles(c.c.graph):
-      if c.c.graph.onDefinition != nil: c.c.graph.onDefinition(c.c.graph, s, info)
-    else:
-      if c.graph.onDefinition != nil: c.graph.onDefinition(c.graph, s, info)
+    if c.graph.onDefinition != nil: c.graph.onDefinition(c.graph, s, info)
 
   template onDefResolveForward*(info: TLineInfo; s: PSym) =
-    when compiles(c.c.graph):
-      if c.c.graph.onDefinitionResolveForward != nil:
-        c.c.graph.onDefinitionResolveForward(c.c.graph, s, info)
-    else:
-      if c.graph.onDefinitionResolveForward != nil:
-        c.graph.onDefinitionResolveForward(c.graph, s, info)
+    if c.graph.onDefinitionResolveForward != nil:
+      c.graph.onDefinitionResolveForward(c.graph, s, info)
 
 else:
   template onUse*(info: TLineInfo; s: PSym) = discard

compiler/semmagic.nim

@@ -202,6 +202,10 @@ proc evalTypeTrait(c: PContext; traitCall: PNode, operand: PType, context: PSym)
       localError(c.config, traitCall.info,
         "distinctBase expects a distinct type as argument. The given type was " & typeToString(operand))
       result = newType(tyError, context).toNode(traitCall.info)
+  of "isRecursivePointer":
+    let operand = operand.skipTypes({tyGenericInst})
+    let cond = isRecursivePointer(operand)
+    result = newIntNodeT(toInt128(ord(cond)), traitCall, c.graph)
   else:
     localError(c.config, traitCall.info, "unknown trait: " & s)
     result = newNodeI(nkEmpty, traitCall.info)

compiler/transf.nim

@@ -554,14 +554,14 @@ proc putArgInto(arg: PNode, formal: PType): TPutArgInto =
   # inline context.
   if formal.kind == tyTypeDesc: return paDirectMapping
   if skipTypes(formal, abstractInst).kind in {tyOpenArray, tyVarargs}:
-    case arg.kind
-    of nkStmtListExpr:
-      return paComplexOpenarray
+    case arg.skipHidden.kind
     of nkBracket:
       return paFastAsgnTakeTypeFromArg
+    of nkSym:
+      return paDirectMapping
     else:
-      return paDirectMapping    # XXX really correct?
-                                # what if ``arg`` has side-effects?
+      return paComplexOpenarray
+
   case arg.kind
   of nkEmpty..nkNilLit:
     result = paDirectMapping
@@ -644,7 +644,7 @@ proc transformFor(c: PTransf, n: PNode): PNode =
   # generate access statements for the parameters (unless they are constant)
   pushTransCon(c, newC)
   for i in 1..<call.len:
-    var arg = transform(c, call[i])
+    let arg = transform(c, call[i])
     let ff = skipTypes(iter.typ, abstractInst)
     # can happen for 'nim check':
     if i >= ff.n.len: return result
@@ -671,9 +671,8 @@ proc transformFor(c: PTransf, n: PNode): PNode =
       idNodeTablePut(newC.mapping, formal, arg)
       # XXX BUG still not correct if the arg has a side effect!
     of paComplexOpenarray:
-      let typ = newType(tySequence, formal.owner)
-      addSonSkipIntLit(typ, formal.typ[0])
-      var temp = newTemp(c, typ, formal.info)
+      # arrays will deep copy here (pretty bad).
+      var temp = newTemp(c, arg.typ, formal.info)
       addVar(v, temp)
       stmtList.add(newAsgnStmt(c, nkFastAsgn, temp, arg))
       idNodeTablePut(newC.mapping, formal, temp)

compiler/types.nim

@@ -593,7 +593,10 @@ proc typeToString(typ: PType, prefer: TPreferedDesc = preferName): string =
     of tyUncheckedArray:
       result = "UncheckedArray[" & typeToString(t[0]) & ']'
     of tySequence:
-      result = "seq[" & typeToString(t[0]) & ']'
+      if t.sym != nil and prefer != preferResolved:
+        result = t.sym.name.s
+      else:
+        result = "seq[" & typeToString(t[0]) & ']'
     of tyOpt:
       result = "opt[" & typeToString(t[0]) & ']'
     of tyOrdinal:
@@ -1623,7 +1626,7 @@ proc isTupleRecursive(t: PType, cycleDetector: var IntSet): bool =
       if isTupleRecursive(t[i], cycleDetectorCopy):
         return true
   of tyAlias, tyRef, tyPtr, tyGenericInst, tyVar, tyLent, tySink,
-      tyArray, tyUncheckedArray, tySequence:
+      tyArray, tyUncheckedArray, tySequence, tyDistinct:
     return isTupleRecursive(t.lastSon, cycleDetector)
   else:
     return false
@@ -1632,6 +1635,23 @@ proc isTupleRecursive*(t: PType): bool =
   var cycleDetector = initIntSet()
   isTupleRecursive(t, cycleDetector)
 
+proc isRecursivePointer(typ: PType, isPointer: bool): bool =
+  if typ == nil:
+    return false
+  case typ.kind
+  of tyObject, tyTuple:
+    return isPointer and canFormAcycle(typ)
+  of tyRef, tyPtr:
+    return isRecursivePointer(typ.lastSon, isPointer = true)
+  of tyAlias, tyGenericInst, tyVar, tyLent, tySink, tyArray, tyUncheckedArray, tySequence, tyDistinct:
+    return isRecursivePointer(typ.lastSon, isPointer)
+  else:
+    return false
+
+proc isRecursivePointer*(t: PType): bool =
+  isRecursivePointer(t, false)
+
+
 proc isException*(t: PType): bool =
   # check if `y` is object type and it inherits from Exception
   assert(t != nil)

compiler/unittest_light.nim

@@ -16,20 +16,19 @@ proc mismatch*[T](lhs: T, rhs: T): string =
   result.add "\n"
   result.add "lhs:{" & replaceInvisible(
       $lhs) & "}\nrhs:{" & replaceInvisible($rhs) & "}\n"
-  when compiles(lhs.len):
+  when T is (string | seq | array):
     if lhs.len != rhs.len:
       result.add "lhs.len: " & $lhs.len & " rhs.len: " & $rhs.len & "\n"
-    when compiles(lhs[0]):
-      var i = 0
-      while i < lhs.len and i < rhs.len:
-        if lhs[i] != rhs[i]: break
-        i.inc
-      result.add "first mismatch index: " & $i & "\n"
-      if i < lhs.len and i < rhs.len:
-        result.add "lhs[i]: {" & quoted($lhs[i]) & "}\nrhs[i]: {" & quoted(
-            $rhs[i]) & "}\n"
-      result.add "lhs[0..<i]:{" & replaceInvisible($lhs[
-          0..<i]) & "}"
+    var i = 0
+    while i < lhs.len and i < rhs.len:
+      if lhs[i] != rhs[i]: break
+      i.inc
+    result.add "first mismatch index: " & $i & "\n"
+    if i < lhs.len and i < rhs.len:
+      result.add "lhs[i]: {" & quoted($lhs[i]) & "}\nrhs[i]: {" & quoted(
+          $rhs[i]) & "}\n"
+    result.add "lhs[0..<i]:{" & replaceInvisible($lhs[
+        0..<i]) & "}"
 
 proc assertEquals*[T](lhs: T, rhs: T) =
   when false: # can be useful for debugging to see all that's fed to this.

lib/core/macros.nim

@@ -519,10 +519,6 @@ proc `$`*(arg: LineInfo): string =
   # BUG: without `result = `, gives compile error
   result = arg.filename & "(" & $arg.line & ", " & $arg.column & ")"
 
-#proc lineinfo*(n: NimNode): LineInfo {.magic: "NLineInfo", noSideEffect.}
-#  ## returns the position the node appears in the original source file
-#  ## in the form filename(line, col)
-
 proc getLine(arg: NimNode): int {.magic: "NLineInfo", noSideEffect.}
 proc getColumn(arg: NimNode): int {.magic: "NLineInfo", noSideEffect.}
 proc getFile(arg: NimNode): string {.magic: "NLineInfo", noSideEffect.}

lib/pure/collections/critbits.nim

@@ -179,11 +179,7 @@ proc `[]=`*[T](c: var CritBitTree[T], key: string, val: T) =
 template get[T](c: CritBitTree[T], key: string): T =
   let n = rawGet(c, key)
   if n == nil:
-    when compiles($key):
-      raise newException(KeyError, "key not found: " & $key)
-    else:
-      raise newException(KeyError, "key not found")
-
+    raise newException(KeyError, "key not found: " & $key)
   n.val
 
 proc `[]`*[T](c: CritBitTree[T], key: string): T {.inline.} =

lib/pure/collections/deques.nim

@@ -69,9 +69,9 @@ template initImpl(result: typed, initialSize: int) =
   assert isPowerOfTwo(initialSize)
   result.mask = initialSize-1
   newSeq(result.data, initialSize)
-  
+
 template checkIfInitialized(deq: typed) =
-  when compiles(defaultInitialSize):
+  when defaultInitialSize > 0:
     if deq.mask == 0:
       initImpl(deq, defaultInitialSize)