wip

compiler/ast2nif.nim

@@ -867,10 +867,14 @@ proc cursorFromIndexEntry(c: var DecodeContext; module: FileIndex; entry: NifInd
   nifcursors.parse(s[], buf, entry.info)
   result = cursorAt(buf, 0)
 
-proc moduleId(c: var DecodeContext; suffix: string): FileIndex =
+type
+  LoadFlag* = enum
+    LoadFullAst, AlwaysLoadInterface
+
+proc moduleId(c: var DecodeContext; suffix: string; flags: set[LoadFlag] = {}): FileIndex =
   var isKnownFile = false
   result = c.infos.config.registerNifSuffix(suffix, isKnownFile)
-  if not isKnownFile:
+  if not isKnownFile or AlwaysLoadInterface in flags:
     let modFile = (getNimcacheDir(c.infos.config) / RelativeFile(suffix & ".nif")).string
     let idxFile = (getNimcacheDir(c.infos.config) / RelativeFile(suffix & ".s.idx.nif")).string
     if not fileExists(modFile):
@@ -1562,7 +1566,7 @@ proc loadImport(c: var DecodeContext; s: var Stream; deps: var seq[ModuleSuffix]
   else:
     raiseAssert "expected ParRi but got " & $tok.kind
 
-proc processTopLevel(c: var DecodeContext; s: var Stream; loadFullAst: bool; suffix: string; module: int): PrecompiledModule =
+proc processTopLevel(c: var DecodeContext; s: var Stream; flags: set[LoadFlag] = {}; suffix: string; module: int): PrecompiledModule =
   result = PrecompiledModule(topLevel: newNode(nkStmtList))
   var localSyms = initTable[string, PSym]()
 
@@ -1614,7 +1618,7 @@ proc processTopLevel(c: var DecodeContext; s: var Stream; loadFullAst: bool; suf
         loadImport(c, s, result.deps, t)
       elif t.tagId == implTag:
         cont = false
-      elif loadFullAst:
+      elif LoadFullAst in flags:
         # Parse the full statement
         var buf = createTokenBuf(50)
         nextSubtree(s, buf, t)
@@ -1629,9 +1633,9 @@ proc processTopLevel(c: var DecodeContext; s: var Stream; loadFullAst: bool; suf
       cont = false
 
 proc loadNifModule*(c: var DecodeContext; suffix: ModuleSuffix; interf, interfHidden: var TStrTable;
-                    loadFullAst: bool = false): PrecompiledModule =
+                    flags: set[LoadFlag] = {}): PrecompiledModule =
     # Ensure module index is loaded - moduleId returns the FileIndex for this suffix
-  let module = moduleId(c, string(suffix))
+  let module = moduleId(c, string(suffix), flags)
 
   # Populate interface tables from the NIF index structure
   # Symbols are created as stubs (Partial state) and will be loaded lazily via loadSym
@@ -1645,14 +1649,14 @@ proc loadNifModule*(c: var DecodeContext; suffix: ModuleSuffix; interf, interfHi
   if t.kind == ParLe and pool.tags[t.tagId] == toNifTag(nkStmtList):
     t = next(s[])  # skip (stmts
     t = next(s[])  # skip flags
-    result = processTopLevel(c, s[], loadFullAst, string(suffix), module.int)
+    result = processTopLevel(c, s[], flags, string(suffix), module.int)
   else:
     result = PrecompiledModule(topLevel: newNode(nkStmtList))
 
 proc loadNifModule*(c: var DecodeContext; f: FileIndex; interf, interfHidden: var TStrTable;
-                    loadFullAst: bool = false): PrecompiledModule =
+                    flags: set[LoadFlag] = {}): PrecompiledModule =
   let suffix = ModuleSuffix(moduleSuffix(c.infos.config, f))
-  result = loadNifModule(c, suffix, interf, interfHidden, loadFullAst)
+  result = loadNifModule(c, suffix, interf, interfHidden, flags)
 
 when isMainModule:
   import std / syncio

compiler/ccgtypes.nim

@@ -1864,7 +1864,7 @@ proc genTypeInfoV2Impl(m: BModule; t, origType: PType, name: Rope; info: TLineIn
 
 proc myModuleOpenForCodegen(m: BModule; idx: FileIndex): bool {.inline.} =
   if moduleOpenForCodegen(m.g.graph, idx):
-    result = idx.int < m.g.modules.len and m.g.modules[idx.int] != nil
+    result = idx.int < m.g.mods.len and m.g.mods[idx.int] != nil
   else:
     result = false
 
@@ -1898,7 +1898,7 @@ proc genTypeInfoV2(m: BModule; t: PType; info: TLineInfo): Rope =
   let owner = t.skipTypes(typedescPtrs).itemId.module
   if owner != m.module.position and myModuleOpenForCodegen(m, FileIndex owner):
     # make sure the type info is created in the owner module
-    discard genTypeInfoV2(m.g.modules[owner], origType, info)
+    discard genTypeInfoV2(m.g.mods[owner], origType, info)
     # reference the type info as extern here
     cgsym(m, "TNimTypeV2")
     declareNimType(m, "TNimTypeV2", result, owner)
@@ -1983,7 +1983,7 @@ proc genTypeInfoV1(m: BModule; t: PType; info: TLineInfo): Rope =
   var owner = t.skipTypes(typedescPtrs).itemId.module
   if owner != m.module.position and myModuleOpenForCodegen(m, FileIndex owner):
     # make sure the type info is created in the owner module
-    discard genTypeInfoV1(m.g.modules[owner], origType, info)
+    discard genTypeInfoV1(m.g.mods[owner], origType, info)
     # reference the type info as extern here
     cgsym(m, "TNimType")
     cgsym(m, "TNimNode")

compiler/cgen.nim

@@ -67,19 +67,19 @@ proc findPendingModule(m: BModule, s: PSym): BModule =
   # TODO fixme
   if m.config.symbolFiles == v2Sf or optCompress in m.config.globalOptions:
     let ms = s.itemId.module  #getModule(s)
-    result = m.g.modules[ms]
+    result = m.g.mods[ms]
   elif m.config.cmd in {cmdNifC, cmdM}:
     var ms = getModule(s)
     registerModule m.g.graph, ms
-    if ms.position >= m.g.modules.len:
+    if ms.position >= m.g.mods.len:
       result = newModule(m.g, ms, m.config, idGeneratorFromModule(ms))
     else:
-      result = m.g.modules[ms.position]
+      result = m.g.mods[ms.position]
       if result == nil:
         result = newModule(m.g, ms, m.config, idGeneratorFromModule(ms))
   else:
     var ms = getModule(s)
-    result = m.g.modules[ms.position]
+    result = m.g.mods[ms.position]
 
 proc initLoc(k: TLocKind, lode: PNode, s: TStorageLoc, flags: TLocFlags = {}): TLoc =
   result = TLoc(k: k, storage: s, lode: lode,
@@ -133,10 +133,10 @@ proc getModuleDllPath(m: BModule): Rope =
   result = makeCString(dir.string & "/" & filename)
 
 proc getModuleDllPath(m: BModule, module: int): Rope =
-  result = getModuleDllPath(m.g.modules[module])
+  result = getModuleDllPath(m.g.mods[module])
 
 proc getModuleDllPath(m: BModule, s: PSym): Rope =
-  result = getModuleDllPath(m.g.modules[s.itemId.module])
+  result = getModuleDllPath(m.g.mods[s.itemId.module])
 
 import std/macros
 
@@ -1960,7 +1960,7 @@ proc registerModuleToMain(g: BModuleList; m: BModule) =
 
   if m.hcrOn:
     var hcrModuleMeta = newBuilder("")
-    let systemModulePath = getModuleDllPath(m, g.modules[g.graph.config.m.systemFileIdx.int].module)
+    let systemModulePath = getModuleDllPath(m, g.mods[g.graph.config.m.systemFileIdx.int].module)
     let mainModulePath = getModuleDllPath(m, m.module)
     hcrModuleMeta.addDeclWithVisibility(Private):
       hcrModuleMeta.addArrayVarWithInitializer(kind = Local,
@@ -1977,7 +1977,7 @@ proc registerModuleToMain(g: BModuleList; m: BModule) =
           g.graph.importDeps.withValue(FileIndex(m.module.position), deps):
             for curr in deps[]:
               hcrModuleMeta.addField(modules, ""):
-                hcrModuleMeta.add(getModuleDllPath(m, g.modules[curr.int].module))
+                hcrModuleMeta.add(getModuleDllPath(m, g.mods[curr.int].module))
           hcrModuleMeta.addField(modules, ""):
             hcrModuleMeta.add("\"\"")
     hcrModuleMeta.addDeclWithVisibility(ExportLib):
@@ -2388,10 +2388,10 @@ proc newModule(g: BModuleList; module: PSym; conf: ConfigRef; idgen: IdGenerator
   # we should create only one cgen module for each module sym
   result = rawNewModule(g, module, conf)
   result.idgen = idgen
-  if module.position >= g.modules.len:
-    setLen(g.modules, module.position + 1)
+  if module.position >= g.mods.len:
+    setLen(g.mods, module.position + 1)
   #growCache g.modules, module.position
-  g.modules[module.position] = result
+  g.mods[module.position] = result
 
 template injectG() {.dirty.} =
   if graph.backend == nil:
@@ -2654,7 +2654,7 @@ proc genForwardedProcs(g: BModuleList) =
   while g.forwardedProcs.len > 0:
     let
       prc = g.forwardedProcs.pop()
-      m = g.modules[prc.itemId.module]
+      m = g.mods[prc.itemId.module]
     if sfForward in prc.flags:
       internalError(m.config, prc.info, "still forwarded: " & prc.name.s)
 

compiler/cgendata.nim

@@ -117,7 +117,7 @@ type
   BModuleList* = ref object of RootObj
     mainModProcs*, mainModInit*, otherModsInit*, mainDatInit*: Builder
     mapping*: Rope             # the generated mapping file (if requested)
-    modules*: seq[BModule]     # list of all compiled modules
+    mods*: seq[BModule]     # list of all compiled modules
     modulesClosed*: seq[BModule] # list of the same compiled modules, but in the order they were closed
     forwardedProcs*: seq[PSym] # procs that did not yet have a body
     generatedHeader*: BModule

compiler/ic/cbackend.nim

@@ -40,7 +40,7 @@ proc setupBackendModule(g: ModuleGraph; m: var LoadedModule) =
   var bmod = cgen.newModule(BModuleList(g.backend), m.module, g.config, idgenFromLoadedModule(m))
 
 proc generateCodeForModule(g: ModuleGraph; m: var LoadedModule; alive: var AliveSyms) =
-  var bmod = BModuleList(g.backend).modules[m.module.position]
+  var bmod = BModuleList(g.backend).mods[m.module.position]
   assert bmod != nil
   bmod.flags.incl useAliveDataFromDce
   bmod.alive = move alive[m.module.position]

compiler/modulegraphs.nim

@@ -814,7 +814,7 @@ proc moduleFromRodFile*(g: ModuleGraph; fileIdx: FileIndex;
 
 when not defined(nimKochBootstrap):
   proc moduleFromNifFile*(g: ModuleGraph; fileIdx: FileIndex;
-                          loadFullAst: bool = false): PrecompiledModule =
+                          flags: set[LoadFlag] = {}): PrecompiledModule =
     ## Returns 'nil' if the module needs to be recompiled.
     ## Loads module from NIF file when optCompress is enabled.
     ## When loadFullAst is true, loads the complete module AST for code generation.
@@ -836,7 +836,7 @@ when not defined(nimKochBootstrap):
 
     result = loadNifModule(ast.program, fileIdx,
                            g.ifaces[fileIdx.int].interf,
-                           g.ifaces[fileIdx.int].interfHidden, loadFullAst)
+                           g.ifaces[fileIdx.int].interfHidden, flags)
     result.module = m
 
     # Register hooks from NIF index with the module graph

compiler/nifbackend.nim

@@ -28,7 +28,7 @@ import ast, options, lineinfos, modulegraphs, cgendata, cgen,
 proc loadModuleDependencies(g: ModuleGraph; mainFileIdx: FileIndex): seq[PrecompiledModule] =
   ## Traverse the module dependency graph using a stack.
   ## Returns all modules that need code generation, in dependency order.
-  let mainModule = moduleFromNifFile(g, mainFileIdx, loadFullAst=true)
+  let mainModule = moduleFromNifFile(g, mainFileIdx, {LoadFullAst})
 
   var stack: seq[ModuleSuffix] = @[]
   result = @[]
@@ -46,7 +46,7 @@ proc loadModuleDependencies(g: ModuleGraph; mainFileIdx: FileIndex): seq[Precomp
     if not visited.containsOrIncl(suffix.string):
       let nifFile = toGeneratedFile(g.config, AbsoluteFile(suffix.string), ".nif")
       let fileIdx = msgs.fileInfoIdx(g.config, nifFile)
-      let precomp = moduleFromNifFile(g, fileIdx, loadFullAst=true)
+      let precomp = moduleFromNifFile(g, fileIdx, {LoadFullAst})
       if precomp.module != nil:
         result.add precomp
         for dep in precomp.deps:
@@ -75,7 +75,7 @@ proc finishModule(g: ModuleGraph; bmod: BModule) =
 proc generateCodeForModule(g: ModuleGraph; precomp: PrecompiledModule) =
   ## Generate C code for a single module.
   let moduleId = precomp.module.position
-  var bmod = BModuleList(g.backend).modules[moduleId]
+  var bmod = BModuleList(g.backend).mods[moduleId]
   if bmod == nil:
     bmod = setupNifBackendModule(g, precomp.module)
 
@@ -90,17 +90,16 @@ proc generateCode*(g: ModuleGraph; mainFileIdx: FileIndex) =
   # Reset backend state
   resetForBackend(g)
 
-  # Ensure systemFileIdx is set up (might not be set in cmdNifC path)
-  if g.config.m.systemFileIdx == InvalidFileIdx:
-    g.config.m.systemFileIdx = msgs.fileInfoIdx(g.config,
-        g.config.libpath / RelativeFile"system.nim")
+  var isKnownFile = false
+  let systemFileIdx = registerNifSuffix(g.config, "sysma2dyk", isKnownFile)
+  g.config.m.systemFileIdx = systemFileIdx
+  #msgs.fileInfoIdx(g.config,
+  #    g.config.libpath / RelativeFile"system.nim")
 
   # Load system module first - it's always needed and contains essential hooks
   var precompSys = PrecompiledModule(module: nil)
-  let systemFileIdx = g.config.m.systemFileIdx
-  if systemFileIdx != InvalidFileIdx:
-    precompSys = moduleFromNifFile(g, systemFileIdx, loadFullAst=true)
-    g.systemModule = precompSys.module
+  precompSys = moduleFromNifFile(g, systemFileIdx, {LoadFullAst, AlwaysLoadInterface})
+  g.systemModule = precompSys.module
 
   # Load all modules in dependency order using stack traversal
   # This must happen BEFORE any code generation so that hooks are loaded into loadedOps
@@ -116,7 +115,7 @@ proc generateCode*(g: ModuleGraph; mainFileIdx: FileIndex) =
 
   # Also ensure system module is set up and generated first if it exists
   if precompSys.module != nil:
-    let systemBmod = BModuleList(g.backend).modules[precompSys.module.position]
+    let systemBmod = BModuleList(g.backend).mods[precompSys.module.position]
     if systemBmod == nil:
       discard setupNifBackendModule(g, precompSys.module)
     generateCodeForModule(g, precompSys)
@@ -134,7 +133,7 @@ proc generateCode*(g: ModuleGraph; mainFileIdx: FileIndex) =
   # during code generation of `main.nim` we can trigger the code generation
   # of symbols in different modules so we need to finish these modules
   # here later, after the above loop!
-  for m in BModuleList(g.backend).modules:
+  for m in BModuleList(g.backend).mods:
     if m != nil:
       assert m.module != nil
       #if sfMainModule notin m.module.flags: