- CodePosition now stores source file references rather than source file names, allowing easier matching

- Starting work on error recording and display
- Fixed compilation of modules with dependencies
- Added a couple improvements to code typing for matching brackets
- Fixed java source compilation of abstract classes and methods

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/DefinitionMember.java

 	public boolean isExtern() {
 		return Modifiers.isExtern(modifiers);
 	}
+	
+	public boolean isPrivate() {
+		return Modifiers.isPrivate(modifiers);
+	}
 }

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

 import org.json.JSONArray;
 import org.json.JSONObject;
 import org.openzen.zencode.shared.CompileException;
+import org.openzen.zencode.shared.FileSourceFile;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.compiler.CompilationUnit;
 import org.openzen.zenscript.constructor.ConstructorException;
 			if (file.isDirectory()) {
 				pkg.addPackage(loadPackage(file.getName(), file));
 			} else if (file.isFile() && file.getName().toLowerCase().endsWith(".zs")) {
-				pkg.addFile(new SourceFile(file.getName(), file));
+				pkg.addFile(new FileSourceFile(file.getName(), file));
 			}
 		}
 		

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

-/*
- * 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.io.File;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class SourceFile {
-	public final String name;
-	public final File file;
-	
-	public SourceFile(String name, File file) {
-		this.name = name;
-		this.file = file;
-	}
-}

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

 import java.io.File;
 import java.util.HashMap;
 import java.util.Map;
+import org.openzen.zencode.shared.FileSourceFile;
+import org.openzen.zencode.shared.SourceFile;
 
 /**
  *
 	}
 	
 	public void addFile(SourceFile file) {
-		sourceFiles.put(file.name, file);
+		sourceFiles.put(file.getFilename(), file);
 	}
 }

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

+/*
+ * 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 org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.ide.host.IDESourceFile;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class IDECodeError {
+	public final IDESourceFile file;
+	public final CodePosition position;
+	public final String message;
+	
+	public IDECodeError(IDESourceFile file, CodePosition position, String message) {
+		this.file = file;
+		this.position = position;
+		this.message = message;
+	}
+}

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

  */
 package org.openzen.zenscript.ide.codemodel;
 
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Consumer;
+import org.openzen.zenscript.compiler.CompilationUnit;
+import org.openzen.zenscript.compiler.SemanticModule;
+import org.openzen.zenscript.compiler.ZenCodeCompiler;
+import org.openzen.zenscript.constructor.Library;
+import org.openzen.zenscript.constructor.ModuleLoader;
+import org.openzen.zenscript.constructor.module.DirectoryModuleReference;
+import org.openzen.zenscript.constructor.module.ModuleReference;
 import org.openzen.zenscript.ide.host.DevelopmentHost;
+import org.openzen.zenscript.ide.host.IDEModule;
 import org.openzen.zenscript.ide.host.IDESourceFile;
+import org.openzen.zenscript.ide.ui.view.output.ErrorOutputSpan;
+import org.openzen.zenscript.ide.ui.view.output.OutputLine;
+import org.openzen.zenscript.validator.ValidationLogEntry;
+import stdlib.Strings;
 
 /**
  *
  */
 public class IDECodeSpace {
 	private final DevelopmentHost host;
+	private final Map<IDESourceFile, List<IDECodeError>> sourceFileErrors = new HashMap<>();
 	
 	public IDECodeSpace(DevelopmentHost host) {
 		this.host = host;
+		
+		ModuleLoader loader = new ModuleLoader(new CompilationUnit(), exception -> {
+			
+		});
+		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/host/IDEModule.java

  */
 package org.openzen.zenscript.ide.host;
 
+import java.util.function.Consumer;
+import org.openzen.zenscript.constructor.ModuleLoader;
+import org.openzen.zenscript.ide.codemodel.IDECodeError;
+
 /**
  *
  * @author Hoofdgebruiker
 	public String getName();
 	
 	public IDEPackage getRootPackage();
+	
+	void prebuild(ModuleLoader loader, Consumer<IDECodeError> errors);
 }

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

  */
 package org.openzen.zenscript.ide.host;
 
-import java.io.IOException;
-import java.io.Reader;
 import org.openzen.drawablegui.live.LiveString;
+import org.openzen.zencode.shared.SourceFile;
 
 /**
  *
 public interface IDESourceFile {
 	public LiveString getName();
 	
-	public Reader read() throws IOException;
+	public SourceFile getFile();
 	
 	public void update(String content);
 }

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

  */
 package org.openzen.zenscript.ide.host.local;
 
+import java.util.function.Consumer;
+import org.openzen.zenscript.compiler.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.IDEModule;
 import org.openzen.zenscript.ide.host.IDEPackage;
 
 	public IDEPackage getRootPackage() {
 		return rootPackage;
 	}
+	
+	@Override
+	public void prebuild(ModuleLoader loader, Consumer<IDECodeError> errors) {
+		SemanticModule module = loader.getModule(this.module.getName());
+		module.validate(entry -> errors.accept(new IDECodeError(null, entry.position, entry.message)));
+	}
 }

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

 import org.openzen.drawablegui.live.LiveList;
 import org.openzen.drawablegui.live.MutableLiveList;
 import org.openzen.drawablegui.live.SortedLiveList;
-import org.openzen.zenscript.constructor.module.SourceFile;
+import org.openzen.zencode.shared.FileSourceFile;
+import org.openzen.zencode.shared.SourceFile;
 import org.openzen.zenscript.constructor.module.SourcePackage;
 import org.openzen.zenscript.ide.host.IDEPackage;
 import org.openzen.zenscript.ide.host.IDESourceFile;
 			ex.printStackTrace(); // TODO
 		}
 		
