added tools and web dirs

lib/pure/macros.nim

@@ -8,10 +8,10 @@
 #
 
 
-## This module contains the interface to the compiler's abstract syntax 
+## This module contains the interface to the compiler's abstract syntax 
 ## tree (`AST`:idx:). Macros operate on this tree.
-
-## .. include:: ../doc/astspec.txt
+
+## .. include:: ../doc/astspec.txt
 
 #[[[cog
 #def toEnum(name, elems):
@@ -39,38 +39,38 @@ type
     nnkInt16Lit, nnkInt32Lit, nnkInt64Lit, nnkFloatLit, 
     nnkFloat32Lit, nnkFloat64Lit, nnkStrLit, nnkRStrLit, 
     nnkTripleStrLit, nnkMetaNode, nnkNilLit, nnkDotCall, 
-    nnkCommand, nnkCall, nnkGenericCall, nnkExplicitTypeListCall, 
-    nnkExprEqExpr, nnkExprColonExpr, nnkIdentDefs, nnkVarTuple, 
-    nnkInfix, nnkPrefix, nnkPostfix, nnkPar, 
-    nnkCurly, nnkBracket, nnkBracketExpr, nnkPragmaExpr, 
-    nnkRange, nnkDotExpr, nnkCheckedFieldExpr, nnkDerefExpr, 
-    nnkIfExpr, nnkElifExpr, nnkElseExpr, nnkLambda, 
-    nnkAccQuoted, nnkTableConstr, nnkQualified, nnkBind, 
-    nnkSymChoice, nnkHiddenStdConv, nnkHiddenSubConv, nnkHiddenCallConv, 
-    nnkConv, nnkCast, nnkAddr, nnkHiddenAddr, 
-    nnkHiddenDeref, nnkObjDownConv, nnkObjUpConv, nnkChckRangeF, 
-    nnkChckRange64, nnkChckRange, nnkStringToCString, nnkCStringToString, 
-    nnkPassAsOpenArray, nnkAsgn, nnkFastAsgn, nnkDefaultTypeParam, 
-    nnkGenericParams, nnkFormalParams, nnkOfInherit, nnkModule, 
-    nnkProcDef, nnkConverterDef, nnkMacroDef, nnkTemplateDef, 
-    nnkIteratorDef, nnkOfBranch, nnkElifBranch, nnkExceptBranch, 
-    nnkElse, nnkMacroStmt, nnkAsmStmt, nnkPragma, 
-    nnkIfStmt, nnkWhenStmt, nnkForStmt, nnkWhileStmt, 
-    nnkCaseStmt, nnkVarSection, nnkConstSection, nnkConstDef, 
-    nnkTypeSection, nnkTypeDef, nnkYieldStmt, nnkTryStmt, 
-    nnkFinally, nnkRaiseStmt, nnkReturnStmt, nnkBreakStmt, 
-    nnkContinueStmt, nnkBlockStmt, nnkDiscardStmt, nnkStmtList, 
-    nnkImportStmt, nnkFromStmt, nnkImportAs, nnkIncludeStmt, 
-    nnkCommentStmt, nnkStmtListExpr, nnkBlockExpr, nnkStmtListType, 
-    nnkBlockType, nnkVm, nnkTypeOfExpr, nnkObjectTy, 
+    nnkCommand, nnkCall, nnkCallStrLit, nnkExprEqExpr, 
+    nnkExprColonExpr, nnkIdentDefs, nnkVarTuple, nnkInfix, 
+    nnkPrefix, nnkPostfix, nnkPar, nnkCurly, 
+    nnkBracket, nnkBracketExpr, nnkPragmaExpr, nnkRange, 
+    nnkDotExpr, nnkCheckedFieldExpr, nnkDerefExpr, nnkIfExpr, 
+    nnkElifExpr, nnkElseExpr, nnkLambda, nnkAccQuoted, 
+    nnkTableConstr, nnkQualified, nnkBind, nnkSymChoice, 
+    nnkHiddenStdConv, nnkHiddenSubConv, nnkHiddenCallConv, nnkConv, 
+    nnkCast, nnkAddr, nnkHiddenAddr, nnkHiddenDeref, 
+    nnkObjDownConv, nnkObjUpConv, nnkChckRangeF, nnkChckRange64, 
+    nnkChckRange, nnkStringToCString, nnkCStringToString, nnkPassAsOpenArray, 
+    nnkAsgn, nnkFastAsgn, nnkGenericParams, nnkFormalParams, 
+    nnkOfInherit, nnkModule, nnkProcDef, nnkConverterDef, 
+    nnkMacroDef, nnkTemplateDef, nnkIteratorDef, nnkOfBranch, 
+    nnkElifBranch, nnkExceptBranch, nnkElse, nnkMacroStmt, 
+    nnkAsmStmt, nnkPragma, nnkIfStmt, nnkWhenStmt, 
+    nnkForStmt, nnkWhileStmt, nnkCaseStmt, nnkVarSection, 
+    nnkConstSection, nnkConstDef, nnkTypeSection, nnkTypeDef, 
+    nnkYieldStmt, nnkTryStmt, nnkFinally, nnkRaiseStmt, 
+    nnkReturnStmt, nnkBreakStmt, nnkContinueStmt, nnkBlockStmt, 
+    nnkDiscardStmt, nnkStmtList, nnkImportStmt, nnkFromStmt, 
+    nnkIncludeStmt, nnkCommentStmt, nnkStmtListExpr, nnkBlockExpr, 
+    nnkStmtListType, nnkBlockType, nnkTypeOfExpr, nnkObjectTy, 
     nnkTupleTy, nnkRecList, nnkRecCase, nnkRecWhen, 
