'assert' is now implemented without compiler magic

compiler/ast.nim

@@ -370,7 +370,8 @@ type
     mConTArr, mConTT, mSlice, 
     mFields, mFieldPairs,
     mAppendStrCh, mAppendStrStr, mAppendSeqElem, 
-    mInRange, mInSet, mRepr, mExit, mSetLengthStr, mSetLengthSeq, mAssert, 
+    mInRange, mInSet, mRepr, mExit, mSetLengthStr, mSetLengthSeq, 
+    mAssert, mAstToStr, mRand,
     mSwap, mIsNil, mArrToSeq, mCopyStr, mCopyStrLast, 
     mNewString, mNewStringOfCap,
     mReset,

compiler/ccgexprs.nim

@@ -607,7 +607,7 @@ proc genCheckedRecordField(p: BProc, e: PNode, d: var TLoc) =
       InternalError(e.info, "genCheckedRecordField") # generate the checks:
     for i in countup(1, sonsLen(e) - 1):
       it = e.sons[i]
-      assert(it.kind == nkCall)
+      assert(it.kind in nkCallKinds)
       assert(it.sons[0].kind == nkSym)
       op = it.sons[0].sym
       if op.magic == mNot: it = it.sons[1]
@@ -1403,7 +1403,7 @@ proc genMagicExpr(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
   of mIncl, mExcl, mCard, mLtSet, mLeSet, mEqSet, mMulSet, mPlusSet, mMinusSet,
      mInSet:
     genSetOp(p, e, d, op)
-  of mNewString, mNewStringOfCap, mCopyStr, mCopyStrLast, mExit:
+  of mNewString, mNewStringOfCap, mCopyStr, mCopyStrLast, mExit, mRand:
     var opr = e.sons[0].sym
     if lfNoDecl notin opr.loc.flags:
       discard cgsym(p.module, opr.loc.r.ropeToStr)

compiler/evals.nim

@@ -1162,7 +1162,8 @@ proc evalAux(c: PEvalContext, n: PNode, flags: TEvalFlags): PNode =
   of nkEmpty: result = n
   of nkSym: result = evalSym(c, n, flags)
   of nkType..nkNilLit: result = copyNode(n) # end of atoms
-  of nkCall, nkHiddenCallConv, nkMacroStmt, nkCommand, nkCallStrLit: 
+  of nkCall, nkHiddenCallConv, nkMacroStmt, nkCommand, nkCallStrLit, nkInfix,
+     nkPrefix, nkPostfix: 
     result = evalMagicOrCall(c, n)
   of nkCurly, nkBracket, nkRange: 
     # flags need to be passed here for mNAddMultiple :-(

compiler/msgs.nim

@@ -412,6 +412,7 @@ const
   PosErrorFormat* = "$1($2, $3) Error: $4"
   PosWarningFormat* = "$1($2, $3) Warning: $4"
   PosHintFormat* = "$1($2, $3) Hint: $4"
+  PosContextFormat = "$1($2, $3) Info: $4"
   RawErrorFormat* = "Error: $1"
   RawWarningFormat* = "Warning: $1"
   RawHintFormat* = "Hint: $1"
@@ -536,10 +537,10 @@ proc writeContext(lastinfo: TLineInfo) =
   var info = lastInfo
   for i in countup(0, len(msgContext) - 1): 
     if msgContext[i] != lastInfo and msgContext[i] != info: 
-      MsgWriteln(posErrorFormat % [toFilename(msgContext[i]), 
-                                   coordToStr(msgContext[i].line), 
-                                   coordToStr(msgContext[i].col), 
-                                   getMessageStr(errInstantiationFrom, "")])
+      MsgWriteln(posContextFormat % [toFilename(msgContext[i]), 
+                                     coordToStr(msgContext[i].line), 
+                                     coordToStr(msgContext[i].col), 
+                                     getMessageStr(errInstantiationFrom, "")])
     info = msgContext[i]
 
 proc rawMessage*(msg: TMsgKind, args: openarray[string]) = 

compiler/semexprs.nim

@@ -993,6 +993,12 @@ proc semMagic(c: PContext, n: PNode, s: PSym, flags: TExprFlags): PNode =
       result = semDirectOp(c, n, flags)
   of mSlurp: result = semSlurp(c, n, flags)
   of mExpandToAst: result = semExpandToAst(c, n, s, flags)
+  of mAstToStr:
+    if sonsLen(n) == 2:
+      result = newStrNodeT(renderTree(n[1], {renderNoComments}), n)
+      result.typ = getSysType(tyString)
+    else:
+      result = semDirectOp(c, n, flags)
   else: result = semDirectOp(c, n, flags)
 
 proc semIfExpr(c: PContext, n: PNode): PNode = 

compiler/semfold.nim

@@ -209,6 +209,8 @@ proc evalOp(m: TMagic, n, a, b, c: PNode): PNode =
      mParseExprToAst, mParseStmtToAst, mExpandToAst,
      mNLen..mNError, mEqRef: 
     nil
+  of mRand:
+    result = newIntNodeT(math.random(a.getInt.int), n)
   else: InternalError(a.info, "evalOp(" & $m & ')')
   
 proc getConstIfExpr(c: PSym, n: PNode): PNode = 
@@ -440,6 +442,8 @@ proc getConstExpr(m: PSym, n: PNode): PNode =
           result = magicCall(m, n)
       of mIs:
         result = newIntNodeT(ord(sameType(n[1].typ, n[2].typ)), n)
+      of mAstToStr:
+        result = newStrNodeT(renderTree(n[1], {renderNoComments}), n)
       else:
         result = magicCall(m, n)
     except EOverflow: 

compiler/semstmts.nim

@@ -404,7 +404,7 @@ proc semFor(c: PContext, n: PNode): PNode =
   openScope(c.tab)
   n.sons[length-2] = semExprNoDeref(c, n.sons[length-2], {efWantIterator})
   var call = n.sons[length-2]
-  if call.kind != nkCall or call.sons[0].kind != nkSym or
+  if call.kind notin nkCallKinds or call.sons[0].kind != nkSym or
       call.sons[0].sym.kind != skIterator: 
     GlobalError(n.sons[length - 2].info, errIteratorExpected)
   elif call.sons[0].sym.magic != mNone:

compiler/sigmatch.nim

@@ -597,7 +597,7 @@ proc matchesAux*(c: PContext, n: PNode, m: var TCandidate,
   var f = 1 # iterates over formal parameters
   var a = 1 # iterates over the actual given arguments
   m.state = csMatch           # until proven otherwise
-  m.call = newNodeI(nkCall, n.info)
+  m.call = newNodeI(n.kind, n.info)
   m.call.typ = base(m.callee) # may be nil
   var formalLen = sonsLen(m.callee.n)
   addSon(m.call, copyTree(n.sons[0]))

compiler/syntaxes.nim

@@ -117,7 +117,7 @@ proc getParser(ident: PIdent): TParserKind =
   rawMessage(errInvalidDirectiveX, ident.s)
 
 proc getCallee(n: PNode): PIdent = 
-  if (n.kind == nkCall) and (n.sons[0].kind == nkIdent): 
+  if n.kind in nkCallKinds and n.sons[0].kind == nkIdent: 
     result = n.sons[0].ident
   elif n.kind == nkIdent: 
     result = n.ident

compiler/transf.nim

@@ -468,7 +468,7 @@ proc transformFor(c: PTransf, n: PNode): PTransNode =
     addVar(v, copyTree(n.sons[i])) # declare new vars
   add(result, v.ptransNode)
   var call = n.sons[length - 2]
-  if call.kind != nkCall or call.sons[0].kind != nkSym:
+  if call.kind notin nkCallKinds or call.sons[0].kind != nkSym:
     InternalError(call.info, "transformFor")
   
   var newC = newTransCon(call.sons[0].sym)