the test suite is mostly green again

compiler/ast.nim

@@ -922,12 +922,6 @@ proc delSon(father: PNode, idx: int) =
   for i in countup(idx, length - 2): father.sons[i] = father.sons[i + 1]
   setlen(father.sons, length - 1)
 
-proc hasSons*(n: PNode): bool {.inline.} =
-  result = n.kind notin { nkCharLit..nkInt64Lit,
-                          nkFloatLit..nkFloat64Lit,
-                          nkStrLit..nkTripleStrLit,
-                          nkSym, nkIdent }
-
 proc copyNode(src: PNode): PNode = 
   # does not copy its sons!
   if src == nil: 
@@ -959,18 +953,6 @@ proc shallowCopy*(src: PNode): PNode =
   of nkStrLit..nkTripleStrLit: result.strVal = src.strVal
   else: newSeq(result.sons, sonsLen(src))
 
-proc copySons*(src: PNode): Pnode =
-  # copies a node and its immediate sons
-  if src == nil: return nil
-  assert src.hasSons
-  result = newNode(src.kind)
-  result.info = src.info
-  result.typ = src.typ
-  result.flags = src.flags * PersistentNodeFlags
-  newSeq(result.sons, src.len)
-  for i in countup(0, src.len - 1):
-    result.sons[i] = src.sons[i]
-
 proc copyTree(src: PNode): PNode = 
   # copy a whole syntax tree; performs deep copying
   if src == nil: 

compiler/semexprs.nim

@@ -491,15 +491,15 @@ proc expectStringArg(c: PContext, n: PNode, i: int): PNode =
   
 include semmagic
 