-    nnkRefTy, nnkPtrTy, nnkVarTy, nnkAbstractTy, 
+    nnkRefTy, nnkPtrTy, nnkVarTy, nnkDistinctTy, 
     nnkProcTy, nnkEnumTy, nnkEnumFieldDef, nnkReturnToken
   TNimNodeKinds* = set[TNimrodNodeKind]
   TNimrodTypeKind* = enum
     ntyNone, ntyBool, ntyChar, ntyEmpty, 
-    ntyArrayConstr, ntyNil, ntyGeneric, ntyGenericInst, 
-    ntyGenericParam, ntyAbstract, ntyEnum, ntyOrdinal, 
+    ntyArrayConstr, ntyNil, ntyExpr, ntyStmt, 
+    ntyTypeDesc, ntyGenericInvokation, ntyGenericBody, ntyGenericInst, 
+    ntyGenericParam, ntyDistinct, ntyEnum, ntyOrdinal, 
     ntyArray, ntyObject, ntyTuple, ntySet, 
     ntyRange, ntyPtr, ntyRef, ntyVar, 
     ntySequence, ntyProc, ntyPointer, ntyOpenArray, 
@@ -79,8 +79,8 @@ type
     ntyFloat, ntyFloat32, ntyFloat64, ntyFloat128
   TNimTypeKinds* = set[TNimrodTypeKind]
   TNimrodSymKind* = enum
-    nskUnknownSym, nskConditional, nskDynLib, nskParam, 
-    nskTypeParam, nskTemp, nskType, nskConst, 
+    nskUnknown, nskConditional, nskDynLib, nskParam, 
+    nskGenericParam, nskTemp, nskType, nskConst, 
     nskVar, nskProc, nskIterator, nskConverter, 
     nskMacro, nskTemplate, nskField, nskEnumField, 
     nskForVar, nskModule, nskLabel, nskStub
@@ -91,7 +91,6 @@ type
   TNimrodIdent = object of TObject
     ## represents a Nimrod identifier in the AST
 
-  TNimrodNode {.final.} = object   # hidden
   TNimrodSymbol {.final.} = object # hidden
   TNimrodType {.final.} = object   # hidden
   
@@ -103,12 +102,9 @@ type
     ## represents a Nimrod *symbol* in the compiler; a *symbol* is a looked-up
     ## *ident*.
   
