support circular imports

> if we can support mutually defined recursive function,
> we should also support circular imports.

- call `handleImport` after `handleDefine`
- `handleDefine` -- should not evaluate `exp` -- evaluate on first `modFindValue`

Author: xieyuheng

TODO.md

@@ -1,7 +1,4 @@
-call `handleImport` after `handleDefine` -- to support circular imports
-
-- if we can support mutually defined recursive function,
-  we should also support circular imports.
+test circular imports
 
 # lazy evaluation
 

src/lang/load/handleDefine.ts

@@ -1,21 +1,13 @@
-import { emptyEnv } from "../env/Env.ts"
-import { evaluate } from "../evaluate/evaluate.ts"
 import { modDefine } from "../mod/index.ts"
 import type { Mod } from "../mod/Mod.ts"
 import type { Stmt } from "../stmt/Stmt.ts"
 
 export async function handleDefine(mod: Mod, stmt: Stmt): Promise<void> {
   if (stmt.kind === "Define") {
-    const value = evaluate(mod, emptyEnv(), stmt.exp)
-    if (value.kind === "Lambda") {
-      value.definedName = stmt.name
-    }
-
     modDefine(mod, stmt.name, {
       mod,
       name: stmt.name,
       exp: stmt.exp,
-      value,
     })
 
     return

src/lang/load/handleImport.ts

@@ -1,7 +1,7 @@
 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 { load } from "./load.ts"
 
 export async function handleImport(mod: Mod, stmt: Stmt): Promise<void> {
   if (stmt.kind === "Import") {
@@ -20,20 +20,16 @@ async function importOne(
 ): Promise<void> {
   const url = modResolve(mod, path)
   if (url.href === mod.url.href) {
-    throw new Error(`I can not circular import: ${path}`)
+    throw new Error(`[import] A module can not import itself: ${path}`)
   }
 
-  const found = globalLoadedMods.get(url.href)
-  if (found === undefined) {
-    throw new Error(`Mod is not loaded: ${path}`)
-  }
+  const importedMod = await load(url)
 
   const { name, rename } = entry
-
-  const def = modFind(found.mod, name)
+  const def = modFind(importedMod, name)
   if (def === undefined) {
     throw new Error(
-      `I can not import undefined name: ${name}, from path: ${path}`,
+      `[import] I can not import undefined name: ${name}, from path: ${path}`,
     )
   }
 

src/lang/load/load.ts

@@ -1,30 +1,20 @@
 import { ParsingError } from "@xieyuheng/x-data.js"
 import fs from "node:fs"
-import { createMod, modResolve, type Mod } from "../mod/index.ts"
+import { createMod, type Mod } from "../mod/index.ts"
 import { parseStmts } from "../parse/index.ts"
 import { globalLoadedMods } from "./globalLoadedMods.ts"
 import { run } from "./run.ts"
 
 export async function load(url: URL): Promise<Mod> {
   const found = globalLoadedMods.get(url.href)
-  if (found !== undefined) {
-    return found.mod
-  }
+  if (found !== undefined) return found.mod
 
   const text = await fs.promises.readFile(url.pathname, "utf8")
 
   try {
     const mod = createMod(url)
     mod.stmts = parseStmts(text)
     globalLoadedMods.set(url.href, { mod, text })
-
-    for (const stmt of mod.stmts) {
-      if (stmt.kind === "Import") {
-        const importedUrl = modResolve(mod, stmt.path)
-        await load(importedUrl)
-      }
-    }
-
     await run(mod)
     return mod
   } catch (error) {

src/lang/load/run.ts

@@ -8,11 +8,9 @@ import { handleImport } from "./handleImport.ts"
 export async function run(mod: Mod): Promise<void> {
   if (mod.isFinished) return
 
-  for (const stmt of mod.stmts) await handleImport(mod, stmt)
   for (const stmt of mod.stmts) await handleDefine(mod, stmt)
-
+  for (const stmt of mod.stmts) await handleImport(mod, stmt)
   for (const def of modOwnDefs(mod).values()) assertAllNamesDefined(mod, def)
-
   for (const stmt of mod.stmts) await handleEffect(mod, stmt)
 
   mod.isFinished = true

src/lang/mod/Mod.ts

@@ -1,3 +1,5 @@
+import { emptyEnv } from "../env/Env.ts"
+import { evaluate } from "../evaluate/evaluate.ts"
 import { type Exp } from "../exp/index.ts"
 import { type Stmt } from "../stmt/index.ts"
 import { type Value } from "../value/index.ts"
@@ -6,7 +8,7 @@ export type Def = {
   mod: Mod
   name: string
   exp: Exp
-  value: Value
+  value?: Value
 }
 
 export type Mod = {
@@ -42,7 +44,16 @@ export function modFind(mod: Mod, name: string): Def | undefined {
 export function modFindValue(mod: Mod, name: string): Value | undefined {
   const def = modFind(mod, name)
   if (def === undefined) return undefined
-  return def.value
+
+  if (def.value) return def.value
+
+  const value = evaluate(def.mod, emptyEnv(), def.exp)
+  if (value.kind === "Lambda") {
+    value.definedName = def.name
+  }
+
+  def.value = value
+  return value
 }
 
 export function modResolve(mod: Mod, href: string): URL {