nandi/clonim · 8c9eb04

⑂ 8c9eb04

feat: resolve host-provided namespaces

nandithebull committed 2026-09-21T00:38:10-07:00 Browse files

8c9eb04 parent: e5a8bce

modified src/namespaces.nim +24 -2 Viewed

@@ -16,7 +16,7 @@ type
16	16	defs, privateDefs, required: HashSet[string]
17	17	Resolver = ref object
18	18	roots: seq[string]
19		- cores: HashSet[string]
	19	+ cores, hosts: HashSet[string]
20	20	spaces: Table[string, Namespace]
21	21	active: seq[string]
22	22	loaded: HashSet[string]
@@ -64,6 +64,22 @@ proc registeredCoreNames(): HashSet[string] =
64	64	finally:
65	65	globals = saved
66	66
	67	+proc registeredHostNames(): HashSet[string] =
	68	+ ## Runtime functions in named host namespaces (for example clojure.string)
	69	+ ## do not need a shadow source file merely to be required by user code.
	70	+ let saved = globals
	71	+ globals = initTable[string, VarCell]()
	72	+ try:
	73	+ registerCore()
	74	+ for name, cell in globals:
	75	+ if cell.bound: result.incl name
	76	+ finally:
	77	+ globals = saved
	78	+
	79	+proc hasHostNamespace(r: Resolver, name: string): bool =
	80	+ for candidate in r.hosts:
	81	+ if candidate.startsWith(name & "/"): return true
	82	+
67	83	proc registerNamespaceCore*() =
68	84	## Call after registerCore in the generated program, before resolving cells.
69	85	## Both spellings share a cell, so rebinding remains coherent.
@@ -85,6 +101,7 @@ proc checkVar(r: Resolver, ns: Namespace, target, name: string,
85	101	fail("no definition " & canonical)
86	102	if target != ns.name and target notin ns.required:
87	103	fail("namespace " & target & " is not required by " & ns.name)
	104	+ if canonical in r.hosts: return
88	105	if not r.spaces.hasKey(target) or name notin r.spaces[target].defs:
89	106	fail("no definition " & canonical)
90	107	if target != ns.name and name in r.spaces[target].privateDefs:
@@ -299,6 +316,10 @@ proc process(r: Resolver, forms: seq[Value], expected = "")
299	316	proc load(r: Resolver, name: string) =
300	317	validNamespace(name)
301	318	if name == "clojure.core": return
	319	+ if r.hasHostNamespace(name):
	320	+ discard r.space(name)
	321	+ r.loaded.incl name
	322	+ return
302	323	if name in r.active: fail("dependency cycle: " & (r.active & @[name]).join(" -> "))
303	324	if name in r.loaded: return
304	325	let relative = name.replace('.', '/').replace('-', '_')
@@ -410,6 +431,7 @@ proc resolveSource*(src: string, sourceRoots: seq[string]): seq[Value] =
410	431	## Forward references require declare. Qualified references require a direct
411	432	## require, except for the current namespace and implicit clojure.core.
412	433	## Unknown and externally private vars are rejected during analysis.
413		- let r = Resolver(roots: sourceRoots, cores: registeredCoreNames())
	434	+ let r = Resolver(roots: sourceRoots, cores: registeredCoreNames(),
	435	+ hosts: registeredHostNames())
414	436	r.process(readAll(src))
415	437	r.output

      defs, privateDefs, required: HashSet[string]
    Resolver = ref object
      roots: seq[string]
--    cores: HashSet[string]
++    cores, hosts: HashSet[string]
      spaces: Table[string, Namespace]
      active: seq[string]
      loaded: HashSet[string]
    finally:
      globals = saved
++proc registeredHostNames(): HashSet[string] =
++  ## Runtime functions in named host namespaces (for example clojure.string)
++  ## do not need a shadow source file merely to be required by user code.
++  let saved = globals
++  globals = initTable[string, VarCell]()
++  try:
++    registerCore()
++    for name, cell in globals:
++      if cell.bound: result.incl name
++  finally:
++    globals = saved
++
++proc hasHostNamespace(r: Resolver, name: string): bool =
++  for candidate in r.hosts:
++    if candidate.startsWith(name & "/"): return true
++
  proc registerNamespaceCore*() =
    ## Call after registerCore in the generated program, before resolving cells.
    ## Both spellings share a cell, so rebinding remains coherent.
      fail("no definition " & canonical)
    if target != ns.name and target notin ns.required:
      fail("namespace " & target & " is not required by " & ns.name)
++  if canonical in r.hosts: return
    if not r.spaces.hasKey(target) or name notin r.spaces[target].defs:
      fail("no definition " & canonical)
    if target != ns.name and name in r.spaces[target].privateDefs:
  proc load(r: Resolver, name: string) =
    validNamespace(name)
    if name == "clojure.core": return
++  if r.hasHostNamespace(name):
++    discard r.space(name)
++    r.loaded.incl name
++    return
    if name in r.active: fail("dependency cycle: " & (r.active & @[name]).join(" -> "))
    if name in r.loaded: return
    let relative = name.replace('.', '/').replace('-', '_')
    ## Forward references require declare. Qualified references require a direct
    ## require, except for the current namespace and implicit clojure.core.
    ## Unknown and externally private vars are rejected during analysis.
--  let r = Resolver(roots: sourceRoots, cores: registeredCoreNames())
++  let r = Resolver(roots: sourceRoots, cores: registeredCoreNames(),
++                   hosts: registeredHostNames())
    r.process(readAll(src))
    r.output

modified tests/test_namespaces.nim +4 -0 Viewed

@@ -28,6 +28,10 @@ suite "static namespace resolution":
28	28	check forms[0].kind == kStr
29	29	check forms[0].s == "(?i)^did:[a-z0-9]+:"
30	30
	31	+ test "host namespaces resolve without placeholder source files":
	32	+ checkForms("(ns user (:require [clojure.string :as str])) (str/trim \" hi \")",
	33	+ "(clojure.string/trim \" hi \")")
	34	+
31	35	test "definitions resolve sequentially, including core shadowing":
32	36	checkForms("(inc 1) (def inc (fn [x] x)) (inc 2)",
33	37	"(clojure.core/inc 1) (def user/inc (fn [x] x)) (user/inc 2)")

      check forms[0].kind == kStr
      check forms[0].s == "(?i)^did:[a-z0-9]+:"
++  test "host namespaces resolve without placeholder source files":
++    checkForms("(ns user (:require [clojure.string :as str])) (str/trim \" hi \")",
++      "(clojure.string/trim \" hi \")")
++
    test "definitions resolve sequentially, including core shadowing":
      checkForms("(inc 1) (def inc (fn [x] x)) (inc 2)",
        "(clojure.core/inc 1) (def user/inc (fn [x] x)) (user/inc 2)")