- Added correct type variable resolution

- Fixed a number of bugs
- Upgrading build system to a more uniform system
- Improving error output (for IDE)
- Changed parser to generate line offsets differently (easier for IDE to process)

CodeModel/src/main/java/org/openzen/zenscript/codemodel/FunctionHeader.java

@@ -6,8 +6,6 @@
 package org.openzen.zenscript.codemodel;
 
 import java.util.Arrays;
-import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
@@ -17,7 +15,6 @@ import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
@@ -113,6 +110,36 @@ public class FunctionHeader {
 		hasUnknowns = hasUnknowns(parameters, returnType);
 	}
 	
+	public boolean isVariadic() {
+		return parameters.length > 0 && parameters[parameters.length - 1].variadic;
+	}
+	
+	public boolean isVariadicCall(CallArguments arguments, TypeScope scope) {
+		if (!isVariadic())
+			return false;
+		if (arguments.arguments.length < parameters.length - 1)
+			return false;
+		if (arguments.arguments.length != parameters.length)
+			return true;
+		if (scope.getTypeMembers(arguments.arguments[arguments.arguments.length - 1].type).canCastImplicit(parameters[parameters.length - 1].type))
+			return false;
+		
+		return true;
+	}
+	
+	public boolean isVariadicCall(CallArguments arguments) {
+		if (!isVariadic())
+			return false;
+		if (arguments.arguments.length < parameters.length - 1)
+			return false;
+		if (arguments.arguments.length != parameters.length)
+			return true;
+		if (arguments.arguments[arguments.arguments.length - 1].type.equals(parameters[parameters.length - 1].type))
+			return false;
+		
+		return true;
+	}
+	
 	public boolean[] useTypeParameters() {
 		boolean[] useTypeParameters = new boolean[typeParameters.length];
 		for (int i = 0; i < useTypeParameters.length; i++)
@@ -132,6 +159,18 @@ public class FunctionHeader {
 		this.returnType = returnType;
 	}
 	
+	public StoredType getParameterType(boolean isVariadic, int index) {
+		return getParameter(isVariadic, index).type;
+	}
+	
+	public FunctionParameter getParameter(boolean isVariadic, int index) {
+		if (isVariadic && index >= parameters.length - 1) {
+			return parameters[parameters.length - 1];
+		} else {
+			return parameters[index];
+		}
+	}
+	
 	public boolean isDenormalized() {
 		if (!returnType.getNormalized().equals(returnType))
 			return true;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/GenericMapper.java

@@ -26,6 +26,9 @@ public class GenericMapper {
 	private final Map<TypeParameter, StoredType> mapping;
 	
 	public GenericMapper(CodePosition position, GlobalTypeRegistry registry, Map<TypeParameter, StoredType> mapping) {
+		if (mapping == null)
+			throw new IllegalArgumentException();
+		
 		this.position = position;
 		this.registry = registry;
 		this.mapping = mapping;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/CompilingPackage.java

@@ -80,7 +80,7 @@ public class CompilingPackage {
 			return null;
 		
 		if (packages.containsKey(name.get(index).name))
-			return packages.get(name.get(index)).getType(context, name, index + 1);
+			return packages.get(name.get(index).name).getType(context, name, index + 1);
 		
 		if (types.containsKey(name.get(index).name)) {
 			CompilingType type = types.get(name.get(index).name);

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/CallArguments.java

@@ -56,8 +56,9 @@ public class CallArguments {
 	public CallArguments normalize(CodePosition position, TypeScope scope, FunctionHeader header) {
 		CallArguments result = this;
 		
+		boolean isVariadic = header.isVariadicCall(this, scope);
 		for (int i = 0; i < arguments.length; i++) {
-			arguments[i] = arguments[i].normalize(scope).castImplicit(position, scope, header.parameters[i].type);
+			arguments[i] = arguments[i].normalize(scope).castImplicit(position, scope, header.getParameterType(isVariadic, i));
 		}
 		
 		if (arguments.length < header.parameters.length) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/ExpressionVisitor.java

@@ -98,6 +98,10 @@ public interface ExpressionVisitor<T> {
 		throw new RuntimeException("Invalid expression");
 	}
 	
+	default T visitInvalidAssign(InvalidAssignExpression expression) {
+		throw new RuntimeException("Invalid expression");
+	}
+	
 	T visitIs(IsExpression expression);
 	
 	T visitMakeConst(MakeConstExpression expression);

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/ExpressionVisitorWithContext.java

@@ -96,6 +96,8 @@ public interface ExpressionVisitorWithContext<C, R> {
 	
 	R visitInvalid(C context, InvalidExpression expression);
 	
+	R visitInvalidAssign(C context, InvalidAssignExpression expression);
+	
 	R visitIs(C context, IsExpression expression);
 	
 	R visitMakeConst(C context, MakeConstExpression expression);

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/InvalidAssignExpression.java

@@ -0,0 +1,48 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.expression;
+
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class InvalidAssignExpression extends Expression {
+	public final InvalidExpression target;
+	public final Expression source;
+	
+	public InvalidAssignExpression(CodePosition position, InvalidExpression target, Expression source) {
+		super(position, source.type, source.thrownType);
+		
+		this.target = target;
+		this.source = source;
+	}
+
+	@Override
+	public <T> T accept(ExpressionVisitor<T> visitor) {
+		return visitor.visitInvalidAssign(this);
+	}
+
+	@Override
+	public <C, R> R accept(C context, ExpressionVisitorWithContext<C, R> visitor) {
+		return visitor.visitInvalidAssign(context, this);
+	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return new InvalidAssignExpression(
+				position,
+				target,
+				transformer.transform(source));
+	}
+
+	@Override
+	public Expression normalize(TypeScope scope) {
+		return new InvalidAssignExpression(position, target, source.normalize(scope));
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/InvalidExpression.java

@@ -5,6 +5,7 @@
  */
 package org.openzen.zenscript.codemodel.expression;
 
+import jdk.nashorn.internal.ir.Assignment;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
@@ -29,6 +30,11 @@ public class InvalidExpression extends Expression {
 	public InvalidExpression(StoredType type, CompileException cause) {
 		this(cause.position, type, cause.code, cause.message);
 	}
+	
+	@Override
+	public Expression assign(CodePosition position, TypeScope scope, Expression value) {
+		return new InvalidAssignExpression(position, this, value);
+	}
 
 	@Override
 	public <T> T accept(ExpressionVisitor<T> visitor) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/DefinitionTypeID.java

@@ -128,7 +128,7 @@ public class DefinitionTypeID implements TypeID {
 	public StoredType instance(GenericMapper mapper, StorageTag storage) {
 		if (!hasTypeParameters() && outer == null)
 			return stored(storage);
-		if (mapper.getMapping().isEmpty())
+		if (mapper == null || mapper.getMapping().isEmpty())
 			return stored(storage);
 		if (mapper.registry == null)
 			throw new NullPointerException();

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/member/TypeMemberGroup.java

@@ -293,8 +293,10 @@ public class TypeMemberGroup {
 	public Expression call(CodePosition position, TypeScope scope, Expression target, CallArguments arguments, boolean allowStaticUsage) throws CompileException {
 		FunctionalMemberRef method = selectMethod(position, scope, arguments, true, allowStaticUsage);
 		FunctionHeader instancedHeader = method.getHeader().fillGenericArguments(position, scope, arguments.typeArguments);
+		
+		boolean isVariadicCall = instancedHeader.isVariadicCall(arguments, scope);
 		for (int i = 0; i < arguments.arguments.length; i++) {
-			arguments.arguments[i] = arguments.arguments[i].castImplicit(position, scope, instancedHeader.parameters[i].type);
+			arguments.arguments[i] = arguments.arguments[i].castImplicit(position, scope, instancedHeader.getParameterType(isVariadicCall, i));
 		}
 
 		scope.getPreparer().prepare(method.getTarget());

Constructor/src/main/java/org/openzen/zenscript/constructor/Library.java

@@ -8,8 +8,9 @@ package org.openzen.zenscript.constructor;
 import java.io.File;
 import org.json.JSONArray;
 import org.json.JSONObject;
-import org.openzen.zenscript.constructor.module.DirectoryModuleReference;
 import org.openzen.zenscript.constructor.module.ModuleReference;
+import org.openzen.zenscript.constructor.module.SourceModuleReference;
+import org.openzen.zenscript.constructor.module.directory.DirectorySourceModule;
 
 /**
  *
@@ -28,7 +29,7 @@ public class Library {
 		modules = new ModuleReference[modulesJson.length()];
 		for (int i = 0; i < modulesJson.length(); i++) {
 			String moduleName = modulesJson.getString(i);
-			modules[i] = new DirectoryModuleReference(moduleName, new File(this.directory, moduleName), false);
+			modules[i] = new SourceModuleReference(new DirectorySourceModule(moduleName, new File(this.directory, moduleName), false), false);
 		}
 	}
 }

Constructor/src/main/java/org/openzen/zenscript/constructor/Main.java

@@ -6,8 +6,9 @@ import java.util.function.Consumer;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.constructor.module.DirectoryModuleReference;
 import org.openzen.zenscript.constructor.module.ModuleReference;
+import org.openzen.zenscript.constructor.module.SourceModuleReference;
+import org.openzen.zenscript.constructor.module.directory.DirectorySourceModule;
 
 public class Main {
     /**
@@ -29,7 +30,7 @@ public class Main {
 		GlobalTypeRegistry registry = new GlobalTypeRegistry(stdlib);
 		
 		ModuleLoader moduleLoader = new ModuleLoader(registry, exceptionLogger);
-		moduleLoader.register("stdlib", new DirectoryModuleReference("stdlib", new File("../../StdLibs/stdlib"), true));
+		moduleLoader.register("stdlib", new SourceModuleReference(new DirectorySourceModule("stdlib", new File("../../StdLibs/stdlib"), true), true));
 		
 		Project project = new Project(currentDirectory);
 		for (Library library : project.libraries) {

Constructor/src/main/java/org/openzen/zenscript/constructor/ParsedModule.java

@@ -61,7 +61,7 @@ public class ParsedModule {
 		return files.toArray(new ParsedFile[files.size()]);
 	}
 	
-	private void parse(List<ParsedFile> files, CompilingPackage pkg, BracketExpressionParser bracketParser, File directory) throws ParseException {
+	public static void parse(List<ParsedFile> files, CompilingPackage pkg, BracketExpressionParser bracketParser, File directory) throws ParseException {
 		for (File file : directory.listFiles()) {
 			if (file.getName().endsWith(".zs")) {
 				files.add(ParsedFile.parse(pkg, bracketParser, file));

Constructor/src/main/java/org/openzen/zenscript/constructor/Project.java

@@ -11,10 +11,11 @@ import java.util.ArrayList;
 import java.util.List;
 import org.json.JSONArray;
 import org.json.JSONObject;
-import org.openzen.zenscript.constructor.module.DirectoryModuleReference;
 import org.openzen.zenscript.constructor.module.ModuleReference;
 import org.openzen.zenscript.compiler.Target;
 import org.openzen.zenscript.compiler.TargetType;
+import org.openzen.zenscript.constructor.module.SourceModuleReference;
+import org.openzen.zenscript.constructor.module.directory.DirectorySourceModule;
 
 /**
  *
@@ -55,13 +56,13 @@ public class Project {
 		for (int i = 0; i < jsonModules.length(); i++) {
 			Object module = jsonModules.get(i);
 			if (module instanceof String) {
-				modules[i] = new DirectoryModuleReference(module.toString(), new File(directory, module.toString()), false);
+				modules[i] = new SourceModuleReference(new DirectorySourceModule(module.toString(), new File(directory, module.toString())));
 			} else if (module instanceof JSONObject) {
 				JSONObject jsonModule = (JSONObject) module;
 				String name = jsonModule.getString("name");
 				switch (jsonModule.getString("type")) {
 					case "directory":
-						modules[i] = new DirectoryModuleReference(name, new File(directory, jsonModule.getString("directory")), false);
+						modules[i] = new SourceModuleReference(new DirectorySourceModule(name, new File(directory, jsonModule.getString("directory"))));
 						break;
 					default:
 						throw new ConstructorException("Invalid module type: " + jsonModule.getString("type"));

Constructor/src/main/java/org/openzen/zenscript/constructor/module/DirectoryModuleReference.java

@@ -5,6 +5,7 @@
  */
 package org.openzen.zenscript.constructor.module;
 
+import org.openzen.zenscript.constructor.module.directory.SourceDirectoryPackage;
 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
@@ -38,7 +39,7 @@ public class DirectoryModuleReference implements ModuleReference {
 	private final String moduleName;
 	private final File directory;
 	private final boolean isStdlib;
-	private SourcePackage rootPackage = null;
+	private SourceDirectoryPackage rootPackage = null;
 	
 	public DirectoryModuleReference(String moduleName, File directory, boolean isStdlib) {
 		this.moduleName = moduleName;
@@ -120,18 +121,18 @@ public class DirectoryModuleReference implements ModuleReference {
 	}
 	
 	@Override
-	public SourcePackage getRootPackage() {
+	public SourceDirectoryPackage getRootPackage() {
 		if (rootPackage == null)
 			rootPackage = loadPackage("", new File(directory, "src"));
 		
 		return rootPackage;
 	}
 	
-	private SourcePackage loadPackage(String name, File directory) {
+	private SourceDirectoryPackage loadPackage(String name, File directory) {
 		if (!directory.exists())
 			throw new IllegalArgumentException("Directory does not exist: " + directory.getAbsolutePath());
 		
-		SourcePackage pkg = new SourcePackage(directory, name);
+		SourceDirectoryPackage pkg = new SourceDirectoryPackage(directory, name);
 		
 		for (File file : directory.listFiles()) {
 			if (file.isDirectory()) {

Constructor/src/main/java/org/openzen/zenscript/constructor/module/SourceModule.java

@@ -0,0 +1,28 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.constructor.module;
+
+import java.util.Map;
+import java.util.function.Consumer;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zenscript.codemodel.SemanticModule;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.ISymbol;
+import org.openzen.zenscript.constructor.ModuleLoader;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface SourceModule {
+	public String getName();
+	
+	public SourcePackage getRootPackage();
+	
+	public SemanticModule[] loadDependencies(ModuleLoader loader, GlobalTypeRegistry registry, Consumer<CompileException> exceptionLogger);
+	
+	public Map<String, ISymbol> getGlobals(SemanticModule module);
+}

Constructor/src/main/java/org/openzen/zenscript/constructor/module/SourceModuleReference.java

@@ -0,0 +1,99 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.constructor.module;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.CompileExceptionCode;
+import org.openzen.zencode.shared.SourceFile;
+import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.Module;
+import org.openzen.zenscript.codemodel.ModuleSpace;
+import org.openzen.zenscript.codemodel.SemanticModule;
+import org.openzen.zenscript.codemodel.context.CompilingPackage;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.constructor.ConstructorException;
+import org.openzen.zenscript.constructor.ModuleLoader;
+import org.openzen.zenscript.codemodel.type.storage.StorageType;
+import org.openzen.zenscript.lexer.ParseException;
+import org.openzen.zenscript.parser.BracketExpressionParser;
+import org.openzen.zenscript.parser.ParsedFile;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class SourceModuleReference implements ModuleReference {
+	private final SourceModule module;
+	private final boolean isStdlib;
+	
+	public SourceModuleReference(SourceModule module) {
+		this(module, false);
+	}
+	
+	public SourceModuleReference(SourceModule module, boolean isStdlib) {
+		this.module = module;
+		this.isStdlib = isStdlib;
+	}
+	
+	@Override
+	public String getName() {
+		return module.getName();
+	}
+
+	@Override
+	public SemanticModule load(ModuleLoader loader, GlobalTypeRegistry registry, Consumer<CompileException> exceptionLogger) {
+		SemanticModule[] dependencies = module.loadDependencies(loader, registry, exceptionLogger);
+
+		ModuleSpace space = new ModuleSpace(registry, new ArrayList<>(), StorageType.getStandard());
+		for (SemanticModule module : dependencies) {
+			try {
+				space.addModule(module.name, module);
+			} catch (CompileException ex) {
+				throw new ConstructorException("Error: exception during compilation", ex);
+			}
+		}
+
+		ZSPackage pkg = isStdlib ? registry.stdlib : new ZSPackage(null, getName());
+		Module module = new Module(getName());
+		CompilingPackage compilingPackage = new CompilingPackage(pkg, module);
+
+		ParsedFile[] parsedFiles = parse(compilingPackage, exceptionLogger);
+		SemanticModule result = ParsedFile.compileSyntaxToSemantic(dependencies, compilingPackage, parsedFiles, space, FunctionParameter.NONE, exceptionLogger);
+		result.globals.putAll(this.module.getGlobals(result));
+		return result;
+	}
+	
+	@Override
+	public SourcePackage getRootPackage() {
+		return module.getRootPackage();
+	}
+	
+	public ParsedFile[] parse(CompilingPackage compilingPackage, Consumer<CompileException> exceptionLogger) {
+		// TODO: load bracket parsers from host plugins
+		List<ParsedFile> files = new ArrayList<>();
+		parse(files, compilingPackage, null, module.getRootPackage(), exceptionLogger);
+		return files.toArray(new ParsedFile[files.size()]);
+	}
+	
+	private static void parse(List<ParsedFile> files, CompilingPackage pkg, BracketExpressionParser bracketParser, SourcePackage directory, Consumer<CompileException> exceptionLogger) {
+		for (SourceFile file : directory.getFiles()) {
+			try {
+				files.add(ParsedFile.parse(pkg, bracketParser, file));
+			} catch (ParseException ex) {
+				exceptionLogger.accept(new CompileException(ex.position, CompileExceptionCode.PARSE_ERROR, ex.message));
+			}
+		}
+		for (SourcePackage subpkg : directory.getSubPackages()) {
+			CompilingPackage innerPackage = pkg.getOrCreatePackage(subpkg.getName());
+			pkg.addPackage(subpkg.getName(), innerPackage);
+			parse(files, innerPackage, bracketParser, subpkg, exceptionLogger);
+		}
+	}
+}

Constructor/src/main/java/org/openzen/zenscript/constructor/module/SourcePackage.java

@@ -5,32 +5,21 @@
  */
 package org.openzen.zenscript.constructor.module;
 
-import java.io.File;
-import java.util.HashMap;
-import java.util.Map;
-import org.openzen.zencode.shared.FileSourceFile;
+import java.util.Collection;
 import org.openzen.zencode.shared.SourceFile;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class SourcePackage {
-	public final File directory;
-	public final String name;
-	public final Map<String, SourcePackage> subPackages = new HashMap<>();
-	public final Map<String, SourceFile> sourceFiles = new HashMap<>();
+public interface SourcePackage {
+	public String getName();
 	
-	public SourcePackage(File directory, String name) {
-		this.directory = directory;
-		this.name = name;
-	}
+	public Collection<? extends SourcePackage> getSubPackages();
 	
-	public void addPackage(SourcePackage pkg) {
-		subPackages.put(pkg.name, pkg);
-	}
+	public Collection<? extends SourceFile> getFiles();
 	
-	public void addFile(SourceFile file) {
-		sourceFiles.put(file.getFilename(), file);
-	}
+	public SourcePackage createSubPackage(String name);
+	
+	public SourceFile createSourceFile(String name);
 }

Constructor/src/main/java/org/openzen/zenscript/constructor/module/directory/DirectorySourceModule.java

@@ -0,0 +1,129 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.constructor.module.directory;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Consumer;
+import org.json.JSONArray;
+import org.json.JSONObject;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.ModuleSpace;
+import org.openzen.zenscript.codemodel.SemanticModule;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.ISymbol;
+import org.openzen.zenscript.codemodel.type.TypeSymbol;
+import org.openzen.zenscript.codemodel.type.storage.StorageType;
+import org.openzen.zenscript.constructor.ConstructorException;
+import org.openzen.zenscript.constructor.JSONUtils;
+import org.openzen.zenscript.constructor.ModuleLoader;
+import org.openzen.zenscript.constructor.module.SourceModule;
+import org.openzen.zenscript.constructor.module.SourcePackage;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DirectorySourceModule implements SourceModule {
+	private final String moduleName;
+	private final boolean isStdLib;
+	private final JSONObject json;
+	
+	private final SourcePackage rootPackage;
+	
+	public DirectorySourceModule(String moduleName, File directory) {
+		this(moduleName, directory, false);
+	}
+	
+	public DirectorySourceModule(String moduleName, File directory, boolean isStdLib) {
+		this.moduleName = moduleName;
+		this.isStdLib = isStdLib;
+		
+		this.rootPackage = new SourceDirectoryPackage(new File(directory, "src"), moduleName);
+		
+		if (!directory.exists())
+			throw new ConstructorException("Error: module directory not found: " + directory);
+		
+		File jsonFile = new File(directory, "module.json");
+		if (!jsonFile.exists())
+			throw new ConstructorException("Error: module.json file not found in module " + moduleName);
+		
+		try {
+			json = JSONUtils.load(jsonFile);
+		} catch (IOException ex) {
+			throw new ConstructorException("Error: could not load module.json: " + ex.getMessage());
+		}
+	}
+
+	@Override
+	public String getName() {
+		return moduleName;
+	}
+
+	@Override
+	public SourcePackage getRootPackage() {
+		return rootPackage;
+	}
+
+	@Override
+	public SemanticModule[] loadDependencies(ModuleLoader loader, GlobalTypeRegistry registry, Consumer<CompileException> exceptionLogger) {
+		List<String> dependencyNames = new ArrayList<>();
+		if (!isStdLib)
+			dependencyNames.add("stdlib");
+
+		JSONArray jsonDependencies = json.optJSONArray("dependencies");
+		if (jsonDependencies != null) {
+			for (int i = 0; i < jsonDependencies.length(); i++) {
+				dependencyNames.add(jsonDependencies.getString(i));
+			}
+		}
+		// TODO: annotation type registration
+		ModuleSpace space = new ModuleSpace(registry, new ArrayList<>(), StorageType.getStandard());
+		SemanticModule[] dependencies = new SemanticModule[dependencyNames.size()];
+		for (int i = 0; i < dependencies.length; i++) {
+			String dependencyName = dependencyNames.get(i);
+			SemanticModule module = loader.getModule(dependencyName);
+			dependencies[i] = module;
+
+			try {
+				space.addModule(dependencyName, module);
+			} catch (CompileException ex) {
+				throw new ConstructorException("Error: exception during compilation", ex);
+			}
+		}
+
+		return dependencies;
+	}
+
+	@Override
+	public Map<String, ISymbol> getGlobals(SemanticModule module) {
+		JSONObject jsonGlobals = json.optJSONObject("globals");
+		if (jsonGlobals == null)
+			return Collections.emptyMap();
+		
+		Map<String, ISymbol> result = new HashMap<>();
+		for (String key : jsonGlobals.keySet()) {
+			JSONObject global = jsonGlobals.getJSONObject(key);
+			switch (global.getString("type")) {
+				case "Definition":
+					HighLevelDefinition definition = module.definitions.getDefinition(global.getString("definition"));
+					if (definition == null)
+						throw new ConstructorException("No such definition: " + global.getString("definition"));
+					result.put(key, new TypeSymbol(definition));
+					break;
+				default:
+					throw new ConstructorException("Invalid global type: " + global.getString("type"));
+			}
+		}
+		return result;
+	}
+}

Constructor/src/main/java/org/openzen/zenscript/constructor/module/directory/SourceDirectoryPackage.java

@@ -0,0 +1,85 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.constructor.module.directory;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import org.openzen.zencode.shared.FileSourceFile;
+import org.openzen.zencode.shared.SourceFile;
+import org.openzen.zenscript.constructor.module.SourcePackage;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class SourceDirectoryPackage implements SourcePackage {
+	public final File directory;
+	public final String name;
+	public final Map<String, SourceDirectoryPackage> subPackages = new HashMap<>();
+	public final Map<String, SourceFile> sourceFiles = new HashMap<>();
+	
+	public SourceDirectoryPackage(File directory, String name) {
+		this.directory = directory;
+		this.name = name;
+		
+		for (File file : directory.listFiles()) {
+			if (file.isDirectory())
+				subPackages.put(file.getName(), new SourceDirectoryPackage(file, file.getName()));
+			else if (file.isFile() && file.getName().endsWith(".zs"))
+				sourceFiles.put(file.getName(), new FileSourceFile(file.getName(), file));
+		}
+	}
+	
+	public void addPackage(SourceDirectoryPackage pkg) {
+		subPackages.put(pkg.name, pkg);
+	}
+	
+	public void addFile(SourceFile file) {
+		sourceFiles.put(file.getFilename(), file);
+	}
+
+	@Override
+	public String getName() {
+		return name;
+	}
+
+	@Override
+	public Collection<? extends SourcePackage> getSubPackages() {
+		return subPackages.values();
+	}
+
+	@Override
+	public Collection<? extends SourceFile> getFiles() {
+		return sourceFiles.values();
+	}
+
+	@Override
+	public SourcePackage createSubPackage(String name) {
+		File file = new File(directory, name);
+		file.mkdir();
+		
+		SourceDirectoryPackage sourcePackage = new SourceDirectoryPackage(file, name);
+		subPackages.put(name, sourcePackage);
+		return sourcePackage;
+	}
+
+	@Override
+	public SourceFile createSourceFile(String name) {
+		File file = new File(directory, name);
+		try {
+			file.createNewFile();
+		} catch (IOException ex) {
+			ex.printStackTrace(); // TODO
+		}
+		
+		FileSourceFile sourceFile = new FileSourceFile(name, file);
+		sourceFiles.put(name, sourceFile);
+		return sourceFile;
+	}
+}

DrawableGui/src/main/java/org/openzen/drawablegui/listeners/DummyListenerHandle.java

@@ -1,28 +0,0 @@
-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.drawablegui.listeners;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class DummyListenerHandle<T> implements ListenerHandle<T> {
-	private final T listener;
-
-	public DummyListenerHandle(T listener) {
-		this.listener = listener;
-	}
-
-	@Override
-	public T getListener() {
-		return listener;
-	}
-
-	@Override
-	public void close() {
-
-	}
-}

DrawableGui/src/main/java/org/openzen/drawablegui/listeners/ListenerHandle.java

@@ -1,27 +0,0 @@
-/* Licensed under GPLv3 - https://opensource.org/licenses/GPL-3.0 */
-package org.openzen.drawablegui.listeners;
-
-import java.io.Closeable;
-
-/**
- * An EvenListenerHandle is returned when an EventListener is registered in an
- * EventListenerList, which can then be used to unregister the event listener.
- *
- * @param <T> Event type
- * @author Stan Hebben
- */
-public interface ListenerHandle<T> extends Closeable
-{
-	/**
-	 * Gets this handle's listener.
-	 *
-	 * @return listener
-	 */
-	public T getListener();
-
-	/**
-	 * Closes (unregisters) the event listener from the list it was registered to.
-	 */
-	@Override
-	public void close();
-}

DrawableGui/src/main/java/org/openzen/drawablegui/listeners/ListenerList.java

@@ -1,165 +0,0 @@
-/* Licensed under GPLv3 - https://opensource.org/licenses/GPL-3.0 */
-package org.openzen.drawablegui.listeners;
-
-import java.util.function.Consumer;
-
-/**
- * Implements a list of event listeners. This class is thread-safe and listeners
- * can be added or removed concurrently, no external locking is ever needed.
- * Also, it's very lightweight.
- *
- * @param <T> event type
- * @author Stan Hebben
- */
-public class ListenerList<T>
-{
-    public static final int PRIORITY_HIGH = 100;
-    public static final int PRIORITY_DEFAULT = 0;
-    public static final int PRIORITY_LOW = -100;
-	
-	// implements a linked list of nodes
-	protected volatile EventListenerNode first = null;
-	protected EventListenerNode last = null;
-
-	/**
-	 * Adds an IEventListener to the list.
-	 *
-	 * @param listener event listener
-	 * @return event listener's handle
-	 */
-	public ListenerHandle<T> add(T listener)
-	{
-        return add(listener, PRIORITY_DEFAULT);
-    }
-
-    public ListenerHandle<T> add(T listener, int priority)
-	{
-		EventListenerNode node = new EventListenerNode(listener, priority);
-
-		synchronized (this) {
-			if (first == null) {
-				first = last = node;
-			} else {
-                // prioritized list: where to insert?
-                EventListenerNode previousNode = last;
-                while (previousNode != null && priority > previousNode.priority) {
-                    previousNode = previousNode.prev;
-                }
-
-                if (previousNode == null) {
-                    node.next = first;
-                    first.prev = previousNode;
-                    first = node;
-                } else {
-                    if (previousNode.next == null) {
-                        last = node;
-                    } else {
-                        previousNode.next.prev = node;
-                    }
-
-                    previousNode.next = node;
-                    node.prev = previousNode;
-                }
-            }
-		}
-
-		return node;
-	}
-
-	/**
-	 * Removes an IEventListener from the list.
-	 *
-	 * @param listener listener to be removed
-	 * @return true if the listener was removed, false it it wasn't there
-	 */
-	public synchronized boolean remove(T listener)
-	{
-		EventListenerNode current = first;
-
-		while (current != null) {
-			if (current.listener == listener) {
-				current.close();
-				return true;
-			}
-
-            current = current.next;
-		}
-
-		return false;
-	}
-	
-	/**
-	 * Clears this listener list.
-	 */
-	public synchronized void clear()
-	{
-		first = last = null;
-	}
-	
-	/**
-	 * Invokes the given consumer for every listener in the list.
-	 * 
-	 * @param consumer consumer to be called for each listener
-	 */
-	public void accept(Consumer<T> consumer)
-	{
-		EventListenerNode current = first;
-		
-		while (current != null) {
-			consumer.accept(current.listener);
-			current = current.next;
-		}
-	}
-
-	/**
-	 * Checks if there are any listeners in this list.
-	 *
-	 * @return true if empty
-	 */
-	public boolean isEmpty()
-	{
-		return first == null;
-	}
-
-	// #######################
-	// ### Private classes ###
-	// #######################
-
-	protected class EventListenerNode implements ListenerHandle<T>
-	{
-		protected final T listener;
-        protected final int priority;
-		protected EventListenerNode next = null;
-		protected EventListenerNode prev = null;
-
-		public EventListenerNode(T handler, int priority)
-		{
-			this.listener = handler;
-            this.priority = priority;
-		}
-
-		@Override
-		public T getListener()
-		{
-			return listener;
-		}
-
-		@Override
-		public void close()
-		{
-			synchronized (ListenerList.this) {
-				if (prev == null) {
-					first = next;
-				} else {
-					prev.next = next;
-				}
-
-				if (next == null) {
-					last = prev;
-				} else {
-					next.prev = prev;
-				}
-			}
-		}
-	}
-}

DrawableGui/src/main/java/org/openzen/drawablegui/live/ImmutableLiveBool.java

@@ -1,34 +0,0 @@
-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.drawablegui.live;
-
-import org.openzen.drawablegui.listeners.DummyListenerHandle;
-import org.openzen.drawablegui.listeners.ListenerHandle;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class ImmutableLiveBool implements LiveBool {
-	public static final ImmutableLiveBool TRUE = new ImmutableLiveBool(true);
-	public static final ImmutableLiveBool FALSE = new ImmutableLiveBool(false);
-	
-	private final boolean value;
-	
-	private ImmutableLiveBool(boolean value) {
-		this.value = value;
-	}
-
-	@Override
-	public boolean getValue() {
-		return value;
-	}
-
-	@Override
-	public ListenerHandle<Listener> addListener(Listener listener) {
-		return new DummyListenerHandle<>(listener);
-	}
-}

DrawableGui/src/main/java/org/openzen/drawablegui/live/ImmutableLiveObject.java

@@ -1,31 +0,0 @@
-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.drawablegui.live;
-
-import org.openzen.drawablegui.listeners.DummyListenerHandle;
-import org.openzen.drawablegui.listeners.ListenerHandle;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class ImmutableLiveObject<T> implements LiveObject<T> {
-	private final T value;
-	
-	public ImmutableLiveObject(T value) {
-		this.value = value;
-	}
-	
-	@Override
-	public T getValue() {
-		return value;
-	}
-
-	@Override
-	public ListenerHandle<Listener<T>> addListener(Listener<T> listener) {
-		return new DummyListenerHandle<>(listener);
-	}
-}

DrawableGui/src/main/java/org/openzen/drawablegui/live/ImmutableLiveString.java

@@ -1,31 +0,0 @@
-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.drawablegui.live;
-
-import org.openzen.drawablegui.listeners.DummyListenerHandle;
-import org.openzen.drawablegui.listeners.ListenerHandle;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class ImmutableLiveString implements LiveString {
-	private final String value;
-
-	public ImmutableLiveString(String value) {
-		this.value = value;
-	}
-	
-	@Override
-	public ListenerHandle<Listener> addListener(Listener listener) {
-		return new DummyListenerHandle<>(listener);
-	}
-
-	@Override
-	public String getValue() {
-		return value;
-	}
-}

DrawableGui/src/main/java/org/openzen/drawablegui/live/InverseLiveBool.java

@@ -1,30 +0,0 @@
-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.drawablegui.live;
-
-import org.openzen.drawablegui.listeners.ListenerHandle;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class InverseLiveBool implements LiveBool {
-	private final LiveBool source;
-	
-	public InverseLiveBool(LiveBool source) {
-		this.source = source;
-	}
-
-	@Override
-	public boolean getValue() {
-		return !source.getValue();
-	}
-
-	@Override
-	public ListenerHandle<Listener> addListener(Listener listener) {
-		return source.addListener((oldValue, newValue) -> listener.onChanged(!oldValue, !newValue));
-	}
-}

DrawableGui/src/main/java/org/openzen/drawablegui/live/LiveArrayList.java

@@ -1,91 +0,0 @@
-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.drawablegui.live;
-
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-import org.openzen.drawablegui.listeners.ListenerHandle;
-import org.openzen.drawablegui.listeners.ListenerList;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class LiveArrayList<T> implements MutableLiveList<T> {
-	private final List<T> values = new ArrayList<>();
-	private final ListenerList<Listener<T>> listeners = new ListenerList<>();
-
-	@Override
-	public void add(T value) {
-		int index = values.size();
-		values.add(value);
-		listeners.accept(listener -> listener.onInserted(index, value));
-	}
-
-	@Override
-	public void add(int index, T value) {
-		values.add(index, value);
-		listeners.accept(listener -> listener.onInserted(index, value));
-	}
-
-	@Override
-	public void set(int index, T value) {
-		T oldValue = values.set(index, value);
-		listeners.accept(listener -> listener.onChanged(index, oldValue, value));
-	}
-
-	@Override
-	public void remove(int index) {
-		T oldValue = values.remove(index);
-		listeners.accept(listener -> listener.onRemoved(index, oldValue));
-	}
-
-	@Override
-	public void remove(T value) {
-		int index = indexOf(value);
-		if (index < 0)
-			return;
-		
-		remove(index);
-	}
-	
-	@Override
-	public void clear() {
-		for (int i = size() - 1; i >= 0; i--)
-			remove(i);
-	}
-
-	@Override
-	public int indexOf(T value) {
-		return values.indexOf(value);
-	}
-	
-	@Override
-	public int size() {
-		return values.size();
-	}
-
-	@Override
-	public T get(int index) {
-		return values.get(index);
-	}
-	
-	@Override
-	public void close() {
-		// TODO: close closeables
-	}
-
-	@Override
-	public Iterator<T> iterator() {
-		return values.iterator();
-	}
-
-	@Override
-	public ListenerHandle<Listener<T>> addListener(Listener<T> listener) {
-		return listeners.add(listener);
-	}
-}

DrawableGui/src/main/java/org/openzen/drawablegui/live/LiveBool.java

@@ -1,22 +0,0 @@
-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.drawablegui.live;
-
-import org.openzen.drawablegui.listeners.ListenerHandle;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public interface LiveBool {
-	public boolean getValue();
-	
-	public ListenerHandle<Listener> addListener(Listener listener);
-	
-	public interface Listener {
-		void onChanged(boolean oldValue, boolean newValue);
-	}
-}

DrawableGui/src/main/java/org/openzen/drawablegui/live/LiveInt.java

@@ -1,24 +0,0 @@
-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.drawablegui.live;
-
-import org.openzen.drawablegui.listeners.ListenerHandle;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public interface LiveInt {
-	int getValue();
-	
-	void setValue(int value);
-	
-	ListenerHandle<Listener> addListener(Listener listener);
-	
-	interface Listener {
-		void onChanged(int oldValue, int newValue);
-	}
-}

DrawableGui/src/main/java/org/openzen/drawablegui/live/LiveList.java

@@ -1,36 +0,0 @@
-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.drawablegui.live;
-
-import java.util.Iterator;
-import org.openzen.drawablegui.listeners.ListenerHandle;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public interface LiveList<T> extends Iterable<T> {
-	int indexOf(T value);
-	
-	int size();
-	
-	T get(int index);
-	
-	void close();
-	
-	@Override
-	Iterator<T> iterator();
-	
-	ListenerHandle<Listener<T>> addListener(Listener<T> listener);
-	
-	interface Listener<T> {
-		void onInserted(int index, T value);
-		
-		void onChanged(int index, T oldValue, T newValue);
-		
-		void onRemoved(int index, T oldValue);
-	}
-}

DrawableGui/src/main/java/org/openzen/drawablegui/live/LiveObject.java

@@ -1,22 +0,0 @@
-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.drawablegui.live;
-
-import org.openzen.drawablegui.listeners.ListenerHandle;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public interface LiveObject<T> {
-	public T getValue();
-	
-	public ListenerHandle<Listener<T>> addListener(Listener<T> listener);
-	
-	public interface Listener<T> {
-		void onUpdated(T oldValue, T newValue);
-	}
-}

DrawableGui/src/main/java/org/openzen/drawablegui/live/LiveString.java

@@ -1,22 +0,0 @@
-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.drawablegui.live;
-
-import org.openzen.drawablegui.listeners.ListenerHandle;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public interface LiveString {
-	ListenerHandle<Listener> addListener(Listener listener);
-	
-	String getValue();
-	
-	interface Listener {
-		void onChanged(String oldValue, String newValue);
-	}
-}

DrawableGui/src/main/java/org/openzen/drawablegui/live/MutableLiveList.java

@@ -1,24 +0,0 @@
-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.drawablegui.live;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public interface MutableLiveList<T> extends LiveList<T> {
-	void add(T value);
-	
-	void add(int index, T value);
-	
-	void set(int index, T value);
-	
-	void remove(int index);
-	
-	void remove(T value);
-	
-	void clear();
-}

DrawableGui/src/main/java/org/openzen/drawablegui/live/SimpleLiveBool.java

@@ -1,46 +0,0 @@
-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.drawablegui.live;
-
-import org.openzen.drawablegui.listeners.ListenerHandle;
-import org.openzen.drawablegui.listeners.ListenerList;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class SimpleLiveBool implements MutableLiveBool {
-	private final ListenerList<LiveBool.Listener> listeners = new ListenerList<>();
-	private boolean value;
-	
-	public SimpleLiveBool() {
-		this(false);
-	}
-	
-	public SimpleLiveBool(boolean value) {
-		this.value = value;
-	}
-	
-	@Override
-	public boolean getValue() {
-		return value;
-	}
-	
-	@Override
-	public void setValue(boolean value) {
-		if (value == this.value)
-			return;
-		
-		boolean oldValue = this.value;
-		this.value = value;
-		listeners.accept(listener -> listener.onChanged(oldValue, value));
-	}
-	
-	@Override
-	public ListenerHandle<LiveBool.Listener> addListener(LiveBool.Listener listener) {
-		return listeners.add(listener);
-	}
-}

DrawableGui/src/main/java/org/openzen/drawablegui/live/SimpleLiveInt.java

@@ -1,42 +0,0 @@
-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.drawablegui.live;
-
-import org.openzen.drawablegui.listeners.ListenerHandle;
-import org.openzen.drawablegui.listeners.ListenerList;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class SimpleLiveInt implements LiveInt {
-	private final ListenerList<Listener> listeners = new ListenerList<>();
-	private int value;
-
-	public SimpleLiveInt(int value) {
-		this.value = value;
-	}
-	
-	@Override
-	public int getValue() {
-		return value;
-	}
-
-	@Override
-	public void setValue(int value) {
-		if (value == this.value)
-			return;
-		
-		int oldValue = this.value;
-		this.value = value;
-		listeners.accept(listener -> listener.onChanged(oldValue, value));
-	}
-
-	@Override
-	public ListenerHandle<Listener> addListener(Listener listener) {
-		return listeners.add(listener);
-	}
-}

DrawableGui/src/main/java/org/openzen/drawablegui/live/SimpleLiveString.java

@@ -1,43 +0,0 @@
-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.drawablegui.live;
-
-import org.openzen.drawablegui.listeners.ListenerHandle;
-import org.openzen.drawablegui.listeners.ListenerList;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class SimpleLiveString implements MutableLiveString {
-	private final ListenerList<Listener> listeners = new ListenerList<>();
-	
-	private String value;
-	
-	public SimpleLiveString(String value) {
-		this.value = value;
-	}
-
-	@Override
-	public ListenerHandle<Listener> addListener(Listener listener) {
-		return listeners.add(listener);
-	}
-
-	@Override
-	public String getValue() {
-		return value;
-	}
-
-	@Override
-	public void setValue(String value) {
-		if (value.equals(this.value))
-			return;
-		
-		String oldValue = this.value;
-		this.value = value;
-		listeners.accept(listener -> listener.onChanged(oldValue, value));
-	}
-}

DrawableGui/src/main/java/org/openzen/drawablegui/scroll/DScrollPane.java

@@ -53,6 +53,9 @@ public class DScrollPane implements DComponent, DScrollContext {
 	private final ListenerHandle<FunctionIntIntToVoid> offsetYListener;
 	private final ListenerHandle<BiConsumer<DSizing, DSizing>> contentsSizingListener;
 	
+	private boolean isHorizontalScrollbarVisible = true;
+	private boolean isVerticalScrollbarVisible = true;
+	
 	private DComponent hovering = null;
 	
 	private DSubSurface subSurface;
@@ -81,6 +84,7 @@ public class DScrollPane implements DComponent, DScrollContext {
 			
 			contents.setBounds(new DIRectangle(0, 0, bounds.width, Math.max(bounds.height, newPreferences.preferredHeight)));
 			contentsHeight.setValue(newPreferences.preferredHeight);
+			contentsWidth.setValue(newPreferences.preferredWidth);
 		});
 	}
 
@@ -136,25 +140,28 @@ public class DScrollPane implements DComponent, DScrollContext {
 		shape = context.shadowPath(0, style.shape.instance(style.margin.apply(bounds)), DTransform2D.IDENTITY, style.backgroundColor, style.shadow);
 		style.border.update(context, style.margin.apply(bounds));
 		
+		int scrollBarWidth = verticalScrollBar.getSizing().getValue().preferredWidth;
+		int scrollBarHeight = horizontalScrollBar.getSizing().getValue().preferredHeight;
+		int scrollBarMarginX = isHorizontalScrollbarVisible ? scrollBarWidth : 0;
+		int scrollBarMarginY = isVerticalScrollbarVisible ? scrollBarHeight : 0;
+		
 		int width = Math.max(
-				bounds.width - style.border.getPaddingHorizontal(),
+				bounds.width - style.border.getPaddingHorizontal() - scrollBarMarginX,
 				contents.getSizing().getValue().preferredWidth);
 		int height = Math.max(
-				bounds.height - style.border.getPaddingHorizontal(),
+				bounds.height - style.border.getPaddingHorizontal() - scrollBarMarginY,
 				contents.getSizing().getValue().preferredHeight);
-		int scrollBarWidth = verticalScrollBar.getSizing().getValue().preferredWidth;
-		int scrollBarHeight = horizontalScrollBar.getSizing().getValue().preferredHeight;
-
+		
 		verticalScrollBar.setBounds(new DIRectangle(
 				bounds.x + bounds.width - scrollBarWidth - style.border.getPaddingRight() - style.margin.right,
 				bounds.y + style.border.getPaddingTop() + style.margin.top,
 				scrollBarWidth,
-				bounds.height - style.border.getPaddingVertical() - style.margin.getVertical()));
+				bounds.height - style.border.getPaddingVertical() - style.margin.getVertical() - scrollBarMarginY));
 		
 		horizontalScrollBar.setBounds(new DIRectangle(
 				bounds.x + style.border.getPaddingLeft() + style.margin.left,
 				bounds.y + bounds.height - scrollBarHeight - style.border.getPaddingBottom() - style.margin.bottom,
-				bounds.width - style.border.getPaddingHorizontal() - style.margin.getHorizontal(),
+				bounds.width - style.border.getPaddingHorizontal() - style.margin.getHorizontal() - scrollBarMarginX,
 				scrollBarHeight));
 		
 		contents.setBounds(new DIRectangle(0, 0, width, height));
@@ -171,7 +178,10 @@ public class DScrollPane implements DComponent, DScrollContext {
 	
 	@Override
 	public void onMouseScroll(DMouseEvent e) {
-		offsetY.setValue(offsetY.getValue() + e.deltaZ * 50);
+		if (e.has(DMouseEvent.SHIFT))
+			offsetX.setValue(offsetX.getValue() + e.deltaZ * 50);
+		else
+			offsetY.setValue(offsetY.getValue() + e.deltaZ * 50);
 	}
 	
 	@Override
@@ -318,9 +328,14 @@ public class DScrollPane implements DComponent, DScrollContext {
 
 		@Override
 		public void invoke(int oldValue, int newValue) {
+			int scrollBarWidth = verticalScrollBar.getSizing().getValue().preferredWidth;
+			int scrollBarHeight = horizontalScrollBar.getSizing().getValue().preferredHeight;
+			int scrollBarMarginX = isHorizontalScrollbarVisible ? scrollBarWidth : 0;
+			int scrollBarMarginY = isVerticalScrollbarVisible ? scrollBarHeight : 0;
+			
 			int valueX = offsetX.getValue();
-			if (valueX > contentsWidth.getValue() - bounds.width)
-				valueX = contentsWidth.getValue() - bounds.width;
+			if (valueX > contentsWidth.getValue() - (bounds.width - scrollBarMarginX))
+				valueX = contentsWidth.getValue() - (bounds.width - scrollBarMarginX);
 			if (valueX < 0)
 				valueX = 0;
 			
@@ -328,8 +343,8 @@ public class DScrollPane implements DComponent, DScrollContext {
 				offsetX.setValue(valueX);
 			
 			int valueY = offsetY.getValue();
-			if (valueY > contentsHeight.getValue() - bounds.height)
-				valueY = contentsHeight.getValue() - bounds.height;
+			if (valueY > contentsHeight.getValue() - (bounds.height - scrollBarMarginY))
+				valueY = contentsHeight.getValue() - (bounds.height - scrollBarMarginY);
 			if (valueY < 0)
 				valueY = 0;
 			

IDE/src/main/java/org/openzen/zenscript/ide/Main.java

@@ -1,18 +1,24 @@
 package org.openzen.zenscript.ide;
 
+import java.awt.GraphicsEnvironment;
+import java.awt.Rectangle;
 import java.awt.event.WindowAdapter;
 import java.awt.event.WindowEvent;
 import java.io.File;
 import java.io.IOException;
 import javax.swing.JFrame;
+import live.LiveObject;
 import live.MutableLiveBool;
+import live.SimpleLiveObject;
 import org.openzen.drawablegui.DUIWindow;
 import org.openzen.zenscript.ide.host.DevelopmentHost;
 import org.openzen.zenscript.ide.host.local.LocalProjectDevelopmentHost;
 import org.openzen.drawablegui.swing.SwingWindow;
 import org.openzen.zenscript.constructor.Project;
+import org.openzen.zenscript.ide.host.IDECompileState;
 import org.openzen.zenscript.ide.host.IDEPropertyDirectory;
 import org.openzen.zenscript.ide.host.IDEPropertyStore;
+import org.openzen.zenscript.ide.host.IDETarget;
 import org.openzen.zenscript.ide.ui.IDEWindow;
 import org.openzen.zenscript.ide.ui.view.WindowView;
 
@@ -23,7 +29,8 @@ public class Main {
     public static void main(String... args) throws IOException {
 		if (args.length == 0) {
 			// testing environment - TODO project chooser/creator
-			args = new String[] { "../../ZenCode", "SharedJavaSource" };
+			//args = new String[] { "../../ZenCode", "SharedJavaSource" };
+			args = new String[] { "../../ZenCode", "CodeModelJavaSource" };
 		}
 		
 		Arguments arguments = new Arguments(args);
@@ -43,19 +50,42 @@ public class Main {
 		if (target == null && host.getTargets().getLength() > 0)
 			target = host.getTargets().getAt(0).getName();
 		
+		IDETarget targetObject = null;
+		for (IDETarget t : host.getTargets())
+			if (t.getName().equals(target))
+				targetObject = t;
+		
+		if (targetObject == null)
+			throw new IllegalStateException("No target specified");
+		
+		LiveObject<IDETarget> liveTarget = new SimpleLiveObject<>(targetObject);
+		LiveObject<IDECompileState> compileState = liveTarget.getValue().load(); // TODO: update this when target changes
+		
 		IDEPropertyDirectory uiState = properties.getRoot().getSubdirectory("uiState");
 		IDEWindow window = new IDEWindow(host, target);
-		WindowView root = new WindowView(window, host, uiState);
+		WindowView root = new WindowView(window, host, uiState, compileState);
 		
 		int pixelPerInch = java.awt.Toolkit.getDefaultToolkit().getScreenResolution();
 		MutableLiveBool maximized = uiState.getLiveBool("maximized", false);
 		SwingWindow swingWindow = new SwingWindow("ZenCode IDE - " + host.getName(), root, false);
-		swingWindow.setSize(
-				uiState.getInt("width", 800 * pixelPerInch / 96),
-				uiState.getInt("height", 600 * pixelPerInch / 96));
-		swingWindow.setLocation(
-				uiState.getInt("x", 0),
-				uiState.getInt("y", 0));
+		
+		int x = uiState.getInt("x", 0);
+		int y = uiState.getInt("y", 0);
+		int width = uiState.getInt("width", 800 * pixelPerInch / 96);
+		int height = uiState.getInt("height", 600 * pixelPerInch / 96);
+		GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();
+		Rectangle bounds = env.getMaximumWindowBounds();
+		if (x < bounds.x)
+			x = bounds.x;
+		if (y < bounds.y)
+			y = bounds.y;
+		if (width > bounds.width)
+			width = bounds.width;
+		if (height > bounds.height)
+			height = bounds.height;
+		
+		swingWindow.setSize(width, height);
+		swingWindow.setLocation(x, y);
 		swingWindow.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 		swingWindow.setExtendedState(maximized.getValue() ? JFrame.MAXIMIZED_BOTH : JFrame.NORMAL);
 		swingWindow.setVisible(true);

IDE/src/main/java/org/openzen/zenscript/ide/codemodel/IDECodeSpace.java

@@ -1,57 +0,0 @@
-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-package org.openzen.zenscript.ide.codemodel;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.constructor.ModuleLoader;
-import org.openzen.zenscript.ide.host.DevelopmentHost;
-import org.openzen.zenscript.ide.host.IDEModule;
-import org.openzen.zenscript.ide.host.IDESourceFile;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class IDECodeSpace {
-	private final DevelopmentHost host;
-	private final Map<IDESourceFile, List<IDECodeError>> sourceFileErrors = new HashMap<>();
-	
-	public IDECodeSpace(DevelopmentHost host) {
-		this.host = host;
-		
-		ZSPackage root = ZSPackage.createRoot();
-		ZSPackage stdlib = new ZSPackage(root, "stdlib");
-		GlobalTypeRegistry registry = new GlobalTypeRegistry(stdlib);
-		ModuleLoader loader = new ModuleLoader(registry, exception -> {
-			exception.printStackTrace();
-		});
-		for (IDEModule module : host.getModules()) {
-			module.prebuild(loader, this::addError);
-		}
-	}
-	
-	public void onSaved(IDESourceFile file) {
-		
-	}
-	
-	public List<IDECodeError> getErrors(IDESourceFile file) {
-		return sourceFileErrors.getOrDefault(file, Collections.emptyList());
-	}
-	
-	private void addError(IDECodeError error) {
-		if (error.file == null)
-			return;
-		if (!sourceFileErrors.containsKey(error.file))
-			sourceFileErrors.put(error.file, new ArrayList<>());
-		sourceFileErrors.get(error.file).add(error);
-	}
-}

IDE/src/main/java/org/openzen/zenscript/ide/codemodel/IDECodeError.java → IDE/src/main/java/org/openzen/zenscript/ide/host/IDECodeError.java

@@ -3,10 +3,9 @@
  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.ide.codemodel;
+package org.openzen.zenscript.ide.host;
 
 import org.openzen.zencode.shared.CodePosition;
-import org.openzen.zenscript.ide.host.IDESourceFile;
 
 /**
  *

IDE/src/main/java/org/openzen/zenscript/ide/host/IDECompileState.java

@@ -0,0 +1,16 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.ide.host;
+
+import live.LiveList;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface IDECompileState {
+	public LiveList<IDECodeError> getErrors(IDESourceFile file);
+}

IDE/src/main/java/org/openzen/zenscript/ide/host/IDEModule.java

@@ -7,7 +7,6 @@ package org.openzen.zenscript.ide.host;
 
 import java.util.function.Consumer;
 import org.openzen.zenscript.constructor.ModuleLoader;
-import org.openzen.zenscript.ide.codemodel.IDECodeError;
 
 /**
  *

IDE/src/main/java/org/openzen/zenscript/ide/host/IDETarget.java

@@ -6,6 +6,7 @@
 package org.openzen.zenscript.ide.host;
 
 import java.util.function.Consumer;
+import live.LiveObject;
 import org.openzen.zenscript.ide.ui.view.output.OutputLine;
 
 /**
@@ -19,6 +20,8 @@ public interface IDETarget {
 	
 	boolean canRun();
 	
+	LiveObject<IDECompileState> load();
+	
 	void build(Consumer<OutputLine> output);
 	
 	void run(Consumer<OutputLine> output);

IDE/src/main/java/org/openzen/zenscript/ide/host/local/LocalCompileState.java

@@ -0,0 +1,34 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.ide.host.local;
+
+import java.util.HashMap;
+import java.util.Map;
+import live.LiveArrayList;
+import live.LiveList;
+import org.openzen.zenscript.ide.host.IDECodeError;
+import org.openzen.zenscript.ide.host.IDECompileState;
+import org.openzen.zenscript.ide.host.IDESourceFile;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class LocalCompileState implements IDECompileState {
+	private final Map<IDESourceFile, LiveArrayList<IDECodeError>> errors = new HashMap<>();
+
+	public void addError(IDESourceFile file, IDECodeError error) {
+		if (!errors.containsKey(file))
+			errors.put(file, new LiveArrayList<>());
+		
+		errors.get(file).add(error);
+	}
+	
+	@Override
+	public LiveList<IDECodeError> getErrors(IDESourceFile file) {
+		return errors.getOrDefault(file, new LiveArrayList<>());
+	}
+}

IDE/src/main/java/org/openzen/zenscript/ide/host/local/LocalModule.java

@@ -9,7 +9,7 @@ import java.util.function.Consumer;
 import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.constructor.ModuleLoader;
 import org.openzen.zenscript.constructor.module.ModuleReference;
-import org.openzen.zenscript.ide.codemodel.IDECodeError;
+import org.openzen.zenscript.ide.host.IDECodeError;
 import org.openzen.zenscript.ide.host.IDEModule;
 import org.openzen.zenscript.ide.host.IDEModuleType;
 import org.openzen.zenscript.ide.host.IDEPackage;

IDE/src/main/java/org/openzen/zenscript/ide/host/local/LocalPackage.java

@@ -8,6 +8,7 @@ package org.openzen.zenscript.ide.host.local;
 import java.io.File;
 import java.io.IOException;
 import java.util.Arrays;
+import java.util.Collection;
 
 import live.LiveArrayList;
 import live.LiveList;
@@ -16,6 +17,7 @@ import live.SortedLiveList;
 
 import org.openzen.zencode.shared.FileSourceFile;
 import org.openzen.zencode.shared.SourceFile;
+import org.openzen.zenscript.constructor.module.directory.SourceDirectoryPackage;
 import org.openzen.zenscript.constructor.module.SourcePackage;
 import org.openzen.zenscript.ide.host.IDEPackage;
 import org.openzen.zenscript.ide.host.IDESourceFile;
@@ -35,20 +37,11 @@ public class LocalPackage implements IDEPackage {
 	public LocalPackage(SourcePackage pkg) {
 		this.pkg = pkg;
 		
-		String[] subPackageKeys = pkg.subPackages.keySet()
-				.toArray(new String[pkg.subPackages.size()]);
-		Arrays.sort(subPackageKeys);
-		
-		String[] sourceFileKeys = pkg.sourceFiles.keySet()
-				.toArray(new String[pkg.sourceFiles.size()]);
-		Arrays.sort(sourceFileKeys);
-		
-		for (SourcePackage subPackage : pkg.subPackages.values()) {
+		for (SourcePackage subPackage : pkg.getSubPackages())
 			subPackages.add(new LocalPackage(subPackage));
-		}
-		for (SourceFile sourceFile : pkg.sourceFiles.values()) {
+		
+		for (SourceFile sourceFile : pkg.getFiles())
 			sourceFiles.add(new LocalSourceFile(sourceFile));
-		}
 		
 		subPackagesSorted = new SortedLiveList<>(subPackages, (a, b) -> a.getName().compareTo(b.getName()));
 		sourceFilesSorted = new SortedLiveList<>(sourceFiles, (a, b) -> a.getName().getValue().compareTo(b.getName().getValue()));
@@ -56,7 +49,7 @@ public class LocalPackage implements IDEPackage {
 	
 	@Override
 	public String getName() {
-		return pkg.name;
+		return pkg.getName();
 	}
 
 	@Override
@@ -71,28 +64,16 @@ public class LocalPackage implements IDEPackage {
 	
 	@Override
 	public IDEPackage createSubPackage(String name) {
-		File file = new File(this.pkg.directory, name);
-		file.mkdir();
-		
-		SourcePackage sourcePackage = new SourcePackage(file, name);
-		IDEPackage pkg = new LocalPackage(sourcePackage);
-		this.pkg.subPackages.put(name, sourcePackage);
-		subPackages.add(pkg);
-		return pkg;
+		SourcePackage subpkg = this.pkg.createSubPackage(name);
+		LocalPackage local = new LocalPackage(subpkg);
+		subPackages.add(local);
+		return local;
 	}
 	
 	@Override
 	public IDESourceFile createSourceFile(String name) {
-		File file = new File(this.pkg.directory, name);
-		try {
-			file.createNewFile();
-		} catch (IOException ex) {
-			ex.printStackTrace(); // TODO
-		}
-		
-		FileSourceFile sourceFile = new FileSourceFile(name, file);
+		SourceFile sourceFile = pkg.createSourceFile(name);
 		IDESourceFile localSourceFile = new LocalSourceFile(sourceFile);
-		this.pkg.sourceFiles.put(name, sourceFile);
 		sourceFiles.add(localSourceFile);
 		return localSourceFile;
 	}

IDE/src/main/java/org/openzen/zenscript/ide/host/local/LocalSourceFile.java

@@ -11,6 +11,7 @@ import java.io.IOException;
 import java.io.OutputStreamWriter;
 import java.io.Writer;
 import java.nio.charset.StandardCharsets;
+import java.util.Objects;
 
 import live.LiveString;
 import live.MutableLiveString;
@@ -57,4 +58,26 @@ public class LocalSourceFile implements IDESourceFile {
 			ex.printStackTrace();
 		}
 	}
+
+	@Override
+	public int hashCode() {
+		int hash = 3;
+		hash = 83 * hash + Objects.hashCode(this.file);
+		return hash;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj) {
+			return true;
+		}
+		if (obj == null) {
+			return false;
+		}
+		if (getClass() != obj.getClass()) {
+			return false;
+		}
+		final LocalSourceFile other = (LocalSourceFile) obj;
+		return file == other.file;
+	}
 }

IDE/src/main/java/org/openzen/zenscript/ide/host/local/LocalTarget.java

@@ -10,6 +10,8 @@ import java.util.HashSet;
 import java.util.Set;
 import java.util.Stack;
 import java.util.function.Consumer;
+import live.LiveObject;
+import live.SimpleLiveObject;
 import org.openzen.zenscript.codemodel.SemanticModule;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
@@ -18,8 +20,12 @@ import org.openzen.zenscript.compiler.ZenCodeCompiler;
 import org.openzen.zenscript.constructor.Library;
 import org.openzen.zenscript.constructor.ModuleLoader;
 import org.openzen.zenscript.constructor.Project;
-import org.openzen.zenscript.constructor.module.DirectoryModuleReference;
+import org.openzen.zenscript.constructor.module.directory.DirectorySourceModule;
 import org.openzen.zenscript.constructor.module.ModuleReference;
+import org.openzen.zenscript.constructor.module.SourceModuleReference;
+import org.openzen.zenscript.ide.host.IDECodeError;
+import org.openzen.zenscript.ide.host.IDECompileState;
+import org.openzen.zenscript.ide.host.IDESourceFile;
 import org.openzen.zenscript.ide.host.IDETarget;
 import org.openzen.zenscript.ide.ui.view.output.ErrorOutputSpan;
 import org.openzen.zenscript.ide.ui.view.output.OutputLine;
@@ -34,6 +40,7 @@ import stdlib.Strings;
 public class LocalTarget implements IDETarget {
 	private final Project project;
 	private final Target target;
+	private final SimpleLiveObject<IDECompileState> state = new SimpleLiveObject<>(null);
 	
 	public LocalTarget(Project project, Target target) {
 		this.project = project;
@@ -54,31 +61,49 @@ public class LocalTarget implements IDETarget {
 	public boolean canRun() {
 		return target.canRun();
 	}
+	
+	@Override
+	public LiveObject<IDECompileState> load() {
+		if (state.getValue() == null)
+			state.setValue(precompile());
+		
+		return state;
+	}
 
 	@Override
 	public void build(Consumer<OutputLine> output) {
-		buildInternal(output);
+		buildInternal(output, new LocalCompileState(), true);
 	}
 
 	@Override
 	public void run(Consumer<OutputLine> output) {
-		ZenCodeCompiler compiler = buildInternal(output);
+		ZenCodeCompiler compiler = buildInternal(output, new LocalCompileState(), true);
 		if (compiler != null)
 			compiler.run();
 	}
 	
-	private ZenCodeCompiler buildInternal(Consumer<OutputLine> output) {
+	private IDECompileState precompile() {
+		LocalCompileState result = new LocalCompileState();
+		buildInternal(line -> {}, result, false);
+		return result;
+	}
+	
+	private ZenCodeCompiler buildInternal(Consumer<OutputLine> output, LocalCompileState state, boolean compile) {
 		ZSPackage root = ZSPackage.createRoot();
 		ZSPackage stdlibPackage = new ZSPackage(root, "stdlib");
 		GlobalTypeRegistry registry = new GlobalTypeRegistry(stdlibPackage);
 		
 		ModuleLoader moduleLoader = new ModuleLoader(registry, exception -> {
+			IDESourceFile sourceFile = new LocalSourceFile(exception.position.file);
+			state.addError(sourceFile, new IDECodeError(sourceFile, exception.position, exception.message));
+			
 			String[] lines = Strings.split(exception.getMessage(), '\n');
 			for (String line : lines) {
 				output.accept(new OutputLine(new ErrorOutputSpan(line)));
 			}
 		});
-		moduleLoader.register("stdlib", new DirectoryModuleReference("stdlib", new File("../../StdLibs/stdlib"), true));
+		//moduleLoader.register("stdlib", new DirectoryModuleReference("stdlib", new File("../../StdLibs/stdlib"), true));
+		moduleLoader.register("stdlib", new SourceModuleReference(new DirectorySourceModule("stdlib", new File("../../StdLibs/stdlib"), true), true));
 		Set<String> compiledModules = new HashSet<>();
 		
 		Consumer<ValidationLogEntry> validationLogger = entry -> {
@@ -86,6 +111,9 @@ public class LocalTarget implements IDETarget {
 			output.accept(new OutputLine(new ErrorOutputSpan(entry.kind + " " + entry.position.toString() + ": " + message[0])));
 			for (int i = 1; i < message.length; i++)
 				output.accept(new OutputLine(new ErrorOutputSpan("    " + message[i])));
+			
+			IDESourceFile sourceFile = new LocalSourceFile(entry.position.file);
+			state.addError(sourceFile, new IDECodeError(sourceFile, entry.position, entry.message));
 		};
 		try {
 			for (Library library : project.libraries) {
@@ -99,25 +127,29 @@ public class LocalTarget implements IDETarget {
 			SemanticModule module = moduleLoader.getModule(target.getModule());
 			module = Validator.validate(module.normalize(), validationLogger);
 			
-			ZenCodeCompiler compiler = target.createCompiler(module);
-			if (!module.isValid())
-				return compiler;
-			
-			SemanticModule stdlib = moduleLoader.getModule("stdlib");
-			stdlib = Validator.validate(stdlib.normalize(), validationLogger);
-			if (!stdlib.isValid())
-				return compiler;
-			
-			compiler.addModule(stdlib);
-			compiledModules.add(stdlib.name);
-			
-			boolean isValid = compileDependencies(moduleLoader, compiler, compiledModules, new Stack<>(), module, validationLogger);
-			if (!isValid)
+			if (compile) {
+				ZenCodeCompiler compiler = target.createCompiler(module);
+				if (!module.isValid())
+					return compiler;
+
+				SemanticModule stdlib = moduleLoader.getModule("stdlib");
+				stdlib = Validator.validate(stdlib.normalize(), validationLogger);
+				if (!stdlib.isValid())
+					return compiler;
+
+				compiler.addModule(stdlib);
+				compiledModules.add(stdlib.name);
+
+				boolean isValid = compileDependencies(moduleLoader, compiler, compiledModules, new Stack<>(), module, validationLogger);
+				if (!isValid)
+					return compiler;
+
+				compiler.addModule(module);
+				compiler.finish();
 				return compiler;
-			
-			compiler.addModule(module);
-			compiler.finish();
-			return compiler;
+			} else {
+				return null;
+			}
 		} catch (Exception ex) {
 			ex.printStackTrace();
 			

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/WindowView.java

@@ -5,6 +5,7 @@
  */
 package org.openzen.zenscript.ide.ui.view;
 
+import live.LiveObject;
 import live.LiveString;
 import live.SimpleLiveObject;
 import live.SimpleLiveString;
@@ -19,8 +20,10 @@ import org.openzen.drawablegui.style.DShadow;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.style.DStylesheetBuilder;
 import org.openzen.zenscript.ide.host.DevelopmentHost;
+import org.openzen.zenscript.ide.host.IDECompileState;
 import org.openzen.zenscript.ide.host.IDEPropertyDirectory;
 import org.openzen.zenscript.ide.host.IDESourceFile;
+import org.openzen.zenscript.ide.host.IDETarget;
 import org.openzen.zenscript.ide.ui.IDEDockWindow;
 import org.openzen.zenscript.ide.ui.IDEWindow;
 import org.openzen.zenscript.ide.ui.view.aspectbar.AspectBarView;
@@ -38,11 +41,14 @@ public final class WindowView extends DSideLayout {
 	public final LiveString status = new SimpleLiveString("IDE initialized");
 	private final ProjectBrowser projectBrowser;
 	
-	public WindowView(IDEWindow window, DevelopmentHost host, IDEPropertyDirectory settings) {
+	private final LiveObject<IDECompileState> compileState;
+	
+	public WindowView(IDEWindow window, DevelopmentHost host, IDEPropertyDirectory settings, LiveObject<IDECompileState> compileState) {
 		super(DStyleClass.inline(
 				new DStylesheetBuilder().color("backgroundColor", 0xFFEEEEEE).build()),
 				DEmptyView.INSTANCE);
 		this.window = window;
+		this.compileState = compileState;
 		
 		projectBrowser = new ProjectBrowser(window, host, settings.getSubdirectory("projectBrowserExpansionState"));
 		
@@ -69,7 +75,7 @@ public final class WindowView extends DSideLayout {
 	private class DockWindowListener implements IDEDockWindow.Listener {
 		@Override
 		public void onOpen(IDESourceFile sourceFile) {
-			SourceEditor editor = new SourceEditor(DStyleClass.EMPTY, window, sourceFile);
+			SourceEditor editor = new SourceEditor(DStyleClass.EMPTY, window, sourceFile, compileState);
 			DScalableSize size = new DScalableSize(new DDpDimension(280), new DDpDimension(280));
 			TabbedViewComponent tab = new TabbedViewComponent(
 					sourceFile.getName(),

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/editor/SourceEditor.java

@@ -15,6 +15,7 @@ import live.ImmutableLiveString;
 import live.InverseLiveBool;
 import live.LiveObject;
 import live.LiveBool;
+import live.LiveList;
 import live.MutableLiveObject;
 import live.SimpleLiveBool;
 
@@ -43,6 +44,8 @@ import org.openzen.drawablegui.draw.DDrawnRectangle;
 import org.openzen.drawablegui.draw.DDrawnShape;
 import org.openzen.drawablegui.draw.DDrawnText;
 import org.openzen.drawablegui.style.DStyleClass;
+import org.openzen.zenscript.ide.host.IDECodeError;
+import org.openzen.zenscript.ide.host.IDECompileState;
 import org.openzen.zenscript.ide.ui.icons.SaveIcon;
 import org.openzen.zenscript.ide.ui.icons.ShadedCodeIcon;
 import org.openzen.zenscript.ide.ui.icons.ShadedSaveIcon;
@@ -85,6 +88,9 @@ public class SourceEditor implements DComponent {
 	private final IDEWindow window;
 	private final IDEAspectToolbar editToolbar = new IDEAspectToolbar(0, ShadedCodeIcon.BLUE, "Edit", "Source code editor");
 	
+	private final LiveList<IDECodeError> errors;
+	private ListenerHandle<LiveList.Listener<IDECodeError>> errorListListener = null;
+	
 	private final LiveBool updated;
 	
 	private DDrawnRectangle background;
@@ -96,10 +102,9 @@ public class SourceEditor implements DComponent {
 	private final List<DDrawnRectangle> multiLineSelection = new ArrayList<>();
 	private final List<DDrawnText> lineNumbers = new ArrayList<>();
 	private final List<List<DDrawnText>> drawnTokens = new ArrayList<>();
+	private final List<DDrawnShape> errorLines = new ArrayList<>();
 	
-	//private DDrawnShape test;
-	
-	public SourceEditor(DStyleClass styleClass, IDEWindow window, IDESourceFile sourceFile) {
+	public SourceEditor(DStyleClass styleClass, IDEWindow window, IDESourceFile sourceFile, LiveObject<IDECompileState> compileState) {
 		this.styleClass = styleClass;
 		this.window = window;
 		this.sourceFile = sourceFile;
@@ -121,6 +126,10 @@ public class SourceEditor implements DComponent {
 		} catch (IOException ex) {
 			ex.printStackTrace();
 		}
+		
+		errors = compileState.getValue().getErrors(sourceFile);
+		errors.addListener(new ErrorListListener());
+		System.out.println("Code errors: " + errors.getLength());
 	}
 	
 	public LiveBool isUpdated() {
@@ -132,6 +141,9 @@ public class SourceEditor implements DComponent {
 		if (blinkTimer != null)
 			blinkTimer.close();
 		
+		if (errorListListener != null)
+			errorListListener.close();
+		
 		tokenListener.close();
 	}
 
@@ -196,11 +208,6 @@ public class SourceEditor implements DComponent {
 			cursor = null;
 		}
 		
-		/*if (test != null) {
-			test.close();
-			test = null;
-		}*/
-		
 		if (blinkTimer != null)
 			blinkTimer.close();
 		
@@ -213,6 +220,14 @@ public class SourceEditor implements DComponent {
 				token.close();
 		drawnTokens.clear();
 		
+		if (errorListListener != null) {
+			errorListListener.close();
+			errorListListener = null;
+		}
+		for (DDrawnShape shape : errorLines)
+			shape.close();
+		errorLines.clear();
+		
 		clearMultilineSelection();
 	}
 	
@@ -264,7 +279,15 @@ public class SourceEditor implements DComponent {
 					bounds.y + style.selectionPaddingTop + i * fullLineHeight + fontMetrics.getAscent());
 		}
 		
-		//test = surface.strokePath(z + 4, new WavyLine(bounds.x + 50, bounds.y + 50, 100, surface.getContext().dp(2), surface.getContext().dp(3)), DTransform2D.IDENTITY, IDEStyling.ERROR_RED, surface.getScale());
+		for (DDrawnShape shape : errorLines)
+			shape.close();
+		errorLines.clear();
+		if (errorListListener != null)
+			errorListListener.close();
+		
+		for (IDECodeError error : errors)
+			errorLines.add(createShapeForError(error));
+		errorListListener = errors.addListener(new ErrorListListener());
 		
 		layoutLines(0);
 	}
@@ -767,7 +790,7 @@ public class SourceEditor implements DComponent {
 		
 		DSizing sizing = new DSizing(width + lineBarWidth, fullLineHeight * tokens.getLineCount());
 		this.sizing.setValue(sizing);
-		System.out.println("Preferred size: " + sizing.preferredWidth + " x " + sizing.preferredHeight);
+		//System.out.println("Preferred size: " + sizing.preferredWidth + " x " + sizing.preferredHeight);
 	}
 	
 	private class TokenListener implements TokenModel.Listener {
@@ -934,4 +957,42 @@ public class SourceEditor implements DComponent {
 			}
 		}
 	}
+	
+	private DDrawnShape createShapeForError(IDECodeError error) {
+		SourcePosition fromPosition = new SourcePosition(tokens, error.position.fromLine - 1, error.position.fromLineOffset);
+		int fromX = getX(fromPosition);
+		int fromY = getY(fromPosition);
+		
+		SourcePosition toPosition = new SourcePosition(tokens, error.position.toLine - 1, error.position.toLineOffset);
+		int toX = getX(toPosition);
+		int toY = getY(toPosition);
+		
+		int length = Math.max((int)(10 * context.getScale()), toX - fromX);
+		
+		int height = (int)(2 * context.getScale());
+		int offset = fullLineHeight - height - (int)(1.5 * context.getScale());
+		WavyLine line = new WavyLine(fromX, fromY + offset, length, height, 3 * context.getScale());
+		return context.strokePath(
+				context.z + 4,
+				line, DTransform2D.IDENTITY, style.errorWavyLineColor, context.getScale());
+	}
+	
+	private class ErrorListListener implements LiveList.Listener<IDECodeError> {
+
+		@Override
+		public void onInserted(int index, IDECodeError value) {
+			errorLines.add(index, createShapeForError(value));
+		}
+
+		@Override
+		public void onChanged(int index, IDECodeError oldValue, IDECodeError newValue) {
+			errorLines.get(index).close();
+			errorLines.set(index, createShapeForError(newValue));
+		}
+
+		@Override
+		public void onRemoved(int index, IDECodeError oldValue) {
+			errorLines.remove(index).close();
+		}
+	}
 }

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/editor/SourceEditorStyle.java

@@ -31,6 +31,8 @@ public class SourceEditorStyle {
 	public final int cursorWidth;
 	public final int cursorColor;
 	
+	public final int errorWavyLineColor;
+	
 	public SourceEditorStyle(DStyleDefinition style) {
 		this.backgroundColor = style.getColor("backgroundColor", 0xFFFFFFFF);
 		this.lineBarBackgroundColor = style.getColor("lineBarBackgroundColor", 0xFFE9E8E2);
@@ -50,5 +52,7 @@ public class SourceEditorStyle {
 		
 		this.cursorWidth = style.getDimension("cursorWidth", new DDpDimension(1));
 		this.cursorColor = style.getColor("cursorColor", 0xFF000000);
+		
+		this.errorWavyLineColor = style.getColor("errorWavyLineColor", 0xFFFF0000);
 	}
 }

JavaIntegration/src/main/java/org/openzen/zencode/java/JavaNativeModule.java

@@ -155,6 +155,7 @@ public class JavaNativeModule {
 		JavaClass jcls = JavaClass.fromInternalName(getInternalName(cls), JavaClass.Kind.CLASS);
 		compiled.setClassInfo(definition, jcls);
 		StoredType thisType = registry.getForMyDefinition(definition).stored();
+		TypeVariableContext context = new TypeVariableContext();
 		
 		for (Field field : cls.getDeclaredFields()) {
 			if (!field.isAnnotationPresent(ZenCodeGlobals.Global.class))
@@ -163,7 +164,7 @@ public class JavaNativeModule {
 				continue;
 			
 			ZenCodeGlobals.Global global = field.getAnnotation(ZenCodeGlobals.Global.class);
-			StoredType type = loadStoredType(field.getAnnotatedType());
+			StoredType type = loadStoredType(context, field.getAnnotatedType());
 			String name = global.value().isEmpty() ? field.getName() : global.value();
 			FieldMember fieldMember = new FieldMember(CodePosition.NATIVE, definition, Modifiers.PUBLIC | Modifiers.STATIC, name, thisType, type, registry, Modifiers.PUBLIC, 0, null);
 			definition.addMember(fieldMember);
@@ -181,7 +182,7 @@ public class JavaNativeModule {
 			
 			ZenCodeGlobals.Global global = method.getAnnotation(ZenCodeGlobals.Global.class);
 			String name = global.value().isEmpty() ? method.getName() : global.value();
-			MethodMember methodMember = new MethodMember(CodePosition.NATIVE, definition, Modifiers.PUBLIC | Modifiers.STATIC, name, getHeader(method), null);
+			MethodMember methodMember = new MethodMember(CodePosition.NATIVE, definition, Modifiers.PUBLIC | Modifiers.STATIC, name, getHeader(context, method), null);
 			definition.addMember(methodMember);
 			
 			boolean isGenericResult = methodMember.header.getReturnType().isGeneric();
@@ -200,7 +201,8 @@ public class JavaNativeModule {
 		HighLevelDefinition definition = addClass(method.getDeclaringClass());
 		JavaClass jcls = JavaClass.fromInternalName(getInternalName(method.getDeclaringClass()), JavaClass.Kind.CLASS);
 		
-		MethodMember methodMember = new MethodMember(CodePosition.NATIVE, definition, Modifiers.PUBLIC | Modifiers.STATIC, method.getName(), getHeader(method), null);
+		TypeVariableContext context = new TypeVariableContext();
+		MethodMember methodMember = new MethodMember(CodePosition.NATIVE, definition, Modifiers.PUBLIC | Modifiers.STATIC, method.getName(), getHeader(context, method), null);
 		definition.addMember(methodMember);
 		boolean isGenericResult = methodMember.header.getReturnType().isGeneric();
 		compiled.setMethodInfo(methodMember, new JavaMethod(jcls, JavaMethod.Kind.STATIC, method.getName(), false, getMethodDescriptor(method), method.getModifiers(), isGenericResult));
@@ -242,16 +244,18 @@ public class JavaNativeModule {
 		ZSPackage classPkg = getPackage(className);
 		className = className.contains(".") ? className.substring(className.lastIndexOf('.') + 1) : className;
 		
+		TypeVariableContext context = new TypeVariableContext();
 		TypeVariable<Class<T>>[] javaTypeParameters = cls.getTypeParameters();
 		TypeParameter[] typeParameters = new TypeParameter[cls.getTypeParameters().length];
 		for (int i = 0; i < javaTypeParameters.length; i++) {
 			TypeVariable<Class<T>> typeVariable = javaTypeParameters[i];
 			TypeParameter parameter = new TypeParameter(CodePosition.NATIVE, typeVariable.getName());
 			for (AnnotatedType bound : typeVariable.getAnnotatedBounds()) {
-				TypeID type = loadType(bound);
+				TypeID type = loadType(context, bound);
 				parameter.addBound(new ParameterTypeBound(CodePosition.NATIVE, type));
 			}
 			typeParameters[i] = parameter;
+			context.put(typeVariable, parameter);
 		}
 		
 		HighLevelDefinition definition;
@@ -270,14 +274,14 @@ public class JavaNativeModule {
 			definition = new ClassDefinition(CodePosition.NATIVE, module, classPkg, className, Modifiers.PUBLIC);
 			javaClass = JavaClass.fromInternalName(internalName, JavaClass.Kind.CLASS);
 			
-			if (cls.getSuperclass() != null && shouldLoadClass(cls.getSuperclass())) {
-				definition.setSuperType(loadType(cls.getSuperclass(), false, false));
+			if (cls.getAnnotatedSuperclass() != null && shouldLoadType(cls.getAnnotatedSuperclass().getType())) {
+				definition.setSuperType(loadType(context, cls.getAnnotatedSuperclass()));
 			}
 		}
 		
-		for (Class<?> iface : cls.getInterfaces()) {
-			if (shouldLoadClass(iface)) {
-				TypeID type = loadType(iface, false, false);
+		for (AnnotatedType iface : cls.getAnnotatedInterfaces()) {
+			if (shouldLoadType(iface.getType())) {
+				TypeID type = loadType(context, iface);
 				ImplementationMember member = new ImplementationMember(CodePosition.NATIVE, definition, Modifiers.PUBLIC, type);
 				definition.members.add(member);
 				compiled.setImplementationInfo(member, new JavaImplementation(true, javaClass));
@@ -298,7 +302,7 @@ public class JavaNativeModule {
 			
 			final String fieldName = annotation.value().isEmpty() ? field.getName() : annotation.value();
 			
-			StoredType fieldType = loadStoredType(field.getAnnotatedType());
+			StoredType fieldType = loadStoredType(context, field.getAnnotatedType());
 			FieldMember member = new FieldMember(CodePosition.NATIVE, definition, Modifiers.PUBLIC, fieldName, thisType, fieldType, registry, 0, 0, null);
 			definition.addMember(member);
 			compiled.setFieldInfo(member, new JavaField(javaClass, field.getName(), getDescriptor(field.getType())));
@@ -308,7 +312,7 @@ public class JavaNativeModule {
 		for (java.lang.reflect.Constructor constructor : cls.getConstructors()) {
 			ZenCodeType.Constructor constructorAnnotation = (ZenCodeType.Constructor) constructor.getAnnotation(ZenCodeType.Constructor.class);
 			if (constructorAnnotation != null) {
-				ConstructorMember member = asConstructor(definition, constructor);
+				ConstructorMember member = asConstructor(context, definition, constructor);
 				definition.addMember(member);
 				compiled.setMethodInfo(member, getMethod(javaClass, constructor));
 				hasConstructor = true;
@@ -324,7 +328,7 @@ public class JavaNativeModule {
 		for (Method method : cls.getDeclaredMethods()) {
 			ZenCodeType.Method methodAnnotation = method.getAnnotation(ZenCodeType.Method.class);
 			if (methodAnnotation != null) {
-				MethodMember member = asMethod(definition, method, methodAnnotation);
+				MethodMember member = asMethod(context, definition, method, methodAnnotation);
 				definition.addMember(member);
 				compiled.setMethodInfo(member, getMethod(javaClass, method, member.header.getReturnType()));
 				continue;
@@ -332,28 +336,28 @@ public class JavaNativeModule {
 			
 			ZenCodeType.Getter getter = method.getAnnotation(ZenCodeType.Getter.class);
 			if (getter != null) {
-				GetterMember member = asGetter(definition, method, getter);
+				GetterMember member = asGetter(context, definition, method, getter);
 				definition.addMember(member);
 				compiled.setMethodInfo(member, getMethod(javaClass, method, member.getType()));
 			}
 			
 			ZenCodeType.Setter setter = method.getAnnotation(ZenCodeType.Setter.class);
 			if (setter != null) {
-				SetterMember member = asSetter(definition, method, setter);
+				SetterMember member = asSetter(context, definition, method, setter);
 				definition.addMember(member);
 				compiled.setMethodInfo(member, getMethod(javaClass, method, BasicTypeID.VOID.stored));
 			}
 			
 			ZenCodeType.Operator operator = method.getAnnotation(ZenCodeType.Operator.class);
 			if (operator != null) {
-				OperatorMember member = asOperator(definition, method, operator);
+				OperatorMember member = asOperator(context, definition, method, operator);
 				definition.addMember(member);
 				compiled.setMethodInfo(member, getMethod(javaClass, method, member.header.getReturnType()));
 			}
 			
 			ZenCodeType.Caster caster = method.getAnnotation(ZenCodeType.Caster.class);
 			if (caster != null) {
-				CasterMember member = asCaster(definition, method, caster);
+				CasterMember member = asCaster(context, definition, method, caster);
 				definition.addMember(member);
 				compiled.setMethodInfo(member, getMethod(javaClass, method, member.toType));
 			}
@@ -368,6 +372,15 @@ public class JavaNativeModule {
 		return definition;
 	}
 	
+	private boolean shouldLoadType(Type type) {
+		if (type instanceof Class)
+			return shouldLoadClass((Class<?>)type);
+		if (type instanceof ParameterizedType)
+			return shouldLoadType(((ParameterizedType)type).getRawType());
+		
+		return false;
+	}
+	
 	private boolean shouldLoadClass(Class<?> cls) {
 		return isInBasePackage(cls.getName());
 	}
@@ -390,8 +403,8 @@ public class JavaNativeModule {
 		return name;
 	}
 	
-	private ConstructorMember asConstructor(HighLevelDefinition definition, java.lang.reflect.Constructor method) {
-		FunctionHeader header = getHeader(method);
+	private ConstructorMember asConstructor(TypeVariableContext context, HighLevelDefinition definition, java.lang.reflect.Constructor method) {
+		FunctionHeader header = getHeader(context, method);
 		return new ConstructorMember(
 				CodePosition.NATIVE,
 				definition,
@@ -400,9 +413,9 @@ public class JavaNativeModule {
 				null);
 	}
 	
-	private MethodMember asMethod(HighLevelDefinition definition, Method method, ZenCodeType.Method annotation) {
+	private MethodMember asMethod(TypeVariableContext context, HighLevelDefinition definition, Method method, ZenCodeType.Method annotation) {
 		String name = annotation != null && !annotation.value().isEmpty() ? annotation.value() : method.getName();
-		FunctionHeader header = getHeader(method);
+		FunctionHeader header = getHeader(context, method);
 		return new MethodMember(
 				CodePosition.NATIVE,
 				definition,
@@ -412,8 +425,8 @@ public class JavaNativeModule {
 				null);
 	}
 	
-	private OperatorMember asOperator(HighLevelDefinition definition, Method method, ZenCodeType.Operator annotation) {
-		FunctionHeader header = getHeader(method);
+	private OperatorMember asOperator(TypeVariableContext context, HighLevelDefinition definition, Method method, ZenCodeType.Operator annotation) {
+		FunctionHeader header = getHeader(context, method);
 		if (isStatic(method.getModifiers()))
 			throw new IllegalArgumentException("operator method cannot be static");
 		
@@ -429,8 +442,8 @@ public class JavaNativeModule {
 				null);
 	}
 	
-	private GetterMember asGetter(HighLevelDefinition definition, Method method, ZenCodeType.Getter annotation) {
-		StoredType type = loadStoredType(method.getAnnotatedReturnType());
+	private GetterMember asGetter(TypeVariableContext context, HighLevelDefinition definition, Method method, ZenCodeType.Getter annotation) {
+		StoredType type = loadStoredType(context, method.getAnnotatedReturnType());
 		String name = null;
 		if (annotation != null && !annotation.value().isEmpty())
 			name = annotation.value();
@@ -440,11 +453,11 @@ public class JavaNativeModule {
 		return new GetterMember(CodePosition.NATIVE, definition, getMethodModifiers(method), name, type, null);
 	}
 	
-	private SetterMember asSetter(HighLevelDefinition definition, Method method, ZenCodeType.Setter annotation) {
+	private SetterMember asSetter(TypeVariableContext context, HighLevelDefinition definition, Method method, ZenCodeType.Setter annotation) {
 		if (method.getParameterCount() != 1)
 			throw new IllegalArgumentException("Illegal setter: must have exactly 1 parameter");
 		
-		StoredType type = loadStoredType(method.getAnnotatedParameterTypes()[0]);
+		StoredType type = loadStoredType(context, method.getAnnotatedParameterTypes()[0]);
 		String name = null;
 		if (annotation != null && !annotation.value().isEmpty())
 			name = annotation.value();
@@ -454,26 +467,28 @@ public class JavaNativeModule {
 		return new SetterMember(CodePosition.NATIVE, definition, getMethodModifiers(method), name, type, null);
 	}
 	
-	private CasterMember asCaster(HighLevelDefinition definition, Method method, ZenCodeType.Caster annotation) {
+	private CasterMember asCaster(TypeVariableContext context, HighLevelDefinition definition, Method method, ZenCodeType.Caster annotation) {
 		boolean implicit = annotation != null && annotation.implicit();
 		int modifiers = Modifiers.PUBLIC;
 		if (implicit)
 			modifiers |= Modifiers.IMPLICIT;
 		
-		StoredType toType = loadStoredType(method.getAnnotatedReturnType());
+		StoredType toType = loadStoredType(context, method.getAnnotatedReturnType());
 		return new CasterMember(CodePosition.NATIVE, definition, modifiers, toType, null);
 	}
 	
-	private FunctionHeader getHeader(java.lang.reflect.Constructor constructor) {
+	private FunctionHeader getHeader(TypeVariableContext context, java.lang.reflect.Constructor constructor) {
 		return getHeader(
+				context,
 				null,
 				constructor.getAnnotatedParameterTypes(),
 				constructor.getTypeParameters(),
 				constructor.getAnnotatedExceptionTypes());
 	}
 	
-	private FunctionHeader getHeader(Method method) {
+	private FunctionHeader getHeader(TypeVariableContext context, Method method) {
 		return getHeader(
+				context,
 				method.getAnnotatedReturnType(),
 				method.getAnnotatedParameterTypes(),
 				method.getTypeParameters(),
@@ -481,39 +496,41 @@ public class JavaNativeModule {
 	}
 	
 	private FunctionHeader getHeader(
+			TypeVariableContext context,
 			AnnotatedType javaReturnType,
 			AnnotatedType[] parameterTypes,
 			TypeVariable<Method>[] javaTypeParameters,
 			AnnotatedType[] exceptionTypes) {
-		StoredType returnType = javaReturnType == null ? BasicTypeID.VOID.stored : loadStoredType(javaReturnType);
+		StoredType returnType = javaReturnType == null ? BasicTypeID.VOID.stored : loadStoredType(context, javaReturnType);
 		
 		FunctionParameter[] parameters = new FunctionParameter[parameterTypes.length];
 		for (int i = 0; i < parameters.length; i++) {
-			parameters[i] = new FunctionParameter(loadStoredType(parameterTypes[i]));
+			parameters[i] = new FunctionParameter(loadStoredType(context, parameterTypes[i]));
 		}
 		
 		TypeParameter[] typeParameters = new TypeParameter[javaTypeParameters.length];
 		for (int i = 0; i < javaTypeParameters.length; i++) {
 			TypeVariable<Method> javaTypeParameter = javaTypeParameters[i];
 			typeParameters[i] = new TypeParameter(CodePosition.UNKNOWN, javaTypeParameter.getName());
+			context.put(javaTypeParameter, typeParameters[i]);
 			
 			for (AnnotatedType bound : javaTypeParameter.getAnnotatedBounds())
-				typeParameters[i].addBound(new ParameterTypeBound(CodePosition.NATIVE, loadType(bound)));
+				typeParameters[i].addBound(new ParameterTypeBound(CodePosition.NATIVE, loadType(context, bound)));
 		}
 		
 		if (exceptionTypes.length > 1)
 			throw new IllegalArgumentException("A method can only throw a single exception type!");
 		
-		StoredType thrownType = exceptionTypes.length == 0 ? null : loadStoredType(exceptionTypes[0]);
+		StoredType thrownType = exceptionTypes.length == 0 ? null : loadStoredType(context, exceptionTypes[0]);
 		return new FunctionHeader(typeParameters, returnType, thrownType, AutoStorageTag.INSTANCE, parameters);
 	}
 	
-	private StoredType loadStoredType(AnnotatedType annotatedType) {
-		TypeID baseType = loadType(annotatedType);
+	private StoredType loadStoredType(TypeVariableContext context, AnnotatedType annotatedType) {
+		TypeID baseType = loadType(context, annotatedType);
 		return baseType.stored();
 	}
 	
-	private TypeID loadType(AnnotatedType annotatedType) {
+	private TypeID loadType(TypeVariableContext context, AnnotatedType annotatedType) {
 		if (annotatedType.isAnnotationPresent(ZenCodeType.USize.class))
 			return BasicTypeID.USIZE;
 		else if (annotatedType.isAnnotationPresent(ZenCodeType.NullableUSize.class))
@@ -523,10 +540,10 @@ public class JavaNativeModule {
 		boolean unsigned = annotatedType.isAnnotationPresent(ZenCodeType.Unsigned.class);
 		
 		Type type = annotatedType.getType();
-		return loadType(type, nullable, unsigned);
+		return loadType(context, type, nullable, unsigned);
 	}
 	
-	private TypeID loadType(Type type, boolean nullable, boolean unsigned) {
+	private TypeID loadType(TypeVariableContext context, Type type, boolean nullable, boolean unsigned) {
 		if (type instanceof Class) {
 			Class<?> classType = (Class<?>) type;
 			if (unsigned) {
@@ -535,7 +552,7 @@ public class JavaNativeModule {
 				else
 					throw new IllegalArgumentException("This class cannot be used as unsigned: " + classType);
 			} else if (classType.isArray()) {
-				return registry.getArray(loadType(classType.getComponentType(), false, false).stored(), 1);
+				return registry.getArray(loadType(context, classType.getComponentType(), false, false).stored(), 1);
 			}
 			
 			if (typeByClass.containsKey(classType))
@@ -551,9 +568,12 @@ public class JavaNativeModule {
 			Type[] parameters = parameterizedType.getActualTypeArguments();
 			StoredType[] codeParameters = new StoredType[parameters.length];
 			for (int i = 0; i < parameters.length; i++)
-				codeParameters[i] = loadType(parameters[i], false, false).stored();
+				codeParameters[i] = loadType(context, parameters[i], false, false).stored();
 			
 			return registry.getForDefinition(definition, codeParameters);
+		} else if (type instanceof TypeVariable) {
+			TypeVariable variable = (TypeVariable)type;
+			return registry.getGeneric(context.get(variable));
 		} else {
 			throw new IllegalArgumentException("Could not analyze type: " + type);
 		}
@@ -621,4 +641,19 @@ public class JavaNativeModule {
 		
 		return new JavaMethod(cls, kind, method.getName(), false, getMethodDescriptor(method), method.getModifiers(), result.isGeneric());
 	}
+	
+	private static class TypeVariableContext {
+		private final Map<TypeVariable, TypeParameter> typeVariables = new HashMap<>();
+		
+		public void put(TypeVariable variable, TypeParameter parameter) {
+			typeVariables.put(variable, parameter);
+		}
+		
+		public TypeParameter get(TypeVariable variable) {
+			if (!typeVariables.containsKey(variable))
+				throw new IllegalStateException("Could not find type variable " + variable.getName());
+			
+			return typeVariables.get(variable);
+		}
+	}
 }

ModuleSerializer/src/main/java/org/openzen/zenscript/moduleserializer/Main.java

@@ -9,10 +9,12 @@ import java.io.File;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.util.Collections;
-import org.openzen.zenscript.compiler.CompilationUnit;
-import org.openzen.zenscript.compiler.SemanticModule;
+import org.openzen.zenscript.codemodel.SemanticModule;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.constructor.ModuleLoader;
-import org.openzen.zenscript.constructor.module.DirectoryModuleReference;
+import org.openzen.zenscript.constructor.module.SourceModuleReference;
+import org.openzen.zenscript.constructor.module.directory.DirectorySourceModule;
 
 /**
  *
@@ -20,9 +22,11 @@ import org.openzen.zenscript.constructor.module.DirectoryModuleReference;
  */
 public class Main {
 	public static void main(String[] args) throws IOException {
-		CompilationUnit compilationUnit = new CompilationUnit();
-		ModuleLoader loader = new ModuleLoader(compilationUnit, exception -> exception.printStackTrace());
-		loader.register("stdlib", new DirectoryModuleReference("stdlib", new File("../../StdLibs/stdlib"), true));
+		ZSPackage root = ZSPackage.createRoot();
+		ZSPackage stdlib = new ZSPackage(root, "stdlib");
+		GlobalTypeRegistry registry = new GlobalTypeRegistry(stdlib);
+		ModuleLoader loader = new ModuleLoader(registry, exception -> exception.printStackTrace());
+		loader.register("stdlib", new SourceModuleReference(new DirectorySourceModule("stdlib", new File("../../StdLibs/stdlib"), true), true));
 		
 		SemanticModule module = loader.getModule("stdlib");
 		ModuleSerializer serializer = new ModuleSerializer(new SerializationOptions(

Parser/src/main/java/org/openzen/zenscript/lexer/CountingCharReader.java

@@ -17,19 +17,17 @@ import org.openzen.zencode.shared.SourceFile;
 public class CountingCharReader implements CharReader {
 	private final CharReader reader;
 	private final SourceFile file;
-	private final int tabSize;
 	
 	private int line;
 	private int lineOffset;
 	
-	public CountingCharReader(CharReader reader, SourceFile file, int tabSize)
+	public CountingCharReader(CharReader reader, SourceFile file)
 	{
 		this.reader = reader;
 		this.file = file;
-		this.tabSize = tabSize;
 		
 		line = 1;
-		lineOffset = 1;
+		lineOffset = 0;
 	}
 	
 	public CodePosition getPosition() {
@@ -51,9 +49,7 @@ public class CountingCharReader implements CharReader {
 		
 		if (ch == '\n') {
 			line++;
-			lineOffset = 1;
-		} else if (ch == '\t') {
-			lineOffset += tabSize;
+			lineOffset = 0;
 		} else {
 			lineOffset++;
 		}

Parser/src/main/java/org/openzen/zenscript/lexer/LLParserTokenStream.java

@@ -59,7 +59,7 @@ public class LLParserTokenStream<TT extends TokenType, T extends Token<TT>> exte
             if (marks.isEmpty()) {
                 tokenMemoryOffset++;
             } else {
-                tokenMemory.add(new PositionedToken(getPosition(), result));
+                tokenMemory.add(new PositionedToken(getPosition(), getPositionBeforeWhitespace(), result));
             }
             tokenMemoryCurrent++;
 			return result;
@@ -75,6 +75,15 @@ public class LLParserTokenStream<TT extends TokenType, T extends Token<TT>> exte
         }
 	}
 	
+	@Override
+	public CodePosition getPositionBeforeWhitespace() {
+		if (tokenMemoryCurrent < tokenMemoryOffset + tokenMemory.size()) {
+            return tokenMemory.get((tokenMemoryCurrent) - tokenMemoryOffset).positionBeforeWhitespace;
+        } else {
+            return super.getPositionBeforeWhitespace();
+        }
+	}
+	
 	public boolean isNext(TT type) {
 		return peek().getType() == type;
 	}
@@ -92,7 +101,7 @@ public class LLParserTokenStream<TT extends TokenType, T extends Token<TT>> exte
         if (t.getType() == type) {
             return next();
         } else {
-			throw new ParseException(getPosition(), error);
+			throw new ParseException(getPosition().withLength(t.getContent().length()), error);
         }
     }
 	
@@ -113,10 +122,12 @@ public class LLParserTokenStream<TT extends TokenType, T extends Token<TT>> exte
 	
 	private class PositionedToken {
 		public final CodePosition position;
+		public final CodePosition positionBeforeWhitespace;
 		public final T token;
 		
-		public PositionedToken(CodePosition position, T token) {
+		public PositionedToken(CodePosition position, CodePosition positionBeforeWhitespace, T token) {
 			this.position = position;
+			this.positionBeforeWhitespace = positionBeforeWhitespace;
 			this.token = token;
 		}
 	}

Parser/src/main/java/org/openzen/zenscript/lexer/TokenParser.java

@@ -42,7 +42,7 @@ public class TokenParser<T extends Token<TT>, TT extends TokenType> implements T
 		if (eof.isWhitespace()) // important for the advance() method
 			throw new IllegalArgumentException("EOF cannot be whitespace");
 		
-        this.reader = new CountingCharReader(reader, file, 4);
+        this.reader = new CountingCharReader(reader, file);
         this.dfa = dfa;
 		this.eof = eof;
 		this.invalid = invalid;

Parser/src/main/java/org/openzen/zenscript/lexer/WhitespaceFilteringParser.java

@@ -15,6 +15,7 @@ public class WhitespaceFilteringParser<TT extends TokenType, T extends Token<TT>
 	private final TokenStream<TT, T> stream;
 	private T next;
 	private CodePosition position;
+	private CodePosition positionBeforeWhitespace;
 	private String whitespace;
 	
 	public WhitespaceFilteringParser(TokenStream<TT, T> stream) throws ParseException {
@@ -64,6 +65,10 @@ public class WhitespaceFilteringParser<TT extends TokenType, T extends Token<TT>
 	public CodePosition getPosition() {
 		return position;
 	}
+	
+	public CodePosition getPositionBeforeWhitespace() {
+		return positionBeforeWhitespace;
+	}
 
 	@Override
 	public TT getEOF() {
@@ -73,6 +78,7 @@ public class WhitespaceFilteringParser<TT extends TokenType, T extends Token<TT>
 	private void advance() throws ParseException {
 		whitespace = "";
 		position = stream.getPosition();
+		positionBeforeWhitespace = position;
 		next = stream.next();
 		while (next.getType().isWhitespace()) {
 			whitespace += next.getContent();

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedExpression.java

@@ -370,9 +370,9 @@ public abstract class ParsedExpression {
 				ZSToken indexString = parser.optional(T_IDENTIFIER);
 				if (indexString != null) {
 					List<IParsedType> genericParameters = IParsedType.parseTypeArguments(parser);
-					base = new ParsedExpressionMember(position, base, indexString.content, genericParameters);
+					base = new ParsedExpressionMember(position.until(parser.getPositionBeforeWhitespace()), base, indexString.content, genericParameters);
 				} else if (parser.optional(T_DOLLAR) != null) {
-					base = new ParsedExpressionOuter(position, base);
+					base = new ParsedExpressionOuter(position.until(parser.getPositionBeforeWhitespace()), base);
 				} else {
 					ZSToken indexString2 = parser.optional(T_STRING_SQ);
 					if (indexString2 == null)
@@ -380,15 +380,16 @@ public abstract class ParsedExpression {
 					
 					if (indexString2 != null) {
 						// TODO: handle this properly
-						base = new ParsedExpressionMember(position, base, unescape(indexString2.content).orElse("INVALID STRING"), Collections.emptyList());
+						base = new ParsedExpressionMember(position.until(parser.getPositionBeforeWhitespace()), base, unescape(indexString2.content).orElse("INVALID STRING"), Collections.emptyList());
 					} else {
+						position = parser.getPosition();
 						ZSToken last = parser.next();
-						throw new ParseException(parser.getPosition(), "Invalid expression, last token: " + last.content);
+						throw new ParseException(position.until(parser.getPositionBeforeWhitespace()), "Invalid expression, last token: " + last.content);
 					}
 				}
 			} else if (parser.optional(T_DOT2) != null) {
 				ParsedExpression to = readAssignExpression(parser, options);
-				return new ParsedExpressionRange(position, base, to);
+				return new ParsedExpressionRange(position.until(parser.getPositionBeforeWhitespace()), base, to);
 			} else if (parser.optional(T_SQOPEN) != null) {
 				List<ParsedExpression> indexes = new ArrayList<>();
 				do {
@@ -443,7 +444,7 @@ public abstract class ParsedExpression {
 					name = name.substring(1);
 				
 				List<IParsedType> genericParameters = IParsedType.parseTypeArguments(parser);
-				return new ParsedExpressionVariable(position, name, genericParameters);
+				return new ParsedExpressionVariable(position.until(parser.getPositionBeforeWhitespace()), name, genericParameters);
 			}
 			case T_LOCAL_IDENTIFIER: {
 				String name = parser.next().content.substring(1);

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedExpressionAssign.java

@@ -10,8 +10,11 @@ import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.expression.InvalidAssignExpression;
+import org.openzen.zenscript.codemodel.expression.InvalidExpression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
@@ -31,11 +34,21 @@ public class ParsedExpressionAssign extends ParsedExpression {
 
 	@Override
 	public IPartialExpression compile(ExpressionScope scope) throws CompileException {
-		IPartialExpression cLeft = left.compile(scope);
-		List<StoredType> resultHints = cLeft.getAssignHints();
-		
-		Expression cRight = right.compile(scope.withHints(resultHints)).eval();
-		return cLeft.assign(position, scope, cRight);
+		try {
+			IPartialExpression cLeft = left.compile(scope);
+			List<StoredType> resultHints = cLeft.getAssignHints();
+			Expression cRight = right.compile(scope.withHints(resultHints)).eval();
+			return cLeft.assign(position, scope, cRight);
+		} catch (CompileException ex) {
+			InvalidExpression invalid = new InvalidExpression(BasicTypeID.VOID.stored, ex);
+			Expression cRight;
+			try {
+				cRight = right.compile(scope).eval();
+			} catch (CompileException ex2) {
+				cRight = new InvalidExpression(BasicTypeID.VOID.stored, ex2);
+			}
+			return new InvalidAssignExpression(position, invalid, cRight);
+		}
 	}
 
 	@Override

Parser/src/main/java/org/openzen/zenscript/parser/member/ParsedFunctionalMember.java

@@ -76,6 +76,9 @@ public abstract class ParsedFunctionalMember extends ParsedDefinitionMember {
 		getCompiled().setBody(body.compile(innerScope, getCompiled().header));
 		
 		if (getCompiled().header.getReturnType().isBasic(BasicTypeID.UNDETERMINED)) {
+			if (getCompiled().body == null)
+				throw new CompileException(position, CompileExceptionCode.CANNOT_INFER_RETURN_TYPE, "Method return type could not be inferred");
+			
 			StoredType returnType = getCompiled().body.getReturnType();
 			if (returnType == null) {
 				throw new CompileException(position, CompileExceptionCode.CANNOT_INFER_RETURN_TYPE, "Method return type could not be inferred");

ScriptingExample/scripts/integration.zs

@@ -5,6 +5,9 @@ val instance = new TestClass("Instance");
 println("Name: " + instance.name);
 instance.dump();
 
+var generated = instance.generate();
+println(generated.getValue());
+
 class TestOperators {
 	public (name as string) as void {
 		println("MyTestClass: " + name);
@@ -14,11 +17,11 @@ class TestOperators {
 	//	=> "key " + key;
 }
 
-class TestImplementation {
+/*class TestImplementation {
 	public implements TestInterface {
 		interfaceMethod() => "TestImplementation";
 	}
-}
+}*/
 
 val testInstance = new TestOperators();
 //testInstance("something");
@@ -32,7 +35,7 @@ printMany(objects);
 println(<test string>);
 println(<test string>.name);
 println(<test string>.interfaceMethod());
-println(new TestImplementation().interfaceMethod());
+//println(new TestImplementation().interfaceMethod());
 
 var diamond = <item:minecraft:diamond>;
 var dirt = <item:minecraft:dirt>;

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/Main.java

@@ -24,6 +24,8 @@ public class Main {
 		
 		JavaNativeModule example = scriptingEngine.createNativeModule("example", "org.openzen.zenscript.scriptingexample");
 		example.addGlobals(Globals.class);
+		example.addClass(TestBaseInterface.class);
+		example.addClass(TestGenericInterface.class);
 		example.addClass(TestClass.class);
 		example.addClass(TestInterface.class);
 		scriptingEngine.registerNativeProvided(example);

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/TestBaseInterface.java

@@ -0,0 +1,17 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.scriptingexample;
+
+import org.openzen.zencode.java.ZenCodeType;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface TestBaseInterface<T> extends ZenCodeType {
+	@Method
+	T getValue();
+}

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/TestClass.java

@@ -42,4 +42,9 @@ public class TestClass implements TestInterface {
 	public String interfaceMethod() {
 		return "Interface method of " + name;
 	}
+	
+	@Method
+	public TestGenericInterface<String> generate() {
+		return () -> name;
+	}
 }

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/TestGenericInterface.java

@@ -0,0 +1,14 @@
+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.scriptingexample;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface TestGenericInterface<T> extends TestBaseInterface<T> {
+	
+}

Shared/src/main/java/org/openzen/zencode/shared/CodePosition.java

@@ -37,6 +37,10 @@ public final class CodePosition {
             throw new AssertionError("From and to positions must be in the same file!");
         return new CodePosition(file, fromLine, fromLineOffset, to.toLine, to.toLineOffset);
     }
+	
+	public CodePosition withLength(int characters) {
+		return new CodePosition(file, fromLine, fromLineOffset, fromLine, fromLineOffset + characters);
+	}
     
     public String toString() {
         return fromLine == 0 && fromLineOffset == 0 ? file.getFilename() : file.getFilename() + ":" + Integer.toString(fromLine) + ":" + Integer.toString(fromLineOffset);

Shared/src/main/java/org/openzen/zencode/shared/CompileExceptionCode.java

@@ -75,5 +75,7 @@ public enum CompileExceptionCode {
 	INVALID_STORAGE_TYPE_ARGUMENTS,
 	STORAGE_NOT_SUPPORTED,
 	INCOMPATIBLE_STORAGE_TAG,
-	INVALID_TYPE_ARGUMENTS
+	INVALID_TYPE_ARGUMENTS,
+	
+	PARSE_ERROR
 }

Validator/src/main/java/org/openzen/zenscript/validator/visitors/ExpressionValidator.java

@@ -362,6 +362,13 @@ public class ExpressionValidator implements ExpressionVisitor<Void> {
 		validator.logError(ValidationLogEntry.Code.INVALID_EXPRESSION, expression.position, expression.message);
 		return null;
 	}
+	
+	@Override
+	public Void visitInvalidAssign(InvalidAssignExpression expression) {
+		expression.target.accept(this);
+		expression.source.accept(this);
+		return null;
+	}
 
 	@Override
 	public Void visitIs(IsExpression expression) {
@@ -748,6 +755,7 @@ public class ExpressionValidator implements ExpressionVisitor<Void> {
 	private void checkCallArguments(CodePosition position, FunctionHeader originalHeader, FunctionHeader instancedHeader, CallArguments arguments) {
 		ValidationUtils.validateTypeArguments(validator, position, originalHeader.typeParameters, arguments.typeArguments);
 		
+		boolean isVariadic = instancedHeader.isVariadicCall(arguments);
 		for (int i = 0; i < arguments.arguments.length; i++) {
 			Expression argument = arguments.arguments[i];
 			argument.accept(this);
@@ -766,7 +774,7 @@ public class ExpressionValidator implements ExpressionVisitor<Void> {
 				}
 			}
 			
-			FunctionParameter parameter = instancedHeader.parameters[i];
+			FunctionParameter parameter = instancedHeader.getParameter(isVariadic, i);
 			if (!parameter.type.equals(argument.type)) {
 				validator.logError(
 						ValidationLogEntry.Code.INVALID_CALL_ARGUMENT,