- Changed the way static is determined in an expression writer

- Minor code improvements; make better use of JavaMethodInfo

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

  */
 package org.openzen.zenscript.javabytecode;
 
-import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
 
 import org.objectweb.asm.ClassWriter;
 		implement(INT_TO_FLOAT, JavaWriter::i2f);
 		implement(INT_TO_DOUBLE, JavaWriter::i2d);
 		implement(INT_TO_CHAR, JavaWriter::i2s);
-		INT_TO_STRING.setTag(JavaMethodInfo.class, new JavaMethodInfo(jInteger, "toString", "(I)Ljava/lang/String;", true));
+		INT_TO_STRING.setTag(JavaMethodInfo.class, new JavaMethodInfo(jInteger, "toString", "(I)Ljava/lang/String;", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC));
 		
 		implement(LONG_TO_BYTE, writer -> { writer.l2i(); writer.i2b(); });
 		implement(LONG_TO_SBYTE, writer -> { writer.l2i(); writer.i2b(); });
 		implement(LONG_TO_FLOAT, JavaWriter::l2f);
 		implement(LONG_TO_DOUBLE, JavaWriter::l2d);
 		implement(LONG_TO_CHAR, writer -> { writer.l2i(); writer.i2s(); });
-		LONG_TO_STRING.setTag(JavaMethodInfo.class, new JavaMethodInfo(jLong, "toString", "(J)Ljava/lang/String;", true));
+		LONG_TO_STRING.setTag(JavaMethodInfo.class, new JavaMethodInfo(jLong, "toString", "(J)Ljava/lang/String;", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC));
 		