-		SourceFile sourceFile = new SourceFile(name, file);
+		FileSourceFile sourceFile = new FileSourceFile(name, file);
 		IDESourceFile localSourceFile = new LocalSourceFile(sourceFile);
 		this.pkg.sourceFiles.put(name, sourceFile);
 		sourceFiles.add(localSourceFile);

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

  */
 package org.openzen.zenscript.ide.host.local;
 
-import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
-import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
-import java.io.InputStreamReader;
 import java.io.OutputStreamWriter;
-import java.io.Reader;
 import java.io.Writer;
 import java.nio.charset.StandardCharsets;
 import org.openzen.drawablegui.live.LiveString;
 import org.openzen.drawablegui.live.MutableLiveString;
 import org.openzen.drawablegui.live.SimpleLiveString;
-import org.openzen.zenscript.constructor.module.SourceFile;
+import org.openzen.zencode.shared.FileSourceFile;
+import org.openzen.zencode.shared.SourceFile;
 import org.openzen.zenscript.ide.host.IDESourceFile;
 
 /**
 	
 	public LocalSourceFile(SourceFile file) {
 		this.file = file;
-		this.name = new SimpleLiveString(file.name);
+		this.name = new SimpleLiveString(file.getFilename());
 	}
 
 	@Override
 	}
 
 	@Override
-	public Reader read() throws IOException {
-		return new InputStreamReader(
-				new BufferedInputStream(new FileInputStream(file.file)),
-				StandardCharsets.UTF_8);
+	public SourceFile getFile() {
+		return file;
 	}
 
 	@Override
 	public void update(String content) {
 		try {
-			Writer writer = new OutputStreamWriter(new BufferedOutputStream(new FileOutputStream(file.file)), StandardCharsets.UTF_8);
-			writer.write(content);
-			writer.close();
+			if (file instanceof FileSourceFile) {
+				Writer writer = new OutputStreamWriter(new BufferedOutputStream(new FileOutputStream(((FileSourceFile)file).file)), StandardCharsets.UTF_8);
+				writer.write(content);
+				writer.close();
+			} else {
+				throw new UnsupportedOperationException("Cannot write to a non-file source file!");
+			}
 		} catch (IOException ex) {
 			ex.printStackTrace();
 		}

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

 				continue;
 			
 			SemanticModule dependencyModule = loader.getModule(dependency);
-			module = module.normalize();
-			module.validate(logger);
-			if (!module.isValid())
+			dependencyModule = dependencyModule.normalize();
+			dependencyModule.validate(logger);
+			if (!dependencyModule.isValid())
 				return false;
 			
 			if (!compileDependencies(loader, compiler, compiledModules, dependencyModule, logger))
 				return false;
 			
-			module.compile(compiler);
-			compiledModules.add(module.name);
+			dependencyModule.compile(compiler);
+			compiledModules.add(dependencyModule.name);
 		}
 		
 		return true;

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

+/*
+ * 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.ui.view.editor;
+
+import org.openzen.drawablegui.DPath;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class PathGenerator {
+	private PathGenerator() {}
+	
+	public static class CubicBezierCurve {
+		public final float p1x;
+		public final float p1y;
+		public final float p2x;
+		public final float p2y;
+		public final float p3x;
+		public final float p3y;
+		public final float p4x;
+		public final float p4y;
+		
+		public CubicBezierCurve(float p1x, float p1y, float p2x, float p2y, float p3x, float p3y, float p4x, float p4y) {
+			this.p1x = p1x;
+			this.p1y = p1y;
+			this.p2x = p2x;
+			this.p2y = p2y;
+			this.p3x = p3x;
+			this.p3y = p3y;
+			this.p4x = p4x;
+			this.p4y = p4y;
+		}
+		
+		public void cut(float t0, float t1) {
+			// https://stackoverflow.com/questions/11703283/cubic-bezier-curve-segment
+			// P'1 = u0u0u0 P1 + (t0u0u0 + u0t0u0 + u0u0t0) P2 + (t0t0u0 + u0t0t0 + t0u0t0) P3 + t0t0t0 P4
+			// P'2 = u0u0u1 P1 + (t0u0u1 + u0t0u1 + u0u0t1) P2 + (t0t0u1 + u0t0t1 + t0u0t1) P3 + t0t0t1 P4
+			// P'3 = u0u1u1 P1 + (t0u1u1 + u0t1u1 + u0u1t1) P2 + (t0t1u1 + u0t1t1 + t0u1t1) P3 + t0t1t1 P4
+			// P'4 = u1u1u1 P1 + (t1u1u1 + u1t1u1 + u1u1t1) P2 + (t1t1u1 + u1t1t1 + t1u1t1) P3 + t1t1t1 P4
+			// u0 = 1 − t0 and u1 = 1 − t1
+			
+		}
+	}
+}

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

 package org.openzen.zenscript.ide.ui.view.editor;
 
 import java.io.IOException;
+import java.io.Reader;
 import java.util.ArrayList;
 import java.util.List;
 import org.openzen.drawablegui.DComponent;
 import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.lexer.ZSTokenType;
 import org.openzen.drawablegui.DUIContext;
+import org.openzen.drawablegui.Destructible;
 import org.openzen.drawablegui.draw.DDrawSurface;
 import org.openzen.drawablegui.draw.DDrawnRectangle;
 import org.openzen.drawablegui.draw.DDrawnShape;
 	private final List<DDrawnText> lineNumbers = new ArrayList<>();
 	private final List<List<DDrawnText>> drawnTokens = new ArrayList<>();
 	
+	//private DDrawnShape test;
+	
 	public SourceEditor(DStyleClass styleClass, IDEWindow window, IDESourceFile sourceFile) {
 		this.styleClass = styleClass;
 		this.window = window;
 		this.sourceFile = sourceFile;
 		
-		tokens = new TokenModel(sourceFile.getName().getValue(), tab.length());
+		tokens = new TokenModel(sourceFile.getFile(), tab.length());
 		tokenListener = tokens.addListener(new TokenListener());
 		
 		editToolbar.controls.add(() -> new IconButtonControl(DStyleClass.EMPTY, ShadedSaveIcon.PURPLE, SaveIcon.GREY, unchanged, new ImmutableLiveString("Save file"), e -> save()));
 		updated = new InverseLiveBool(unchanged);
 		
 		try {
+			Reader reader = sourceFile.getFile().open();
 			TokenParser<ZSToken, ZSTokenType> parser = ZSTokenParser.createRaw(
-					sourceFile.getName().getValue(),
-					new ReaderCharReader(sourceFile.read()),
+					sourceFile.getFile(),
+					new ReaderCharReader(reader),
 					tab.length());
 			tokens.set(parser);
+			reader.close();
 		} catch (IOException ex) {
 			ex.printStackTrace();
 		}
 			cursor = null;
 		}
 		
+		/*if (test != null) {
+			test.close();
+			test = null;
+		}*/
+		
 		if (blinkTimer != null)
 			blinkTimer.close();
 		
 					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());
