Remove expr/stmt (#5857)

tests/vm/tanonproc.nim

@@ -42,7 +42,7 @@ proc getOrElse[T](o: Option[T], def: T): T =
 proc quoteStr(s: string): Option[string] =
   s.some.notEmpty.map(v => "`" & v & "`")
 
-macro str(s: string): stmt =
+macro str(s: string): typed =
   let x = s.strVal
   let y = quoteStr(x)
   let sn = newStrLitNode(y.getOrElse("NONE"))

tests/vm/tasmparser.nim

@@ -10,10 +10,10 @@ var
   cpp {.compileTime.} = ""
   token {.compileTime.} = ""
 
-proc log (msg: string) {.compileTime.} =
+proc log(msg: string) {.compileTime.} =
     echo msg
 
-proc asmx64 () {.compileTime} =
+proc asmx64() {.compileTime} =
 
   #log "code = $1" % code
 
@@ -36,7 +36,7 @@ proc asmx64 () {.compileTime} =
   const end_or_symbol_or_comment_or_passthrough = symbolStart + end_or_comment + passthrough_start
 
 
-  proc abortAsmParse (err:string) =
+  proc abortAsmParse(err:string) =
     discard
 
   let codeLen = code.len
@@ -49,17 +49,17 @@ proc asmx64 () {.compileTime} =
 
   var state:asmParseState = leading
 
-  proc checkEnd (err:string) =
-    let ch = code [start]
-    if int (ch) == 0:
-      abortAsmParse (err)
+  proc checkEnd(err:string) =
+    let ch = code[start]
+    if int(ch) == 0:
+      abortAsmParse(err)
 
-  proc get_passthrough () =
+  proc get_passthrough() =
     inc start
     let prev_start = start
     let prev_token = token
-    start += code.parseUntil (token, passthrough_end, start)
-    checkEnd ("Failed to find passthrough end delimiter from offset $1 for:$2\n$3" % [$prev_start, $(code [prev_start-prev_token.len..prev_start]), token[1..token.len-1]])
+    start += code.parseUntil(token, passthrough_end, start)
+    checkEnd("Failed to find passthrough end delimiter from offset $1 for:$2\n$3" % [$prev_start, $(code[prev_start-prev_token.len..prev_start]), token[1..token.len-1]])
     inc start
     cpp.add "`"
     cpp.add token
@@ -67,27 +67,27 @@ proc asmx64 () {.compileTime} =
 
   var inparse = true
 
-  proc checkCmdEnd () =
+  proc checkCmdEnd() =
     if codeLen == start:
       state = endCmd
       inparse = false
 
   while inparse:
-    checkCmdEnd ()
+    checkCmdEnd()
 
-    log ("state=$1 start=$2" % [$state, $start])
+    log("state=$1 start=$2" % [$state, $start])
 
     case state:
     of leading:
 
       echo "b100 ", start
-      start += code.skipWhile (leadingWhiteSpace, start)
+      start += code.skipWhile(leadingWhiteSpace, start)
       echo "b200 ", start
-      let ch = code [start]
+      let ch = code[start]
       if ch in endOfLine:
-        inc (line)
+        inc(line)
         #echo "c100 ", start, ' ', code
-        start += code.skipWhile (endOfline, start)
+        start += code.skipWhile(endOfline, start)
         #echo "c200 ", start, ' ', code
         continue
       elif ch in symbolStart:
@@ -95,20 +95,20 @@ proc asmx64 () {.compileTime} =
       elif ch in eolComment:
         state = skipToEndOfLine
       elif ch in passthrough_start:
-        get_passthrough ()
+        get_passthrough()
         echo "d100 ", start
-        start += code.parseUntil (token, end_or_symbol_or_comment_or_passthrough, start)
+        start += code.parseUntil(token, end_or_symbol_or_comment_or_passthrough, start)
         echo "d200 ", start
         cpp.add token
         state = mnemonic
-      elif int (ch) == 0:
+      elif int(ch) == 0:
         break
       else:
-        abortAsmParse ("after '$3' illegal character at offset $1: $2" % [$start, $(int (ch)), token])
+        abortAsmParse("after '$3' illegal character at offset $1: $2" % [$start, $(int(ch)), token])
 
     of mnemonic:
       echo "e100 ", start
-      start += code.parseWhile (token, symbol, start)
+      start += code.parseWhile(token, symbol, start)
       echo "e200 ", start
       cpp.add xp
       cpp.add token
@@ -118,29 +118,29 @@ proc asmx64 () {.compileTime} =
     of betweenArguments:
       let tmp = start
       let rcode = code
-      start += rcode.parseUntil (token, end_or_symbol_or_comment_or_passthrough, tmp)
+      start += rcode.parseUntil(token, end_or_symbol_or_comment_or_passthrough, tmp)
       cpp.add token
 
       if codeLen <= start:
         state = endCmd
         continue
 
-      let ch = code [start]
+      let ch = code[start]
       if ch in passthrough_start:
-        get_passthrough ()
+        get_passthrough()
         continue
-      if (ch in {'x', 'X'}) and ('0' == code [start-1]):
-        token = $(code [start])
+      if(ch in {'x', 'X'}) and('0' == code[start-1]):
+        token = $(code[start])
         cpp.add token
         inc start
         continue
       state = arguments
 
     of arguments:
-      if code [start] in end_or_comment:
+      if code[start] in end_or_comment:
         state = endCmd
         continue
-      start += code.parseWhile (token, symbol, start)
+      start += code.parseWhile(token, symbol, start)
       cpp.add xp
       cpp.add token
       state = betweenArguments
@@ -151,21 +151,21 @@ proc asmx64 () {.compileTime} =
 
     of skipToEndOfLine:
       echo "a100 ", start
-      start += code.skipUntil (endOfLine, start)
+      start += code.skipUntil(endOfLine, start)
       echo "a200 ", start
-      start += code.skipWhile (endOfline, start)
+      start += code.skipWhile(endOfline, start)
       echo "a300 ", start
       inc line
       state = leading
 
   cpp.add asmx64post
 
-  echo ($cpp)
+  echo($cpp)
 
-macro asmx64x (code_in:expr) : stmt =
+macro asmx64x(code_in:untyped) : typed =
   code = $code_in
-  echo ("code.len = $1, code = >>>$2<<<" % [$code.len, code])
-  asmx64 ()
+  echo("code.len = $1, code = >>>$2<<<" % [$code.len, code])
+  asmx64()
   discard result
 
 asmx64x """

tests/vm/tcomponent.nim

@@ -70,12 +70,12 @@ proc parse_component(body: NimNode): Component =
           result.procs_index.add(procdef.identifier.name)
       else: discard
 
-macro component*(name: expr, body: stmt): stmt {.immediate.} =
+macro component*(name, body: untyped): typed =
   let component = parse_component(body)
   registry.addComponent($name, component)
   parseStmt("discard")
 
-macro component_builtins(body: stmt): stmt {.immediate.} =
+macro component_builtins(body: untyped): typed =
   let builtin = parse_component(body)
   registry.field_index = builtin.field_index
   registry.procs_index = builtin.procs_index
@@ -88,7 +88,7 @@ proc bind_methods*(component: var Component, identifier: Ident): seq[NimNode] =
     procdef.params.insert(this_field, 0)
     result.add(procdef.render())
 
-macro bind_components*(type_name, component_names: expr): stmt {.immediate.} =
+macro bind_components*(type_name, component_names: untyped): typed =
   result = newStmtList()
   let identifier = newIdent(type_name)
   let components = newBracket(component_names)

tests/vm/teval1.nim

@@ -5,7 +5,7 @@ proc testProc: string {.compileTime.} =
   result = result & ""
 
 when true:
-  macro test(n: stmt): stmt {.immediate.} =
+  macro test(n: untyped): untyped =
     result = newNimNode(nnkStmtList)
     echo "#", testProc(), "#"
   test:
@@ -20,5 +20,3 @@ echo "##", x, "##"
 static:
     var i, j: set[int8] = {}
     var k = i + j
-
-

tests/vm/texcl.nim

@@ -15,13 +15,13 @@ proc initOpts(): set[nlOptions] =
   result.incl nloDebug
   result.incl nloNone
   result.excl nloDebug
-  
+
 const cOpts = initOpts()
 
-macro nlo(): stmt =
+macro nlo(): typed =
   nlOpts.incl(nloNone)
   nlOpts.excl(nloDebug)
   result = newEmptyNode()
 
 nlo()
-echo nloDebug in cOpts
+echo nloDebug in cOpts

tests/vm/tmitems.nim

@@ -7,7 +7,7 @@ discard """
 # bug #3731
 var list {.compileTime.} = newSeq[int]()
 
-macro calc*(): stmt {.immediate.} =
+macro calc*(): typed =
   list.add(1)
   for c in list.mitems:
     c = 13
@@ -19,7 +19,7 @@ calc()
 
 # bug #3859
 import macros
-macro m: stmt =
+macro m: typed =
   var s = newseq[NimNode](3)
   # var s: array[3,NimNode]                 # not working either
   for i in 0..<s.len: s[i] = newLit(3)    # works

tests/vm/tstaticprintseq.nim

@@ -24,7 +24,7 @@ bb
 
 const s = @[1,2,3]
 
-macro foo: stmt =
+macro foo: typed =
   for e in s:
     echo e
 
@@ -34,7 +34,7 @@ static:
   for e in s:
     echo e
 
-macro bar(x: static[seq[int]]): stmt =
+macro bar(x: static[seq[int]]): untyped =
   for e in x:
     echo e
 
@@ -55,7 +55,7 @@ static:
   var m2: TData = data
   for x in m2.numbers: echo x
 
-macro ff(d: static[TData]): stmt =
+macro ff(d: static[TData]): typed =
   for x in d.letters:
     echo x
 

tests/vm/tstringnil.nim

@@ -41,7 +41,7 @@ proc buildSuiteContents(suiteName, suiteDesc, suiteBloc: NimNode): tuple[tests:
 
   return (tests: tests)
 
-macro suite(suiteName, suiteDesc: expr, suiteBloc: stmt): stmt {.immediate.} =
+macro suite(suiteName, suiteDesc, suiteBloc: untyped): typed =
   let contents = buildSuiteContents(suiteName, suiteDesc, suiteBloc)
 
 # Test above

tests/vm/ttouintconv.nim

@@ -20,7 +20,7 @@ msg: '''
 
 #bug #2514
 
-macro foo(): stmt =
+macro foo(): typed =
   var x = 8'u8
   var y = 9'u16
   var z = 17'u32
@@ -57,21 +57,21 @@ macro foo(): stmt =
 
   var zz = 0x7FFFFFFF'u32
   echo zz
-  
-macro foo2(): stmt =
+
+macro foo2(): typed =
   var xx = 0x7FFFFFFFFFFFFFFF
   echo xx
-  
+
   var yy = 0
   echo yy
-  
+
   var zz = 0x80'u8
   echo zz
-  
+
   var ww = -9
   var vv = ww.uint
   var kk = vv.uint32
   echo kk
-  
+
 foo()
 foo2()

tests/vm/twrongconst.nim

@@ -4,6 +4,6 @@ discard """
 """
 
 var x: array[100, char]
-template foo : expr = x[42]
+template foo : char = x[42]
 
 const myConst = foo