-		FLOAT_BITS.setTag(JavaMethodInfo.class, new JavaMethodInfo(jFloat, "floatToRawIntBits", "(F)I", true));
-		DOUBLE_BITS.setTag(JavaMethodInfo.class, new JavaMethodInfo(jDouble, "doubleToRawLongBits", "(D)J", true));
-		FLOAT_FROMBITS.setTag(JavaMethodInfo.class, new JavaMethodInfo(jFloat, "intBitsToFloat", "(I)F", true));
-		DOUBLE_FROMBITS.setTag(JavaMethodInfo.class, new JavaMethodInfo(jDouble, "longBitsToDouble", "(J)D", true));
+		FLOAT_BITS.setTag(JavaMethodInfo.class, new JavaMethodInfo(jFloat, "floatToRawIntBits", "(F)I", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC));
+		DOUBLE_BITS.setTag(JavaMethodInfo.class, new JavaMethodInfo(jDouble, "doubleToRawLongBits", "(D)J", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC));
+		FLOAT_FROMBITS.setTag(JavaMethodInfo.class, new JavaMethodInfo(jFloat, "intBitsToFloat", "(I)F", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC));
+		DOUBLE_FROMBITS.setTag(JavaMethodInfo.class, new JavaMethodInfo(jDouble, "longBitsToDouble", "(J)D", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC));
 	}
 	
 	private static void implement(DefinitionMember member, JavaBytecodeImplementation implementation) {
 		// (TODO: can we break very long scripts into smaller methods? for the extreme scripts)
 		final JavaClassWriter visitor = scriptBlocks.get(methodName);
 		visitor.hasRun = true;
-		final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(new JavaWriter(visitor, Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "run", "()V", null, null));
+		JavaMethodInfo method = new JavaMethodInfo(new JavaClassInfo(methodName), "run", "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
+		final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(new JavaWriter(visitor, method, null, null));
 		statementVisitor.start();
 		for (Statement statement : script.statements) {
 			statement.accept(statementVisitor);
 			throw new IllegalStateException("Already finished!");
 		finished = true;
 		
-		final JavaWriter runWriter = new JavaWriter(scriptsClassWriter, Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "run", "()V", null, null);
+		JavaMethodInfo runMethod = new JavaMethodInfo(new JavaClassInfo("Scripts"), "run", "()V", Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC);
+		final JavaWriter runWriter = new JavaWriter(scriptsClassWriter, runMethod, null, null);
 		runWriter.start();
 		for (Map.Entry<String, JavaClassWriter> entry : scriptBlocks.entrySet()) {
 			final String owner = entry.getKey();

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

  */
 package org.openzen.zenscript.javabytecode;
 
+import org.objectweb.asm.Opcodes;
+
 /**
  *
  * @author Hoofdgebruiker
 public class JavaMethodInfo {
 	public final JavaClassInfo javaClass;
 	public final String name;
-	public final String signature;
-	public final boolean isStatic;
-	
-	public JavaMethodInfo(JavaClassInfo javaClass, String name, String signature) {
-		this(javaClass, name, signature, false);
-	}
+	public final String descriptor;
+	public final int modifiers;
 	
-	public JavaMethodInfo(JavaClassInfo javaClass, String name, String signature, boolean isStatic) {
+	public JavaMethodInfo(JavaClassInfo javaClass, String name, String signature, int modifiers) {
 		this.javaClass = javaClass;
 		this.name = name;
-		this.signature = signature;
-		this.isStatic = isStatic;
+		this.descriptor = signature;
+		this.modifiers = modifiers;
+	}
+	
+	public boolean isStatic() {
+		return (modifiers & Opcodes.ACC_STATIC) > 0;
 	}
 }

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

 
 public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
     private final JavaWriter javaWriter;
-    private final boolean isInit;
-
-
-    public JavaExpressionVisitor(final JavaWriter javaWriter) {
-        this(javaWriter, false);
-    }
-
-    public JavaExpressionVisitor(JavaWriter javaWriter, boolean isInit) {
+	
+    public JavaExpressionVisitor(JavaWriter javaWriter) {
         this.javaWriter = javaWriter;
-        this.isInit = isInit;
     }
 
     private static Class<?> getForEquals(ITypeID id) {
         }
         //TODO: Test with actual static method
         final JavaMethodInfo info = expression.member.getTag(JavaMethodInfo.class);
-        javaWriter.invokeStatic(info.javaClass.internalClassName, info.name, info.signature);
+        javaWriter.invokeStatic(info.javaClass.internalClassName, info.name, info.descriptor);
         return null;
     }
 
     @Override
     public Void visitSetField(SetFieldExpression expression) {
         javaWriter.loadObject(0);
-        if (expression.field.isFinal() && !isInit)
-            throw new CompileException(expression.position, CompileExceptionCode.CANNOT_SET_FINAL_VARIABLE, "Cannot set a final field!");
         expression.value.accept(this);
         if (!checkAndPutFieldInfo(expression.field, false))
             throw new IllegalStateException("Missing field info on a field member!");
 
     @Override
     public Void visitSetFunctionParameter(SetFunctionParameterExpression expression) {
-        //TODO is static?
-        final boolean isStatic = false;
         expression.value.accept(this);
-        javaWriter.store(expression.type.accept(JavaTypeVisitor.INSTANCE), isStatic ? expression.parameter.index : expression.parameter.index + 1);
+        javaWriter.store(expression.type.accept(JavaTypeVisitor.INSTANCE), javaWriter.method.isStatic() ? expression.parameter.index : expression.parameter.index + 1);
         return null;
     }
 
     @Override
     public Void visitSetLocalVariable(SetLocalVariableExpression expression) {
-        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);
         JavaMethodInfo methodInfo = member.getTag(JavaMethodInfo.class);
         if (methodInfo == null)
             return false;
-        if (methodInfo.isStatic) {
-            getJavaWriter().invokeStatic(
-                    methodInfo.javaClass.internalClassName,
+        if (methodInfo.isStatic()) {
+            getJavaWriter().invokeStatic(methodInfo.javaClass.internalClassName,
                     methodInfo.name,
-                    methodInfo.signature);
+                    methodInfo.descriptor);
         } else {
-            getJavaWriter().invokeVirtual(
-                    methodInfo.javaClass.internalClassName,
+            getJavaWriter().invokeVirtual(methodInfo.javaClass.internalClassName,
                     methodInfo.name,
-                    methodInfo.signature);
+                    methodInfo.descriptor);
         }
         return true;
     }

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

 public class JavaStatementVisitor implements StatementVisitor<Void> {
     private final JavaWriter javaWriter;
     public final JavaExpressionVisitor expressionVisitor;
-    private final boolean isInit;
-
-    public JavaStatementVisitor(final JavaWriter javaWriter) {
-        this(javaWriter, false);
-    }
-
+	
     /**
      * @param javaWriter the method writer that compiles the statement
-     * @param isInit is the method a class initializer
      */
-    public JavaStatementVisitor(JavaWriter javaWriter, boolean isInit) {
+    public JavaStatementVisitor(JavaWriter javaWriter) {
         this.javaWriter = javaWriter;
-        this.expressionVisitor = new JavaExpressionVisitor(javaWriter, isInit);
-        this.isInit = isInit;
+        this.expressionVisitor = new JavaExpressionVisitor(javaWriter);
     }
 
     @Override

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

 import java.util.Map;
 
 import static org.objectweb.asm.Opcodes.*;
+import org.openzen.zenscript.javabytecode.JavaMethodInfo;
 
 public class JavaWriter {
+	public final JavaMethodInfo method;
+	
     private final LocalVariablesSorter visitor;
     private final List<JavaLocalVariableInfo> localVariableInfos = new ArrayList<>();
     private boolean debug = false;
     private int labelIndex = 1;
     private Map<Label, String> labelNames = new HashMap<>();
 
-    public JavaWriter(ClassVisitor visitor, boolean nameVariables, int access, String name, String description, String signature, String[] exceptions, String... annotations) {
-        final MethodVisitor methodVisitor = visitor.visitMethod(access, name, description, signature, exceptions);
+    public JavaWriter(ClassVisitor visitor, boolean nameVariables, JavaMethodInfo method, String signature, String[] exceptions, String... annotations) {
+		this.method = method;
+		
+        final MethodVisitor methodVisitor = visitor.visitMethod(method.modifiers, method.name, method.descriptor, signature, exceptions);
 
         for (String annotation : annotations) {
             methodVisitor.visitAnnotation(annotation, true).visitEnd();
         }
 
-        this.visitor = new LocalVariablesSorter(access, description, methodVisitor);
+        this.visitor = new LocalVariablesSorter(method.modifiers, method.descriptor, methodVisitor);
         this.nameVariables = nameVariables;
     }
 
-    public JavaWriter(ClassVisitor visitor, int access, String name, String description, String signature, String[] exceptions, String... annotations) {
-        this(visitor, true, access, name, description, signature, exceptions, annotations);
+    public JavaWriter(ClassVisitor visitor, JavaMethodInfo method, String signature, String[] exceptions, String... annotations) {
+        this(visitor, true, method, signature, exceptions, annotations);
     }
 
     private static String signature(Class aClass) {

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

 import org.openzen.zenscript.codemodel.definition.*;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ExpressionVisitor;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.javabytecode.JavaClassInfo;
 import org.openzen.zenscript.javabytecode.JavaEnumInfo;
 import org.openzen.zenscript.javabytecode.JavaMethodInfo;
-import org.openzen.zenscript.javabytecode.TestIsStaticInfo;
 import org.openzen.zenscript.javabytecode.compiler.*;
 
 import java.util.Iterator;
         else
             superType = Type.getType(definition.superType.accept(JavaTypeClassVisitor.INSTANCE));
 
+		JavaClassInfo toClass = new JavaClassInfo(definition.name);
         JavaClassWriter writer = new JavaClassWriter(ClassWriter.COMPUTE_FRAMES);
 
         //TODO: Calculate signature from generic parameters
         for (IDefinitionMember member : definition.members) {
             if (member instanceof ConstructorMember) {
                 final ConstructorMember constructorMember = (ConstructorMember) member;
-
-
                 constructorMember.body.add(0, new ExpressionStatement(constructorMember.position, new Expression(constructorMember.position, BasicTypeID.VOID) {
                     @Override
                     public <T> T accept(ExpressionVisitor<T> visitor) {
                     }
                 }));
             }
-            member.accept(new JavaMemberVisitor(writer, definition.name));
-
-
+			
+            member.accept(new JavaMemberVisitor(writer, toClass));
         }
         writer.visitEnd();
         return writer.toByteArray();
 
     @Override
     public byte[] visitInterface(InterfaceDefinition definition) {
+		JavaClassInfo toClass = new JavaClassInfo(definition.name);
         ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
 
         //TODO: Calculate signature from generic parameters
         String signature = null;
         writer.visit(Opcodes.V1_8, definition.modifiers | Opcodes.ACC_INTERFACE | Opcodes.ACC_ABSTRACT, definition.name, signature, Type.getInternalName(Object.class), null);
         for (IDefinitionMember member : definition.members) {
-            member.accept(new JavaMemberVisitor(writer, definition.name));
+            member.accept(new JavaMemberVisitor(writer, toClass));
         }
         writer.visitEnd();
         return writer.toByteArray();
             }
         }
 
-        final JavaWriter clinitWriter = new JavaWriter(writer, true, Opcodes.ACC_STATIC, "<clinit>", "()V", null, null);
-        final JavaStatementVisitor clinitVisitor = new JavaStatementVisitor(clinitWriter, true);
+		JavaClassInfo toClass = new JavaClassInfo(definition.name);
+		JavaMethodInfo clinitInfo = new JavaMethodInfo(toClass, "<clinit>", "()V", Opcodes.ACC_STATIC);
+        final JavaWriter clinitWriter = new JavaWriter(writer, clinitInfo, null, null);
+        final JavaStatementVisitor clinitVisitor = new JavaStatementVisitor(clinitWriter);
         clinitVisitor.start();
         int constantCount = 0;
         for (IDefinitionMember member : definition.members) {
                 ++constantCount;
                 member.setTag(JavaEnumInfo.class, new JavaEnumInfo(clinitVisitor));
             }
-            member.accept(new JavaMemberVisitor(writer, definition.name));
+            member.accept(new JavaMemberVisitor(writer, toClass));
         }
 
         clinitWriter.constant(constantCount);
         //Enum Stuff(required!)
         writer.visitField(Opcodes.ACC_STATIC | Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL | Opcodes.ACC_SYNTHETIC, "$VALUES", "[L" + definition.name + ";", null, null).visitEnd();
 
-        JavaWriter valuesWriter = new JavaWriter(writer, true, Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC, "values", "()[L" + definition.name + ";", null, null);
+		JavaMethodInfo valuesMethodInfo = new JavaMethodInfo(toClass, "values", "()[L" + definition.name + ";", Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
+        JavaWriter valuesWriter = new JavaWriter(writer, true, valuesMethodInfo, null, null);
         valuesWriter.start();
         valuesWriter.getStaticField(definition.name, "$VALUES", "[L" + definition.name + ";");
         valuesWriter.invokeVirtual("[L" + definition.name + ";", "clone", "()Ljava/lang/Object;");
         valuesWriter.returnObject();
         valuesWriter.end();
 
-
-        JavaWriter valueOfWriter = new JavaWriter(writer, true, Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC, "valueOf", "(Ljava/lang/String;)L" + definition.name + ";", null, null);
+		JavaMethodInfo valueOfMethodInfo = new JavaMethodInfo(toClass, "valueOf", "(Ljava/lang/String;)L" + definition.name + ";", Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC);
+        JavaWriter valueOfWriter = new JavaWriter(writer, true, valueOfMethodInfo, null, null);
         valueOfWriter.start();
         valueOfWriter.invokeStatic("java/lang/Class", "forName", "(Ljava/lang/String;)Ljava/lang/Class;");
         valueOfWriter.loadObject(0);
     @Override
     public byte[] visitFunction(FunctionDefinition definition) {
         final String signature = CompilerUtils.calcSign(definition.header, false);
-        final JavaWriter writer = new JavaWriter(outerWriter, true, CompilerUtils.calcAccess(definition.modifiers) | Opcodes.ACC_STATIC, definition.name, CompilerUtils.calcDesc(definition.header, false), signature, null);
+		
+		final JavaClassInfo toClass = new JavaClassInfo(CompilerUtils.calcClasName(definition.position));
+		final JavaMethodInfo methodInfo = new JavaMethodInfo(toClass, definition.name, CompilerUtils.calcDesc(definition.header, false), CompilerUtils.calcAccess(definition.modifiers) | Opcodes.ACC_STATIC);
+
+		final JavaWriter writer = new JavaWriter(outerWriter, true, methodInfo, signature, null);
         final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(writer);
         statementVisitor.start();
         final Iterator<Statement> statementIterator = definition.statements.iterator();
                     writer.aConstNull();
                 writer.returnType(type.accept(JavaTypeVisitor.INSTANCE));
             }
-
         }
 
         statementVisitor.end();
-
-        final JavaMethodInfo methodInfo = new JavaMethodInfo(new JavaClassInfo(CompilerUtils.calcClasName(definition.position)), definition.name, signature, true);
-
+		
         definition.setTag(JavaMethodInfo.class, methodInfo);
         definition.caller.setTag(JavaMethodInfo.class, methodInfo);
         return null;

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

 import org.objectweb.asm.Type;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.Modifiers;
-import org.openzen.zenscript.codemodel.expression.ConstructorThisCallExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.member.*;
-import org.openzen.zenscript.codemodel.statement.ExpressionStatement;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.javabytecode.JavaClassInfo;
 import org.openzen.zenscript.javabytecode.JavaEnumInfo;
 public class JavaMemberVisitor implements MemberVisitor<Void> {
 
     private final ClassWriter writer;
-    private final String className;
+	private final JavaClassInfo toClass;
 
-    public JavaMemberVisitor(ClassWriter writer, String className) {
+    public JavaMemberVisitor(ClassWriter writer, JavaClassInfo toClass) {
         this.writer = writer;
-        this.className = className;
+		this.toClass = toClass;
     }
 
     @Override
         String signature = null;
         final String descriptor = Type.getDescriptor(member.type.accept(JavaTypeClassVisitor.INSTANCE));
         writer.visitField(member.modifiers, member.name, descriptor, signature, null).visitEnd();
-        member.setTag(JavaFieldInfo.class, new JavaFieldInfo(new JavaClassInfo(className), member.name, descriptor));
+        member.setTag(JavaFieldInfo.class, new JavaFieldInfo(toClass, member.name, descriptor));
         return null;
     }
 
     @Override
     public Void visitConstructor(ConstructorMember member) {
+        final boolean isEnum = member.hasTag(JavaEnumInfo.class);
+		String descriptor = CompilerUtils.calcDesc(member.header, isEnum);
+		final JavaMethodInfo method = new JavaMethodInfo(toClass, "<init>", descriptor, isEnum ? Opcodes.ACC_PRIVATE : CompilerUtils.calcAccess(member.modifiers));
+		
         final Label constructorStart = new Label();
         final Label constructorEnd = new Label();
-        final boolean isEnum = member.hasTag(JavaEnumInfo.class);
-        final JavaWriter constructorWriter = new JavaWriter(writer, isEnum ? Opcodes.ACC_PRIVATE : member.modifiers, "<init>", CompilerUtils.calcDesc(member.header, isEnum), CompilerUtils.calcSign(member.header, isEnum), null);
+        final JavaWriter constructorWriter = new JavaWriter(writer, method, CompilerUtils.calcSign(member.header, isEnum), null);
         constructorWriter.label(constructorStart);
         for (FunctionParameter parameter : member.header.parameters) {
             if(isEnum)
                 parameter.index += 2;
             constructorWriter.nameVariable(parameter.index + 1, parameter.name, constructorStart, constructorEnd, Type.getType(parameter.type.accept(JavaTypeClassVisitor.INSTANCE)));
         }
-        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(constructorWriter, true);
+        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(constructorWriter);
         statementVisitor.start();
 
         for (Statement statement : member.body) {
 
     @Override
     public Void visitMethod(MethodMember member) {
+        final boolean isAbstract = member.body == null || member.body.isEmpty() || Modifiers.isAbstract(member.modifiers);
+		int modifiers = (isAbstract ? Opcodes.ACC_ABSTRACT : 0)
+				| (member.isStatic() ? Opcodes.ACC_STATIC : 0)
+				| CompilerUtils.calcAccess(member.modifiers);
+		final JavaMethodInfo method = new JavaMethodInfo(
+				toClass,
+				member.name,
+				CompilerUtils.calcSign(member.header, false),
+				modifiers);
+		
         final Label methodStart = new Label();
         final Label methodEnd = new Label();
-        final boolean isAbstract = member.body == null || member.body.isEmpty() || Modifiers.isAbstract(member.modifiers);
-        final JavaWriter methodWriter = new JavaWriter(writer, isAbstract ? member.modifiers | Opcodes.ACC_ABSTRACT : member.modifiers, member.name, CompilerUtils.calcDesc(member.header, false), CompilerUtils.calcSign(member.header, false), null);
+        final JavaWriter methodWriter = new JavaWriter(writer, method, CompilerUtils.calcSign(member.header, false), null);
         methodWriter.label(methodStart);
         for (final FunctionParameter parameter : member.header.parameters) {
             methodWriter.nameParameter(0, parameter.name);
             statementVisitor.end();
         }
 
-        member.setTag(JavaMethodInfo.class, new JavaMethodInfo(new JavaClassInfo(className), member.name, CompilerUtils.calcSign(member.header, false), member.isStatic()));
-
+        member.setTag(JavaMethodInfo.class, method);
         return null;
     }
 

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

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import org.objectweb.asm.Opcodes;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.Modifiers;
 	
 	public GlobalRegistry(ZSPackage globals) {
 		JavaClassInfo jPrintStream = new JavaClassInfo("java/io/PrintStream");
-		PRINTSTREAM_PRINTLN.setTag(JavaMethodInfo.class, new JavaMethodInfo(jPrintStream, "println", "(Ljava/lang/String;)V"));
+		PRINTSTREAM_PRINTLN.setTag(JavaMethodInfo.class, new JavaMethodInfo(jPrintStream, "println", "(Ljava/lang/String;)V", Opcodes.ACC_PUBLIC));
 		
 		JavaClassInfo jSystem = new JavaClassInfo("java/lang/System");
 		SYSTEM_OUT.setTag(JavaFieldInfo.class, new JavaFieldInfo(jSystem, "out", "Ljava/io/PrintStream;"));
 			JavaClassInfo myClassInfo = new JavaClassInfo("my/test/MyClass");
 			
 			MethodMember member = new MethodMember(CodePosition.NATIVE, myClassDefinition, Modifiers.PUBLIC, "test", new FunctionHeader(BasicTypeID.STRING));
-			member.setTag(JavaMethodInfo.class, new JavaMethodInfo(myClassInfo, "test", "()Ljava/lang/String;"));
+			member.setTag(JavaMethodInfo.class, new JavaMethodInfo(myClassInfo, "test", "()Ljava/lang/String;", Opcodes.ACC_PUBLIC));
 			myClassDefinition.addMember(member);
 			
 			packageMyPackage.register(myClassDefinition);