+		
 		layoutLines(0);
 	}
 	
 		}
 	}
 	
+	private void setCursor(SourcePosition position) {
+		setCursor(position, position);
+	}
+	
 	private void setCursor(SourcePosition start, SourcePosition end) {
 		cursorStart = start;
 		cursorEnd = end;
 		if (value.equals("{")) {
 			String indent = tokens.getLine(cursorEnd.line).getIndent();
 			tokens.insert(cursorEnd, "{\n" + indent + "\t\n" + indent + "}");
-			
-			SourcePosition position = new SourcePosition(tokens, cursorEnd.line + 1, indent.length() + 1);
-			setCursor(position, position);
-		} else if (value.equals(";")) {
-			String indent = tokens.getLine(cursorEnd.line).getIndent();
-			tokens.insert(cursorEnd, ";\n" + indent);
-			
-			SourcePosition position = new SourcePosition(tokens, cursorEnd.line + 1, indent.length());
-			setCursor(position, position);
+			setCursor(new SourcePosition(tokens, cursorEnd.line + 1, indent.length() + 1));
+		} else if (value.equals("\"")) {
+			if (!tokens.extract(cursorEnd, cursorEnd.advance(1)).equals("\""))
+				tokens.insert(cursorEnd, "\"\"");
+			setCursor(cursorEnd.advance(1));
+		} else if (value.equals("(")) {
+			tokens.insert(cursorEnd, "()");
+			setCursor(cursorEnd.advance(1));
+		} else if (value.equals(")") && tokens.extract(cursorEnd, cursorEnd.advance(1)).equals(")")){
+			setCursor(cursorEnd.advance(1));
+		} else if (value.equals("[")) {
+			tokens.insert(cursorEnd, "[]");
+			setCursor(cursorEnd.advance(1));
+		} else if (value.equals("]") && tokens.extract(cursorEnd, cursorEnd.advance(1)).equals("]")) {
+			setCursor(cursorEnd.advance(1));
 		} else {
 			tokens.insert(cursorEnd, value);
-			
-			SourcePosition position = new SourcePosition(tokens, cursorEnd.line, cursorEnd.offset + value.length());
-			setCursor(position, position);
+			setCursor(cursorEnd.advance(value.length()));
 		}
 		
 		unchanged.setValue(false);
 		@Override
 		public void onLineChanged(int index) {
 			if (bounds != null) {
-				removeLineTokens(drawnTokens.get(index));
-				drawnTokens.get(index).clear();
-				drawnTokens.get(index).addAll(lineToTokens(tokens.getLine(index)));
+				Destructible.close(drawnTokens.get(index));
+				drawnTokens.set(index, lineToTokens(tokens.getLine(index)));
 				layoutLine(index);
 			}
 		}
 			
 			if (bounds != null) {
 				lineNumbers.remove(lineNumbers.size() - 1).close();
-				removeLineTokens(drawnTokens.remove(index));
+				Destructible.close(drawnTokens.remove(index));
 				layoutLines(index);
 			}
 		}
