extract handleImport from handleDefine

Author: xieyuheng

TODO.md

@@ -1,13 +1,12 @@
-> refactor `load` to support circular imports
->
-> - if we can support mutually defined recursive function,
->   we should also support circular imports.
-
-extract `handleImport` from `handleDefine`
 `run` should be async
 call `run` in `load`
 rename `run/` to `load/`
 
+call `handleImport` after `handleDefine` -- to support circular imports
+
+- if we can support mutually defined recursive function,
+  we should also support circular imports.
+
 # lazy evaluation
 
 [problem] we can use `Y`! -- `DelayedApply` can replace `Lazy`? -- what evaluation strategy is this?

src/lang/run/handleDefine.ts

@@ -1,10 +1,8 @@
 import { emptyEnv } from "../env/Env.ts"
 import { evaluate } from "../evaluate/evaluate.ts"
-import { modDefine, modFind, modResolve } from "../mod/index.ts"
+import { modDefine } from "../mod/index.ts"
 import type { Mod } from "../mod/Mod.ts"
-import type { ImportEntry, Stmt } from "../stmt/Stmt.ts"
-import { globalLoadedMods } from "./globalLoadedMods.ts"
-import { run } from "./run.ts"
+import type { Stmt } from "../stmt/Stmt.ts"
 
 export function handleDefine(mod: Mod, stmt: Stmt): void {
   if (stmt.kind === "Define") {
@@ -22,37 +20,4 @@ export function handleDefine(mod: Mod, stmt: Stmt): void {
 
     return
   }
-
-  if (stmt.kind === "Import") {
-    for (const entry of stmt.entries) {
-      importOne(mod, stmt.path, entry)
-    }
-
-    return
-  }
-}
-
-function importOne(mod: Mod, path: string, entry: ImportEntry): void {
-  const url = modResolve(mod, path)
-  if (url.href === mod.url.href) {
-    throw new Error(`I can not circular import: ${path}`)
-  }
-
-  const found = globalLoadedMods.get(url.href)
-  if (found === undefined) {
-    throw new Error(`Mod is not loaded: ${path}`)
-  }
-
-  run(found.mod)
-
-  const { name, rename } = entry
-
-  const def = modFind(found.mod, name)
-  if (def === undefined) {
-    throw new Error(
-      `I can not import undefined name: ${name}, from path: ${path}`,
-    )
-  }
-
-  modDefine(mod, rename || name, def)
 }

src/lang/run/handleImport.ts

@@ -0,0 +1,40 @@
+import { modDefine, modFind, modResolve } from "../mod/index.ts"
+import type { Mod } from "../mod/Mod.ts"
+import type { ImportEntry, Stmt } from "../stmt/Stmt.ts"
+import { globalLoadedMods } from "./globalLoadedMods.ts"
+import { run } from "./run.ts"
+
+export function handleImport(mod: Mod, stmt: Stmt): void {
+  if (stmt.kind === "Import") {
+    for (const entry of stmt.entries) {
+      importOne(mod, stmt.path, entry)
+    }
+
+    return
+  }
+}
+
+function importOne(mod: Mod, path: string, entry: ImportEntry): void {
+  const url = modResolve(mod, path)
+  if (url.href === mod.url.href) {
+    throw new Error(`I can not circular import: ${path}`)
+  }
+
+  const found = globalLoadedMods.get(url.href)
+  if (found === undefined) {
+    throw new Error(`Mod is not loaded: ${path}`)
+  }
+
+  run(found.mod)
+
+  const { name, rename } = entry
+
+  const def = modFind(found.mod, name)
+  if (def === undefined) {
+    throw new Error(
+      `I can not import undefined name: ${name}, from path: ${path}`,
+    )
+  }
+
+  modDefine(mod, rename || name, def)
+}

src/lang/run/run.ts

@@ -3,10 +3,12 @@ import { formatExp } from "../format/formatExp.ts"
 import { modFind, modOwnDefs, type Def, type Mod } from "../mod/index.ts"
 import { handleDefine } from "./handleDefine.ts"
 import { handleEffect } from "./handleEffect.ts"
+import { handleImport } from "./handleImport.ts"
 
 export function run(mod: Mod): void {
   if (mod.isFinished) return
 
+  for (const stmt of mod.stmts) handleImport(mod, stmt)
   for (const stmt of mod.stmts) handleDefine(mod, stmt)
 
   for (const def of modOwnDefs(mod).values()) assertAllNamesDefined(mod, def)