refactorings to prepare the compiler for IC (#15935)

* added ic specific Nim code; WIP
* make the symbol import mechanism lazy; WIP
* ensure that modules can be imported multiple times
* ambiguity checking
* handle converters and TR macros properly
* make 'enum' test category green again
* special logic for semi-pure enums
* makes nimsuggest tests green again
* fixes nimdata
* makes nimpy green again
* makes more important packages work

compiler/ic/to_packed_ast.nim

@@ -0,0 +1,90 @@
+#
+#
+#           The Nim Compiler
+#        (c) Copyright 2020 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+import std / [hashes, tables]
+import packed_ast, bitabs
+import ".." / [ast, idents, lineinfos, options, pathutils, msgs]
+
+type
+  Context = object
+    thisModule: int32
+    lastFile: FileIndex # remember the last lookup entry.
+    lastLit: LitId
+    filenames: Table[FileIndex, LitId]
+
+proc toLitId(x: FileIndex; ir: var PackedTree; c: var Context): LitId =
+  if x == c.lastFile:
+    result = c.lastLit
+  else:
+    result = c.filenames.getOrDefault(x)
+    if result == LitId(0):
+      let p = msgs.toFullPath(ir.sh.config, x)
+      result = getOrIncl(ir.sh.strings, p)
+      c.filenames[x] = result
+    c.lastFile = x
+    c.lastLit = result
+
+proc toPackedInfo(x: TLineInfo; ir: var PackedTree; c: var Context): PackedLineInfo =
+  PackedLineInfo(line: x.line, col: x.col, file: toLitId(x.fileIndex, ir, c))
+
+proc toPackedType(t: PType; ir: var PackedTree; c: var Context): TypeId =
+  result = TypeId(0)
+
+proc toPackedSym(s: PSym; ir: var PackedTree; c: var Context): SymId =
+  result = SymId(0)
+
+proc toPackedSymNode(n: PNode; ir: var PackedTree; c: var Context) =
+  assert n.kind == nkSym
+  let t = toPackedType(n.typ, ir, c)
+
+  if n.sym.itemId.module == c.thisModule:
+    # it is a symbol that belongs to the module we're currently
+    # packing:
+    let sid = toPackedSym(n.sym, ir, c)
+    ir.nodes.add Node(kind: n.kind, flags: n.flags, operand: int32(sid),
+      typeId: t, info: toPackedInfo(n.info, ir, c))
+  else:
+    # store it as an external module reference:
+    #  nkModuleRef
+    discard
+
+
+proc toPackedNode*(n: PNode; ir: var PackedTree; c: var Context) =
+  template toP(x: TLineInfo): PackedLineInfo = toPackedInfo(x, ir, c)
+
+  case n.kind
+  of nkNone, nkEmpty, nkNilLit:
+    ir.nodes.add Node(kind: n.kind, flags: n.flags, operand: 0,
+      typeId: toPackedType(n.typ, ir, c), info: toP n.info)
+  of nkIdent:
+    ir.nodes.add Node(kind: n.kind, flags: n.flags, operand: int32 getOrIncl(ir.sh.strings, n.ident.s),
+      typeId: toPackedType(n.typ, ir, c), info: toP n.info)
+  of nkSym:
+    toPackedSymNode(n, ir, c)
+  of directIntLit:
+    ir.nodes.add Node(kind: n.kind, flags: n.flags, operand: int32(n.intVal),
+      typeId: toPackedType(n.typ, ir, c), info: toP n.info)
+  of externIntLit:
+    ir.nodes.add Node(kind: n.kind, flags: n.flags, operand: int32 getOrIncl(ir.sh.integers, n.intVal),
+      typeId: toPackedType(n.typ, ir, c), info: toP n.info)
+  of nkStrLit..nkTripleStrLit:
+    ir.nodes.add Node(kind: n.kind, flags: n.flags, operand: int32 getOrIncl(ir.sh.strings, n.strVal),
+      typeId: toPackedType(n.typ, ir, c), info: toP n.info)
+  of nkFloatLit..nkFloat128Lit:
+    ir.nodes.add Node(kind: n.kind, flags: n.flags, operand: int32 getOrIncl(ir.sh.floats, n.floatVal),
+      typeId: toPackedType(n.typ, ir, c), info: toP n.info)
+  else:
+    let patchPos = ir.prepare(n.kind, n.flags, toPackedType(n.typ, ir, c), toP n.info)
+    for i in 0..<n.len:
+      toPackedNode(n[i], ir, c)
+    ir.patch patchPos
+
+proc moduleToIr*(n: PNode; ir: var PackedTree; module: PSym) =
+  var c = Context(thisModule: module.itemId.module)
+  toPackedNode(n, ir, c)