small cleanup of ast.nim

2026-04-22 23:35:22 +00:00 · 2015-02-23 20:45:42 +01:00
parent 1e6aef62ba
commit 9080d3a9a9
1 changed files with 106 additions and 150 deletions
--- a/compiler/ast.nim
+++ b/compiler/ast.nim
@@ -377,7 +377,7 @@ type
    
    tyFromExpr #\
      # This is a type representing an expression that depends
-      # on generic parameters (the exprsesion is stored in t.n)
+      # on generic parameters (the expression is stored in t.n)
      # It will be converted to a real type only during generic
      # instantiation and prior to this it has the potential to
      # be any type.
@@ -918,50 +918,6 @@ const
    # only used when 'gCmd == cmdPretty': Indicates that the symbol has been
    # imported via 'importc: "fullname"' and no format string.

-# creator procs:
-proc newSym*(symKind: TSymKind, name: PIdent, owner: PSym,
-             info: TLineInfo): PSym
-proc newType*(kind: TTypeKind, owner: PSym): PType
-proc newNode*(kind: TNodeKind): PNode
-proc newIntNode*(kind: TNodeKind, intVal: BiggestInt): PNode
-proc newIntTypeNode*(kind: TNodeKind, intVal: BiggestInt, typ: PType): PNode
-proc newFloatNode*(kind: TNodeKind, floatVal: BiggestFloat): PNode
-proc newStrNode*(kind: TNodeKind, strVal: string): PNode
-proc newIdentNode*(ident: PIdent, info: TLineInfo): PNode
-proc newSymNode*(sym: PSym): PNode
-proc newNodeI*(kind: TNodeKind, info: TLineInfo): PNode
-proc newNodeIT*(kind: TNodeKind, info: TLineInfo, typ: PType): PNode
-proc initStrTable*(x: var TStrTable)
-proc initTable*(x: var TTable)
-proc initIdTable*(x: var TIdTable)
-proc initObjectSet*(x: var TObjectSet)
-proc initIdNodeTable*(x: var TIdNodeTable)
-proc initNodeTable*(x: var TNodeTable)
-  
-# copy procs:
-proc copyType*(t: PType, owner: PSym, keepId: bool): PType
-proc copySym*(s: PSym, keepId: bool = false): PSym
-proc assignType*(dest, src: PType)
-proc copyStrTable*(dest: var TStrTable, src: TStrTable)
-proc copyTable*(dest: var TTable, src: TTable)
-proc copyObjectSet*(dest: var TObjectSet, src: TObjectSet)
-proc copyIdTable*(dest: var TIdTable, src: TIdTable)
-proc sonsLen*(n: PNode): int {.inline.}
-proc sonsLen*(n: PType): int {.inline.}
-proc lastSon*(n: PNode): PNode {.inline.}
-proc lastSon*(n: PType): PType {.inline.}
-proc newSons*(father: PNode, length: int)
-proc newSons*(father: PType, length: int)
-proc addSon*(father, son: PNode)
-proc delSon*(father: PNode, idx: int)
-proc hasSonWith*(n: PNode, kind: TNodeKind): bool
-proc hasSubnodeWith*(n: PNode, kind: TNodeKind): bool
-proc replaceSons*(n: PNode, oldKind, newKind: TNodeKind)
-proc copyNode*(src: PNode): PNode
-  # does not copy its sons!
-proc copyTree*(src: PNode): PNode
-  # does copy its sons!
-
 proc isCallExpr*(n: PNode): bool =
  result = n.kind in nkCallKinds

@@ -988,7 +944,54 @@ proc `[]`*(n: PNode, i: int): PNode {.inline.} =
 template `{}`*(n: PNode, i: int): expr = n[i -| n]
 template `{}=`*(n: PNode, i: int, s: PNode): stmt =
  n.sons[i -| n] = s
