- Separated calls from casts

- Fixed priorities for brackets in the code formatter
- Added code position to definitions
- In a FieldMember the final status is now stored in the modifiers instead of a separate field
- WIP on implementing function definitions properly

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/ExpressionFormatter.java

 import org.openzen.zenscript.codemodel.expression.CapturedLocalVariableExpression;
 import org.openzen.zenscript.codemodel.expression.CapturedParameterExpression;
 import org.openzen.zenscript.codemodel.expression.CapturedThisExpression;
+import org.openzen.zenscript.codemodel.expression.CastExpression;
 import org.openzen.zenscript.codemodel.expression.CheckNullExpression;
 import org.openzen.zenscript.codemodel.expression.CoalesceExpression;
 import org.openzen.zenscript.codemodel.expression.ConditionalExpression;
 import org.openzen.zenscript.codemodel.expression.StaticSetterExpression;
 import org.openzen.zenscript.codemodel.expression.ThisExpression;
 import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
-import org.openzen.zenscript.codemodel.member.CasterMember;
 import org.openzen.zenscript.codemodel.member.OperatorMember;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.StringUtils;
 				default:
 					throw new UnsupportedOperationException("Unknown operator: " + operator.operator);
 			}
-		} else if (expression.member instanceof CasterMember) {
-			CasterMember casterMember = (CasterMember) expression.member;
-			
-			StringBuilder result = new StringBuilder();
-			result.append(expression.target.accept(this).value);
-			if (!casterMember.isImplicit()) {
-				result.append(" as ");
-				result.append(casterMember.toType.accept(typeFormatter));
-			}
-			return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
 		} else {
 			StringBuilder result = new StringBuilder();
 			result.append(expression.target.accept(this).value);
 	}
 	
 	private void format(StringBuilder result, CallArguments arguments) {
+		if (arguments == null || arguments.typeArguments == null)
+			throw new IllegalArgumentException("Arguments cannot be null!");
+		
 		if (arguments.typeArguments.length > 0) {
 			result.append("<");
 			
 	public ExpressionString visitCapturedThis(CapturedThisExpression expression) {
 		return new ExpressionString("this", OperatorPriority.PRIMARY);
 	}
+	
+	@Override
+	public ExpressionString visitCast(CastExpression expression) {
+		StringBuilder result = new StringBuilder();
+		result.append(expression.target.accept(this).value);
+		if (!expression.isImplicit) {
+			result.append(" as ");
+			result.append(expression.member.toType.accept(typeFormatter));
+		}
+		return new ExpressionString(result.toString(), OperatorPriority.PRIMARY);
+	}
 
 	@Override
 	public ExpressionString visitCheckNull(CheckNullExpression expression) {

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/OperatorPriority.java

 	}
 	
 	public static boolean shouldWrapLeft(OperatorPriority inner, OperatorPriority outer) {
-		return inner == outer || inner.priority > outer.priority;
+		return inner == outer || inner.priority <= outer.priority;
 	}
 	
 	public static boolean shouldWrapRight(OperatorPriority inner, OperatorPriority outer) {
-		return (inner == outer && inner.isCommutative) || (inner.priority > outer.priority);
+		return (inner == outer && inner.isCommutative) || (inner.priority <= outer.priority);
 	}
 }

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

 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.shared.CodePosition;
 import org.openzen.zenscript.shared.Taggable;
 
 /**
  * @author Hoofdgebruiker
  */
 public abstract class HighLevelDefinition extends Taggable {
+	public final CodePosition position;
 	public final ZSPackage pkg;
 	public final String name;
 	public final int modifiers;
 	public HighLevelDefinition outerDefinition;
 	public ITypeID superType;
 	
-	public HighLevelDefinition(ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+	public HighLevelDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		this.position = position;
 		this.pkg = pkg;
 		this.name = name;
 		this.modifiers = modifiers;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/definition/AliasDefinition.java

 
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.shared.CodePosition;
 
 /**
  *
 public class AliasDefinition extends HighLevelDefinition {
 	public ITypeID type;
 	
-	public AliasDefinition(ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
-		super(pkg, name, modifiers, outerDefinition);
+	public AliasDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		super(position, pkg, name, modifiers, outerDefinition);
 	}
 	
 	public void setType(ITypeID type) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/definition/ClassDefinition.java

 
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.shared.CodePosition;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class ClassDefinition extends HighLevelDefinition {
-	public ClassDefinition(ZSPackage pkg, String name, int modifiers) {
-		this(pkg, name, modifiers, null);
+	public ClassDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers) {
+		this(position, pkg, name, modifiers, null);
 	}
 	
-	public ClassDefinition(ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
-		super(pkg, name, modifiers, outerDefinition);
+	public ClassDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		super(position, pkg, name, modifiers, outerDefinition);
 	}
 	
 	public void setSuperclass(ITypeID superclass) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/definition/EnumDefinition.java

 package org.openzen.zenscript.codemodel.definition;
 
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.shared.CodePosition;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class EnumDefinition extends HighLevelDefinition {
-	public EnumDefinition(ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
-		super(pkg, name, modifiers, outerDefinition);
+	public EnumDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		super(position, pkg, name, modifiers, outerDefinition);
 	}
 
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/definition/ExpansionDefinition.java

 
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.shared.CodePosition;
 
 /**
  *
 public class ExpansionDefinition extends HighLevelDefinition {
 	public ITypeID target;
 	
-	public ExpansionDefinition(ZSPackage pkg, int modifiers, HighLevelDefinition outerDefinition) {
-		super(pkg, null, modifiers, outerDefinition);
+	public ExpansionDefinition(CodePosition position, ZSPackage pkg, int modifiers, HighLevelDefinition outerDefinition) {
+		super(position, pkg, null, modifiers, outerDefinition);
 	}
 
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/definition/FunctionDefinition.java

 import java.util.List;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.OperatorType;
+import org.openzen.zenscript.codemodel.member.OperatorMember;
 import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.type.member.DefinitionMemberGroup;
+import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
+import org.openzen.zenscript.shared.CodePosition;
 
 /**
  *
 public class FunctionDefinition extends HighLevelDefinition {
 	public FunctionHeader header;
 	public List<Statement> statements;
+	public OperatorMember caller;
+	public DefinitionMemberGroup callerGroup = new DefinitionMemberGroup();
 	
-	public FunctionDefinition(ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
-		super(pkg, name, modifiers, outerDefinition);
+	public FunctionDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		super(position, pkg, name, modifiers, outerDefinition);
+	}
+	
+	public FunctionDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, FunctionHeader header) {
+		this(position, pkg, name, modifiers, (HighLevelDefinition) null);
+		setHeader(header);
 	}
 	
 	public void setHeader(FunctionHeader header) {
 		this.header = header;
+		addMember(caller = new OperatorMember(position, modifiers | Modifiers.MODIFIER_STATIC, OperatorType.CALL, header));
+		callerGroup.addMethod(caller, TypeMemberPriority.SPECIFIED);
 	}
 	
 	public void setCode(List<Statement> statements) {
 		this.statements = statements;
+		caller.setBody(statements);
 	}
 
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/definition/InterfaceDefinition.java

 import java.util.List;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.shared.CodePosition;
 
 /**
  *
 public class InterfaceDefinition extends HighLevelDefinition {
 	private final List<ITypeID> baseInterfaces = new ArrayList<>();
 	
-	public InterfaceDefinition(ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
-		super(pkg, name, modifiers, outerDefinition);
+	public InterfaceDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		super(position, pkg, name, modifiers, outerDefinition);
 	}
 	
 	public void addBaseInterface(ITypeID baseInterface) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/definition/StructDefinition.java

 package org.openzen.zenscript.codemodel.definition;
 
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.shared.CodePosition;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class StructDefinition extends HighLevelDefinition {
-	public StructDefinition(ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
-		super(pkg, name, modifiers, outerDefinition);
+	public StructDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		super(position, pkg, name, modifiers, outerDefinition);
 	}
 
 	@Override

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

  * @author Hoofdgebruiker
  */
 public class CallArguments {
-	public static final CallArguments EMPTY = new CallArguments(new Expression[0]);
 	public static final ITypeID[] NO_TYPE_ARGUMENTS = new ITypeID[0];
+	public static final CallArguments EMPTY = new CallArguments(new Expression[0]);
 	
 	public final ITypeID[] typeArguments;
 	public final Expression[] arguments;
 	}
 	
 	public CallArguments(ITypeID[] typeArguments, Expression[] arguments) {
+		if (typeArguments == null)
+			throw new IllegalArgumentException("Type arguments cannot be null!");
+		if (arguments == null)
+			throw new IllegalArgumentException("Arguments cannot be null!");
+		
 		this.typeArguments = typeArguments;
 		this.arguments = arguments;
 	}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.expression;
+
+import org.openzen.zenscript.codemodel.member.CasterMember;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class CastExpression extends Expression {
+	public final Expression target;
+	public final CasterMember member;
+	public final boolean isImplicit;
+	
+	public CastExpression(CodePosition position, Expression target, CasterMember member, boolean isImplicit) {
+		super(position, member.getTargetType());
+		
+		this.target = target;
+		this.member = member;
+		this.isImplicit = isImplicit;
+	}
+
+	@Override
+	public <T> T accept(ExpressionVisitor<T> visitor) {
+		return visitor.visitCast(this);
+	}
+}

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

 	}
 	
 	public Expression castImplicit(CodePosition position, TypeScope scope, ITypeID asType) {
-		return scope.getTypeMembers(type).castImplicit(position, this, asType);
+		return scope.getTypeMembers(type).castImplicit(position, this, asType, true);
 	}
 	
 	@Override

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

 	
 	public T visitCapturedThis(CapturedThisExpression expression);
 	
+	public T visitCast(CastExpression expression);
+	
 	public T visitCheckNull(CheckNullExpression expression);
 	
 	public T visitCoalesce(CoalesceExpression expression);

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

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
-import org.openzen.zenscript.codemodel.expression.CallExpression;
+import org.openzen.zenscript.codemodel.expression.CastExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 	}
 
 	@Override
-	public Expression cast(CodePosition position, Expression value, ITypeID toType) {
-		return new CallExpression(position, value, this, header, CallArguments.EMPTY);
+	public Expression call(CodePosition position, Expression target, FunctionHeader instancedHeader, CallArguments arguments) {
+		throw new UnsupportedOperationException("Cannot call a caster!");
+	}
+
+	@Override
+	public Expression cast(CodePosition position, Expression value, boolean implicit) {
+		return new CastExpression(position, value, this, implicit);
 	}
 	
 	@Override

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

 	public boolean isStatic() {
 		return Modifiers.isStatic(modifiers);
 	}
+	
+	public boolean isFinal() {
+		return Modifiers.isFinal(modifiers);
+	}
 }

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

 package org.openzen.zenscript.codemodel.member;
 
 import java.util.Map;
+import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 public class FieldMember extends DefinitionMember {
 	public final String name;
 	public final ITypeID type;
-	public final boolean isFinal;
 	public Expression initializer;
 	
-	public FieldMember(CodePosition position, int modifiers, String name, ITypeID type, boolean isFinal) {
+	public FieldMember(CodePosition position, int modifiers, String name, ITypeID type) {
 		super(position, modifiers);
 		
 		this.name = name;
 		this.type = type;
-		this.isFinal = isFinal;
 	}
 	
 	public void setInitializer(Expression initializer) {
 
 	@Override
 	public DefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		return new FieldMember(position, modifiers, name, type.withGenericArguments(registry, mapping), isFinal);
+		return new FieldMember(position, modifiers, name, type.withGenericArguments(registry, mapping));
 	}
 
 	@Override

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

 public interface ICasterMember extends IDefinitionMember {
 	public ITypeID getTargetType();
 	
-	public Expression cast(CodePosition position, Expression value, ITypeID toType);
+	public Expression cast(CodePosition position, Expression value, boolean implicit);
 	
 	public boolean isImplicit();
 }

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

 
 	@Override
 	public Expression call(CodePosition position, TypeScope scope, List<ITypeID> hints, CallArguments arguments) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		return group.callStatic(position, scope, arguments);
 	}
 	
 	@Override

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

 import org.openzen.zenscript.codemodel.definition.ClassDefinition;
 import org.openzen.zenscript.codemodel.definition.EnumDefinition;
 import org.openzen.zenscript.codemodel.definition.StructDefinition;
-import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.CallTranslator;
 import org.openzen.zenscript.codemodel.expression.ConstantCharExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantUIntExpression;
 			FunctionHeader addHeader = new FunctionHeader(VOID, new FunctionParameter(baseType, "value"));
 			members.addMethod(new MethodMember(CodePosition.BUILTIN, 0, "add", addHeader), TypeMemberPriority.SPECIFIED);
 
-			members.addField(new FieldMember(CodePosition.BUILTIN, 0, "length", INT, false), TypeMemberPriority.SPECIFIED);
+			members.addField(new FieldMember(CodePosition.BUILTIN, Modifiers.MODIFIER_FINAL, "length", INT), TypeMemberPriority.SPECIFIED);
 		}
 
 		members.addGetter(new GetterMember(CodePosition.BUILTIN, 0, "empty", BOOL), TypeMemberPriority.SPECIFIED);
 		
 		members.addOperator(new OperatorMember(BUILTIN, 0, OperatorType.CONTAINS, new FunctionHeader(BOOL, new FunctionParameter(keyType, "key"))), TypeMemberPriority.SPECIFIED);
 
-		members.addField(new FieldMember(BUILTIN, 0, "length", INT, true), TypeMemberPriority.SPECIFIED);
+		members.addField(new FieldMember(BUILTIN, Modifiers.MODIFIER_FINAL, "length", INT), TypeMemberPriority.SPECIFIED);
 		members.addGetter(new GetterMember(BUILTIN, 0, "empty", BOOL), TypeMemberPriority.SPECIFIED);
 		members.addGetter(new GetterMember(BUILTIN, 0, "keys", cache.getRegistry().getArray(keyType, 1)), TypeMemberPriority.SPECIFIED);
 		return null;
 		ITypeID fromType = range.from;
 		ITypeID toType = range.to;
 
-		members.addField(new FieldMember(BUILTIN, 0, "from", fromType, true), TypeMemberPriority.SPECIFIED);
-		members.addField(new FieldMember(BUILTIN, 0, "to", toType, true), TypeMemberPriority.SPECIFIED);
+		members.addField(new FieldMember(BUILTIN, Modifiers.MODIFIER_FINAL, "from", fromType), TypeMemberPriority.SPECIFIED);
+		members.addField(new FieldMember(BUILTIN, Modifiers.MODIFIER_FINAL, "to", toType), TypeMemberPriority.SPECIFIED);
 		members.addIterator(new RangeIterator(range), TypeMemberPriority.SPECIFIED);
 		return null;
 	}
 	}
 	
 	private static CallTranslator castedTargetCall(FunctionalMember member, CasterMember caster) {
-		return call -> member.call(call.position, caster.call(call.position, call.target, CallArguments.EMPTY), call.arguments);
+		return call -> member.call(call.position, caster.cast(call.position, call.target, true), call.arguments);
 	}
 }

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

 		return false;
 	}
 	
