Comptime module system

Makefile

@@ -5,18 +5,17 @@ SRC_FILES := $(basename $(shell find fnl -type f -name "*.fnl" ! -name "macros.f
 default: deps compile test
 
 deps:
-	scripts/dep.sh bakpakin Fennel afebcb22999fe2a2f2174299f9c63b7e0f25022f
+	scripts/dep.sh sioonhho Fennel aniseed-comptime-module-system-support
 	scripts/dep.sh norcalli nvim.lua 5d57be0b6eea6c06977b1c5fe0752da909cf4154
 	cd deps/Fennel && make build
 
 compile:
 	rm -rf lua
 	for f in $(SRC_FILES); do \
 		mkdir -p lua/$$(dirname $$f); \
-		deps/Fennel/fennel scripts/internal/compile.fnl fnl/$$f.fnl > lua/$$f.lua; \
+		deps/Fennel/fennel --compile --plugin module-system-plugin.fnl fnl/$$f.fnl > lua/$$f.lua; \
 	done
 	mkdir -p lua/aniseed/deps
-	cp fnl/aniseed/macros.fnl lua/aniseed
 	cp deps/Fennel/fennel.lua lua/aniseed/deps/fennel.lua
 	cp deps/Fennel/fennelview.lua lua/aniseed/deps/fennelview.lua
 	cp deps/nvim.lua/lua/nvim.lua lua/aniseed/deps/nvim.lua

example.fnl

@@ -0,0 +1,7 @@
+(module mymod
+  {require {a aniseed.core}})
+
+(def- private-val :this-is-private)
+
+(+ 10 20)
+(a.println "Hello, World!")

fnl/aniseed/autoload.fnl

@@ -1,6 +1,6 @@
 (module aniseed.autoload)
 
-(defn autoload [name]
+(defn autoload [alias name]
   "Like autoload from Vim Script! A replacement for require that will load the
   module when you first use it. Use it in Aniseed module macros with:
 
@@ -10,27 +10,21 @@
   startup dramatically. Only works with table modules, if the module you're
   requiring is a function etc you need to use the normal require."
 
-  (let [res {:aniseed/autoload-enabled? true
-             :aniseed/autoload-module false}]
+  (fn ensure []
+    (set-forcibly! alias (require name))
+    alias)
 
-    (fn ensure []
-      (if (. res :aniseed/autoload-module)
-        (. res :aniseed/autoload-module)
-        (let [m (require name)]
-          (tset res :aniseed/autoload-module m)
-          m)))
+  (setmetatable
+    {}
 
-    (setmetatable
-      res
+    {:__call
+     (fn [t ...]
+       ((ensure) ...))
 
-      {:__call
-       (fn [t ...]
-         ((ensure) ...))
+     :__index
+     (fn [t k]
+       (. (ensure) k))
 
-       :__index
-       (fn [t k]
-         (. (ensure) k))
-
-       :__newindex
-       (fn [t k v]
-         (tset (ensure) k v))})))
+     :__newindex
+     (fn [t k v]
+       (tset (ensure) k v))}))

fnl/aniseed/compile.fnl

@@ -4,29 +4,25 @@
              nvim aniseed.nvim
              fennel aniseed.fennel}})
 
-(defn macros-prefix [code opts]
-  (let [macros-module :aniseed.macros
-        filename (-?> (a.get opts :filename)
-                      (string.gsub
-                        (.. (nvim.fn.getcwd) fs.path-sep)
-                        ""))]
-    (.. "(local *file* "
-        (if filename
-          (.. "\"" (string.gsub filename "\\" "\\\\") "\"")
-          "nil")
-        ")"
-        "(require-macros \"" macros-module "\")\n" code)))
+(local base-path (-?> (. (debug.getinfo 1 :S) :source)
+                      (: :gsub :^. "")
+                      (: :gsub (string.gsub *file* :fnl :lua) "")))
 
 (defn str [code opts]
   "Compile some Fennel code as a string into Lua. Maps to
   fennel.compileString with some wrapping, returns an (ok? result)
   tuple. Automatically requires the Aniseed macros."
 
-  (let [fnl (fennel.impl)]
+  (let [fnl (fennel.impl)
+        plugins ["module-system-plugin.fnl"]
+        plugins (icollect [_ plugin (ipairs plugins)]
+                  (fnl.dofile (.. base-path plugin)
+                              {:env :_COMPILER
+                               :useMetadata true}))]
     (xpcall
       #(fnl.compileString
-         (macros-prefix code opts)
-         (a.merge {:allowedGlobals false} opts))
+         code
+         (a.merge {:allowedGlobals false : plugins} opts))
       fnl.traceback)))
 
 (defn file [src dest]

fnl/aniseed/eval.fnl

@@ -5,14 +5,22 @@
              fennel aniseed.fennel
              compile aniseed.compile}})
 
