Fixed enum constants

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

 
 import java.util.Map;
 import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.expression.CallExpression;
+import org.openzen.zenscript.codemodel.expression.NewExpression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
  */
 public class EnumConstantMember extends DefinitionMember {
 	public final String name;
+	public final int value;
 	
-	public EnumConstantMember(CodePosition position, String name) {
+	public NewExpression constructor;
+	
+	public EnumConstantMember(CodePosition position, String name, int value) {
 		super(position, Modifiers.MODIFIER_STATIC);
 		
 		this.name = name;
+		this.value = value;
 	}
 
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/member/TypeMemberBuilder.java

 		if (constructors.getMethodMembers().isEmpty()) {
 			if (definition instanceof ClassDefinition) {
 				// add default constructor
-				constructors.addMethod(new ConstructorMember(BUILTIN, 0, new FunctionHeader(VOID)), TypeMemberPriority.SPECIFIED);
+				constructors.addMethod(new ConstructorMember(BUILTIN, Modifiers.MODIFIER_PUBLIC, new FunctionHeader(VOID)), TypeMemberPriority.SPECIFIED);
 			} else if (definition instanceof StructDefinition) {
 				// add default struct constructors
-				constructors.addMethod(new ConstructorMember(BUILTIN, 0, new FunctionHeader(VOID)), TypeMemberPriority.SPECIFIED);
+				constructors.addMethod(new ConstructorMember(BUILTIN, Modifiers.MODIFIER_PUBLIC, new FunctionHeader(VOID)), TypeMemberPriority.SPECIFIED);
 				
 				List<FieldMember> fields = ((StructDefinition)definition).getFields();
 				if (!fields.isEmpty()) {
 					}
 					constructors.addMethod(new ConstructorMember(BUILTIN, 0, new FunctionHeader(VOID, parameters)), TypeMemberPriority.SPECIFIED);
 				}
+			} else if (definition instanceof EnumDefinition) {
+				// add default constructor
+				constructors.addMethod(new ConstructorMember(BUILTIN, Modifiers.MODIFIER_PRIVATE, new FunctionHeader(VOID)), TypeMemberPriority.SPECIFIED);
 			}
 		}
 		

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

 package org.openzen.zenscript.javabytecode.compiler;
 
-import com.sun.istack.internal.Nullable;
 import org.objectweb.asm.*;
 import org.objectweb.asm.commons.LocalVariablesSorter;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
             visitor.visitLocalVariable(name, type.getDescriptor(), null, start, end, local);
     }
 
-    public void nameParameter(int modifier, @Nullable String name) {
+    public void nameParameter(int modifier, String name) {
         if (nameVariables)
             visitor.visitParameter(name, modifier);
     }

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedEnum.java

 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.definition.EnumDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
+import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.lexer.ZSTokenStream;
 import org.openzen.zenscript.lexer.ZSTokenType;
+import org.openzen.zenscript.linker.BaseScope;
+import org.openzen.zenscript.linker.ExpressionScope;
 import org.openzen.zenscript.parser.member.ParsedDefinitionMember;
 import org.openzen.zenscript.shared.CodePosition;
 
 		
 		List<ParsedEnumConstant> enumValues = new ArrayList<>();
 		while (!tokens.isNext(ZSTokenType.T_ACLOSE) && !tokens.isNext(ZSTokenType.T_SEMICOLON)) {
-			enumValues.add(ParsedEnumConstant.parse(tokens));
+			enumValues.add(ParsedEnumConstant.parse(tokens, enumValues.size()));
 			if (tokens.optional(ZSTokenType.T_COMMA) == null)
 				break;
 		}
 	public HighLevelDefinition getCompiled() {
 		return compiled;
 	}
+	
+	@Override
+	public void compileMembers(BaseScope scope) {
+		super.compileMembers(scope);
+		
+		for (ParsedEnumConstant constant : enumValues) {
+			compiled.addMember(constant.getCompiled());
+		}
+	}
+
+	@Override
+	public void compileCode(BaseScope scope) {
+		super.compileCode(scope);
+		
+		DefinitionTypeID type = new DefinitionTypeID(compiled, new ITypeID[0]);
+		ExpressionScope evalScope = new ExpressionScope(scope);
+		for (ParsedEnumConstant constant : enumValues) {
+			constant.compileCode(type, evalScope);
+		}
+	}
 }

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedEnumConstant.java

 import java.util.ArrayList;
 import java.util.List;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
+import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.lexer.ZSToken;
 import org.openzen.zenscript.lexer.ZSTokenStream;
 import org.openzen.zenscript.lexer.ZSTokenType;
+import org.openzen.zenscript.linker.ExpressionScope;
+import org.openzen.zenscript.parser.expression.ParsedCallArguments;
 import org.openzen.zenscript.parser.expression.ParsedExpression;
+import org.openzen.zenscript.parser.expression.ParsedNewExpression;
 import org.openzen.zenscript.shared.CodePosition;
 
 /**
  * @author Hoofdgebruiker
  */
 public class ParsedEnumConstant {
-	public static ParsedEnumConstant parse(ZSTokenStream tokens) {
+	public static ParsedEnumConstant parse(ZSTokenStream tokens, int value) {
 		ZSToken name = tokens.required(ZSTokenType.T_IDENTIFIER, "identifier expected");
 		List<ParsedExpression> arguments = new ArrayList<>();
 		if (tokens.optional(ZSTokenType.T_BROPEN) != null) {
 			tokens.required(ZSTokenType.T_BRCLOSE, ") expected");
 		}
 		
-		return new ParsedEnumConstant(name.position, name.content, arguments);
+		return new ParsedEnumConstant(name.position, name.content, value, arguments);
 	}
 	
 	public final CodePosition position;
 	
 	private final EnumConstantMember compiled;
 	
-	public ParsedEnumConstant(CodePosition position, String name, List<ParsedExpression> arguments) {
+	public ParsedEnumConstant(CodePosition position, String name, int value, List<ParsedExpression> arguments) {
 		this.position = position;
 		this.name = name;
 		this.arguments = arguments;
 		
-		compiled = new EnumConstantMember(position, name);
+		compiled = new EnumConstantMember(position, name, value);
+	}
+	
+	public EnumConstantMember getCompiled() {
+		return compiled;
+	}
+	
+	public void compileCode(DefinitionTypeID type, ExpressionScope scope) {
+		ParsedCallArguments arguments = new ParsedCallArguments(this.arguments);
+		compiled.constructor = ParsedNewExpression.compile(position, type, arguments, scope);
 	}
 }

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

 		return true;
 	}
 	
-	public static Expression compile(CodePosition position, ITypeID type, ParsedCallArguments arguments, ExpressionScope scope) {
+	public static NewExpression compile(CodePosition position, ITypeID type, ParsedCallArguments arguments, ExpressionScope scope) {
 		DefinitionMemberGroup constructors = scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CONSTRUCTOR);
 		List<ITypeID>[] predictedTypes = constructors.predictCallTypes(scope, scope.hints, arguments.arguments.size());
 		CallArguments compiledArguments = arguments.compileCall(position, scope, constructors);

ScriptingExample/scripts/enums.zs

+enum TestEnum {
+	HELLO,
+	WORLD
+}
+
+enum TestEnum2 {
+	HELLO("Hello"),
+	WORLD("World");
+	
+	val value as string;
+	
+	this(value as string) {
+		this.value = value;
+	}
+}