-		
-		private void removeLineTokens(List<DDrawnText> tokens) {
-			for (DDrawnText token : tokens)
-				token.close();
-		}
 	}
 	
 	private enum TokenClass {

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

 import java.util.Set;
 import org.openzen.drawablegui.listeners.ListenerHandle;
 import org.openzen.drawablegui.listeners.ListenerList;
+import org.openzen.zencode.shared.SourceFile;
 import org.openzen.zenscript.lexer.ZSToken;
 import org.openzen.zenscript.lexer.ZSTokenType;
 
 public class TokenModel {
 	private final ListenerList<Listener> listeners = new ListenerList<>();
 	
-	private final String filename;
+	private final SourceFile file;
 	private final int spacesPerTab;
 	private final List<TokenLine> lines = new ArrayList<>();
 	private long version = 0;
 	
-	public TokenModel(String filename, int spacesPerTab) {
-		this.filename = filename;
+	public TokenModel(SourceFile file, int spacesPerTab) {
+		this.file = file;
 		this.spacesPerTab = spacesPerTab;
 	}
 	
 	}
 	
 	private void relex(int fromLine, int fromToken, int toLine, int toToken) {
-		TokenRelexer reparser = new TokenRelexer(filename, lines, fromLine, fromToken, toLine, toToken, spacesPerTab);
+		TokenRelexer reparser = new TokenRelexer(file, lines, fromLine, fromToken, toLine, toToken, spacesPerTab);
 		List<ZSToken> tokens = reparser.relex();
 		replaceTokens(fromLine, fromToken, reparser.getLine(), reparser.getToken(), tokens);
 	}
 		TokenLine currentLine = lines.get(line);
 		Set<Integer> insertedLines = new HashSet<>();
 		Set<Integer> modifiedLines = new HashSet<>();
+		modifiedLines.add(line);
 		while (tokens.hasNext()) {
 			ZSToken token = tokens.next();
 			if (token.type.multiline && token.content.indexOf('\n') >= 0) {

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

 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
+import org.openzen.zencode.shared.SourceFile;
 import org.openzen.zenscript.lexer.CharReader;
 import org.openzen.zenscript.lexer.TokenParser;
 import org.openzen.zenscript.lexer.ZSToken;
  */
 public class TokenRelexer {
 	private final List<TokenLine> lines;
-	private final String filename;
+	private final SourceFile file;
 	private final int toLine;
 	private final int toToken;
 	private final int spacesPerTab;
 	private int lineIndex;
 	private int token;
 	
-	public TokenRelexer(String filename, List<TokenLine> lines, int fromLine, int fromToken, int toLine, int toToken, int spacesPerTab) {
+	public TokenRelexer(SourceFile file, List<TokenLine> lines, int fromLine, int fromToken, int toLine, int toToken, int spacesPerTab) {
 		if (fromToken < 0 || toToken < 0)
 			throw new IllegalArgumentException("fromToken or toToken cannot be < 0");
 		
 		this.lines = lines;
-		this.filename = filename;
+		this.file = file;
 		this.toLine = toLine;
 		this.toToken = toToken;
 		
 	
 	public List<ZSToken> relex() {
 		RelexCharReader reader = new RelexCharReader();
-		TokenParser<ZSToken, ZSTokenType> reparser = ZSTokenParser.createRaw(filename, reader, spacesPerTab);
+		TokenParser<ZSToken, ZSTokenType> reparser = ZSTokenParser.createRaw(file, reader, spacesPerTab);
 		List<ZSToken> result = new ArrayList<>();
 		while ((lineIndex < toLine || token < toToken || !reader.isAtTokenBoundary()) && reparser.hasNext())
 			result.add(reparser.next());

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

+/*
+ * 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.ui.view.editor;
+
+import org.openzen.drawablegui.DPath;
+import org.openzen.drawablegui.DPathTracer;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class WavyLine implements DPath {
+	private final int x;
+	private final int y;
+	private final int width;
+	private final int height;
+	private final float stride;
+	
+	public WavyLine(int x, int y, int width, int height, float stride) {
+		this.x = x;
+		this.y = y;
+		this.width = width;
+		this.height = height;
+		this.stride = stride;
+	}
+	
+	@Override
+	public void trace(DPathTracer tracer) {
+		tracer.moveTo(x, y);
+		for (int i = 0; i < (width / stride); i++) {
+			if ((i % 2) == 0) {
+				tracer.bezierCubic(
+						x + (i + 0.5f) * stride, y,
+						x + (i + 0.5f) * stride, y + height,
+						x + (i + 1) * stride, y + height);
+			} else {
+				tracer.bezierCubic(
+						x + (i + 0.5f) * stride, y + height,
+						x + (i + 0.5f) * stride, y,
+						x + (i + 1) * stride, y);
+			}
+		}
+	}
+}

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaCompiler.java

 	@Override
 	public void addScriptBlock(ScriptBlock script) {
 		final SourceFile sourceFile = script.getTag(SourceFile.class);
-		final String className = getClassName(sourceFile == null ? null : sourceFile.filename);
+		final String className = getClassName(sourceFile == null ? null : sourceFile.getFilename());
 		JavaScriptFile scriptFile = getScriptFile(className);
 		
 		String methodName = scriptFile.scriptMethods.isEmpty() ? "run" : "run" + scriptFile.scriptMethods.size();

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/BaseMemberCompiler.java

 			output.append("protected ");
 		if (Modifiers.isPrivate(modifiers))
 			output.append("private ");
+		if (Modifiers.isAbstract(modifiers))
+			output.append("abstract ");
 		if (Modifiers.isStatic(modifiers))
 			output.append("static ");
 		if (Modifiers.isFinal(modifiers))

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaDefinitionVisitor.java

 		}
 		
 		if (mergedImplementations.size() > 0) {
-			output.append("implements ");
+			output.append(" implements ");
 			for (int i = 0; i < mergedImplementations.size(); i++) {
 				if (i > 0)
 					output.append(", ");
 			output.append("static ");
 		if (Modifiers.isAbstract(modifiers))
 			output.append("abstract ");
-		if (!Modifiers.isVirtual(modifiers))
+		if (!Modifiers.isVirtual(modifiers) && !Modifiers.isAbstract(modifiers))
 			output.append("final ");
 	}
 	

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceCompiler.java

 	private String getFilename(HighLevelDefinition definition) {
 		SourceFile source = definition.getTag(SourceFile.class);
 		if (source != null) {
-			int slash = Math.max(source.filename.lastIndexOf('/'), source.filename.lastIndexOf('\\'));
-			String filename = source.filename.substring(slash < 0 ? 0 : slash + 1);
+			int slash = Math.max(source.getFilename().lastIndexOf('/'), source.getFilename().lastIndexOf('\\'));
+			String filename = source.getFilename().substring(slash < 0 ? 0 : slash + 1);
 			filename = filename.substring(0, filename.lastIndexOf('.'));
 			return filename;
 		} else {

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceTypeVisitor.java

 import org.openzen.zenscript.codemodel.type.OptionalTypeID;
 import org.openzen.zenscript.codemodel.type.RangeTypeID;
 import org.openzen.zenscript.javasource.tags.JavaSourceClass;
-import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
 
 /**
  *

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/prepare/JavaSourcePrepareDefinitionVisitor.java

 import org.openzen.zenscript.codemodel.expression.CastExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
-import org.openzen.zenscript.codemodel.type.ArrayTypeID;
 import org.openzen.zenscript.formattershared.ExpressionString;
 import org.openzen.zenscript.javasource.JavaOperator;
 import org.openzen.zenscript.javasource.tags.JavaSourceClass;
 			cls.addConstructor("constructorWithCause", "");
 			nativeClasses.put("stdlib::Exception", cls);
 		}
+		
+		{
+			JavaNativeClass cls = new JavaNativeClass(new JavaSourceClass("java.io", "IOException"));
+			cls.addConstructor("constructor", "");
+			nativeClasses.put("io::IOException", cls);
+		}
+		
+		{
+			JavaNativeClass cls = new JavaNativeClass(new JavaSourceClass("java.io", "Reader"));
+			cls.addInstanceMethod("destruct", "close");
+			cls.addInstanceMethod("readCharacter", "read");
+			cls.addInstanceMethod("readArray", "read");
+			cls.addInstanceMethod("readArraySlice", "read");
+			nativeClasses.put("io::Reader", cls);
+		}
+		
+		{
+			JavaNativeClass cls = new JavaNativeClass(new JavaSourceClass("java.io", "StringReader"));
+			cls.addInstanceMethod("constructor", "");
+			cls.addInstanceMethod("destructor", "close");
+			cls.addInstanceMethod("readCharacter", "read");
+			cls.addInstanceMethod("readSlice", "read");
+			nativeClasses.put("io::StringReader", cls);
+		}
 	}
 	
 	private final String filename;

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/prepare/JavaSourcePrepareExpansionMethodVisitor.java

 import org.openzen.zenscript.codemodel.member.DestructorMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.codemodel.member.GetterMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ImplementationMember;
 import org.openzen.zenscript.codemodel.member.InnerDefinitionMember;
 import org.openzen.zenscript.codemodel.member.MemberVisitor;
 import org.openzen.zenscript.javasource.JavaSourceTypeNameVisitor;
 import org.openzen.zenscript.javasource.tags.JavaSourceClass;
 import org.openzen.zenscript.javasource.tags.JavaSourceField;
+import org.openzen.zenscript.javasource.tags.JavaSourceImplementation;
 import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
 
 /**
 	public Void visitField(FieldMember member) {
 		// TODO: expansion fields
 		member.setTag(JavaSourceField.class, new JavaSourceField(cls, member.name));
-		cls.empty = false;
+		if (member.hasAutoGetter() || member.hasAutoSetter())
+			cls.empty = false;
 		return null;
 	}
 
 
 	@Override
 	public Void visitDestructor(DestructorMember member) {
-		throw new UnsupportedOperationException("Destructors not allowed on expansions");
+		visitFunctional(member, "");
+		return null;
 	}
 
 	@Override
 	@Override
 	public Void visitImplementation(ImplementationMember member) {
 		// TODO: implementation merge check
-		cls.empty = false;
+		//cls.empty = false; -> TODO: 
+		member.setTag(JavaSourceImplementation.class, new JavaSourceImplementation(false));
+		for (IDefinitionMember implementedMember : member.members)
+			implementedMember.accept(this);
+		
 		return null;
 	}
 

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/tags/JavaSourceImplementation.java

+/*
+ * 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.javasource.tags;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class JavaSourceImplementation {
+	public boolean inline = true;
+	
+	public JavaSourceImplementation() {}
+	
+	public JavaSourceImplementation(boolean inline) {
+		this.inline = inline;
+	}
+}

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

 
 import java.io.IOException;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.SourceFile;
 
 /*
  * To change this license header, choose License Headers in Project Properties.
  */
 public class CountingCharReader implements CharReader {
 	private final CharReader reader;
-	private final String filename;
+	private final SourceFile file;
 	private final int tabSize;
 	
 	private int line;
 	private int lineOffset;
-
-	public CountingCharReader(CharReader reader, String filename, int tabSize)
+	
+	public CountingCharReader(CharReader reader, SourceFile file, int tabSize)
 	{
 		this.reader = reader;
-		this.filename = filename;
+		this.file = file;
 		this.tabSize = tabSize;
 		
 		line = 1;
 	}
 	
 	public CodePosition getPosition() {
-		return new CodePosition(filename, line, lineOffset, line, lineOffset);
+		return new CodePosition(file, line, lineOffset, line, lineOffset);
 	}
 
 	@Override

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
+import org.openzen.zencode.shared.SourceFile;
 
 /**
  * Represents a token stream. A token stream reads characters from a reader and
     /**
      * Creates a token stream using the specified reader and DFA.
      *
-	 * @param filename filename
+	 * @param file filename
      * @param reader reader to read characters from
      * @param dfa DFA to tokenize the stream
 	 * @param eof end of file token type
      */
     public TokenParser(
-			String filename,
+			SourceFile file,
 			CharReader reader, 
 			CompiledDFA<TT> dfa,
 			TT eof,
 		if (eof.isWhitespace()) // important for the advance() method
 			throw new IllegalArgumentException("EOF cannot be whitespace");
 		
-        this.reader = new CountingCharReader(reader, filename, 4);
+        this.reader = new CountingCharReader(reader, file, 4);
         this.dfa = dfa;
 		this.eof = eof;
 		this.invalid = invalid;
     /**
      * Creates a token stream which reads data from the specified string.
      *
-	 * @param filename filename
+	 * @param file filename
      * @param data data to read
      * @param dfa DFA to tokenize the stream
 	 * @param eof end of file token type
      */
-    public TokenParser(String filename, String data, CompiledDFA<TT> dfa, TT eof, TT invalid, TokenFactory<T, TT> factory)
+    public TokenParser(SourceFile file, String data, CompiledDFA<TT> dfa, TT eof, TT invalid, TokenFactory<T, TT> factory)
 	{
-        this(filename, new StringCharReader(data), dfa, eof, invalid, factory);
+        this(file, new StringCharReader(data), dfa, eof, invalid, factory);
     }
 	
 	@Override

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

 
 import java.io.IOException;
 import java.io.Reader;
+import org.openzen.zencode.shared.SourceFile;
 import org.openzen.zenscript.codemodel.WhitespaceInfo;
 
 /**
 public class ZSTokenParser extends LLParserTokenStream<ZSTokenType, ZSToken> {
 	private static final CompiledDFA DFA = CompiledDFA.createLexerDFA(ZSTokenType.values(), ZSTokenType.class);
 	
-	public static TokenParser<ZSToken, ZSTokenType> createRaw(String filename, CharReader reader, int spacesPerTab) {
+	public static TokenParser<ZSToken, ZSTokenType> createRaw(SourceFile file, CharReader reader, int spacesPerTab) {
 		return new TokenParser<>(
-				filename,
+				file,
 				reader,
 				DFA,
 				ZSTokenType.EOF,
 				new ZSTokenFactory(spacesPerTab));
 	}
 	
-	public static ZSTokenParser create(String filename, Reader reader, int spacesPerTab) throws IOException {
-		return new ZSTokenParser(createRaw(filename, new ReaderCharReader(reader), spacesPerTab));
+	public static ZSTokenParser create(SourceFile file, int spacesPerTab) throws IOException {
+		return new ZSTokenParser(createRaw(file, new ReaderCharReader(file.open()), spacesPerTab));
 	}
 	
 	public ZSTokenParser(TokenStream<ZSTokenType, ZSToken> parser) {
 		super(parser);
 	}
 	
-	public String getFilename() {
-		return getPosition().filename;
+	public SourceFile getFile() {
+		return getPosition().file;
 	}
 	
 	public WhitespaceInfo collectWhitespaceInfo(String whitespace, boolean skipLineBefore) {

Parser/src/main/java/org/openzen/zenscript/parser/ParsedFile.java

 import java.io.File;
 import java.io.FileReader;
 import java.io.IOException;
-import java.io.Reader;
-import java.io.StringReader;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
+import org.openzen.zencode.shared.FileSourceFile;
+import org.openzen.zencode.shared.LiteralSourceFile;
 import org.openzen.zencode.shared.SourceFile;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
  */
 public class ParsedFile {
 	public static ParsedFile parse(ZSPackage pkg, File file) throws IOException {
-		String filename = file.toString();
-		try (FileReader reader = new FileReader(file)) {
-			return parse(pkg, filename, reader);
-		}
+		return parse(pkg, new FileSourceFile(file.getName(), file));
 	}
 	
 	public static ParsedFile parse(ZSPackage pkg, String filename, String content) {
-		try (StringReader reader = new StringReader(content)) {
-			return parse(pkg, filename, reader);
+		try {
+			return parse(pkg, new LiteralSourceFile(filename, content));
 		} catch (IOException ex) {
-			throw new AssertionError(); // supposed to never happen in a StringReader
+			throw new AssertionError(); // shouldn't happen
 		}
 	}
 	
-	public static ParsedFile parse(ZSPackage pkg, String filename, Reader reader) throws IOException {
-		ZSTokenParser tokens = ZSTokenParser.create(filename, reader, 4);
+	public static ParsedFile parse(ZSPackage pkg, SourceFile file) throws IOException {
+		ZSTokenParser tokens = ZSTokenParser.create(file, 4);
 		return parse(pkg, tokens);
 	}
 	
 	public static ParsedFile parse(ZSPackage pkg, ZSTokenParser tokens) {
-		ParsedFile result = new ParsedFile(tokens.getFilename());
+		ParsedFile result = new ParsedFile(tokens.getFile());
 		ZSToken eof = null;
 
 		while (true) {
 		return result;
 	}
 	
-	public final String filename;
+	public final SourceFile file;
 	
 	private final List<ParsedImport> imports = new ArrayList<>();
 	private final List<ParsedDefinition> definitions = new ArrayList<>();
 	private final List<ParsedStatement> statements = new ArrayList<>();
 	private WhitespacePostComment postComment = null;
 	
-	public ParsedFile(String filename) {
-		this.filename = filename;
+	public ParsedFile(SourceFile file) {
+		this.file = file;
 	}
 	
 	public boolean hasErrors() {
 	
 	public void listDefinitions(PackageDefinitions definitions) {
 		for (ParsedDefinition definition : this.definitions) {
-			definition.getCompiled().setTag(SourceFile.class, new SourceFile(filename));
+			definition.getCompiled().setTag(SourceFile.class, file);
 			definitions.add(definition.getCompiled());
 			definition.linkInnerTypes();
 		}
 			}
 			
 			ScriptBlock block = new ScriptBlock(statements);
-			block.setTag(SourceFile.class, new SourceFile(filename));
+			block.setTag(SourceFile.class, file);
 			block.setTag(WhitespacePostComment.class, postComment);
 			scripts.add(block);
 		}

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

 import org.openzen.zencode.shared.CodePosition;
 
 public final class CodePosition {
-	public static final CodePosition BUILTIN = new CodePosition("builtin", 0, 0, 0, 0);
-	public static final CodePosition NATIVE = new CodePosition("native", 0, 0, 0, 0);
+	public static final CodePosition BUILTIN = new CodePosition(new VirtualSourceFile("builtin"), 0, 0, 0, 0);
+	public static final CodePosition NATIVE = new CodePosition(new VirtualSourceFile("native"), 0, 0, 0, 0);
 	public final String filename;
+	public final SourceFile file;
 	public final int fromLine;
 	public final int fromLineOffset;
 	public final int toLine;
 	public final int toLineOffset;
 	
-	public CodePosition(String filename, int fromLine, int fromLineOffset, int toLine, int toLineOffset) {
-	    this.filename = filename;
+	public CodePosition(SourceFile file, int fromLine, int fromLineOffset, int toLine, int toLineOffset) {
+		this.file = file;
+	    this.filename = file.getFilename();
 	    this.fromLine = fromLine;
 	    this.fromLineOffset = fromLineOffset;
 	    this.toLine = toLine;
 	public CodePosition until(CodePosition to) {
 	    if (!filename.equals(to.filename))
 	        throw new AssertionError("From and to positions must be in the same file!");
-	    return new CodePosition(filename, fromLine, fromLineOffset, to.toLine, to.toLineOffset);
+	    return new CodePosition(file, fromLine, fromLineOffset, to.toLine, to.toLineOffset);
 	}
 	
 	public String toString() {

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

+/*
+ * 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.zencode.shared;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.nio.charset.StandardCharsets;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class FileSourceFile implements SourceFile {
+	public final String name;
+	public final File file;
+	
+	public FileSourceFile(String name, File file) {
+		this.name = name;
+		this.file = file;
+	}
+
+	@Override
+	public String getFilename() {
+		return name;
+	}
+
+	@Override
+	public Reader open() throws IOException {
+		return new InputStreamReader(
+				new BufferedInputStream(new FileInputStream(file)),
+				StandardCharsets.UTF_8);
+	}
+}

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

+/*
+ * 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.zencode.shared;
+
+import java.io.IOException;
+import java.io.Reader;
+import java.io.StringReader;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class LiteralSourceFile implements SourceFile {
+	private final String filename;
+	private final String contents;
+	
+	public LiteralSourceFile(String filename, String contents) {
+		this.filename = filename;
+		this.contents = contents;
+	}
+
+	@Override
+	public String getFilename() {
+		return filename;
+	}
+
+	@Override
+	public Reader open() throws IOException {
+		return new StringReader(contents);
+	}
+}

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

 package org.openzen.zencode.shared;
 
-public final class SourceFile {
-	public final String filename;
-	
-	public SourceFile(String filename) {
-	    this.filename = filename;
-	}
+import java.io.IOException;
+import java.io.Reader;
+
+public interface SourceFile {
+	String getFilename();
 	
-	public String getFilename() {
-	    return filename;
-	}
+	Reader open() throws IOException;
 }

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

+/*
+ * 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.zencode.shared;
+
+import java.io.IOException;
+import java.io.Reader;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class VirtualSourceFile implements SourceFile {
+	private final String filename;
+	
+	public VirtualSourceFile(String filename) {
+		this.filename = filename;
+	}
+
+	@Override
+	public String getFilename() {
+		return filename;
+	}
+
+	@Override
+	public Reader open() throws IOException {
+		throw new UnsupportedOperationException("Cannot open virtual source files");
+	}
+}

Shared/src/main/java/stdlib/Arrays.java

 
 import java.lang.reflect.Array;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import zsynthetic.Function1;
 import zsynthetic.Function2;
 import zsynthetic.Function3;
 import zsynthetic.Function4;
 import zsynthetic.Function5;
 import zsynthetic.Function6;
+import zsynthetic.Function7;
 
 public final class Arrays {
     private Arrays() {}
 	    }
 	    return result;
 	}
+	
+	public static <K, T> Map<K, T> index(Class<T> typeOfT, T[] self, Class<K> typeOfK, Function7<K, T> key) {
+	    Map<K, T> result = new HashMap<>();
+	    for (T value : self)
+	        
+	        result.put(key.invoke(value), value);
+	    return result;
+	}
 }

Shared/src/main/java/stdlib/Assoc.java

 
 import java.util.HashMap;
 import java.util.Map;
-import zsynthetic.Function7;
+import zsynthetic.Function8;
 
 public final class Assoc {
     private Assoc() {}
-	static <W, K, V> Map<K, W> mapValues(Class<K> typeOfK, Class<V> typeOfV, Map<K, V> self, Class<W> typeOfW, Function7<W, V> projection) {
+	static <W, K, V> Map<K, W> mapValues(Class<K> typeOfK, Class<V> typeOfV, Map<K, V> self, Class<W> typeOfW, Function8<W, V> projection) {
 	    Map<K, W> result = new HashMap<>();
 	    for (Map.Entry<K, V> temp1 : self.entrySet()) {
 	        K k = temp1.getKey();

Shared/src/main/java/stdlib/Result.java

 import stdlib.Result.Error;
 import stdlib.Result.Ok;
 import zsynthetic.Function10;
-import zsynthetic.Function8;
+import zsynthetic.Function11;
 import zsynthetic.Function9;
 
 public abstract class Result<T, E> {
-	public <R> Result<R, E> then(Class<R> typeOfR, Function8<R, E, T> fn) {
+	public <R> Result<R, E> then(Class<R> typeOfR, Function9<R, E, T> fn) {
 	    Result<R, E> temp1;
 	    switch (this.getDiscriminant()) {
 	        case Ok:
 	    return temp1;
 	}
 	
-	public <X> Result<T, X> handle(Class<X> typeOfX, Function9<T, X, E> handler) {
+	public <X> Result<T, X> handle(Class<X> typeOfX, Function10<T, X, E> handler) {
 	    Result<T, X> temp1;
 	    switch (this.getDiscriminant()) {
 	        case Ok:
 	    return temp1;
 	}
 	
-	public T orElse(Function10<T, E> other) {
+	public T orElse(Function11<T, E> other) {
 	    T temp1;
 	    switch (this.getDiscriminant()) {
 	        case Ok:

Shared/src/main/java/zsynthetic/Function10.java

 package zsynthetic;
+import stdlib.Result;
+
 
 @FunctionalInterface
-public interface Function10<T, E>  {
-    T invoke(E error);
+public interface Function10<T, X, E>  {
+    Result<T, X> invoke(E error);
 }

Shared/src/main/java/zsynthetic/Function7.java

 package zsynthetic;
 
 @FunctionalInterface
-public interface Function7<W, V>  {
-    W invoke(V value);
+public interface Function7<K, T>  {
+    K invoke(T value);
 }

Shared/src/main/java/zsynthetic/Function8.java

 package zsynthetic;
-import stdlib.Result;
-
 
 @FunctionalInterface
-public interface Function8<R, E, T>  {
-    Result<R, E> invoke(T result);
+public interface Function8<W, V>  {
+    W invoke(V value);
 }

Shared/src/main/java/zsynthetic/Function9.java

 
 
 @FunctionalInterface
-public interface Function9<T, X, E>  {
-    Result<T, X> invoke(E error);
+public interface Function9<R, E, T>  {
+    Result<R, E> invoke(T result);
 }