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

CodeModel/src/main/java/org/openzen/zenscript/codemodel/FunctionHeader.java

 	}
 	
 	public boolean matchesImplicitly(CodePosition position, CallArguments arguments, TypeScope scope) {
-		if (arguments.arguments.length < minParameters || arguments.arguments.length > maxParameters)
+		if (!accepts(arguments.arguments.length))
 			return false;
 		
 		FunctionHeader header = fillGenericArguments(position, scope, arguments.typeArguments);
-		for (int i = 0; i < header.parameters.length; i++) {
+		for (int i = 0; i < arguments.arguments.length; i++) {
 			if (!scope.getTypeMembers(arguments.arguments[i].type).canCastImplicit(header.parameters[i].type))
 				return false;
 		}

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

 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.statement.StatementTransformer;
-import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.InvalidTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 import org.openzen.zenscript.codemodel.type.storage.UniqueStorageTag;
 	public Expression(CodePosition position, StoredType type, StoredType thrownType) {
 		if (type == null)
 			throw new NullPointerException();
-		if (type.type == BasicTypeID.UNDETERMINED)
-			throw new IllegalArgumentException(position + ": Cannot use undetermined type as expression type");
+		//if (type.type == BasicTypeID.UNDETERMINED)
+		//	throw new IllegalArgumentException(position + ": Cannot use undetermined type as expression type");
 		
 		this.position = position;
 		this.type = type.getNormalized();

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

 	T visitInterfaceCast(InterfaceCastExpression expression);
 	
 	default T visitInvalid(InvalidExpression expression) {
-		throw new RuntimeException("Invalid expression");
+		throw new RuntimeException("Invalid expression @ " + expression.position + ": " + expression.message);
 	}
 	
 	default T visitInvalidAssign(InvalidAssignExpression expression) {
-		throw new RuntimeException("Invalid expression");
+		throw new RuntimeException("Invalid expression @ " + expression.position + ": " + expression.target.message);
 	}
 	
 	T visitIs(IsExpression expression);

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/FunctionalMemberRef.java

 	}
 	
 	public boolean accepts(int arguments) {
-		return arguments >= target.header.minParameters && arguments <= target.header.maxParameters;
+		return target.header.accepts(arguments);
 	}
 	
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ref/PropertyRef.java

 	
 	public final StoredType getType() {
 		if (type == null) {
-			if (member.getType().type == BasicTypeID.UNDETERMINED)
-				throw new IllegalStateException("Property is not yet resolved!");
+			//if (member.getType().type == BasicTypeID.UNDETERMINED)
+			//	throw new IllegalStateException("Property is not yet resolved!");
 			
 			type = mapper == null ? member.getType() : member.getType().instance(mapper);
 			mapper = null;

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

 	public List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<StoredType> hints, int arguments) {
 		List<FunctionHeader> results = new ArrayList<>();
 		for (TypeMember<FunctionalMemberRef> method : group.getMethodMembers()) {
-			if (!method.member.accepts(arguments)  || method.member.isStatic())
+			if (!method.member.accepts(arguments) || method.member.isStatic())
 				continue;
 			
 			try {

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

 	@Override
 	public List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<StoredType> hints, int arguments) {
 		return group.getMethodMembers().stream()
-				.filter(method -> method.member.getHeader().parameters.length == arguments && method.member.isStatic())
+				.filter(method -> method.member.getHeader().accepts(arguments) && method.member.isStatic())
 				.map(method -> method.member.getHeader())
 				.collect(Collectors.toList());
 	}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/ArrayTypeID.java

 
 import java.util.List;
 import java.util.Set;
+import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.expression.ArrayExpression;
+import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 		this.normalized = elementType.getNormalized() == elementType ? this : registry.getArray(elementType.getNormalized(), dimension);
 	}
 	
+	@Override
+	public Expression getDefaultValue() {
+		return new ArrayExpression(CodePosition.UNKNOWN, Expression.NONE, this.stored());
+	}
+	
 	@Override
 	public ArrayTypeID getNormalized() {
 		return normalized;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/BasicTypeID.java

 import java.util.Collections;
 import java.util.List;
 import java.util.Set;
+import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.expression.ConstantBoolExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantByteExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantCharExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantDoubleExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantFloatExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantIntExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantLongExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantSByteExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantShortExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantUIntExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantULongExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantUShortExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantUSizeExpression;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.expression.NullExpression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 	public final String name;
 	public final StoredType stored;
 	
+	private Expression defaultValue = null;
+	
 	BasicTypeID(String name) {
 		this.name = name;
 		stored = new StoredType(this, null);
+		this.defaultValue = defaultValue;
 	}
 	
 	@Override
 	public boolean hasDefaultValue() {
 		return true;
 	}
+	
+	@Override
+	public Expression getDefaultValue() {
+		if (defaultValue == null) // lazy init due to circular initialization in the constant expressions
+			defaultValue = generateDefaultValue();
+		
+		return defaultValue;
+	}
 
 	@Override
 	public void extractTypeParameters(List<TypeParameter> typeParameters) {
 		
 	}
+	
+	private Expression generateDefaultValue() {
+		switch (this) {
+			case NULL: return new NullExpression(CodePosition.UNKNOWN);
+			case BOOL: return new ConstantBoolExpression(CodePosition.UNKNOWN, false);
+			case BYTE: return new ConstantByteExpression(CodePosition.UNKNOWN, 0);
+			case SBYTE: return new ConstantSByteExpression(CodePosition.UNKNOWN, (byte)0);
+			case SHORT: return new ConstantShortExpression(CodePosition.UNKNOWN, (short)0);
+			case USHORT: return new ConstantUShortExpression(CodePosition.UNKNOWN, 0);
+			case INT: return new ConstantIntExpression(CodePosition.UNKNOWN, 0);
+			case UINT: return new ConstantUIntExpression(CodePosition.UNKNOWN, 0);
+			case LONG: return new ConstantLongExpression(CodePosition.UNKNOWN, 0);
+			case ULONG: return new ConstantULongExpression(CodePosition.UNKNOWN, 0);
+			case USIZE: return new ConstantUSizeExpression(CodePosition.UNKNOWN, 0);
+			case FLOAT: return new ConstantFloatExpression(CodePosition.UNKNOWN, 0);
+			case DOUBLE: return new ConstantDoubleExpression(CodePosition.UNKNOWN, 0);
+			default: return null;
+		}
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/OptionalTypeID.java

 import java.util.List;
 import java.util.Objects;
 import java.util.Set;
+import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.expression.NullExpression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 
 		normalized = baseType.getNormalized() == baseType ? this : registry.getOptional(baseType.getNormalized());
 	}
 	
+	@Override
+	public Expression getDefaultValue() {
+		return new NullExpression(CodePosition.UNKNOWN);
+	}
+	
 	@Override
 	public TypeID getNormalized() {
 		return normalized;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/StringTypeID.java

 
 import java.util.List;
 import java.util.Set;
+import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.expression.ConstantStringExpression;
+import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.BorrowStorageTag;
 	
 	private StringTypeID() {}
 	
+	@Override
+	public Expression getDefaultValue() {
+		return new ConstantStringExpression(CodePosition.UNKNOWN, "");
+	}
+	
 	@Override
 	public TypeID getNormalized() {
 		return INSTANCE;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/TypeID.java

 import java.util.Set;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 	
 	boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters);
 	
+	default Expression getDefaultValue() {
+		return null;
+	}
+	
 	// Infers type parameters for this type so it matches with targetType
 	// returns false if that isn't possible
 	default Map<TypeParameter, StoredType> inferTypeParameters(LocalMemberCache cache, StoredType targetType) {

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

 		if (modified.isOptional()) {
 			operator(builtin, OperatorType.EQUALS, new FunctionHeader(BOOL.stored, NULL.stored), BuiltinID.OPTIONAL_IS_NULL);
 			operator(builtin, OperatorType.NOTEQUALS, new FunctionHeader(BOOL.stored, NULL.stored), BuiltinID.OPTIONAL_IS_NOT_NULL);
+			operator(builtin, OperatorType.SAME, new FunctionHeader(BOOL.stored, NULL.stored), BuiltinID.OPTIONAL_IS_NULL);
+			operator(builtin, OperatorType.NOTSAME, new FunctionHeader(BOOL.stored, NULL.stored), BuiltinID.OPTIONAL_IS_NOT_NULL);
 		}
 		
 		processType(builtin);

IDE/src/main/java/org/openzen/zenscript/ide/Main.java

     public static void main(String... args) throws IOException {
 		if (args.length == 0) {
 			// testing environment - TODO project chooser/creator
-			//args = new String[] { "../../ZenCode", "SharedJavaSource" };
-			args = new String[] { "../../ZenCode", "CodeModelJavaSource" };
+			args = new String[] { "../../ZenCode", "SharedJavaSource" };
+			//args = new String[] { "../../ZenCode", "CodeModelJavaSource" };
 		}
 		
 		Arguments arguments = new Arguments(args);

JavaAnnotations/src/main/java/org/openzen/zencode/java/ZenCodeType.java

 	}
 	
 	@Retention(RetentionPolicy.RUNTIME)
-	@Target(ElementType.PACKAGE)
+	@Target(ElementType.PARAMETER)
 	@interface OptionalString {
 		String value() default "";
 	}

JavaIntegration/src/main/java/org/openzen/zencode/java/JavaNativeModule.java

  */
 package org.openzen.zencode.java;
 
-import java.lang.reflect.*;
+import java.lang.reflect.AnnotatedType;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Member;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.Parameter;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
 import org.openzen.zenscript.codemodel.definition.StructDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.expression.ConstantByteExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantDoubleExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantFloatExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantIntExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantLongExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantSByteExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantShortExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantStringExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantUIntExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantULongExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantUShortExpression;
+import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ExpressionSymbol;
 import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
+import org.openzen.zenscript.codemodel.expression.StorageCastExpression;
 import org.openzen.zenscript.codemodel.generic.ParameterTypeBound;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.member.CasterMember;
 import org.openzen.zenscript.codemodel.type.member.BuiltinID;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.type.storage.AutoStorageTag;
+import org.openzen.zenscript.codemodel.type.storage.StaticStorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
-import org.openzen.zenscript.javabytecode.compiler.CompilerUtils;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaCompiledModule;
 import org.openzen.zenscript.javashared.JavaField;
 			final String fieldName = annotation.value().isEmpty() ? field.getName() : annotation.value();
 			
 			StoredType fieldType = loadStoredType(context, field.getAnnotatedType());
-			
 			FieldMember member = new FieldMember(CodePosition.NATIVE, definition, getMethodModifiers(field), fieldName, thisType, fieldType, registry, 0, 0, null);
 			definition.addMember(member);
 			compiled.setFieldInfo(member, new JavaField(javaClass, field.getName(), getDescriptor(field.getType())));
 		return getHeader(
 				context,
 				null,
-				constructor.getAnnotatedParameterTypes(),
+				constructor.getParameters(),
 				constructor.getTypeParameters(),
 				constructor.getAnnotatedExceptionTypes());
 	}
 		return getHeader(
 				context,
 				method.getAnnotatedReturnType(),
-				method.getAnnotatedParameterTypes(),
+				method.getParameters(),
 				method.getTypeParameters(),
 				method.getAnnotatedExceptionTypes());
 	}
 	
+	private Expression getDefaultValue(Parameter parameter, StoredType type) {
+		if (parameter.isAnnotationPresent(ZenCodeType.Optional.class)) {
+			Expression defaultValue = type.type.getDefaultValue();
+			if (defaultValue == null)
+				throw new IllegalArgumentException(type.toString() + " doesn't have a default value");
+			return defaultValue;
+		} else if (parameter.isAnnotationPresent(ZenCodeType.OptionalInt.class)) {
+			ZenCodeType.OptionalInt annotation = parameter.getAnnotation(ZenCodeType.OptionalInt.class);
+			if (type.type == BasicTypeID.BYTE)
+				return new ConstantByteExpression(CodePosition.NATIVE, annotation.value());
+			else if (type.type == BasicTypeID.SBYTE)
+				return new ConstantSByteExpression(CodePosition.NATIVE, (byte)annotation.value());
+			else if (type.type == BasicTypeID.SHORT)
+				return new ConstantShortExpression(CodePosition.NATIVE, (short)annotation.value());
+			else if (type.type == BasicTypeID.USHORT)
+				return new ConstantUShortExpression(CodePosition.NATIVE, annotation.value());
+			else if (type.type == BasicTypeID.INT)
+				return new ConstantIntExpression(CodePosition.NATIVE, annotation.value());
+			else if (type.type == BasicTypeID.UINT)
+				return new ConstantUIntExpression(CodePosition.NATIVE, annotation.value());
+			else
+				throw new IllegalArgumentException("Cannot use int default values for " + type.toString());
+		} else if (parameter.isAnnotationPresent(ZenCodeType.OptionalLong.class)) {
+			ZenCodeType.OptionalLong annotation = parameter.getAnnotation(ZenCodeType.OptionalLong.class);
+			if (type.type == BasicTypeID.LONG)
+				return new ConstantLongExpression(CodePosition.NATIVE, annotation.value());
+			else if (type.type == BasicTypeID.ULONG)
+				return new ConstantULongExpression(CodePosition.NATIVE, annotation.value());
+			else
+				throw new IllegalArgumentException("Cannot use long default values for " + type.toString());
+		} else if (parameter.isAnnotationPresent(ZenCodeType.OptionalFloat.class)) {
+			ZenCodeType.OptionalFloat annotation = parameter.getAnnotation(ZenCodeType.OptionalFloat.class);
+			if (type.type == BasicTypeID.FLOAT)
+				return new ConstantFloatExpression(CodePosition.NATIVE, annotation.value());
+			else
+				throw new IllegalArgumentException("Cannot use float default values for " + type.toString());
+		} else if (parameter.isAnnotationPresent(ZenCodeType.OptionalDouble.class)) {
+			ZenCodeType.OptionalDouble annotation = parameter.getAnnotation(ZenCodeType.OptionalDouble.class);
+			if (type.type == BasicTypeID.DOUBLE)
+				return new ConstantDoubleExpression(CodePosition.NATIVE, annotation.value());
+			else
+				throw new IllegalArgumentException("Cannot use double default values for " + type.toString());
+		} else if (parameter.isAnnotationPresent(ZenCodeType.OptionalString.class)) {
+			ZenCodeType.OptionalString annotation = parameter.getAnnotation(ZenCodeType.OptionalString.class);
+			if (type.type == StringTypeID.INSTANCE) {
+				Expression result = new ConstantStringExpression(CodePosition.NATIVE, annotation.value());
+				if (type.getActualStorage() != StaticStorageTag.INSTANCE)
+					result = new StorageCastExpression(CodePosition.NATIVE, result, type);
+				return result;
+			} else {
+				throw new IllegalArgumentException("Cannot use string default values for " + type.toString());
+			}
+		} else {
+			return null;
+		}
+	}
+
 	private FunctionHeader getHeader(
 			TypeVariableContext context,
 			AnnotatedType javaReturnType,
-			AnnotatedType[] parameterTypes,
+			Parameter[] javaParameters,
 			TypeVariable<Method>[] javaTypeParameters,
 			AnnotatedType[] exceptionTypes) {
 		StoredType returnType = javaReturnType == null ? BasicTypeID.VOID.stored : loadStoredType(context, javaReturnType);
 		
-		FunctionParameter[] parameters = new FunctionParameter[parameterTypes.length];
+		FunctionParameter[] parameters = new FunctionParameter[javaParameters.length];
 		for (int i = 0; i < parameters.length; i++) {
-			parameters[i] = new FunctionParameter(loadStoredType(context, parameterTypes[i]));
+			Parameter parameter = javaParameters[i];
+
+			AnnotatedType parameterType = parameter.getAnnotatedType();
+			StoredType type = loadStoredType(context, parameter.getAnnotatedType());
+			Expression defaultValue = getDefaultValue(parameter, type);
+			parameters[i] = new FunctionParameter(type, parameter.getName(), defaultValue, parameter.isVarArgs());
 		}
 		
 		TypeParameter[] typeParameters = new TypeParameter[javaTypeParameters.length];

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

 import org.openzen.zencode.shared.CompileExceptionCode;
 import org.openzen.zenscript.lexer.ZSTokenType;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 	}
 	
 	private boolean isCompatibleWith(BaseScope scope, FunctionHeader header, StoredType[] typeArguments) {
-		if (arguments.size() != header.parameters.length)
+		if (!header.accepts(arguments.size()))
 			return false;
 		
+		boolean variadic = false;
 		for (int i = 0; i < arguments.size(); i++) {
-			if (typeArguments == null && header.typeParameters != null && header.parameters[i].type.hasInferenceBlockingTypeParameters(header.typeParameters))
+			FunctionParameter parameter = header.getParameter(variadic, i);
+			if (typeArguments == null && header.typeParameters != null && parameter.type.hasInferenceBlockingTypeParameters(header.typeParameters))
 				return false;
 			
-			if (!arguments.get(i).isCompatibleWith(scope, header.parameters[i].type.getNormalized()))
+			if (!arguments.get(i).isCompatibleWith(scope, header.getParameterType(variadic, i).getNormalized()))
 				return false;
 		}
 		

ScriptingExample/scripts/integration.zs

 val instance = new TestClass("Instance");
 println("Name: " + instance.name);
 instance.dump();
+instance.withDefaultParameter("Hello");
+instance.withDefaultParameter("Hello", "moon");
 
 var generated = instance.generate();
 println(generated.getValue());
 floatMethod(5f * count);
 
 invokeFunctional(name => "Hello " + name);
+
+//val x = (a as string) => "hello" + a;
+//invokeFunctional(x);
+
+testOptional(value => value == null ? 0 : value.length as int);

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

 	public TestGenericInterface<String> generate() {
 		return () -> name;
 	}
+	
+	@Method
+	public void withDefaultParameter(String a, @OptionalString("world") String b) {
+		System.out.println(a + " " + b);
+	}
 }

common.gradle

 apply plugin: 'maven'
 
 String mavenGroupId = 'org.openzen.zencode'
-String mavenVersion = '0.3.7'
+String mavenVersion = '0.3.8'
 
 sourceCompatibility = '1.8'
 [compileJava, compileTestJava]*.options*.encoding = 'UTF-8'