-	public Expression castImplicit(CodePosition position, Expression value, ITypeID toType) {
+	public Expression castImplicit(CodePosition position, Expression value, ITypeID toType, boolean implicit) {
 		if (toType == type || toType == BasicTypeID.UNDETERMINED)
 			return value;
 		if (toType == null)
 		if (type == BasicTypeID.NULL && toType.isOptional())
 			return new NullExpression(position, toType);
 		if (toType.isOptional() && canCastImplicit(toType.unwrap()))
-			return new WrapOptionalExpression(position, castImplicit(position, value, toType.unwrap()), toType);
+			return new WrapOptionalExpression(position, castImplicit(position, value, toType.unwrap(), implicit), toType);
 		if (toType.isConst() && canCastImplicit(toType.unwrap()))
-			return new MakeConstExpression(position, castImplicit(position, value, toType.unwrap()), toType);
+			return new MakeConstExpression(position, castImplicit(position, value, toType.unwrap(), implicit), toType);
 		if (type.isOptional() && type.unwrap() == toType)
 			return new CheckNullExpression(position, value);
 		
 		for (TypeMember<ICasterMember> caster : casters) {
 			if (caster.member.isImplicit() && toType == caster.member.getTargetType())
-				return caster.member.cast(position, value, toType);
+				return caster.member.cast(position, value, implicit);
 		}
 		for (TypeMember<ImplementationMember> implementation : implementations) {
 			if (implementation.member.type == toType)
 	
 	public Expression castExplicit(CodePosition position, Expression value, ITypeID toType, boolean optional) {
 		if (this.canCastImplicit(toType))
-			return castImplicit(position, value, toType);
+			return castImplicit(position, value, toType, false);
 		
 		for (TypeMember<ICasterMember> caster : casters)
 			if (toType == caster.member.getTargetType())
-				return caster.member.cast(position, value, toType);
+				return caster.member.cast(position, value, false);
 		
 		throw new CompileException(position, CompileExceptionCode.INVALID_CAST, "Cannot cast " + toString() + " to " + toType + ", even explicitly");
 	}

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

     public Void visitCapturedThis(CapturedThisExpression expression) {
         return null;
     }
+	
+	@Override
+    public Void visitCast(CastExpression expression) {
+		expression.target.accept(this);
+        if (!checkAndExecuteByteCodeImplementation(expression.member) && !checkAndExecuteMethodInfo(expression.member))
+            throw new IllegalStateException("Call target has no method info!");
+		
+        return null;
+	}
 
     @Override
     public Void visitCheckNull(CheckNullExpression expression) {
 
     @Override
     public Void visitSetField(SetFieldExpression expression) {
-        if (expression.field.isFinal)
+        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, false))
 
     @Override
     public Void visitSetStaticField(SetStaticFieldExpression expression) {
-        if (expression.field.isFinal)
+        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, true))

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

 		this.parameters = parameters;
 		this.type = type;
 		
-		compiled = new AliasDefinition(pkg, name, modifiers, outerDefinition);
+		compiled = new AliasDefinition(position, pkg, name, modifiers, outerDefinition);
 	}
 	
 	@Override

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

 		this.genericParameters = genericParameters;
 		this.superclass = superclass;
 		
-		compiled = new ClassDefinition(pkg, name, modifiers, outerDefinition);
+		compiled = new ClassDefinition(position, pkg, name, modifiers, outerDefinition);
 		for (ParsedGenericParameter parameter : genericParameters)
 			compiled.addGenericParameter(parameter.compiled);
 	}

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

 		
 		this.enumValues = enumValues;
 		
