Enums and this()

- Basic work on enumerations, they should work now
- this() constructor calls should work now
- Moved methods for calulcating descriptions and signatures to seperate utils class

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

+package org.openzen.zenscript.javabytecode;
+
+import org.openzen.zenscript.javabytecode.compiler.JavaStatementVisitor;
+
+public class JavaEnumInfo {
+    public final JavaStatementVisitor clinitVisitor;
+
+    public JavaEnumInfo(JavaStatementVisitor clinitVisitor) {
+        this.clinitVisitor = clinitVisitor;
+    }
+}

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

+package org.openzen.zenscript.javabytecode.compiler;
+
+import org.objectweb.asm.Type;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.FunctionParameter;
+
+public class CompilerUtils {
+    public static String calcDesc(FunctionHeader header, boolean isEnum) {
+        StringBuilder descBuilder = new StringBuilder("(");
+        if(isEnum)
+            descBuilder.append("Ljava/lang/String;I");
+        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();
+    }
+
+    public static String calcSign(FunctionHeader header, boolean isEnum) {
+        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();
+    }
+}

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

 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;
-import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
-import org.openzen.zenscript.javabytecode.JavaMethodInfo;
+import org.openzen.zenscript.javabytecode.*;
 import org.openzen.zenscript.shared.CompileException;
 import org.openzen.zenscript.shared.CompileExceptionCode;
 
 
 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) {
         this.javaWriter = javaWriter;
+        this.isInit = isInit;
     }
 
     @Override
 
     @Override
     public Void visitConstructorThisCall(ConstructorThisCallExpression expression) {
+        Type type = expression.objectType.accept(JavaTypeVisitor.INSTANCE);
+        //javaWriter.loadObject(0);
+        for (Expression argument : expression.arguments.arguments) {
+            argument.accept(this);
+        }
+        javaWriter.invokeSpecial(type.getInternalName(), "<init>", CompilerUtils.calcDesc(expression.constructor.header, expression.constructor.hasTag(JavaEnumInfo.class)));
         return null;
     }
 
     @Override
     public Void visitSetField(SetFieldExpression expression) {
         javaWriter.loadObject(0);
-        if (expression.field.isFinal())
+        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))
 
     @Override
     public Void visitThis(ThisExpression expression) {
+        javaWriter.loadObject(0);
         return null;
     }
 

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) {
         this.javaWriter = javaWriter;
-        this.expressionVisitor = new JavaExpressionVisitor(javaWriter);
+        this.expressionVisitor = new JavaExpressionVisitor(javaWriter, isInit);
+        this.isInit = isInit;
     }
 
     @Override

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

 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.Type;
 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.member.ConstructorMember;
+import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 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.codemodel.statement.ExpressionStatement;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.javabytecode.JavaEnumInfo;
+import org.openzen.zenscript.javabytecode.compiler.JavaExpressionVisitor;
+import org.openzen.zenscript.javabytecode.compiler.JavaStatementVisitor;
 import org.openzen.zenscript.javabytecode.compiler.JavaTypeClassVisitor;
+import org.openzen.zenscript.javabytecode.compiler.JavaWriter;
 
 public class JavaDefinitionVisitor implements DefinitionVisitor<byte[]> {
 
     public byte[] visitClass(ClassDefinition definition) {
 
 
-        Type superType;
+        final 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) {
 
-            }
-        }
-        */
+        //TODO: Calculate signature from generic parameters
+        //TODO: Interfaces?
+        String signature = null;
 
 
+        writer.visit(Opcodes.V1_8, definition.modifiers, definition.name, signature, superType.getInternalName(), null);
         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);
-
-
+                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) {
+                        if (visitor instanceof JavaExpressionVisitor) {
+                            JavaWriter javaWriter = ((JavaExpressionVisitor) visitor).getJavaWriter();
+                            javaWriter.loadObject(0);
+                            //TODO Super constructor?
+                            javaWriter.invokeSpecial(Type.getInternalName(Object.class), "<init>", "()V");
+                            for (final IDefinitionMember definitionMember : definition.members) {
+                                if (definitionMember instanceof FieldMember && ((FieldMember) definitionMember).initializer != null) {
+                                    final FieldMember field = (FieldMember) definitionMember;
+                                    javaWriter.loadObject(0);
+                                    field.initializer.accept(visitor);
+                                    javaWriter.putField(definition.name, field.name, Type.getDescriptor(field.type.accept(JavaTypeClassVisitor.INSTANCE)));
+                                }
+                            }
+                        }
+                        return null;
                     }
