Merge remote-tracking branch 'Stan/development' into development

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/ExpressionFormatter.java

 import org.openzen.zenscript.codemodel.expression.NewExpression;
 import org.openzen.zenscript.codemodel.expression.NullExpression;
 import org.openzen.zenscript.codemodel.expression.OrOrExpression;
+import org.openzen.zenscript.codemodel.expression.PanicExpression;
 import org.openzen.zenscript.codemodel.expression.PostCallExpression;
 import org.openzen.zenscript.codemodel.expression.RangeExpression;
 import org.openzen.zenscript.codemodel.expression.SameObjectExpression;
 		return binary(expression.left, expression.right, ZenScriptOperator.OROR);
 	}
 	
+	@Override
+	public ExpressionString visitPanic(PanicExpression expression) {
+		return expression.value.accept(this).unaryPrefix(ZenScriptOperator.PANIC);
+	}
+	
 	@Override
 	public ExpressionString visitPostCall(PostCallExpression expression) {
 		return unaryPostfix(expression.target, ZenScriptOperator.INCREMENT, expression.member.getOperator() == OperatorType.INCREMENT ? "++" : "--");

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/ZenScriptOperator.java

 	CALL(9, null),
 	CAST(9, null),
 	
+	PANIC(10, "panic "),
 	PRIMARY(10, null);
 	
 	private final int priority;

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

  */
 package org.openzen.zenscript.codemodel.expression;
 
-import org.openzen.zenscript.codemodel.member.ConstructorMember;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
  */
 public class ConstructorSuperCallExpression extends Expression {
 	public final ITypeID objectType;
-	public final ConstructorMember constructor;
+	public final FunctionalMemberRef constructor;
 	public final CallArguments arguments;
 	
-	public ConstructorSuperCallExpression(CodePosition position, ITypeID type, ConstructorMember constructor, CallArguments arguments, TypeScope scope) {
+	public ConstructorSuperCallExpression(CodePosition position, ITypeID type, FunctionalMemberRef constructor, CallArguments arguments, TypeScope scope) {
 		super(position, BasicTypeID.VOID, binaryThrow(position, constructor.header.thrownType, multiThrow(position, arguments.arguments)));
 		
 		this.objectType = type;

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

 	
 	public T visitOrOr(OrOrExpression expression);
 	
+	public T visitPanic(PanicExpression expression);
+	
 	public T visitPostCall(PostCallExpression expression);
 	
 	public T visitRange(RangeExpression expression);

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

  */
 package org.openzen.zenscript.codemodel.expression;
 
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
+import java.util.List;
 import org.openzen.zenscript.codemodel.expression.switchvalue.SwitchValue;
+import org.openzen.zenscript.codemodel.statement.BreakStatement;
 import org.openzen.zenscript.codemodel.statement.ExpressionStatement;
+import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.statement.SwitchCase;
 import org.openzen.zenscript.codemodel.statement.SwitchStatement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.CodePosition;
 
 	public SwitchedMatch convertToSwitch(String tempVariable) {
 		VarStatement result = new VarStatement(position, tempVariable, type, null, false);
 		SwitchStatement switchStatement = new SwitchStatement(position, null, value);
+		boolean hasDefault = false;
 		for (MatchExpression.Case matchCase : cases) {
-			Expression caseExpression = new SetLocalVariableExpression(matchCase.value.position, result, matchCase.value);
-			SwitchCase switchCase = new SwitchCase(matchCase.key, Collections.singletonList(new ExpressionStatement(matchCase.value.position, caseExpression)));
+			Expression caseExpression;
+			boolean reachable = true;
+			if (matchCase.value instanceof ThrowExpression || matchCase.value instanceof PanicExpression) {
+				caseExpression = matchCase.value;
+				reachable = false;
+			} else {
+				caseExpression = new SetLocalVariableExpression(matchCase.value.position, result, matchCase.value);
+			}
+			List<Statement> statements = new ArrayList<>();
+			statements.add(new ExpressionStatement(matchCase.value.position, caseExpression));
+			if (reachable)
+				statements.add(new BreakStatement(matchCase.value.position, switchStatement));
+			SwitchCase switchCase = new SwitchCase(matchCase.key, statements);
 			switchStatement.cases.add(switchCase);
+			
+			if (matchCase.key == null)
+				hasDefault = true;
+		}
+		if (!hasDefault) {
+			switchStatement.cases.add(new SwitchCase(null, Collections.singletonList(new ExpressionStatement(position, new PanicExpression(position, BasicTypeID.VOID, new ConstantStringExpression(position, "Missing case"))))));
 		}
 		return new SwitchedMatch(result, switchStatement);
 	}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/PanicExpression.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.codemodel.expression;
+
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class PanicExpression extends Expression {
+	public final Expression value;
+	
+	public PanicExpression(CodePosition position, ITypeID type, Expression value) {
+		super(position, type, null);
+		
+		this.value = value;
+	}
+
+	@Override
+	public <T> T accept(ExpressionVisitor<T> visitor) {
+		return visitor.visitPanic(this);
+	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return new PanicExpression(position, type, transformer.transform(value));
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/partial/PartialTypeExpression.java

 
 	@Override
 	public Expression call(CodePosition position, TypeScope scope, List<ITypeID> hints, CallArguments arguments) {
-		if (arguments.getNumberOfTypeArguments() == 0 && typeParameters.length > 0)
+		if (arguments.getNumberOfTypeArguments() == 0 && (typeParameters != null && typeParameters.length > 0))
 			arguments = new CallArguments(typeParameters, arguments.arguments);
 		
 		return scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CALL).callStatic(position, type, scope, arguments);

CompilerShared/src/main/java/org/openzen/zenscript/compiler/SemanticModule.java

 		for (ScriptBlock script : scripts) {
 			compiler.addScriptBlock(script);
 		}
-		compiler.finish();
 	}
 	
 	public enum State {

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

 			if (!stdlib.isValid())
 				return compiler;
 			stdlib.compile(compiler);
+			compiledModules.add(stdlib.name);
 			
 			boolean isValid = compileDependencies(moduleLoader, compiler, compiledModules, module);
 			if (!isValid)
 				return compiler;
 			
 			module.compile(compiler);
+			compiler.finish();
 			return compiler;
 		} catch (IOException ex) {
 			ex.printStackTrace();

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaExpressionVisitor.java

 
         return null;
     }
-
-    @Override
-    public Void visitPostCall(PostCallExpression expression) {
-        expression.target.accept(this);
-        javaWriter.dup(expression.type.accept(new JavaTypeVisitor()));
+	
+	@Override
+	public Void visitPanic(PanicExpression expression) {
+		// TODO: compile to: throw new AssertionError(expression.value)
+		throw new UnsupportedOperationException("Not yet supported");
+	}
+	
+	@Override
+	public Void visitPostCall(PostCallExpression expression) {
+		expression.target.accept(this);
+		javaWriter.dup(expression.type.accept(new JavaTypeVisitor()));
         if (!checkAndExecuteByteCodeImplementation(expression.member) && !checkAndExecuteMethodInfo(expression.member))
             throw new IllegalStateException("Call target has no method info!");
 

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaPreDecrementVisitor.java

 import org.openzen.zenscript.codemodel.expression.NewExpression;
 import org.openzen.zenscript.codemodel.expression.NullExpression;
 import org.openzen.zenscript.codemodel.expression.OrOrExpression;
+import org.openzen.zenscript.codemodel.expression.PanicExpression;
 import org.openzen.zenscript.codemodel.expression.PostCallExpression;
 import org.openzen.zenscript.codemodel.expression.RangeExpression;
 import org.openzen.zenscript.codemodel.expression.SameObjectExpression;
 	public Void visitOrOr(OrOrExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
 	}
+	
+	@Override
+	public Void visitPanic(PanicExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
 
 	@Override
 	public Void visitPostCall(PostCallExpression expression) {

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaPreIncrementVisitor.java

 import org.openzen.zenscript.codemodel.expression.NewExpression;
 import org.openzen.zenscript.codemodel.expression.NullExpression;
 import org.openzen.zenscript.codemodel.expression.OrOrExpression;
+import org.openzen.zenscript.codemodel.expression.PanicExpression;
 import org.openzen.zenscript.codemodel.expression.PostCallExpression;
 import org.openzen.zenscript.codemodel.expression.RangeExpression;
 import org.openzen.zenscript.codemodel.expression.SameObjectExpression;
 	public Void visitOrOr(OrOrExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
 	}
+	
+	@Override
+	public Void visitPanic(PanicExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
 
 	@Override
 	public Void visitPostCall(PostCallExpression expression) {

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

 import org.openzen.zenscript.codemodel.expression.NewExpression;
 import org.openzen.zenscript.codemodel.expression.NullExpression;
 import org.openzen.zenscript.codemodel.expression.OrOrExpression;
+import org.openzen.zenscript.codemodel.expression.PanicExpression;
 import org.openzen.zenscript.codemodel.expression.PostCallExpression;
 import org.openzen.zenscript.codemodel.expression.RangeExpression;
 import org.openzen.zenscript.codemodel.expression.SameObjectExpression;
 	public Boolean visitOrOr(OrOrExpression expression) {
 		return true;
 	}
+	
+	@Override
+	public Boolean visitPanic(PanicExpression expression) {
+		return true;
+	}
 
 	@Override
 	public Boolean visitPostCall(PostCallExpression expression) {

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

 	public Void visitClass(ClassDefinition definition) {
 		convertModifiers(definition.modifiers);
 		output.append("class ").append(definition.name);
+		JavaSourceUtils.formatTypeParameters(scope, output, definition.genericParameters);
 		if (definition.superType != null) {
 			output.append(" extends ");
 			output.append(scope.type(definition.superType));
 
 	@Override
 	public Void visitInterface(InterfaceDefinition definition) {
-		convertModifiers(definition.modifiers);
+		convertModifiers(definition.modifiers | Modifiers.VIRTUAL); // to prevent 'final'
 		output.append("interface ").append(definition.name);
+		JavaSourceUtils.formatTypeParameters(scope, output, definition.genericParameters);
 		output.append(" {\n");
 		compileMembers(definition);
 		output.append("}\n");
 	public Void visitStruct(StructDefinition definition) {
 		convertModifiers(definition.modifiers | Modifiers.FINAL);
 		output.append("class ").append(definition.name);
+		JavaSourceUtils.formatTypeParameters(scope, output, definition.genericParameters);
 		output.append(" {\n");
 		compileMembers(definition);
 		output.append("}\n");
 	@Override
 	public Void visitFunction(FunctionDefinition definition) {
 		convertModifiers(definition.modifiers | Modifiers.STATIC);
+		
 		return null;
 	}
 
 		output.append("class ");
 		output.append(scope.className);
 		output.append(" {\n");
+		output.append(settings.indent).append("private ").append(scope.className).append("() {}\n");
 		
 		JavaExpansionMemberCompiler memberCompiler = new JavaExpansionMemberCompiler(settings, definition.target, "\t", output, scope);
 		for (IDefinitionMember member : definition.members)
 
 	@Override
 	public Void visitVariant(VariantDefinition variant) {
+		convertModifiers(variant.modifiers | Modifiers.VIRTUAL | Modifiers.ABSTRACT);
+		output.append("class ").append(variant.name);
+		JavaSourceUtils.formatTypeParameters(scope, output, variant.genericParameters);
+		output.append("{\n");
+		compileMembers(variant);
+		output.append(settings.indent).append("public abstract Discriminant getDiscriminant();\n");
+		
+		output.append(settings.indent).append("\n");
+		output.append(settings.indent).append("public static enum Discriminant {\n");
+		for (VariantDefinition.Option option : variant.options) {
+			output.append(settings.indent).append(settings.indent).append(option.name).append(",\n");
+		}
+		output.append(settings.indent).append("}\n");
+		
+		for (VariantDefinition.Option option : variant.options) {
+			output.append(settings.indent).append("\n");
+			output.append(settings.indent).append("public static class ").append(option.name);
+			JavaSourceUtils.formatTypeParameters(scope, output, variant.genericParameters);
+			output.append(" extends ");
+			output.append(variant.name);
+			if (variant.genericParameters != null && variant.genericParameters.length > 0) {
+				output.append('<');
+				for (int i = 0; i < variant.genericParameters.length; i++) {
+					if (i > 0)
+						output.append(", ");
+					output.append(variant.genericParameters[i].name);
+				}
+				output.append('>');
+			}
+			output.append(" {\n");
+			
+			for (int i = 0; i < option.types.length; i++) {
+				String name = option.types.length == 1 ? "value" : "value" + (i + 1);
+				output.append(settings.indent).append(settings.indent).append("public final ").append(scope.type(option.types[i])).append(" ").append(name).append(";\n");
+			}
+			output.append(settings.indent).append(settings.indent).append("\n");
+			output.append(settings.indent).append(settings.indent).append("public ").append(option.name).append("(");
+			for (int i = 0; i < option.types.length; i++) {
+				if (i > 0)
+					output.append(", ");
+				String name = option.types.length == 1 ? "value" : "value" + (i + 1);
+				output.append(scope.type(option.types[i])).append(' ').append(name);
+			}
+			output.append("){\n");
+			for (int i = 0; i < option.types.length; i++) {
+				if (i > 0)
+					output.append(settings.indent).append(settings.indent).append(settings.indent).append(";\n");
+				
+				String name = option.types.length == 1 ? "value" : "value" + (i + 1);
+				output.append(settings.indent).append(settings.indent).append(settings.indent).append("this.").append(name).append(" = ").append(name).append(";\n");
+			}
+			output.append(settings.indent).append(settings.indent).append("}\n");
+			
+			output.append(settings.indent).append(settings.indent).append("\n");
+			output.append(settings.indent).append(settings.indent).append("@Override\n");
+			output.append(settings.indent).append(settings.indent).append("public Discriminant getDiscriminant() {\n");
+			output.append(settings.indent).append(settings.indent).append(settings.indent).append("return Discriminant.").append(option.name).append(";\n");
+			output.append(settings.indent).append(settings.indent).append("}\n");
+			output.append(settings.indent).append("}\n");
+		}
+		
+		output.append("}\n");
 		return null;
 	}
 	
 	}
 	
 	private void compileMembers(HighLevelDefinition definition) {
-		JavaMemberCompiler memberCompiler = new JavaMemberCompiler(settings, "\t", output, scope, false);
+		JavaMemberCompiler memberCompiler = new JavaMemberCompiler(settings, "\t", output, scope, false, scope.isInterface);
 		for (IDefinitionMember member : definition.members)
 			member.accept(memberCompiler);
 		memberCompiler.finish();

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

 import org.openzen.zenscript.codemodel.member.SetterMember;
 import org.openzen.zenscript.codemodel.member.StaticInitializerMember;
 import org.openzen.zenscript.codemodel.statement.BlockStatement;
+import org.openzen.zenscript.codemodel.statement.EmptyStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 		addSpacing();
 		
 		output.append(indent);
-		modifiers(member.modifiers);
+		
+		modifiers(member.modifiers | Modifiers.STATIC);
 		JavaSourceUtils.formatTypeParameters(scope, output, member.header.typeParameters);
 		output.append(scope.type(member.header.returnType));
 		output.append(" ");
 		addSpacing();
 		
 		output.append(indent);
-		modifiers(member.modifiers);
+		modifiers(member.modifiers | Modifiers.STATIC);
 		output.append(scope.type(member.type));
 		output.append(" ");
 		output.append("get").append(StringUtils.capitalize(member.name));
 		addSpacing();
 		
 		output.append(indent);
-		modifiers(member.modifiers);
+		modifiers(member.modifiers | Modifiers.STATIC);
 		output.append("void set").append(StringUtils.capitalize(member.name));
 		output.append("(");
 		output.append(scope.type(member.type));
 		addSpacing();
 		
 		output.append(indent);
-		modifiers(member.modifiers);
+		modifiers(member.modifiers | Modifiers.STATIC);
 		output.append(scope.type(member.header.returnType));
 		output.append(' ');
 		output.append(getOperatorName(member.operator));
 		addSpacing();
 		
 		output.append(indent);
-		modifiers(member.modifiers);
+		modifiers(member.modifiers | Modifiers.STATIC);
 		output.append(scope.type(member.toType));
 		output.append(" ");
 		output.append("to").append(member.toType.accept(new JavaSourceTypeNameVisitor()));

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

 	private final JavaSourceFormattingSettings settings;
 	private final List<FieldMember> fields = new ArrayList<>();
 	private final boolean isExpansion;
+	private final boolean isInterface;
 	private boolean first = true;
 	
-	public JavaMemberCompiler(JavaSourceFormattingSettings settings, String indent, StringBuilder output, JavaSourceFileScope scope, boolean isExpansion) {
+	public JavaMemberCompiler(JavaSourceFormattingSettings settings, String indent, StringBuilder output, JavaSourceFileScope scope, boolean isExpansion, boolean isInterface) {
 		this.indent = indent;
 		this.output = output;
 		this.scope = scope;
 		this.settings = settings;
 		this.isExpansion = isExpansion;
+		this.isInterface = isInterface;
 		
 		fieldInitializerScope = new JavaSourceStatementScope(
 				scope,
 	public Void visitMethod(MethodMember member) {
 		addSpacing();
 		
+		
 		output.append(indent);
+		if (isInterface && member.body != null && !(member.body instanceof EmptyStatement))
+			output.append("default ");
+		
 		modifiers(member.modifiers);
 		JavaSourceUtils.formatTypeParameters(scope, output, member.header.typeParameters);
 		output.append(member.header.returnType.accept(scope.typeVisitor));
 		addSpacing();
 		
 		output.append(indent);
+		if (isInterface && member.body != null && !(member.body instanceof EmptyStatement))
+			output.append("default ");
+		
 		modifiers(member.modifiers);
 		output.append(scope.type(member.type));
 		output.append(" ");
 		addSpacing();
 		
 		output.append(indent);
+		if (isInterface && member.body != null && !(member.body instanceof EmptyStatement))
+			output.append("default ");
+		
 		modifiers(member.modifiers);
 		output.append("void set").append(StringUtils.capitalize(member.name));
 		output.append("(");
 			throw new IllegalStateException("Missing method tag!");
 		
 		output.append(indent);
+		if (isInterface && member.body != null && !(member.body instanceof EmptyStatement))
+			output.append("default ");
+		
 		modifiers(member.modifiers);
 		output.append(scope.type(member.header.returnType));
 		output.append(' ');
 		addSpacing();
 		
 		output.append(indent);
+		if (isInterface && member.body != null && !(member.body instanceof EmptyStatement))
+			output.append("default ");
+		
 		modifiers(member.modifiers);
 		output.append(scope.type(member.toType));
 		output.append(" ");

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

 import org.openzen.zenscript.codemodel.expression.NewExpression;
 import org.openzen.zenscript.codemodel.expression.NullExpression;
 import org.openzen.zenscript.codemodel.expression.OrOrExpression;
+import org.openzen.zenscript.codemodel.expression.PanicExpression;
 import org.openzen.zenscript.codemodel.expression.PostCallExpression;
 import org.openzen.zenscript.codemodel.expression.RangeExpression;
 import org.openzen.zenscript.codemodel.expression.SameObjectExpression;
 		return binary(expression.left, expression.right, JavaOperator.OROR);
 	}
 	
+	@Override
+	public ExpressionString visitPanic(PanicExpression expression) {
+		return new ExpressionString("throw new AssertionError(" + expression.value.accept(this).value + ")", JavaOperator.PRIMARY);
+	}
+	
 	@Override
 	public ExpressionString visitPostCall(PostCallExpression expression) {
 		return unaryPostfix(expression.target, expression.member.getOperator() == OperatorType.INCREMENT ? JavaOperator.INCREMENT : JavaOperator.DECREMENT);
 			case STRING_CONSTRUCTOR_CHARACTERS:
 				return callStatic("new String", expression.arguments.arguments[0]);
 			case ASSOC_CONSTRUCTOR: {
-				String typeName = scope.fileScope.importer.importType("java.util.HashMap");
+				String typeName = scope.type(new JavaSourceClass("HashMap", "java.util.HashMap"));
 				AssocTypeID type = (AssocTypeID) expression.type;
 				
 				StringBuilder result = new StringBuilder();
 				return new ExpressionString(result.toString(), JavaOperator.NEW);
 			}
 			case GENERICMAP_CONSTRUCTOR: {
-				String typeName = scope.fileScope.importer.importType("java.util.HashMap");
+				String typeName = scope.type(new JavaSourceClass("HashMap", "java.util.HashMap"));
 				StringBuilder result = new StringBuilder();
 				result.append("new ").append(typeName).append("<Class<?>, Object>()");
 				return new ExpressionString(result.toString(), JavaOperator.NEW);
 							.append(value.value)
 							.append(";")
 							.toString());
+					return new ExpressionString(temp, JavaOperator.PRIMARY);
 				} else {
 					// TODO: implement
 					throw new UnsupportedOperationException("Not yet supported!");

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

 import java.util.Map;
 import java.util.Set;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.compiler.CompileScope;
 import org.openzen.zenscript.compiler.SemanticModule;
 	}
 	
 	public void write() {
+		System.out.println("Calling write on " + file.getName());
+		
 		for (Map.Entry<HighLevelDefinition, SemanticModule> entry : definitions.entrySet()) {
 			HighLevelDefinition definition = entry.getKey();
 			SemanticModule module = entry.getValue();
 			CompileScope scope = new CompileScope(definition.access, module.compilationUnit.globalTypeRegistry, module.expansions, module.annotations);
 			JavaDefinitionVisitor visitor = new JavaDefinitionVisitor(
 					compiler.settings,
-					new JavaSourceFileScope(importer, compiler.typeGenerator, compiler.helperGenerator, getName(), scope),
+					new JavaSourceFileScope(importer, compiler.typeGenerator, compiler.helperGenerator, getName(), scope, definition instanceof InterfaceDefinition),
 					contents);
 			definition.accept(visitor);
 		}
 		
 		if (!file.getParentFile().exists())
 			file.getParentFile().mkdirs();
-		file.delete();
 		
-		try (Writer writer = new OutputStreamWriter(new BufferedOutputStream(new FileOutputStream(file)), StandardCharsets.UTF_8)) {
+		try (Writer writer = new OutputStreamWriter(new BufferedOutputStream(new FileOutputStream(file, false)), StandardCharsets.UTF_8)) {
 			writer.write("package ");
 			writer.write(pkg.fullName);
 			writer.write(";\n\n");

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

 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.statement.TryCatchStatement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
 import org.openzen.zenscript.codemodel.statement.WhileStatement;
+import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.formattershared.ExpressionString;
 import org.openzen.zenscript.formattershared.StatementFormatter;
 import org.openzen.zenscript.formattershared.StatementFormattingSubBlock;
 import org.openzen.zenscript.formattershared.StatementFormattingTarget;
 import org.openzen.zenscript.javasource.scope.JavaSourceStatementScope;
+import org.openzen.zenscript.javasource.tags.JavaSourceClass;
 import org.openzen.zenscript.shared.StringUtils;
 
 /**
 			Expression value = scope.duplicable(target, statement.value);
 			ExpressionString valueString = scope.expression(target, value);
 			List<StatementFormattingSubBlock> blocks = new ArrayList<>();
-			String variantType = scope.type(statement.value.type);
+			
+			DefinitionTypeID variantType = (DefinitionTypeID)statement.value.type;
+			HighLevelDefinition variant = variantType.definition;
+			String variantTypeName = scope.type(variant.getTag(JavaSourceClass.class));
+			JavaSourceStatementScope innerScope = scope.createBlockScope(statement);
 			for (SwitchCase switchCase : statement.cases) {
 				VariantOptionSwitchValue switchValue = (VariantOptionSwitchValue)switchCase.value;
 				String header = switchValue == null ? "default:" : "case " + switchValue.option.getName() + ":";
 				List<String> statements = new ArrayList<>();
 				if (switchValue != null) {
-					for (VarStatement var : switchValue.parameters)
-						statements.add(scope.type(var.type) + " " + var.name + " = (" + variantType + "." + switchValue.option.getName() + ")" + valueString.value + ";");
+					for (VarStatement var : switchValue.parameters) {
+						StringBuilder statementOutput = new StringBuilder();
+						statementOutput.append(scope.type(var.type)).append(" ").append(var.name).append(" = ((").append(variantTypeName).append(".").append(switchValue.option.getName());
+						if (variant.genericParameters != null && variant.genericParameters.length > 0) {
+							statementOutput.append("<");
+							for (int i = 0; i < variantType.typeParameters.length; i++) {
+								if (i > 0)
+									statementOutput.append(", ");
+								statementOutput.append(scope.type(variantType.typeParameters[i]));
+							}
+							statementOutput.append(">");
+						}
+						statementOutput.append(")").append(valueString.value).append(").").append("value").append(";");
+						statements.add(statementOutput.toString());
+					}
 				}
 				blocks.add(new StatementFormattingSubBlock(header, statements, switchCase.statements));
 			}
 			String name = statement.loopVariables[0].name;
 			
 			if (statement.list instanceof RangeExpression) {
+				String limitName = "limitFor" + StringUtils.capitalize(name);
 				RangeExpression range = (RangeExpression)(statement.list);
-				target.writeLine("int limitFor = " + name + " = " + scope.expression(target, range.to) + ";");
+				target.writeLine("int " + limitName + " = " + scope.expression(target, range.to) + ";");
 				target.writeInner(
-						"for (int " + name + " = " + scope.expression(target, range.from) + "; " + name + " < limitFor" + name + "; " + name + "++)",
+						"for (int " + name + " = " + scope.expression(target, range.from) + "; " + name + " < " + limitName + "; " + name + "++)",
 						statement.content,
 						statement,
 						"");

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

  */
 package org.openzen.zenscript.javasource;
 
+import org.openzen.zenscript.codemodel.generic.GenericParameterBound;
+import org.openzen.zenscript.codemodel.generic.GenericParameterBoundVisitor;
+import org.openzen.zenscript.codemodel.generic.ParameterSuperBound;
+import org.openzen.zenscript.codemodel.generic.ParameterTypeBound;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.javasource.scope.JavaSourceFileScope;
 
 		if (parameters == null || parameters.length == 0)
 			return;
 		
+		TypeParameterBoundVisitor boundVisitor = new TypeParameterBoundVisitor(scope, output);
 		output.append("<");
 		for (int i = 0; i < parameters.length; i++) {
 			if (i > 0)
 			output.append(typeParameter.name);
 			
 			if (typeParameter.bounds.size() > 0) {
-				output.append(" ");
-				// TODO
+				for (GenericParameterBound bound : typeParameter.bounds)
+					bound.accept(boundVisitor);
 			}
 		}
 		output.append("> ");
 	}
+	
+	private static class TypeParameterBoundVisitor implements GenericParameterBoundVisitor<Void> {
+		private final JavaSourceFileScope scope;
+		private final StringBuilder output;
+		
+		public TypeParameterBoundVisitor(JavaSourceFileScope scope, StringBuilder output) {
+			this.scope = scope;
+			this.output = output;
+		}
+
+		@Override
+		public Void visitSuper(ParameterSuperBound bound) {
+			output.append(" super ").append(scope.type(bound.type));
+			return null;
+		}
+
+		@Override
+		public Void visitType(ParameterTypeBound bound) {
+			output.append(" extends ").append(scope.type(bound.type));
+			return null;
+		}
+	}
 }

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

 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.javasource.tags.JavaSourceClass;
 import org.openzen.zenscript.javasource.JavaSourceFile;
+import org.openzen.zenscript.javasource.tags.JavaSourceMethod;
 import org.openzen.zenscript.javasource.tags.JavaSourceVariantOption;
 
 /**
 
 	@Override
 	public Void visitFunction(FunctionDefinition definition) {
+		JavaSourceClass cls = new JavaSourceClass(file.getName(), definition.pkg.fullName + "." + file.getName());
+		definition.setTag(JavaSourceClass.class, cls);
+		JavaSourceMethod method = new JavaSourceMethod(cls, JavaSourceMethod.Kind.STATIC, definition.name);
+		definition.caller.setTag(JavaSourceMethod.class, method);
 		return null;
 	}
 

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

 	public final JavaSourceTypeVisitor typeVisitor;
 	public final JavaSourceObjectTypeVisitor objectTypeVisitor;
 	public final TypeScope semanticScope;
+	public final boolean isInterface;
 	
-	public JavaSourceFileScope(JavaSourceImporter importer, JavaSourceSyntheticTypeGenerator typeGenerator, JavaSourceSyntheticHelperGenerator helperGenerator, String className, TypeScope semanticScope) {
+	public JavaSourceFileScope(
+			JavaSourceImporter importer, 
+			JavaSourceSyntheticTypeGenerator typeGenerator,
+			JavaSourceSyntheticHelperGenerator helperGenerator,
+			String className,
+			TypeScope semanticScope,
+			boolean isInterface)
+	{
 		this.importer = importer;
 		this.typeGenerator = typeGenerator;
 		this.helperGenerator = helperGenerator;
 		this.className = className;
 		this.semanticScope = semanticScope;
+		this.isInterface = isInterface;
 		
 		typeVisitor = new JavaSourceTypeVisitor(importer, typeGenerator);
 		objectTypeVisitor = typeVisitor.objectTypeVisitor;

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

 	K_WHILE(true, "while"),
 	K_FOR(true, "for"),
 	K_THROW(true, "throw"),
+	K_PANIC(true, "panic"),
 	K_LOCK(true, "lock"),
 	K_TRY(true, "try"),
 	K_CATCH(true, "catch"),

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

 				ParsedExpression value = parse(parser);
 				return new ParsedThrowExpression(position, value);
 			}
+			case K_PANIC: {
+				parser.next();
+				ParsedExpression value = parse(parser);
+				return new ParsedPanicExpression(position, value);
+			}
 			case K_MATCH: {
 				parser.next();
 				ParsedExpression source = parse(parser);

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

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.OperatorType;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
+import org.openzen.zenscript.codemodel.expression.ConstructorSuperCallExpression;
 import org.openzen.zenscript.codemodel.expression.ConstructorThisCallExpression;
 import org.openzen.zenscript.codemodel.expression.VariantValueExpression;
 import org.openzen.zenscript.codemodel.expression.switchvalue.SwitchValue;
 			if (!member.isConstructor())
 				throw new CompileException(position, CompileExceptionCode.INTERNAL_ERROR, "Constructor is not a constructor!");
 			
-			return new ConstructorThisCallExpression(position, scope.getThisType().getSuperType(), member, callArguments, scope);
+			return new ConstructorSuperCallExpression(position, scope.getThisType().getSuperType(), member, callArguments, scope);
 		} else if (receiver instanceof ParsedExpressionThis) {
 			// this call (intended as first call in constructor)
 			ITypeID targetType = scope.getThisType();

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedPanicExpression.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.parser.expression;
+
+import org.openzen.zenscript.codemodel.expression.PanicExpression;
+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.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ParsedPanicExpression extends ParsedExpression {
+	public final ParsedExpression value;
+	
+	public ParsedPanicExpression(CodePosition position, ParsedExpression value) {
+		super(position);
+		
+		this.value = value;
+	}
+	
+	@Override
+	public IPartialExpression compile(ExpressionScope scope) {
+		return new PanicExpression(position, scope.getResultTypeHints().isEmpty() ? BasicTypeID.VOID : scope.getResultTypeHints().get(0), value.compile(scope).eval());
+	}
+
+	@Override
+	public boolean hasStrongType() {
+		return true;
+	}
+}

Shared/src/main/java/org/openzen/zenscript/shared/StringUtils.java

 				case '"':
 					if (quote == '"')
 						output.append("\\\"");
+					else
+						output.append('"');
 					break;
 				case '\'':
 					if (quote == '\'')
 						output.append("\\\'");
+					else
+						output.append("'");
 					break;
 				case '\n': output.append("\\n"); break;
 				case '\r': output.append("\\r"); break;

Validator/src/main/java/org/openzen/zenscript/validator/ValidationLogEntry.java

 		SETTING_FINAL_FIELD,
 		SETTING_FINAL_VARIABLE,
 		INVALID_SUPERTYPE,
-		MULTIPLE_DESTRUCTORS
+		MULTIPLE_DESTRUCTORS,
+		PANIC_ARGUMENT_NO_STRING
 	}
 }

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

 import org.openzen.zenscript.codemodel.expression.NewExpression;
 import org.openzen.zenscript.codemodel.expression.NullExpression;
 import org.openzen.zenscript.codemodel.expression.OrOrExpression;
+import org.openzen.zenscript.codemodel.expression.PanicExpression;
 import org.openzen.zenscript.codemodel.expression.PostCallExpression;
 import org.openzen.zenscript.codemodel.expression.RangeExpression;
 import org.openzen.zenscript.codemodel.expression.SameObjectExpression;
 		return null;
 	}
 	
+	@Override
+	public Void visitPanic(PanicExpression expression) {
+		expression.value.accept(this);
+		if (expression.type != BasicTypeID.STRING)
+			validator.logError(ValidationLogEntry.Code.PANIC_ARGUMENT_NO_STRING, expression.position, "Argument to a panic must be a string");
+		return null;
+	}
+	
 	@Override
 	public Void visitPostCall(PostCallExpression expression) {
 		expression.target.accept(this);