More work on Java

- Variable and parameter names should in most cases be stored in the generated code, toggleable with a boolean in JavaWriter
- TryCatch should work, except for returns or jumps outside the block as no finally's will be applied then, also, didnt yet start with Try with resources
- Started with classes, constructors, fields and methods

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

 	public <T> T getTag(Class<T> tag);
 	
 	public <T> void setTag(Class<T> tag, T value);
+
+	boolean hasTag(Class<?> tag);
 }

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

 import org.openzen.zenscript.codemodel.member.DefinitionMember;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import static org.openzen.zenscript.codemodel.type.member.BuiltinTypeMembers.*;
+
+import org.openzen.zenscript.javabytecode.compiler.classes_structs.JavaDefinitionVisitor;
 import org.openzen.zenscript.javabytecode.compiler.JavaStatementVisitor;
 import org.openzen.zenscript.javabytecode.compiler.JavaWriter;
 import org.openzen.zenscript.shared.SourceFile;
 	
 	public void addDefinition(HighLevelDefinition definition) {
 		// convert definition into java class
+		target.register(definition.name, definition.accept(new JavaDefinitionVisitor()));
+
 	}
 	
 	public void addScriptBlock(ScriptBlock script) {
 		for (Statement statement : script.statements) {
 			statement.accept(statementVisitor);
 		}
+		target.register("Scripts", scriptsClassWriter.toByteArray());
 		statementVisitor.end();
 	}
 	

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

 package org.openzen.zenscript.javabytecode;
 
+import org.objectweb.asm.Label;
 import org.objectweb.asm.Type;
 
 public class JavaLocalVariableInfo {
     public final Type type;
     public final int local;
+    public final Label start;
+    public final String name;
+    public Label end;
 
-    public JavaLocalVariableInfo(Type type, int local) {
+    public JavaLocalVariableInfo(Type type, int local, Label start, String name) {
         this.type = type;
         this.local = local;
+        this.start = start;
+        this.end = start;
+        this.name = name;
     }
 }

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

 package org.openzen.zenscript.javabytecode.compiler;
 
-import com.sun.javafx.image.IntPixelGetter;
+import org.objectweb.asm.Label;
 import org.objectweb.asm.Type;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.objectweb.asm.Type;
 import org.openzen.zenscript.codemodel.expression.*;
 import org.openzen.zenscript.codemodel.member.DefinitionMember;
+import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.implementations.IntRange;
 import org.openzen.zenscript.javabytecode.JavaBytecodeImplementation;
 import org.openzen.zenscript.javabytecode.JavaFieldInfo;
 
     @Override
     public Void visitCapturedParameter(CapturedParameterExpression expression) {
+
         return null;
     }
 
 
     @Override
     public Void visitGetField(GetFieldExpression expression) {
-        if (!checkAndGetFieldInfo(expression.field))
+        javaWriter.loadObject(0);
+        if (!checkAndGetFieldInfo(expression.field, false))
             throw new IllegalStateException("Missing field info on a field member!");
         return null;
     }
 
     @Override
     public Void visitGetFunctionParameter(GetFunctionParameterExpression expression) {
+        javaWriter.load(Type.getType(expression.parameter.type.accept(JavaTypeClassVisitor.INSTANCE)), expression.parameter.index + 1);
         return null;
     }
 
     @Override
     public Void visitGetLocalVariable(GetLocalVariableExpression expression) {
+        final Label label = new Label();
         final JavaLocalVariableInfo tag = expression.variable.getTag(JavaLocalVariableInfo.class);
+        tag.end = label;
         javaWriter.load(tag.type, tag.local);
+        javaWriter.label(label);
         return null;
     }
 
     @Override
     public Void visitGetStaticField(GetStaticFieldExpression expression) {
-        if (!checkAndGetFieldInfo(expression.field))
+        if (!checkAndGetFieldInfo(expression.field, true))
             throw new IllegalStateException("Missing field info on a field member!");
         return null;
     }
     }
 
     @Override