-  PNimrodNode* {.compilerproc.} = ref TNimrodNode
+  PNimrodNode* = expr
     ## represents a Nimrod AST node. Macros operate on this type.
     
-  expr* = PNimrodNode
-  stmt* = PNimrodNode
-
 # Nodes should be reference counted to make the `copy` operation very fast!
 # However, this is difficult to achieve: modify(n[0][1]) should propagate to
 # its father. How to do this without back references?
@@ -119,7 +115,7 @@ proc `[]`* (n: PNimrodNode, i: int): PNimrodNode {.magic: "NChild".}
 proc `[]=`* (n: PNimrodNode, i: int, child: PNimrodNode) {.magic: "NSetChild".}
   ## set `n`'s `i`'th child to `child`.
 
-proc `!` *(s: string): TNimrodIdent {.magic: "StrToIdent".}
+proc `!` *(s: string): TNimrodIdent {.magic: "StrToIdent".}
   ## constructs an identifier from the string `s`
 
 proc `$`*(i: TNimrodIdent): string {.magic: "IdentToStr".}
@@ -159,8 +155,8 @@ proc `typ=`*(n: PNimrodNode, typ: PNimrodType) {.magic: "NSetType".}
 proc `strVal=`*(n: PNimrodNode, val: string) {.magic: "NSetStrVal".}
 
 proc newNimNode*(kind: TNimrodNodeKind,
-                 n: PNimrodNode=nil): PNimrodNode {.magic: "NNewNimNode".}
-
+                 n: PNimrodNode=nil): PNimrodNode {.magic: "NNewNimNode".}
+
 proc copyNimNode*(n: PNimrodNode): PNimrodNode {.magic: "NCopyNimNode".}
 proc copyNimTree*(n: PNimrodNode): PNimrodNode {.magic: "NCopyNimTree".}
 
@@ -192,11 +188,11 @@ proc newIdentNode*(i: TNimrodIdent): PNimrodNode {.compileTime.} =
   ## creates an identifier node from `i`
   result = newNimNode(nnkIdent)
   result.ident = i
-
+
 proc newIdentNode*(i: string): PNimrodNode {.compileTime.} =
   ## creates an identifier node from `i`
   result = newNimNode(nnkIdent)
-  result.ident = !i
+  result.ident = !i
 
 proc toStrLit*(n: PNimrodNode): PNimrodNode {.compileTime.} =
   ## converts the AST `n` to the concrete Nimrod code and wraps that 
@@ -227,7 +223,7 @@ proc newCall*(theProc: TNimrodIdent,
   ## the arguments ``args[0..]``.
   result = newNimNode(nnkCall)
   result.add(newIdentNode(theProc))
-  result.add(args)
+  result.add(args)
   
 proc newCall*(theProc: string,
               args: openArray[PNimrodNode]): PNimrodNode {.compileTime.} =
@@ -236,14 +232,14 @@ proc newCall*(theProc: string,
   result = newNimNode(nnkCall)
   result.add(newIdentNode(theProc))
   result.add(args)
-
-proc nestList*(theProc: TNimrodIdent,  
-               x: PNimrodNode): PNimrodNode {.compileTime.} = 
-  ## nests the list `x` into a tree of call expressions:
-  ## ``[a, b, c]`` is transformed into ``theProc(a, theProc(c, d))``
-  var L = x.len
-  result = newCall(theProc, x[L-2], x[L-1])
-  var a = result
-  for i in countdown(L-3, 0):
-    a = newCall(theProc, x[i], copyNimTree(a))
-
+
+proc nestList*(theProc: TNimrodIdent,  
+               x: PNimrodNode): PNimrodNode {.compileTime.} = 
+  ## nests the list `x` into a tree of call expressions:
+  ## ``[a, b, c]`` is transformed into ``theProc(a, theProc(c, d))``
+  var L = x.len
+  result = newCall(theProc, x[L-2], x[L-1])
+  var a = result
+  for i in countdown(L-3, 0):
+    a = newCall(theProc, x[i], copyNimTree(a))
+