-		compiled = new EnumDefinition(pkg, name, modifiers, outerDefinition);
+		compiled = new EnumDefinition(position, pkg, name, modifiers, outerDefinition);
 	}
 
 	@Override

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

 		this.parameters = parameters;
 		this.target = target;
 		
-		this.compiled = new ExpansionDefinition(pkg, modifiers, outerDefinition);
+		this.compiled = new ExpansionDefinition(position, pkg, modifiers, outerDefinition);
 		for (ParsedGenericParameter parameter : parameters)
 			compiled.addGenericParameter(parameter.compiled);
 	}

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

 		this.header = header;
 		this.body = body;
 		
-		compiled = new FunctionDefinition(pkg, name, modifiers, outerDefinition);
+		compiled = new FunctionDefinition(position, pkg, name, modifiers, outerDefinition);
 	}
 
 	@Override

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

 		this.genericParameters = genericParameters;
 		this.superInterfaces = superInterfaces;
 		
-		compiled = new InterfaceDefinition(pkg, name, modifiers, outerDefinition);
+		compiled = new InterfaceDefinition(position, pkg, name, modifiers, outerDefinition);
 	}
 
 	@Override

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

 		
 		this.parameters = parameters;
 		
-		compiled = new StructDefinition(pkg, name, modifiers, outerDefinition);
+		compiled = new StructDefinition(position, pkg, name, modifiers, outerDefinition);
 		for (ParsedGenericParameter parameter : parameters)
 			compiled.addGenericParameter(parameter.compiled);
 	}