-                }
+                }));
             }
-        }
-
-        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;
+        ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
+
+        //TODO: Calculate signature from generic parameters
+        //TODO: Extending Interfaces?
+        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));
+        }
+        writer.visitEnd();
+        return writer.toByteArray();
     }
 
     @Override
     public byte[] visitEnum(EnumDefinition definition) {
-        return null;
+        final 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);
+
+        writer.visit(Opcodes.V1_8, Opcodes.ACC_ENUM | Opcodes.ACC_PUBLIC | Opcodes.ACC_SUPER | Opcodes.ACC_FINAL, definition.name, "Ljava/lang/Enum<L" + definition.name + ";>;", superType.getInternalName(), null);
+
+        for (IDefinitionMember member : definition.members) {
+            if (member instanceof EnumConstantMember) {
+                EnumConstantMember constantMember = (EnumConstantMember) member;
+                writer.visitField(Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC | Opcodes.ACC_FINAL | Opcodes.ACC_ENUM, constantMember.name, "L" + definition.name + ";", null, null).visitEnd();
+            } else if (member instanceof ConstructorMember) {
+                member.setTag(JavaEnumInfo.class, null);
+            }
+        }
+
+        final JavaWriter clinitWriter = new JavaWriter(writer, true, Opcodes.ACC_STATIC, "<clinit>", "()V", null, null);
+        final JavaStatementVisitor clinitVisitor = new JavaStatementVisitor(clinitWriter, true);
+        clinitVisitor.start();
+        int constantCount = 0;
+        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) {
+                        if (visitor instanceof JavaExpressionVisitor) {
+                            JavaWriter javaWriter = ((JavaExpressionVisitor) visitor).getJavaWriter();
+                            javaWriter.getVisitor().newLocal(Type.getType(String.class));
+                            javaWriter.getVisitor().newLocal(Type.getType(int.class));
+                            javaWriter.loadObject(0);
+                            javaWriter.loadObject(1);
+                            javaWriter.loadInt(2);
+                            //javaWriter.invokeSpecial(Type.getInternalName(Enum.class), "<init>", "(Ljava/lang/String;I)V");
+                        }
+                        return null;
+                    }
+                }));
+            } else if (member instanceof EnumConstantMember) {
+                ++constantCount;
+                member.setTag(JavaEnumInfo.class, new JavaEnumInfo(clinitVisitor));
+            }
+            member.accept(new JavaMemberVisitor(writer, definition.name));
+        }
+
+        clinitWriter.constant(constantCount);
+        clinitWriter.newArray(Type.getType("L" + definition.name + ";"));
+
+        for (IDefinitionMember member : definition.members) {
+            if(!(member instanceof EnumConstantMember)) continue;
+            final EnumConstantMember constantMember = (EnumConstantMember) member;
+            clinitWriter.dup();
+            clinitWriter.constant(constantMember.value);
+            clinitWriter.getStaticField(definition.name, constantMember.name, "L" + definition.name + ";");
+            clinitWriter.arrayStore(Type.getType("L" + definition.name + ";"));
+        }
+        clinitWriter.putStaticField(definition.name, "$VALUES", "[L" + definition.name + ";");
+        clinitVisitor.end();
+
+        //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);
+        valuesWriter.start();
+        valuesWriter.getStaticField(definition.name, "$VALUES", "[L" + definition.name + ";");
+        valuesWriter.invokeVirtual("[L" + definition.name + ";", "clone", "()Ljava/lang/Object;");
+        valuesWriter.checkCast("[L" + definition.name + ";");
+        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);
+        valueOfWriter.start();
+        valueOfWriter.invokeStatic("java/lang/Class", "forName", "(Ljava/lang/String;)Ljava/lang/Class;");
+        valueOfWriter.loadObject(0);
+        valueOfWriter.invokeStatic("java/lang/Enum", "valueOf", "(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/Enum;");
+        valueOfWriter.checkCast("L" + definition.name + ";");
+        valueOfWriter.returnObject();
+        valueOfWriter.end();
+
+
+        writer.visitEnd();
+        return writer.toByteArray();
     }
 
     @Override

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

 
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Label;
+import org.objectweb.asm.Opcodes;
 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.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;