-    public Void visitMakeConst(MakeConstExpression expression)
-    {
+    public Void visitMakeConst(MakeConstExpression expression) {
 
         return null;
     }
 
     @Override
     public Void visitNew(NewExpression expression) {
-        String type = Type.getDescriptor(expression.type.accept(JavaTypeClassVisitor.INSTANCE));
+        final String type;
+        if(expression.type instanceof DefinitionTypeID)
+            type = ((DefinitionTypeID) expression.type).definition.name;
+        else
+            type = Type.getDescriptor(expression.type.accept(JavaTypeClassVisitor.INSTANCE));
+
         javaWriter.newObject(type);
         javaWriter.dup();
         StringBuilder signatureBuilder = new StringBuilder("(");
 
     @Override
     public Void visitRange(RangeExpression expression) {
-        if(expression.from.type.accept(JavaTypeClassVisitor.INSTANCE) != int.class)
+        if (expression.from.type.accept(JavaTypeClassVisitor.INSTANCE) != int.class)
             throw new CompileException(expression.position, CompileExceptionCode.INTERNAL_ERROR, "Only integer ranges supported");
         javaWriter.newObject(IntRange.class);
         javaWriter.dup();
 
     @Override
     public Void visitSetField(SetFieldExpression expression) {
+        javaWriter.loadObject(0);
         if (expression.field.isFinal)
             throw new CompileException(expression.position, CompileExceptionCode.CANNOT_SET_FINAL_VARIABLE, "Cannot set a final field!");
         expression.value.accept(this);
-        if (!checkAndPutFieldInfo(expression.field))
+        if (!checkAndPutFieldInfo(expression.field, false))
             throw new IllegalStateException("Missing field info on a field member!");
         return null;
     }
         if (expression.variable.isFinal)
             throw new CompileException(expression.position, CompileExceptionCode.CANNOT_SET_FINAL_VARIABLE, "Cannot set a final variable!");
         expression.value.accept(this);
+        Label label = new Label();
+        javaWriter.label(label);
         final JavaLocalVariableInfo tag = expression.variable.getTag(JavaLocalVariableInfo.class);
+        tag.end = label;
 
         javaWriter.store(tag.type, tag.local);
 
         if (expression.field.isFinal)
             throw new CompileException(expression.position, CompileExceptionCode.CANNOT_SET_FINAL_VARIABLE, "Cannot set a final field!");
         expression.value.accept(this);
-        if (!checkAndPutFieldInfo(expression.field))
+        if (!checkAndPutFieldInfo(expression.field, true))
             throw new IllegalStateException("Missing field info on a field member!");
         return null;
     }
     }
 
 
-    //TODO: Should isStatic go to the fieldInfo or stay here?
     //Will return true if a JavaFieldInfo.class tag exists, and will compile that tag
-    private boolean checkAndPutFieldInfo(DefinitionMember field) {
+    private boolean checkAndPutFieldInfo(DefinitionMember field, boolean isStatic) {
         JavaFieldInfo fieldInfo = field.getTag(JavaFieldInfo.class);
         if (fieldInfo == null)
             return false;
-        if (field.isStatic()) {
+        //TODO Remove isStatic
+        if (field.isStatic() || isStatic) {
             getJavaWriter().putStaticField(fieldInfo.javaClass.internalClassName, fieldInfo.name, fieldInfo.signature);
         } else {
             getJavaWriter().putField(fieldInfo.javaClass.internalClassName, fieldInfo.name, fieldInfo.signature);
         return true;
     }
 
-    private boolean checkAndGetFieldInfo(DefinitionMember field) {
+    private boolean checkAndGetFieldInfo(DefinitionMember field, boolean isStatic) {
         JavaFieldInfo fieldInfo = field.getTag(JavaFieldInfo.class);
         if (fieldInfo == null)
             return false;
-        if (field.isStatic()) {
+        //TODO Remove isStatic
+        if (field.isStatic() || isStatic) {
             getJavaWriter().getStaticField(fieldInfo.javaClass.internalClassName, fieldInfo.name, fieldInfo.signature);
         } else {
             getJavaWriter().getField(fieldInfo.javaClass.internalClassName, fieldInfo.name, fieldInfo.signature);

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

 
 import org.objectweb.asm.Label;
 import org.openzen.zenscript.codemodel.iterator.ForeachIteratorVisitor;
-import org.openzen.zenscript.codemodel.member.CustomIteratorMember;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;

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

 
 public class JavaStatementVisitor implements StatementVisitor<Void> {
     private final JavaWriter javaWriter;
-    private final JavaExpressionVisitor expressionVisitor;
+    public final JavaExpressionVisitor expressionVisitor;
 
     public JavaStatementVisitor(final JavaWriter javaWriter) {
         this.javaWriter = javaWriter;
         //Create local variables
         for (VarStatement variable : statement.loopVariables) {
             final Type type = Type.getType(variable.type.accept(JavaTypeClassVisitor.INSTANCE));
-            variable.setTag(JavaLocalVariableInfo.class, new JavaLocalVariableInfo(type, javaWriter.local(type)));
+            final Label variableStart = new Label();
+            final JavaLocalVariableInfo info = new JavaLocalVariableInfo(type, javaWriter.local(type), variableStart, variable.name);
+            info.end = end;
+            variable.setTag(JavaLocalVariableInfo.class, info);
+            javaWriter.addVariableInfo(info);
         }
 
         //javaWriter.label(min);
 
     @Override
     public Void visitTryCatch(TryCatchStatement statement) {
+        final Label tryCatchStart = new Label();
+        final Label tryFinish = new Label();
+        final Label tryCatchFinish = new Label();
+        final Label finallyStart = new Label();
+
+        javaWriter.label(tryCatchStart);
+        //TODO Check for returns or breaks out of the try-catch and inject finally block before them
+        statement.content.accept(this);
+        javaWriter.label(tryFinish);
+        if (statement.finallyClause != null)
+            statement.finallyClause.accept(this);
+        javaWriter.goTo(tryCatchFinish);
+
+        for (CatchClause catchClause : statement.catchClauses) {
+            final Label catchStart = new Label();
+            javaWriter.label(catchStart);
+
+            //final Type exceptionType = Type.getType(RuntimeException.class);
+            final Type exceptionType = Type.getType(catchClause.exceptionType.accept(JavaTypeClassVisitor.INSTANCE));
+            final int local = javaWriter.local(exceptionType);
+            javaWriter.store(exceptionType, local);
+
+            catchClause.content.accept(this);
+            final Label catchFinish = new Label();
+            javaWriter.label(catchFinish);
+
+            if (statement.finallyClause != null) {
+                statement.finallyClause.accept(this);
+                javaWriter.tryCatch(catchStart, catchFinish, finallyStart, null);
+            }
+
+            javaWriter.tryCatch(tryCatchStart, tryFinish, catchStart, exceptionType.getInternalName());
+            javaWriter.goTo(tryCatchFinish);
+        }
+
+        if (statement.finallyClause != null) {
+            javaWriter.label(finallyStart);
+            final int local = javaWriter.local(Object.class);
+            javaWriter.storeObject(local);
+            statement.finallyClause.accept(this);
+            javaWriter.loadObject(local);
+            javaWriter.aThrow();
+            javaWriter.tryCatch(tryCatchStart, tryFinish, finallyStart, null);
+        }
+        javaWriter.label(tryCatchFinish);
+
         return null;
     }
 
     @Override
     public Void visitVar(VarStatement statement) {
-        Type type = Type.getType(statement.type.accept(JavaTypeClassVisitor.INSTANCE));
+        Type type = statement.type.accept(JavaTypeVisitor.INSTANCE);
         int local = javaWriter.local(type);
         if (statement.initializer != null) {
             statement.initializer.accept(expressionVisitor);
             javaWriter.store(type, local);
         }
-        statement.setTag(JavaLocalVariableInfo.class, new JavaLocalVariableInfo(type, local));
+        final Label variableStart = new Label();
+        javaWriter.label(variableStart);
+        final JavaLocalVariableInfo info = new JavaLocalVariableInfo(type, local, variableStart, statement.name);
+        statement.setTag(JavaLocalVariableInfo.class, info);
+        javaWriter.addVariableInfo(info);
         return null;
     }
 

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

+package org.openzen.zenscript.javabytecode.compiler;
+
+import org.objectweb.asm.Type;
+import org.openzen.zenscript.codemodel.type.*;
+
+public class JavaTypeVisitor implements ITypeVisitor<Type> {
+    public static final JavaTypeVisitor INSTANCE = new JavaTypeVisitor();
+
+    @Override
+    public Type visitBasic(BasicTypeID basic) {
+        return Type.getType(basic.accept(JavaTypeClassVisitor.INSTANCE));
+    }
+
+    @Override
+    public Type visitArray(ArrayTypeID array) {
+        return Type.getType(array.accept(JavaTypeClassVisitor.INSTANCE));
+    }
+
+    @Override
+    public Type visitAssoc(AssocTypeID assoc) {
+        return Type.getType(assoc.accept(JavaTypeClassVisitor.INSTANCE));
+    }
+
+    @Override
+    public Type visitIterator(IteratorTypeID iterator) {
+        return Type.getType(iterator.accept(JavaTypeClassVisitor.INSTANCE));
+    }
+
+    @Override
+    public Type visitFunction(FunctionTypeID function) {
+        return Type.getType(function.accept(JavaTypeClassVisitor.INSTANCE));
+    }
+
+    @Override
+    public Type visitDefinition(DefinitionTypeID definition) {
+        return Type.getType("L" + definition + ";");
+    }
+
+    @Override
+    public Type visitGeneric(GenericTypeID generic) {
+        return Type.getType(generic.accept(JavaTypeClassVisitor.INSTANCE));
+    }
+
+    @Override
+    public Type visitRange(RangeTypeID range) {
+        return Type.getType(range.accept(JavaTypeClassVisitor.INSTANCE));
+    }
+
+    @Override
+    public Type visitConst(ConstTypeID type) {
+        return Type.getType(type.accept(JavaTypeClassVisitor.INSTANCE));
+    }
+
+    @Override
+    public Type visitOptional(OptionalTypeID optional) {
+        return Type.getType(optional.accept(JavaTypeClassVisitor.INSTANCE));
+    }
+}

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/classes_structs/JavaDefinitionVisitor.java

+package org.openzen.zenscript.javabytecode.compiler.classes_structs;
+
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+import org.openzen.zenscript.codemodel.definition.*;
+import org.openzen.zenscript.codemodel.member.ConstructorMember;
+import org.openzen.zenscript.codemodel.member.FieldMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.javabytecode.JavaClassInfo;
+import org.openzen.zenscript.javabytecode.JavaFieldInfo;
+import org.openzen.zenscript.javabytecode.compiler.JavaTypeClassVisitor;
+
+public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
+
+
+    @Override
+    public byte[] visitClass(ClassDefinition definition) {
+
+
+        Type superType;
+        if (definition.superType == null)
+            superType = Type.getType(Object.class);
+        else
+            superType = Type.getType(definition.superType.accept(JavaTypeClassVisitor.INSTANCE));
+
+        ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
+        String signature = null;
+        /* TODO: Calculate signature from generic parameters
+        if(!definition.genericParameters.isEmpty()) {
+            StringBuilder signatureBuilder = new StringBuilder();
+            for (TypeParameter genericParameter : definition.genericParameters) {
+
+            }
+        }
+        */
+
+
+        for (IDefinitionMember member : definition.members) {
+            if (member instanceof ConstructorMember) {
+                for (IDefinitionMember member2 : definition.members) {
+                    if (member2 instanceof FieldMember) {
+                        if (!member2.hasTag(JavaClassInfo.class))
+                            member2.setTag(JavaFieldInfo.class, new JavaFieldInfo(new JavaClassInfo(definition.name), ((FieldMember) member2).name, Type.getDescriptor(((FieldMember) member2).type.accept(JavaTypeClassVisitor.INSTANCE))));
+                        if (!member.hasTag(JavaInitializedVariables.class))
+                            member.setTag(JavaInitializedVariables.class, new JavaInitializedVariables(definition.name));
+                        member.getTag(JavaInitializedVariables.class).fields.add((FieldMember) member2);
+
+
+                    }
+                }
+            }
+        }
+
+        writer.visit(Opcodes.V1_8, definition.modifiers, definition.name, signature, superType.getInternalName(), null);
+        for (IDefinitionMember member : definition.members) {
+            member.accept(new JavaMemberVisitor(writer, definition.name));
+        }
+
+
+        writer.visitEnd();
+        return writer.toByteArray();
+    }
+
+    @Override
+    public byte[] visitInterface(InterfaceDefinition definition) {
+        return null;
+    }
+
+    @Override
+    public byte[] visitEnum(EnumDefinition definition) {
+        return null;
+    }
+
+    @Override
+    public byte[] visitStruct(StructDefinition definition) {
+        return null;
+    }
+
+    @Override
+    public byte[] visitFunction(FunctionDefinition definition) {
+        return null;
+    }
+
+    @Override
+    public byte[] visitExpansion(ExpansionDefinition definition) {
+        return null;
+    }
+
+    @Override
+    public byte[] visitAlias(AliasDefinition definition) {
+        return null;
+    }
+}

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/classes_structs/JavaInitializedVariables.java

+package org.openzen.zenscript.javabytecode.compiler.classes_structs;
+
+import org.openzen.zenscript.codemodel.member.FieldMember;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class JavaInitializedVariables {
+    public final List<FieldMember> fields;
+    public final String owner;
+
+    public JavaInitializedVariables(String owner) {
+        this.owner = owner;
+        fields = new ArrayList<>();
+    }
+
+    public JavaInitializedVariables(List<FieldMember> fields, String owner) {
+        this.fields = fields;
+        this.owner = owner;
+    }
+}

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/classes_structs/JavaMemberVisitor.java

+package org.openzen.zenscript.javabytecode.compiler.classes_structs;
+
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Label;
+import org.objectweb.asm.Type;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.member.*;
+import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.javabytecode.JavaClassInfo;
+import org.openzen.zenscript.javabytecode.JavaMethodInfo;
+import org.openzen.zenscript.javabytecode.compiler.JavaStatementVisitor;
+import org.openzen.zenscript.javabytecode.compiler.JavaTypeClassVisitor;
+import org.openzen.zenscript.javabytecode.compiler.JavaTypeVisitor;
+import org.openzen.zenscript.javabytecode.compiler.JavaWriter;
+
+public class JavaMemberVisitor implements MemberVisitor<Void> {
+
+    private final ClassWriter writer;
+    private final String className;
+
+    public JavaMemberVisitor(ClassWriter writer, String className) {
+        this.writer = writer;
+        this.className = className;
+    }
+
+    @Override
+    public Void visitField(FieldMember member) {
+
+        //TODO calc signature
+        String signature = null;
+        int modifier = member.modifiers;
+        if(member.isFinal)
+            modifier |= Modifiers.MODIFIER_FINAL;
+        writer.visitField(modifier, member.name, Type.getDescriptor(member.type.accept(JavaTypeClassVisitor.INSTANCE)), signature, null).visitEnd();
+        return null;
+    }
+
+    @Override
+    public Void visitConstructor(ConstructorMember member) {
+        final Label constructorStart = new Label();
+        final Label constructorEnd = new Label();
+        final JavaWriter constructorWriter = new JavaWriter(writer, member.modifiers, "<init>", calcDesc(member.header), calcSign(member.header), null);
+        constructorWriter.label(constructorStart);
+        for (FunctionParameter parameter : member.header.parameters) {
+            constructorWriter.nameVariable(parameter.index + 1, parameter.name, constructorStart, constructorEnd, Type.getType(parameter.type.accept(JavaTypeClassVisitor.INSTANCE)));
+        }
+        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(constructorWriter);
+        statementVisitor.start();
+
+        //TODO super constructor
+        constructorWriter.loadObject(0);
+        constructorWriter.invokeSpecial("java/lang/Object", "<init>", "()V");
+
+        if (member.hasTag(JavaInitializedVariables.class)) {
+            final JavaInitializedVariables tag = member.getTag(JavaInitializedVariables.class);
+            for (final FieldMember field : tag.fields) {
+                constructorWriter.loadObject(0);
+                field.initializer.accept(statementVisitor.expressionVisitor);
+                statementVisitor.getJavaWriter().putField(tag.owner, field.name, Type.getDescriptor(field.type.accept(JavaTypeClassVisitor.INSTANCE)));
+            }
+        }
+
+        for (Statement statement : member.body) {
+            statement.accept(statementVisitor);
+        }
+        constructorWriter.label(constructorEnd);
+        statementVisitor.end();
+        return null;
+    }
+
+    @Override
+    public Void visitMethod(MethodMember member) {
+        final Label methodStart = new Label();
+        final Label methodEnd = new Label();
+        final JavaWriter methodWriter = new JavaWriter(writer, member.modifiers, member.name, calcDesc(member.header), calcSign(member.header), null);
+        methodWriter.label(methodStart);
+        for (final FunctionParameter parameter : member.header.parameters) {
+            methodWriter.nameParameter(0, parameter.name);
+            methodWriter.nameVariable(parameter.index + (member.isStatic() ? 0 : 1), parameter.name, methodStart, methodEnd, Type.getType(parameter.type.accept(JavaTypeClassVisitor.INSTANCE)));
+        }
+
+        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(methodWriter);
+        statementVisitor.start();
+
+        for (Statement statement : member.body) {
+            statement.accept(statementVisitor);
+        }
+
+        methodWriter.label(methodEnd);
+        statementVisitor.end();
+        member.setTag(JavaMethodInfo.class, new JavaMethodInfo(new JavaClassInfo(className), member.name, calcSign(member.header), member.isStatic()));
+
+        return null;
+    }
+
+    @Override
+    public Void visitGetter(GetterMember member) {
+        return null;
+    }
+
+    @Override
+    public Void visitSetter(SetterMember member) {
+        return null;
+    }
+
+    @Override
+    public Void visitEnumConstant(EnumConstantMember member) {
+        return null;
+    }
+
+    @Override
+    public Void visitOperator(OperatorMember member) {
+        return null;
+    }
+
+    @Override
+    public Void visitCaster(CasterMember member) {
+        return null;
+    }
+
+    @Override
+    public Void visitCustomIterator(CustomIteratorMember member) {
+        return null;
+    }
+
+    @Override
+    public Void visitCaller(CallerMember member) {
+        return null;
+    }
+
+    @Override
+    public Void visitImplementation(ImplementationMember member) {
+        return null;
+    }
+
+    @Override
+    public Void visitInnerDefinition(InnerDefinitionMember member) {
+        return null;
+    }
+
+    private String calcDesc(FunctionHeader header) {
+        StringBuilder descBuilder = new StringBuilder("(");
+        for (FunctionParameter parameter : header.parameters) {
+            descBuilder.append(Type.getDescriptor(parameter.type.accept(JavaTypeClassVisitor.INSTANCE)));
+        }
+        descBuilder.append(")");
+        descBuilder.append(Type.getDescriptor(header.returnType.accept(JavaTypeClassVisitor.INSTANCE)));
+        return descBuilder.toString();
+    }
+
+    private String calcSign(FunctionHeader header) {
+        StringBuilder signatureBuilder = new StringBuilder("(");
+        for (FunctionParameter parameter : header.parameters) {
+            signatureBuilder.append(parameter.type.accept(JavaTypeVisitor.INSTANCE).getDescriptor());
+        }
+        signatureBuilder.append(")").append(header.returnType.accept(JavaTypeVisitor.INSTANCE).getDescriptor());
+        return signatureBuilder.toString();
+    }
+}

ScriptingExample/scripts/classes.zs

+public class myTestClass {
+
+	var nonFinalInt as int = 10;
+	val finalInt as int = 20;
+
+	public this() {
+
+	}
+
+	public this(nonfinalInt as int) {
+		this.nonFinalInt = nonfinalInt;
+		println(nonfinalInt);
+	}
+
+	public test() as string {
+		return "TEST";
+	}
+}
+
+
+
+val tt = new myTestClass(666);
+println(tt.test());

ScriptingExample/scripts/moreHellos.zs

     } while true;
 }
 
-var test = ["1", "2", "3"];
+var testArray = ["1", "2", "3"];
 
-for item in test {
+for item in testArray {
 	println("test");
 	println(item);
 }
 	println(item + i);
 }
 
-for i in 10 .. 20 {
-	println(i);
+for myI in 10 .. 20 {
+	println(myI);
 }
 
 var lateInit as string;
 lateInit = "initialized later";
-println(lateInit);
+println(lateInit);
+
+
+
+
+
+/*
+catch e as string {
+	println("noLuv");
+}
+*/

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

     public <T> T get(Class<T> cls) {
         return (T) tags.get(cls);
     }
+
+    public boolean hasTag(Class<?> cls) {
+        return tags.containsKey(cls);
+    }
 }

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

 	public final <T> T getTag(Class<T> cls) {
 		return tags.get(cls);
 	}
+
+	public final boolean hasTag(Class<?> cls) {
+		return tags.hasTag(cls);
+	}
 }