A meta information file is a file that summarizes information such as the classes published by a module and the dependencies of other modules that the module imports.

By reading this meta information file instead of parsing the module when importing, parsing time can be reduced.

A meta information file can be generated with the following command:

$ lnsc hello.lns SAVE

What is different from the previous command is the difference between "save" and "SAVE".

Lowercase save will generate only transcompiled Lua code, while uppercase SAVE will generate Lua code and meta information files.

Specifically, the above command will generate hello.lua and hello.meta.

LuneScript will load the .meta file when all of the following conditions are met when importing the module. At this time, the .lns file to be imported is not analyzed.

• .lns has corresponding .lua and .meta

• The update time of each file satisfies the following conditions

  • .lns < .meta

• The following conditions are satisfied for the update time of module mod2 that is imported in mod1.lns to be imported.

  • mod1 > mod2
• The format version of the .meta file is correct

When there are two modules mod1 and mod2, if mod1 imports mod2, then "mod1 depends on mod2".

"mod1 depends on mod2" means that when mod2 is modified, "not only mod2 but also mod1 needs to be transcompiled".

The make command has long been used to build modules with such dependencies. There are various build tools in recent years, but there is no doubt that make is the representative build tool.

The make command controls updating files that depend on defined dependencies when a file is modified.

Defining this dependency manually can be rather tedious.

LuneScript provides the ability to auto-generate dependencies for the make command.

To automatically generate dependencies with LuneScript, specify options when SAVE as follows.

$ lnsc mod1.lns --depends depends/mod1.d SAVE

This will both transcompile mod1.lns and print the dependency information for mod1.lns in depends/mod1.d .

By incorporating this dependency information into the Makefile, you can easily control builds with make without manually defining dependencies.

test/proj/
      |
      +--- Mod1.lns
      |
      +--- Mod2.lns
      |
      +--- Mod3.lns
      |
      +--- Mod4.lns

// @lnsFront: skip
import test.proj.Mod2;

pub fn func(): str {
   return "%s -> %s" (__func__, Mod2.func() );
}
print( func() );

// @lnsFront: skip
import test.proj.Mod3;

pub fn func(): str {
   return "%s -> %s" (__func__, Mod3.func() );
}

// @lnsFront: skip
import test.proj.Mod4;

pub fn func(): str {
   return "%s -> %s" (__func__, Mod4.func() );
}

// @lnsFront: ok
pub fn func(): str {
   return __func__;
}

PROJ_DIR=test/proj
MKFILE=$(PROJ_DIR)/Makefile
SRC_DIR=$(PROJ_DIR)/

.PHONY: test all build setup

define comp
	@echo "$1 -> $2"
	lnsc $1 --depends depends/$(shell echo $1 | sed 's@/@.@g').d SAVE
endef

%.meta: %.lns
	$(call comp,$<,$@)

SRCS =
SRCS += Mod1.lns
SRCS += Mod2.lns
SRCS += Mod3.lns
SRCS += Mod4.lns

SRCS := $(addprefix $(SRC_DIR),$(SRCS))

META_LIST=$(SRCS:.lns=.meta)
LUA_LIST=$(SRCS:.lns=.lua)

-include depends/*.d

all:
	@echo make setup
	@echo make build

setup:
	mkdir -p depends

build: $(META_LIST)