-proc semOverloadedCallAnalyseEffects(c: PContext, n: PNode, orig: PNode,
+proc semOverloadedCallAnalyseEffects(c: PContext, n: PNode, nOrig: PNode,
                                      flags: TExprFlags): PNode =
   if efWantIterator in flags:
-    result = semOverloadedCall(c, n, orig, {skIterator})
+    result = semOverloadedCall(c, n, nOrig, {skIterator})
   elif efInTypeOf in flags:
     # for ``type(countup(1,3))``, see ``tests/ttoseq``.
-    result = semOverloadedCall(c, n, orig, {skIterator, skProc, skMethod, skConverter, skMacro, skTemplate})
+    result = semOverloadedCall(c, n, nOrig, {skIterator, skProc, skMethod, skConverter, skMacro, skTemplate})
   else:
-    result = semOverloadedCall(c, n, orig, {skProc, skMethod, skConverter, skMacro, skTemplate})
+    result = semOverloadedCall(c, n, nOrig, {skProc, skMethod, skConverter, skMacro, skTemplate})
   if result != nil:
     if result.sons[0].kind != nkSym: 
       InternalError("semDirectCallAnalyseEffects")
@@ -513,9 +513,9 @@ proc semOverloadedCallAnalyseEffects(c: PContext, n: PNode, orig: PNode,
         if {sfImportc, sfSideEffect} * callee.flags != {}:
           incl(c.p.owner.flags, sfSideEffect)
 
-proc semDirectCallAnalyseEffects(c: PContext, n: PNode, orig: PNode,
+proc semDirectCallAnalyseEffects(c: PContext, n: PNode, nOrig: PNode,
                                  flags: TExprFlags): PNode =
-  result = semOverloadedCallAnalyseEffects(c, n, orig, flags)
+  result = semOverloadedCallAnalyseEffects(c, n, nOrig, flags)
 
 proc semIndirectOp(c: PContext, n: PNode, flags: TExprFlags): PNode = 
   result = nil
@@ -532,14 +532,14 @@ proc semIndirectOp(c: PContext, n: PNode, flags: TExprFlags): PNode =
       return semExpr(c, result, flags)
   else: 
     n.sons[0] = semExpr(c, n.sons[0])
-  let orig = n.copySons
+  let nOrig = n.copyTree
   semOpAux(c, n)
   var t: PType = nil
   if (n.sons[0].typ != nil): t = skipTypes(n.sons[0].typ, abstractInst)
   if (t != nil) and (t.kind == tyProc): 
     var m: TCandidate
     initCandidate(m, t)
-    matches(c, n, orig, m)
+    matches(c, n, nOrig, m)
     if m.state != csMatch: 
       var msg = msgKindToString(errTypeMismatch)
       for i in countup(1, sonsLen(n) - 1): 
@@ -560,7 +560,7 @@ proc semIndirectOp(c: PContext, n: PNode, flags: TExprFlags): PNode =
     # the old ``prc`` (which is likely an nkIdent) has to be restored:
     if result == nil: 
       n.sons[0] = prc
-      result = semOverloadedCallAnalyseEffects(c, n, orig, flags)
+      result = semOverloadedCallAnalyseEffects(c, n, nOrig, flags)
     if result == nil: 
       GlobalError(n.info, errExprXCannotBeCalled, 
                   renderTree(n, {renderNoComments}))
@@ -571,7 +571,7 @@ proc semIndirectOp(c: PContext, n: PNode, flags: TExprFlags): PNode =
 
 proc semDirectOp(c: PContext, n: PNode, flags: TExprFlags): PNode = 
   # this seems to be a hotspot in the compiler!
-  let nOrig = n.copySons
+  let nOrig = n.copyTree
   semOpAux(c, n)
   result = semOverloadedCallAnalyseEffects(c, n, nOrig, flags)
   if result == nil: 
@@ -1269,12 +1269,11 @@ proc semExpr(c: PContext, n: PNode, flags: TExprFlags = {}): PNode =
     if s != nil: 
       case s.kind
       of skMacro:
-        if c.filename.endsWith("hello.nim") and sfImmediate notin s.flags:
+        if false and sfImmediate notin s.flags: # XXX not yet enabled
           result = semDirectOp(c, n, flags)
         else:
           result = semMacroExpr(c, n, s)
       of skTemplate:
-        var hello = c.filename.endsWith("hello.nim")
         if sfImmediate notin s.flags:
           result = semDirectOp(c, n, flags)
         else:

compiler/semtempl.nim

@@ -7,6 +7,8 @@
 #    distribution, for details about the copyright.
 #
 
+# included from sem.nim
+
 proc isExpr(n: PNode): bool = 
   # returns true if ``n`` looks like an expression
   case n.kind
@@ -191,10 +193,10 @@ proc semTemplateDef(c: PContext, n: PNode): PNode =
   result = n
   if n.sons[bodyPos].kind == nkEmpty: 
     LocalError(n.info, errImplOfXexpected, s.name.s)
-  let curScope = c.tab.tos - 2 # -2 because we have a scope open for parameters
+  let curScope = c.tab.tos - 1
   var proto = SearchForProc(c, s, curScope)
   if proto == nil:
-    addInterfaceOverloadableSymAt(c, s, c.tab.tos - 2)
+    addInterfaceOverloadableSymAt(c, s, curScope)
   else:
     SymTabReplace(c.tab.stack[curScope], proto, s)
 

examples/allany.nim

@@ -1,6 +1,6 @@
 # All and any
 
-template all(container, cond: expr): expr =
+template all(container, cond: expr): expr {.immediate.} =
   block:
     var result = true
     for it in items(container):
@@ -9,7 +9,7 @@ template all(container, cond: expr): expr =
         break
     result
 
-template any(container, cond: expr): expr =
+template any(container, cond: expr): expr {.immediate.} =
   block:
     var result = false
     for it in items(container):

lib/pure/collections/sequtils.nim

@@ -50,7 +50,7 @@ proc filter*[T](seq1: seq[T], pred: proc(item: T): bool): seq[T] =
   ## Returns all items in a sequence that fulfilled the predicate.
   accumulateResult(filter(seq1, pred))
 
-template filterIt*(seq1, pred: expr): expr =
+template filterIt*(seq1, pred: expr): expr {.immediate.} =
   ## Finds a specific item in a sequence as long as the 
   ## predicate returns true. The predicate needs to be an expression
   ## containing ``it``: ``filterIt("abcxyz", it == 'x')``.

lib/pure/colors.nim

@@ -17,15 +17,15 @@ type
 proc `==` *(a, b: TColor): bool {.borrow.}
   ## compares two colors.
   
-template extract(a: TColor, r, g, b: expr) =
+template extract(a: TColor, r, g, b: expr) {.immediate.}=
   var r = a.int shr 16 and 0xff
   var g = a.int shr 8 and 0xff
   var b = a.int and 0xff
   
-template rawRGB(r, g, b: expr): expr =
+template rawRGB(r, g, b: int): expr =
   TColor(r shl 16 or g shl 8 or b)
   
-template colorOp(op: expr) =
+template colorOp(op: expr) {.immediate.} =
   extract(a, ar, ag, ab)
   extract(b, br, bg, bb)
   result = rawRGB(op(ar, br), op(ag, bg), op(ab, bb))

lib/pure/os.nim

@@ -242,12 +242,12 @@ proc UnixToNativePath*(path: string): string {.
         inc(i)
 
 when defined(windows):
-  template wrapUnary(varname, winApiProc, arg: expr) =
+  template wrapUnary(varname, winApiProc, arg: expr) {.immediate.} =
     var tmp = allocWideCString(arg)
     var varname = winApiProc(tmp)
     dealloc tmp
 
-  template wrapBinary(varname, winApiProc, arg, arg2: expr) =
+  template wrapBinary(varname, winApiProc, arg, arg2: expr) {.immediate.} =
     var tmp2 = allocWideCString(arg)
     var varname = winApiProc(tmp2, arg2)
     dealloc tmp2

lib/wrappers/sdl/sdl.nim

@@ -1284,9 +1284,9 @@ type                          # This is the system-independent thread info struc
   TProcedure* = proc ()
 
 type TEventSeq = set[TEventKind]
-template evconv(procName: expr, ptrName: typeDesc, assertions: TEventSeq): stmt =
+template evconv(procName: expr, ptrName: typeDesc, assertions: TEventSeq): stmt {.immediate.} =
   proc `procName`*(event: PEvent): ptrName =
-    assert(assertions.contains(event.kind))
+    assert(contains(assertions, event.kind))
     result = cast[ptrName](event)
 
 evconv(EvActive, PActiveEvent, {ACTIVEEVENT})

tests/compile/tambsym2.nim

@@ -4,5 +4,3 @@ from sdl import PSurface
 discard SDL.CreateRGBSurface(SDL.SWSURFACE, 23, 34,
       32, 0x00FF0000, 0x0000FF00, 0x000000FF, 0xff000000'i32)
 
-
-

tests/compile/ttableconstr.nim

@@ -1,6 +1,6 @@
 # Test if the new table constructor syntax works:
 
-template ignoreExpr(e: expr): stmt =
+template ignoreExpr(e: expr): stmt {.immediate.} =
   nil
 
 # test first class '..' syntactical citizen:  

tests/compile/ttempl3.nim

@@ -26,13 +26,13 @@ echo(ha)
 
 
 # Test identifier generation:
-template prefix(name: expr): expr = `"hu" name`
+template prefix(name: expr): expr {.immediate.} = `"hu" name`
 
 var `hu "XYZ"` = "yay"
 
 echo prefix(XYZ)
 
-template typedef(name: expr, typ: typeDesc) = 
+template typedef(name: expr, typ: typeDesc) {.immediate.} =
   type
     `T name`* = typ
     `P name`* = ref `T name`

tests/compile/ttempl4.nim

@@ -1,5 +1,5 @@
 
-template `:=`(name, val: expr): stmt =
+template `:=`(name, val: expr): stmt {.immediate.} =
   var name = val
 
 ha := 1 * 4

tests/reject/ttempl2.nim

@@ -3,10 +3,10 @@ discard """
   line: 18
   errormsg: "undeclared identifier: \'b\'"
 """
-template declareInScope(x: expr, t: typeDesc): stmt = 
+template declareInScope(x: expr, t: typeDesc): stmt {.immediate.} =
   var x: t
   
-template declareInNewScope(x: expr, t: typeDesc): stmt = 
+template declareInNewScope(x: expr, t: typeDesc): stmt {.immediate.} =
   # open a new scope:
   block: 
     var x: t
@@ -17,5 +17,3 @@ a = 42  # works, `a` is known here
 declareInNewScope(b, int)
 b = 42  #ERROR_MSG undeclared identifier: 'b'
 
-
-

tests/rodfiles/bmethods.nim

@@ -1,4 +1,5 @@
 discard """
+  disabled: true
   output: '''derived class
 base class
 '''

tests/rodfiles/bmethods2.nim

@@ -1,4 +1,5 @@
 discard """
+  disabled: true
   output: '''derived class 2  
 base class
 '''

tests/run/tcurrncy.nim

@@ -21,7 +21,7 @@ template Comparable(typ: typeDesc): stmt =
   proc `<=` * (x, y: typ): bool {.borrow.}
   proc `==` * (x, y: typ): bool {.borrow.}
 
-template DefineCurrency(typ, base: expr): stmt =
+template DefineCurrency(typ, base: expr): stmt {.immediate.} =
   type
     typ* = distinct base
   Additive(typ)

tests/run/tints.nim

@@ -6,7 +6,7 @@ discard """
 
 var testNumber = 0
 
-template test(opr, a, b, c: expr): stmt = 
+template test(opr, a, b, c: expr): stmt {.immediate.} =
   # test the expression at compile and runtime
   block:
     const constExpr = opr(a, b)
@@ -43,5 +43,3 @@ test(`shl`, 0xffffffff'i32, 0x4'i32, 0xfffffff0'i32)
 
 Echo("Success") #OUT Success
 
-
-

tests/run/ttoseq.nim

@@ -2,7 +2,7 @@ discard """
   output: "23456"  
 """
 
-template toSeq*(iter: expr): expr =
+template toSeq*(iter: expr): expr {.immediate.} =
   var result: seq[type(iter)] = @[]
   for x in iter: add(result, x)
   result