Parser/src/main/java/org/openzen/zenscript/parser/member/ParsedField.java

 package org.openzen.zenscript.parser.member;
 
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.linker.BaseScope;
 
 	@Override
 	public void linkTypes(BaseScope scope) {
-		compiled = new FieldMember(position, modifiers, name, type.compile(scope), isFinal);
+		compiled = new FieldMember(position, modifiers | (isFinal ? Modifiers.MODIFIER_FINAL : 0), name, type.compile(scope));
 	}
 
 	@Override

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

  */
 package org.openzen.zenscript.scriptingexample;
 
+import java.io.PrintStream;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.definition.ClassDefinition;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
+import org.openzen.zenscript.codemodel.definition.FunctionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.expression.GetStaticFieldExpression;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.codemodel.type.FunctionTypeID;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.javabytecode.JavaBytecodeImplementation;
 import org.openzen.zenscript.javabytecode.JavaClassInfo;
 import org.openzen.zenscript.javabytecode.JavaFieldInfo;
 import org.openzen.zenscript.javabytecode.JavaMethodInfo;
  * @author Hoofdgebruiker
  */
 public class GlobalRegistry {
+	public final ZSPackage globals = new ZSPackage("");
 	private final ZSPackage rootPackage = new ZSPackage("");
 	private final ZSPackage javaIo = rootPackage.getOrCreatePackage("java").getOrCreatePackage("io");
 	private final ZSPackage javaLang = rootPackage.getOrCreatePackage("java").getOrCreatePackage("lang");
 	
-	public GlobalRegistry() {
+	public GlobalRegistry(ZSPackage globals) {
 		JavaClassInfo jPrintStream = new JavaClassInfo("java/io/PrintStream");
 		PRINTSTREAM_PRINTLN.setTag(JavaMethodInfo.class, new JavaMethodInfo(jPrintStream, "println", "(Ljava/lang/String;)V"));
 		
 		JavaClassInfo jSystem = new JavaClassInfo("java/lang/System");
 		SYSTEM_OUT.setTag(JavaFieldInfo.class, new JavaFieldInfo(jSystem, "out", "Ljava/io/PrintStream;"));
+		
+		PRINTLN.caller.setTag(JavaBytecodeImplementation.class, writer -> {
+			writer.getField(System.class, "out", PrintStream.class);
+			writer.invokeVirtual("java/io/PrintStream", "println", "(Ljava/lang/String;)V");
+		});
 	}
 	
 	public ZSPackage collectPackages() {
 			// eg. package my.package with a class MyClass with a single native method test() returning a string
 			// the visitors can then during compilation check if a method is an instance of NativeMethodMember and treat it accordingly
 			ZSPackage packageMyPackage = rootPackage.getOrCreatePackage("my").getOrCreatePackage("package");
-			ClassDefinition myClassDefinition = new ClassDefinition(packageMyPackage, "MyClass", Modifiers.MODIFIER_PUBLIC, null);
+			ClassDefinition myClassDefinition = new ClassDefinition(CodePosition.NATIVE, packageMyPackage, "MyClass", Modifiers.MODIFIER_PUBLIC, null);
 			JavaClassInfo myClassInfo = new JavaClassInfo("my/test/MyClass");
 			
 			MethodMember member = new MethodMember(CodePosition.NATIVE, Modifiers.MODIFIER_PUBLIC, "test", new FunctionHeader(BasicTypeID.STRING));
 		return globals;
 	}
 	
-	private final ClassDefinition PRINTSTREAM = new ClassDefinition(javaIo, "PrintStream", Modifiers.MODIFIER_EXPORT);
-	private final ClassDefinition SYSTEM = new ClassDefinition(javaLang, "System", Modifiers.MODIFIER_EXPORT);
+	private final ClassDefinition PRINTSTREAM = new ClassDefinition(CodePosition.NATIVE, javaIo, "PrintStream", Modifiers.MODIFIER_EXPORT);
+	private final ClassDefinition SYSTEM = new ClassDefinition(CodePosition.NATIVE, javaLang, "System", Modifiers.MODIFIER_EXPORT);
 	private final MethodMember PRINTSTREAM_PRINTLN = new MethodMember(
 			CodePosition.NATIVE,
 			Modifiers.MODIFIER_EXPORT,
 	
 	private final FieldMember SYSTEM_OUT = new FieldMember(
 			CodePosition.NATIVE,
-			Modifiers.MODIFIER_EXPORT,
+			Modifiers.MODIFIER_EXPORT | Modifiers.MODIFIER_FINAL,
 			"out",
-			DefinitionTypeID.forType(SYSTEM),
-			true);
+			DefinitionTypeID.forType(SYSTEM));
+	
+	
+	private final FunctionDefinition PRINTLN = new FunctionDefinition(
+			CodePosition.NATIVE,
+			globals,
+			"println",
+			Modifiers.MODIFIER_EXPORT,
+			new FunctionHeader(BasicTypeID.VOID, new FunctionParameter(BasicTypeID.STRING)));
 	
 	private class PrintlnSymbol implements ISymbol {
 
 		@Override
 		public IPartialExpression getExpression(CodePosition position, GlobalTypeRegistry types, List<ITypeID> typeArguments) {
+			//return new PartialStaticMemberGroupExpression(position, PRINTLN.callerGroup);
 			return new PartialMemberGroupExpression(
 					position,
 					new GetStaticFieldExpression(position, SYSTEM_OUT),

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

 		ZSPackage pkg = new ZSPackage("");
 		ParsedFile[] parsedFiles = parse(pkg, inputFiles);
 		
-		GlobalRegistry registry = new GlobalRegistry();
+		ZSPackage global = new ZSPackage("");
+		GlobalRegistry registry = new GlobalRegistry(global);
 		SemanticModule module = compileSyntaxToSemantic(parsedFiles, registry);
 		
-		FormattingSettings settings = new FormattingSettings.Builder().build();
+		/*FormattingSettings settings = new FormattingSettings.Builder().build();
 		for (ScriptBlock block : module.scripts) {
 			FileFormatter formatter = new FileFormatter(settings);
 			System.out.println("== " + block.getTag(SourceFile.class).filename + " ==");
 			System.out.println(formatter.format(pkg, block, Collections.emptyList()));
-		}
+		}*/
 		
 		JavaModule javaModule = compileSemanticToJava(module);
 		javaModule.execute();