+(local base-path (-?> (. (debug.getinfo 1 :S) :source)
+                      (: :gsub :^. "")
+                      (: :gsub (string.gsub *file* :fnl :lua) "")))
+
 (defn str [code opts]
   "Like aniseed.compile/str but uses fennel.eval. Returns the result of
   evaluating the given Fennel code with the Aniseed macros automatically
   equired."
-  (let [fnl (fennel.impl)]
+  (let [fnl (fennel.impl)
+        plugins ["module-system-plugin.fnl"]
+        plugins (icollect [_ plugin (ipairs plugins)]
+                  (fnl.dofile (.. base-path plugin)
+                              {:env :_COMPILER
+                               :useMetadata true}))]
     (xpcall
       (fn []
         (-> code
-            (compile.macros-prefix opts)
-            (fnl.eval (a.merge {:compiler-env _G} opts))))
+            (fnl.eval (a.merge {:compiler-env _G : plugins} opts))))
       fnl.traceback)))

lua/aniseed/autoload.lua

@@ -1,78 +1,30 @@
-local _2afile_2a = "fnl/aniseed/autoload.fnl"
+local _2amodule_2a, _2amodule_name_2a, _2afile_2a = nil, nil, nil
 local _0_
 do
-  local name_0_ = "aniseed.autoload"
-  local module_0_
-  do
-    local x_0_ = package.loaded[name_0_]
-    if ("table" == type(x_0_)) then
-      module_0_ = x_0_
-    else
-      module_0_ = {}
-    end
-  end
-  module_0_["aniseed/module"] = name_0_
-  module_0_["aniseed/locals"] = ((module_0_)["aniseed/locals"] or {})
-  do end (module_0_)["aniseed/local-fns"] = ((module_0_)["aniseed/local-fns"] or {})
-  do end (package.loaded)[name_0_] = module_0_
-  _0_ = module_0_
-end
-local autoload
-local function _1_(...)
-  return (require("aniseed.autoload")).autoload(...)
+  local mod_0_ = {["aniseed/local-fns"] = {}, ["aniseed/locals"] = {}, ["aniseed/module"] = "aniseed.autoload"}
+  package.loaded["aniseed.autoload"] = mod_0_
+  _0_ = mod_0_
 end
-autoload = _1_
-local function _2_(...)
-  local ok_3f_0_, val_0_ = nil, nil
-  local function _2_()
-    return {}
+_2amodule_2a, _2amodule_name_2a, _2afile_2a = _0_, "aniseed.autoload", "fnl/aniseed/autoload.fnl"
+local autoload = nil
+local function _1_(alias, name)
+  local function ensure()
+    alias = require(name)
+    return alias
   end
-  ok_3f_0_, val_0_ = pcall(_2_)
-  if ok_3f_0_ then
-    _0_["aniseed/local-fns"] = {}
-    return val_0_
-  else
-    return print(val_0_)
+  local function _2_(t, ...)
+    return ensure()(...)
   end
-end
-local _local_0_ = _2_(...)
-local _2amodule_2a = _0_
-local _2amodule_name_2a = "aniseed.autoload"
-do local _ = ({nil, _0_, nil, {{}, nil, nil, nil}})[2] end
-local autoload0
-do
-  local v_0_
-  do
-    local v_0_0
-    local function autoload1(name)
-      local res = {["aniseed/autoload-enabled?"] = true, ["aniseed/autoload-module"] = false}
-      local function ensure()
-        if res["aniseed/autoload-module"] then
-          return res["aniseed/autoload-module"]
-        else
-          local m = require(name)
-          do end (res)["aniseed/autoload-module"] = m
-          return m
-        end
-      end
-      local function _3_(t, ...)
-        return ensure()(...)
-      end
-      local function _4_(t, k)
-        return ensure()[k]
-      end
-      local function _5_(t, k, v)
-        ensure()[k] = v
-        return nil
-      end
-      return setmetatable(res, {__call = _3_, __index = _4_, __newindex = _5_})
-    end
-    v_0_0 = autoload1
-    _0_["autoload"] = v_0_0
-    v_0_ = v_0_0
+  local function _3_(t, k)
+    return ensure()[k]
+  end
+  local function _4_(t, k, v)
+    ensure()[k] = v
+    return nil
   end
-  local t_0_ = (_0_)["aniseed/locals"]
-  t_0_["autoload"] = v_0_
-  autoload0 = v_0_
+  return setmetatable({}, {__call = _2_, __index = _3_, __newindex = _4_})
 end
+autoload = _1_
+_2amodule_2a["autoload"] = autoload
+_2amodule_2a["aniseed/locals"]["autoload"] = autoload
 return nil