-  
+
+proc newNode*(kind: TNodeKind): PNode = 
+  new(result)
+  result.kind = kind
+  #result.info = UnknownLineInfo() inlined:
+  result.info.fileIndex = int32(- 1)
+  result.info.col = int16(- 1)
+  result.info.line = int16(- 1)
+  when defined(useNodeIds):
+    result.id = gNodeId
+    if result.id == nodeIdToDebug:
+      echo "KIND ", result.kind
+      writeStackTrace()
+    inc gNodeId
+
+proc newIntNode*(kind: TNodeKind, intVal: BiggestInt): PNode = 
+  result = newNode(kind)
+  result.intVal = intVal
+
+proc newIntTypeNode*(kind: TNodeKind, intVal: BiggestInt, typ: PType): PNode = 
+  result = newIntNode(kind, intVal)
+  result.typ = typ
+
+proc newFloatNode*(kind: TNodeKind, floatVal: BiggestFloat): PNode = 
+  result = newNode(kind)
+  result.floatVal = floatVal
+
+proc newStrNode*(kind: TNodeKind, strVal: string): PNode = 
+  result = newNode(kind)
+  result.strVal = strVal
+
+proc newSym*(symKind: TSymKind, name: PIdent, owner: PSym,
+             info: TLineInfo): PSym = 
+  # generates a symbol and initializes the hash field too
+  new(result)
+  result.name = name
+  result.kind = symKind
+  result.flags = {}
+  result.info = info
+  result.options = gOptions
+  result.owner = owner
+  result.offset = - 1
+  result.id = getID()
+  when debugIds: 
+    registerId(result)
+  #if result.id < 2000:
+  #  MessageOut(name.s & " has id: " & toString(result.id))
+
 var emptyNode* = newNode(nkEmpty)
 # There is a single empty node that is shared! Do not overwrite it!

@@ -1031,31 +1034,31 @@ const                         # for all kind of hash tables:
  GrowthFactor* = 2           # must be power of 2, > 0
  StartSize* = 8              # must be power of 2, > 0

-proc copyStrTable(dest: var TStrTable, src: TStrTable) = 
+proc copyStrTable*(dest: var TStrTable, src: TStrTable) = 
  dest.counter = src.counter
  if isNil(src.data): return 
  setLen(dest.data, len(src.data))
  for i in countup(0, high(src.data)): dest.data[i] = src.data[i]
  
-proc copyIdTable(dest: var TIdTable, src: TIdTable) = 
+proc copyIdTable*(dest: var TIdTable, src: TIdTable) = 
  dest.counter = src.counter
  if isNil(src.data): return 
  newSeq(dest.data, len(src.data))
  for i in countup(0, high(src.data)): dest.data[i] = src.data[i]
  
-proc copyTable(dest: var TTable, src: TTable) = 
+proc copyTable*(dest: var TTable, src: TTable) = 
  dest.counter = src.counter
  if isNil(src.data): return 
  setLen(dest.data, len(src.data))
  for i in countup(0, high(src.data)): dest.data[i] = src.data[i]
  
-proc copyObjectSet(dest: var TObjectSet, src: TObjectSet) = 
+proc copyObjectSet*(dest: var TObjectSet, src: TObjectSet) = 
  dest.counter = src.counter
  if isNil(src.data): return 
  setLen(dest.data, len(src.data))
  for i in countup(0, high(src.data)): dest.data[i] = src.data[i]
  
-proc discardSons(father: PNode) = 
+proc discardSons*(father: PNode) = 
  father.sons = nil

 when defined(useNodeIds):
@@ -1065,46 +1068,16 @@ when defined(useNodeIds):
  #429107 # 430443 # 441048 # 441090 # 441153
  var gNodeId: int

-proc newNode(kind: TNodeKind): PNode = 
-  new(result)
-  result.kind = kind
-  #result.info = UnknownLineInfo() inlined:
-  result.info.fileIndex = int32(- 1)
-  result.info.col = int16(- 1)
-  result.info.line = int16(- 1)
-  when defined(useNodeIds):
-    result.id = gNodeId
-    if result.id == nodeIdToDebug:
-      echo "KIND ", result.kind
-      writeStackTrace()
-    inc gNodeId
-
-proc newIntNode(kind: TNodeKind, intVal: BiggestInt): PNode = 
-  result = newNode(kind)
-  result.intVal = intVal
-
-proc newIntTypeNode(kind: TNodeKind, intVal: BiggestInt, typ: PType): PNode = 
-  result = newIntNode(kind, intVal)
-  result.typ = typ
-
-proc newFloatNode(kind: TNodeKind, floatVal: BiggestFloat): PNode = 
-  result = newNode(kind)
-  result.floatVal = floatVal
-
-proc newStrNode(kind: TNodeKind, strVal: string): PNode = 
-  result = newNode(kind)
-  result.strVal = strVal
-
 proc withInfo*(n: PNode, info: TLineInfo): PNode =
  n.info = info
  return n

-proc newIdentNode(ident: PIdent, info: TLineInfo): PNode = 
+proc newIdentNode*(ident: PIdent, info: TLineInfo): PNode = 
  result = newNode(nkIdent)
  result.ident = ident
  result.info = info

-proc newSymNode(sym: PSym): PNode = 
+proc newSymNode*(sym: PSym): PNode = 
  result = newNode(nkSym)
  result.sym = sym
  result.typ = sym.typ
