Add first parts of the Lua standard library

This necessited a bunch of changes:
* LuaContext, functions and linker pass around the current VM
* Injecting the VM to Java functions not works
* Lua VM can be now configured (for now, installed libraries and stdout)

A majority of the standard library is still missing!

Author: bensku

lua4jvm/src/main/java/fi/benjami/code4jvm/lua/LuaStdLib.java

@@ -18,29 +18,27 @@
 
 public class LuaVm {
 
+	private final VmOptions options;
 	private final LuaTable globals;
 
 	public LuaVm() {
-		this.globals = initGlobals();
+		this(VmOptions.DEFAULT);
 	}
 
-	private static LuaTable initGlobals() {
-		var globals = new LuaTable();
-		
-		globals.set("_G", globals);
-		globals.set("_VERSION", "lua4jvm DEV (Lua 5.4)");
-		
-		globals.set("print", LuaStdLib.PRINT);
-		globals.set("tostring", LuaStdLib.TO_STRING);
-		globals.set("type", LuaStdLib.TYPE);
-		globals.set("tonumber", LuaStdLib.TO_NUMBER);
-		
-		var ourLib = new LuaTable();
-		ourLib.set("read", LuaStdLib.READ);
-		ourLib.set("write", LuaStdLib.WRITE);
-		globals.set("code4jvm", ourLib);
-		
-		return globals;
+	public LuaVm(VmOptions options) {
+		this.options = options;
+		this.globals = new LuaTable();
+		installLibraries();
+	}
+	
+	public VmOptions options() {
+		return options;
+	}
+	
+	private void installLibraries() {
+		for (var lib : options.libraries()) {
+			lib.install(this);
+		}
 	}
 
 	public LuaTable globals() {
@@ -66,7 +64,7 @@ public LuaFunction load(LuaModule module, LuaTable env) {
 				List.of(),
 				module.root()
 				);
-		return new LuaFunction(type, new Object[] {env});
+		return new LuaFunction(this, type, new Object[] {env});
 	}
 
 	public Object execute(String chunk) throws Throwable {

lua4jvm/src/main/java/fi/benjami/code4jvm/lua/LuaVm.java

@@ -0,0 +1,61 @@
+package fi.benjami.code4jvm.lua;
+
+import java.io.PrintStream;
+import java.util.Collection;
+import java.util.List;
+
+import fi.benjami.code4jvm.lua.ffi.LuaLibrary;
+import fi.benjami.code4jvm.lua.stdlib.BasicLib;
+
+/**
+ * lua4jvm Lua VM options.
+ *
+ */
+public class VmOptions implements Cloneable {
+	
+	public static final VmOptions DEFAULT = new VmOptions();
+	
+	public static final Builder builder() {
+		return new Builder();
+	}
+
+	private Collection<LuaLibrary> libraries = List.of(BasicLib.INSTANCE);
+	private PrintStream stdOut = System.out;
+	
+	private VmOptions() {}
+	
+	public static class Builder {
+		
+		private VmOptions opts;
+		
+		private Builder() {
+			this.opts = new VmOptions();
+		}
+		
+		public Builder libraries(LuaLibrary... libraries) {
+			opts.libraries = List.of(libraries);
+			return this;
+		}
+		
+		public Builder stdOut(PrintStream out) {
+			opts.stdOut = out;
+			return this;
+		}
+		
+		public VmOptions build() {
+			try {
+				return (VmOptions) opts.clone();
+			} catch (CloneNotSupportedException e) {
+				throw new AssertionError(e);
+			}
+		}
+	}
+	
+	public Collection<LuaLibrary> libraries() {
+		return libraries;
+	}
+	
+	public PrintStream stdOut() {
+		return stdOut;
+	}
+}

lua4jvm/src/main/java/fi/benjami/code4jvm/lua/VmOptions.java

@@ -59,7 +59,7 @@ public static MethodHandle callTarget(LuaType[] argTypes, LuaFunction function,
 
 		// Compile and load the function code, or use something that is already cached
 		var compiledFunc = function.type().specializations().computeIfAbsent(cacheKey, t -> {
-			var ctx = function.type().newContext(truncateReturn, argTypes);
+			var ctx = LuaContext.forFunction(function.owner(), function.type(), truncateReturn, argTypes);
 			var code = generateCode(ctx, function.type(), argTypes, upvalueTypes);
 			try {
 				var lookup = LOOKUP.defineHiddenClassWithClassData(code, ctx.allClassData(), true);

lua4jvm/src/main/java/fi/benjami/code4jvm/lua/compiler/FunctionCompiler.java

@@ -8,6 +8,7 @@
 import fi.benjami.code4jvm.Constant;
 import fi.benjami.code4jvm.Type;
 import fi.benjami.code4jvm.Variable;
+import fi.benjami.code4jvm.lua.LuaVm;
 import fi.benjami.code4jvm.lua.ir.LuaLocalVar;
 import fi.benjami.code4jvm.lua.ir.LuaType;
 import fi.benjami.code4jvm.lua.ir.LuaVariable;
@@ -16,6 +17,34 @@
 
 public class LuaContext {
 
+	public static LuaContext forFunction(LuaVm vm, LuaType.Function type, boolean truncateReturn, LuaType... argTypes) {
+		// Init scope with upvalue types
+		var ctx = new LuaContext(vm, truncateReturn);
+		for (var upvalue : type.upvalues()) {
+			ctx.recordType(upvalue.variable(), upvalue.type());
+		}
+
+		// Add types of function arguments
+		// Missing arguments are allowed and treated as nil
+		var normalArgs = type.acceptedArgs().size();
+		if (type.isVarargs()) {
+			normalArgs--;
+			ctx.recordType(LuaLocalVar.VARARGS, LuaType.UNKNOWN); // No type analysis for these yet
+		}
+		var acceptedArgs = type.acceptedArgs();
+		for (var i = 0; i < normalArgs; i++) {
+			if (argTypes.length > i) {
+				ctx.recordType(acceptedArgs.get(i), argTypes[i]);
+			} else {
+				ctx.recordType(acceptedArgs.get(i), LuaType.NIL);
+			}
+		}
+		
+		// Compute types of local variables and the return type
+		type.body().outputType(ctx);
+		return ctx;
+	}
+	
 	/**
 	 * Local variable type table. When variables are written to, their types
 	 * are recorded here.
@@ -45,12 +74,21 @@ public class LuaContext {
 
 	private boolean allowSpread;
 
-	public LuaContext(boolean truncateReturn) {
+	/**
+	 * The Lua VM that 'owns' this context.
+	 */
+	private final LuaVm owner;
+	private final Constant ownerConstant;
+	
+	public LuaContext(LuaVm owner, boolean truncateReturn) {
+		assert owner != null;
 		this.typeTable = new IdentityHashMap<>();
 		this.variables = new IdentityHashMap<>();
 		this.classData = new ArrayList<>();
 		this.cache = new IdentityHashMap<>();
 		this.truncateReturn = truncateReturn;
+		this.owner = owner;
+		this.ownerConstant = addClassData(owner);
 	}
 
 	public void recordType(LuaVariable variable, LuaType type) {
@@ -187,5 +225,13 @@ public void setAllowSpread(boolean value) {
 	public boolean allowSpread() {
 		return allowSpread;
 	}
+	
+	public LuaVm owner() {
+		return owner;
+	}
+	
+	public Constant ownerConstant() {
+		return ownerConstant;
+	}
 
 }

lua4jvm/src/main/java/fi/benjami/code4jvm/lua/compiler/LuaContext.java

@@ -9,4 +9,5 @@
 @Target(ElementType.PARAMETER)
 public @interface Inject {
 
+	String value() default "default";
 }

lua4jvm/src/main/java/fi/benjami/code4jvm/lua/ffi/Inject.java

@@ -0,0 +1,8 @@
+package fi.benjami.code4jvm.lua.ffi;
+
+import fi.benjami.code4jvm.lua.linker.LuaCallSite;
+
+public interface InjectedArg {
+
+	Object get(LuaCallSite site);
+}

lua4jvm/src/main/java/fi/benjami/code4jvm/lua/ffi/InjectedArg.java

@@ -33,7 +33,7 @@ public record Target(
 			 * Arguments that are injected by Lua VM at the call site.
 			 * Injected arguments must come first!
 			 */
-			List<Class<?>> injectedArgs,
+			List<InjectedArg> injectedArgs,
 
 			/**
 			 * Function arguments. All are required, use multiple targets
@@ -65,7 +65,7 @@ public record Target(
 			MethodHandle method
 	) {}
 
-	public record Arg(String name, LuaType type) {}
+	public record Arg(String name, LuaType type, boolean nullable) {}
 
 	// TODO support functions for generating errors
 
@@ -104,8 +104,12 @@ private MatchResult checkArgs(Target target, LuaType[] argTypes) {
 
 		// Check types of arguments
 		for (var i = 0; i < requiredArgs; i++) {
-			if (!target.arguments.get(i).type.isAssignableFrom(argTypes[i])) {
-				return MatchResult.ARG_TYPE_MISMATCH;
+			var arg = target.arguments.get(i);
+			if (!arg.type.isAssignableFrom(argTypes[i])) {
+				// Allow nil instead of expected type if nullability is allowed
+				if (!arg.nullable ||!argTypes[i].equals(LuaType.NIL)) {
+					return MatchResult.ARG_TYPE_MISMATCH;
+				}
 			}
 		}
 

lua4jvm/src/main/java/fi/benjami/code4jvm/lua/ffi/JavaFunction.java

@@ -10,6 +10,7 @@
 import java.util.HashMap;
 import java.util.List;
 
+import fi.benjami.code4jvm.lua.LuaVm;
 import fi.benjami.code4jvm.lua.ir.LuaType;
 
 /**
@@ -72,14 +73,15 @@ public JavaFunction bindFunction(String name, List<Method> targetMethods) {
 	}
 
 	private JavaFunction.Target toFunctionTarget(Method method) {
-		var injectedArgs = new ArrayList<Class<?>>();
+		var injectedArgs = new ArrayList<InjectedArg>();
 		var args = new ArrayList<JavaFunction.Arg>();
 		for (var param : method.getParameters()) {
-			if (param.isAnnotationPresent(Inject.class)) {
+			var inject = param.getAnnotation(Inject.class);
+			if (inject != null) {
 				if (!args.isEmpty()) {
 					throw new IllegalArgumentException("injected arguments after normal ones in method " + method.getName());
 				}
-				injectedArgs.add(param.getType());
+				injectedArgs.add(toInjectedArg(param.getType(), inject.value()));
 			} else {
 				args.add(toArg(param));
 			}
@@ -100,7 +102,20 @@ private JavaFunction.Target toFunctionTarget(Method method) {
 		return new JavaFunction.Target(injectedArgs, args, method.isVarArgs(), LuaType.of(returnType), multipleReturns, handle);
 	}
 
+	private InjectedArg toInjectedArg(Class<?> type, String source) {
+		// TODO support non-default sources
+		if (!source.equals("default")) {
+			throw new UnsupportedOperationException();
+		}
+		// Handle default injected arg source
+		if (type.equals(LuaVm.class)) {
+			return site -> site.options.owner();
+		} else {
+			throw new IllegalArgumentException("unsupported type for @Inject");
+		}
+	}
+	
 	private JavaFunction.Arg toArg(Parameter param) {
-		return new JavaFunction.Arg(param.getName(), LuaType.of(param.getType()));
+		return new JavaFunction.Arg(param.getName(), LuaType.of(param.getType()), param.isAnnotationPresent(Nullable.class));
 	}
 }

lua4jvm/src/main/java/fi/benjami/code4jvm/lua/ffi/LuaBinder.java

@@ -0,0 +1,14 @@
+package fi.benjami.code4jvm.lua.ffi;
+
+import fi.benjami.code4jvm.lua.LuaVm;
+import fi.benjami.code4jvm.lua.VmOptions;
+
+/**
+ * A library of functions (or other constructs) installable to a Lua VM.
+ * @see VmOptions
+ *
+ */
+public interface LuaLibrary {
+
+	void install(LuaVm vm);
+}

lua4jvm/src/main/java/fi/benjami/code4jvm/lua/ffi/LuaLibrary.java

@@ -0,0 +1,12 @@
+package fi.benjami.code4jvm.lua.ffi;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.PARAMETER)
+public @interface Nullable {
+
+}