+import org.openzen.zenscript.javabytecode.JavaFieldInfo;
 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;
+import org.openzen.zenscript.javabytecode.compiler.*;
 
 public class JavaMemberVisitor implements MemberVisitor<Void> {
 
 
         //TODO calc signature
         String signature = null;
-        writer.visitField(member.modifiers, member.name, Type.getDescriptor(member.type.accept(JavaTypeClassVisitor.INSTANCE)), signature, null).visitEnd();
+        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));
         return null;
     }
 
     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);
+        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);
         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);
+        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(constructorWriter, true);
         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);
         }
     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);
+        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);
         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)));
+            if (!isAbstract)
+                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);
+        if (!isAbstract) {
+            statementVisitor.start();
+            for (Statement statement : member.body) {
+                statement.accept(statementVisitor);
+            }
+
+            methodWriter.label(methodEnd);
+            statementVisitor.end();
         }
 
-        methodWriter.label(methodEnd);
-        statementVisitor.end();
-        member.setTag(JavaMethodInfo.class, new JavaMethodInfo(new JavaClassInfo(className), member.name, calcSign(member.header), member.isStatic()));
+        member.setTag(JavaMethodInfo.class, new JavaMethodInfo(new JavaClassInfo(className), member.name, CompilerUtils.calcSign(member.header, false), member.isStatic()));
 
         return null;
     }
 
     @Override
     public Void visitEnumConstant(EnumConstantMember member) {
+        final JavaStatementVisitor clinitVisitor = member.getTag(JavaEnumInfo.class).clinitVisitor;
+        final JavaWriter clinitWriter = clinitVisitor.getJavaWriter();
+        final String internalName = member.constructor.type.accept(JavaTypeVisitor.INSTANCE).getInternalName();
+
+        clinitWriter.newObject(internalName);
+        clinitWriter.dup();
+        clinitWriter.constant(member.name);
+        clinitWriter.constant(member.value);
+        for (Expression argument : member.constructor.arguments.arguments) {
+            argument.accept(clinitVisitor.expressionVisitor);
+        }
+        clinitWriter.invokeSpecial(internalName, "<init>", CompilerUtils.calcDesc(member.constructor.constructor.header, true));
+        clinitWriter.putStaticField(internalName, member.name, "L" + internalName + ";");
+
+
         return null;
     }
 
         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

 
 
 val tt = new myTestClass(666);
-println(tt.test());
+println(tt.test());
+
+public interface myTestInterface {
+	test() as string;
+}
+
+
+public enum myTestEnum {
+	ADD(6),
+    SUB(6),
+    MUL(7),
+    DIV(7),
+    MOD(7),
+    CAT(6),
+    OR(4),
+    AND(4),
+    XOR(4),
+    NEG(8),
+    NOT(8),
+    INVERT(8),
+    CONTAINS(5),
+    COMPARE(5),
+    ASSIGN(0),
+    ADDASSIGN(0),
+    SUBASSIGN(0),
+    MULASSIGN(0),
+    DIVASSIGN(0),
+    MODASSIGN(0),
+    CATASSIGN(0),
+    ORASSIGN(0),
+    ANDASSIGN(0),
+    XORASSIGN(0),
+    ANDAND(3),
+    OROR(2),
+    TERNARY(1),
+    COALESCE(2),
+    INCREMENT(8),
+    DECREMENT(8),
+    MEMBER(9),
+    RANGE(9),
+    INDEX(9),
+    CALL(9),
+    CAST(9),
+    PRIMARY(10);
+
+	private val priority as int;
+	private val isCommutative as bool;
+
+	this(i as int) {
+		this(i, false);
+	}
+
+	this(i as int, isCommutative as bool) {
+		this.priority = i;
+		this.isCommutative = isCommutative;
+		}
+}