@@ -1116,7 +1089,7 @@ proc newSymNode*(sym: PSym, info: TLineInfo): PNode =
  result.typ = sym.typ
  result.info = info

-proc newNodeI(kind: TNodeKind, info: TLineInfo): PNode =
+proc newNodeI*(kind: TNodeKind, info: TLineInfo): PNode =
  new(result)
  result.kind = kind
  result.info = info
@@ -1155,11 +1128,16 @@ proc newNode*(kind: TNodeKind, info: TLineInfo, sons: TNodeSeq = @[],
      writeStackTrace()
    inc gNodeId

-proc newNodeIT(kind: TNodeKind, info: TLineInfo, typ: PType): PNode = 
+proc newNodeIT*(kind: TNodeKind, info: TLineInfo, typ: PType): PNode = 
  result = newNode(kind)
  result.info = info
  result.typ = typ

+proc addSon*(father, son: PNode) = 
+  assert son != nil
+  if isNil(father.sons): father.sons = @[]
+  add(father.sons, son)
+
 var emptyParams = newNode(nkFormalParams)
 emptyParams.addSon(emptyNode)

@@ -1181,7 +1159,7 @@ proc `$`*(x: TLockLevel): string =
  elif x.ord == UnknownLockLevel.ord: result = "<unknown>"
  else: result = $int16(x)

-proc newType(kind: TTypeKind, owner: PSym): PType = 
+proc newType*(kind: TTypeKind, owner: PSym): PType = 
  new(result)
  result.kind = kind
  result.owner = owner
@@ -1201,8 +1179,38 @@ proc mergeLoc(a: var TLoc, b: TLoc) =
  if a.t == nil: a.t = b.t
  if a.r == nil: a.r = b.r
  #if a.a == 0: a.a = b.a
+
+proc newSons*(father: PNode, length: int) = 
+  if isNil(father.sons): 
+    newSeq(father.sons, length)
+  else:
+    setLen(father.sons, length)
+
+proc newSons*(father: PType, length: int) = 
+  if isNil(father.sons): 
+    newSeq(father.sons, length)
+  else:
+    setLen(father.sons, length)
+
+proc sonsLen*(n: PType): int = 
+  if isNil(n.sons): result = 0
+  else: result = len(n.sons)
+
+proc len*(n: PType): int = 
+  if isNil(n.sons): result = 0
+  else: result = len(n.sons)
  
-proc assignType(dest, src: PType) = 
+proc sonsLen*(n: PNode): int = 
+  if isNil(n.sons): result = 0
+  else: result = len(n.sons)
+  
+proc lastSon*(n: PNode): PNode = 
+  result = n.sons[sonsLen(n) - 1]
+
+proc lastSon*(n: PType): PType = 
+  result = n.sons[sonsLen(n) - 1]
+
+proc assignType*(dest, src: PType) = 
  dest.kind = src.kind
  dest.flags = src.flags
  dest.callConv = src.callConv
@@ -1223,7 +1231,7 @@ proc assignType(dest, src: PType) =
  newSons(dest, sonsLen(src))
  for i in countup(0, sonsLen(src) - 1): dest.sons[i] = src.sons[i]
  
-proc copyType(t: PType, owner: PSym, keepId: bool): PType = 
+proc copyType*(t: PType, owner: PSym, keepId: bool): PType = 
  result = newType(t.kind, owner)
  assignType(result, t)
  if keepId: 
@@ -1232,7 +1240,7 @@ proc copyType(t: PType, owner: PSym, keepId: bool): PType =
    when debugIds: registerId(result)
  result.sym = t.sym          # backend-info should not be copied
  
-proc copySym(s: PSym, keepId: bool = false): PSym = 
+proc copySym*(s: PSym, keepId: bool = false): PSym = 
  result = newSym(s.kind, s.name, s.owner, s.info)
  #result.ast = nil            # BUGFIX; was: s.ast which made problems
  result.typ = s.typ
@@ -1266,24 +1274,7 @@ proc createModuleAlias*(s: PSym, newIdent: PIdent, info: TLineInfo): PSym =
  # XXX once usedGenerics is used, ensure module aliases keep working!
  assert s.usedGenerics == nil
  
-proc newSym(symKind: TSymKind, name: PIdent, owner: PSym,
-            info: TLineInfo): PSym = 
-  # generates a symbol and initializes the hash field too
-  new(result)
-  result.name = name
-  result.kind = symKind
-  result.flags = {}
-  result.info = info
-  result.options = gOptions
-  result.owner = owner
-  result.offset = - 1
-  result.id = getID()
-  when debugIds: 
-    registerId(result)
-  #if result.id < 2000:
-  #  MessageOut(name.s & " has id: " & toString(result.id))
-  
-proc initStrTable(x: var TStrTable) = 
+proc initStrTable*(x: var TStrTable) = 
  x.counter = 0
  newSeq(x.data, StartSize)

@@ -1294,7 +1285,7 @@ proc initTable(x: var TTable) =
  x.counter = 0
  newSeq(x.data, StartSize)

-proc initIdTable(x: var TIdTable) = 
+proc initIdTable*(x: var TIdTable) = 
  x.counter = 0
  newSeq(x.data, StartSize)

@@ -1304,42 +1295,18 @@ proc resetIdTable*(x: var TIdTable) =
  setLen(x.data, 0)
  setLen(x.data, StartSize)

-proc initObjectSet(x: var TObjectSet) = 
+proc initObjectSet*(x: var TObjectSet) = 
  x.counter = 0
  newSeq(x.data, StartSize)

-proc initIdNodeTable(x: var TIdNodeTable) = 
+proc initIdNodeTable*(x: var TIdNodeTable) = 
  x.counter = 0
  newSeq(x.data, StartSize)

-proc initNodeTable(x: var TNodeTable) = 
+proc initNodeTable*(x: var TNodeTable) = 
  x.counter = 0
  newSeq(x.data, StartSize)

-proc sonsLen(n: PType): int = 
-  if isNil(n.sons): result = 0
-  else: result = len(n.sons)
-
-proc len*(n: PType): int = 
-  if isNil(n.sons): result = 0
-  else: result = len(n.sons)
-  
-proc newSons(father: PType, length: int) = 
-  if isNil(father.sons): 
-    newSeq(father.sons, length)
-  else:
-    setLen(father.sons, length)
-
-proc sonsLen(n: PNode): int = 
-  if isNil(n.sons): result = 0
-  else: result = len(n.sons)
-  
-proc newSons(father: PNode, length: int) = 
-  if isNil(father.sons): 
-    newSeq(father.sons, length)
-  else:
-    setLen(father.sons, length)
-
 proc skipTypes*(t: PType, kinds: TTypeKinds): PType =
  ## Used throughout the compiler code to test whether a type tree contains or
  ## doesn't contain a specific type/types - it is often the case that only the
@@ -1377,22 +1344,17 @@ proc rawAddSon*(father, son: PType) =
  add(father.sons, son)
  if not son.isNil: propagateToOwner(father, son)

-proc addSon(father, son: PNode) = 
-  assert son != nil
-  if isNil(father.sons): father.sons = @[]
-  add(father.sons, son)
-
 proc addSonNilAllowed*(father, son: PNode) =
  if isNil(father.sons): father.sons = @[]
  add(father.sons, son)

-proc delSon(father: PNode, idx: int) = 
+proc delSon*(father: PNode, idx: int) = 
  if isNil(father.sons): return 
  var length = sonsLen(father)
  for i in countup(idx, length - 2): father.sons[i] = father.sons[i + 1]
  setLen(father.sons, length - 1)

-proc copyNode(src: PNode): PNode = 
+proc copyNode*(src: PNode): PNode = 
  # does not copy its sons!
  if src == nil: 
    return nil
@@ -1429,7 +1391,7 @@ proc shallowCopy*(src: PNode): PNode =
  of nkStrLit..nkTripleStrLit: result.strVal = src.strVal
  else: newSeq(result.sons, sonsLen(src))

-proc copyTree(src: PNode): PNode = 
+proc copyTree*(src: PNode): PNode = 
  # copy a whole syntax tree; performs deep copying
  if src == nil: 
    return nil
@@ -1450,12 +1412,6 @@ proc copyTree(src: PNode): PNode =
    newSeq(result.sons, sonsLen(src))
    for i in countup(0, sonsLen(src) - 1): 
      result.sons[i] = copyTree(src.sons[i])
-  
-proc lastSon(n: PNode): PNode = 
-  result = n.sons[sonsLen(n) - 1]
-
-proc lastSon(n: PType): PType = 
-  result = n.sons[sonsLen(n) - 1]

 proc hasSonWith(n: PNode, kind: TNodeKind): bool = 
  for i in countup(0, sonsLen(n) - 1): 
@@ -1479,7 +1435,7 @@ proc containsNode*(n: PNode, kinds: TNodeKinds): bool =
    for i in countup(0, sonsLen(n) - 1):
      if n.kind in kinds or containsNode(n.sons[i], kinds): return true

-proc hasSubnodeWith(n: PNode, kind: TNodeKind): bool = 
+proc hasSubnodeWith*(n: PNode, kind: TNodeKind): bool = 
  case n.kind
  of nkEmpty..nkNilLit: result = n.kind == kind
  else: