- Added annotation support

- Removed some redundant types
- Moved scopes to CodeModel and removed Linker
- Added const members and expression support for them
- Added statement transformation (can be used by annotations)

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

 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.ConstExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantBoolExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantByteExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantCharExpression;
 		result.append(expression.ifElse.accept(this));
 		return new ExpressionString(result.toString(), ZenScriptOperator.TERNARY);
 	}
+	
+	@Override
+	public ExpressionString visitConst(ConstExpression expression) {
+		StringBuilder result = new StringBuilder();
+		result.append(expression.type.accept(typeFormatter));
+		result.append('.');
+		result.append(expression.constant.name);
+		return new ExpressionString(result.toString(), ZenScriptOperator.MEMBER);
+	}
 
 	@Override
 	public ExpressionString visitConstantBool(ConstantBoolExpression expression) {
 
 	@Override
 	public ExpressionString visitConstantByte(ConstantByteExpression expression) {
-		return new ExpressionString(Byte.toString(expression.value) + " as byte", ZenScriptOperator.CAST);
+		return new ExpressionString(Integer.toString(expression.value) + " as byte", ZenScriptOperator.CAST);
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.member.CallerMember;
 import org.openzen.zenscript.codemodel.member.CasterMember;
+import org.openzen.zenscript.codemodel.member.ConstMember;
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
 import org.openzen.zenscript.codemodel.member.CustomIteratorMember;
 import org.openzen.zenscript.codemodel.member.DestructorMember;
-import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.codemodel.member.GetterMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 		
 		wasField = field;
 	}
+	
+	@Override
+	public Void visitConst(ConstMember member) {
+		visit(true);
+		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		output.append("const")
+				.append(member.name)
+				.append(" as ")
+				.append(member.type.accept(typeFormatter))
+				.append(" = ")
+				.append(member.value.accept(new ExpressionFormatter(settings, typeFormatter)))
+				.append(";\n");
+		return null;
+	}
 
 	@Override
 	public Void visitField(FieldMember member) {
 			output.append(" = ")
 					.append(member.initializer.accept(new ExpressionFormatter(settings, typeFormatter)));
 		}
-		output.append(";").append("\n");
+		output.append(";\n");
 		return null;
 	}
 

Linker/build.gradle → CodeFormatterShared/build.gradle

 }
 
 dependencies {
-	compile project(':Shared')
 	compile project(':CodeModel')
 }

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

  */
 package org.openzen.zenscript.codemodel;
 
+import org.openzen.zenscript.codemodel.annotations.Annotation;
 import java.util.Map;
 import java.util.Objects;
 import org.openzen.zenscript.codemodel.expression.Expression;
 public class FunctionParameter extends Taggable {
 	public static final FunctionParameter[] NONE = new FunctionParameter[0];
 	
+	public Annotation[] annotations;
 	public final ITypeID type;
 	public final String name;
 	public final Expression defaultValue;
 	public final boolean variadic;
 	
 	public FunctionParameter(ITypeID type) {
+		this.annotations = Annotation.NONE;
 		this.type = type;
 		this.name = "";
 		this.defaultValue = null;
 	}
 	
 	public FunctionParameter(ITypeID type, String name) {
+		this.annotations = Annotation.NONE;
 		this.type = type;
 		this.name = name;
 		this.defaultValue = null;
 	}
 	
 	public FunctionParameter(ITypeID type, String name, Expression defaultValue, boolean variadic) {
+		this.annotations = Annotation.NONE;
 		this.type = type;
 		this.name = name;
 		this.defaultValue = defaultValue;
 	}
 	
 	public FunctionParameter withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments) {
-		return new FunctionParameter(type.withGenericArguments(registry, arguments), name, defaultValue, variadic);
+		FunctionParameter result = new FunctionParameter(type.withGenericArguments(registry, arguments), name, defaultValue, variadic);
+		result.annotations = annotations;
+		return result;
 	}
 	
 	@Override

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

 
 import java.util.ArrayList;
 import java.util.List;
+import org.openzen.zenscript.codemodel.annotations.DefinitionAnnotation;
 import org.openzen.zenscript.codemodel.definition.DefinitionVisitor;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 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.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 	public final List<IDefinitionMember> members = new ArrayList<>();
 	public final AccessScope access = new AccessScope();
 	public TypeParameter[] genericParameters = null;
+	public DefinitionAnnotation[] annotations = DefinitionAnnotation.NONE;
 	
 	public HighLevelDefinition outerDefinition;
 	public ITypeID superType;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/ModuleProcessor.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;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface ModuleProcessor {
+	public ScriptBlock process(ScriptBlock block);
+	
+	public void process(HighLevelDefinition definition);
+}

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

  * @author Hoofdgebruiker
  */
 public class ScriptBlock extends Taggable {
+	public final AccessScope access;
 	public final List<Statement> statements;
 	
-	public ScriptBlock(List<Statement> statements) {
+	public ScriptBlock(AccessScope access, List<Statement> statements) {
+		this.access = access;
 		this.statements = statements;
 	}
+	
+	public ScriptBlock withStatements(List<Statement> newStatements) {
+		ScriptBlock result = new ScriptBlock(access, newStatements);
+		result.addAllTagsFrom(this);
+		return result;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/Annotation.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.annotations;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface Annotation {
+	public static final Annotation[] NONE = new Annotation[0];
+	
+	public void apply();
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/AnnotationDefinition.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.annotations;
+
+import java.util.List;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.expression.CallArguments;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.scope.BaseScope;
+import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.scope.StatementScope;
+import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface AnnotationDefinition {
+	public String getAnnotationName();
+	
+	public List<FunctionHeader> getInitializers(BaseScope scope);
+	
+	public ExpressionScope getScopeForMember(IDefinitionMember member, BaseScope scope);
+	
+	public ExpressionScope getScopeForType(HighLevelDefinition definition, BaseScope scope);
+	
+	public ExpressionScope getScopeForStatement(Statement statement, StatementScope scope);
+	
+	public ExpressionScope getScopeForParameter(FunctionHeader header, FunctionParameter parameter, BaseScope scope);
+	
+	public MemberAnnotation createForMember(CodePosition position, CallArguments arguments);
+	
+	public DefinitionAnnotation createForDefinition(CodePosition position, CallArguments arguments);
+	
+	public StatementAnnotation createForStatement(CodePosition position, CallArguments arguments);
+	
+	public Annotation createForParameter(CodePosition position, CallArguments arguments);
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/AnnotationProcessor.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.annotations;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.ModuleProcessor;
+import org.openzen.zenscript.codemodel.PackageDefinitions;
+import org.openzen.zenscript.codemodel.ScriptBlock;
+import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
+import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.member.CallerMember;
+import org.openzen.zenscript.codemodel.member.CasterMember;
+import org.openzen.zenscript.codemodel.member.ConstMember;
+import org.openzen.zenscript.codemodel.member.ConstructorMember;
+import org.openzen.zenscript.codemodel.member.CustomIteratorMember;
+import org.openzen.zenscript.codemodel.member.DestructorMember;
+import org.openzen.zenscript.codemodel.member.FieldMember;
+import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.member.GetterMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.member.ImplementationMember;
+import org.openzen.zenscript.codemodel.member.InnerDefinitionMember;
+import org.openzen.zenscript.codemodel.member.MemberVisitor;
+import org.openzen.zenscript.codemodel.member.MethodMember;
+import org.openzen.zenscript.codemodel.member.OperatorMember;
+import org.openzen.zenscript.codemodel.member.SetterMember;
+import org.openzen.zenscript.codemodel.member.StaticInitializerMember;
+import org.openzen.zenscript.codemodel.scope.DefinitionScope;
+import org.openzen.zenscript.codemodel.scope.FileScope;
+import org.openzen.zenscript.codemodel.scope.FunctionScope;
+import org.openzen.zenscript.codemodel.scope.GlobalScriptScope;
+import org.openzen.zenscript.codemodel.scope.StatementScope;
+import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class AnnotationProcessor implements ModuleProcessor {
+	private final ZSPackage rootPackage;
+	private final PackageDefinitions packageDefinitions;
+	private final GlobalTypeRegistry globalRegistry;
+	private final List<ExpansionDefinition> expansions;
+	private final List<AnnotationDefinition> annotations;
+	
+	public AnnotationProcessor(
+			ZSPackage rootPackage,
+			PackageDefinitions packageDefinitions,
+			GlobalTypeRegistry globalRegistry,
+			List<ExpansionDefinition> expansions,
+			List<AnnotationDefinition> annotations) {
+		this.rootPackage = rootPackage;
+		this.packageDefinitions = packageDefinitions;
+		this.globalRegistry = globalRegistry;
+		this.expansions = expansions;
+		this.annotations = annotations;
+	}
+	
+	@Override
+	public ScriptBlock process(ScriptBlock block) {
+		FileScope fileScope = new FileScope(block.access, rootPackage, packageDefinitions, globalRegistry, expansions, new HashMap<>(), annotations);
+		StatementScope scope = new GlobalScriptScope(fileScope);
+		List<Statement> transformed = new ArrayList<>();
+		boolean unchanged = true;
+		for (Statement statement : block.statements) {
+			Statement newStatement = process(statement, scope);
+			transformed.add(newStatement);
+			unchanged &= statement == newStatement;
+		}
+		return unchanged ? block : block.withStatements(transformed);
+	}
+	
+	@Override
+	public void process(HighLevelDefinition definition) {
+		FileScope fileScope = new FileScope(definition.access, rootPackage, packageDefinitions, globalRegistry, expansions, new HashMap<>(), annotations);
+		DefinitionScope scope = new DefinitionScope(fileScope, definition);
+		for (DefinitionAnnotation annotation : definition.annotations) {
+			annotation.apply(definition, scope);
+		}
+		
+		MemberAnnotationVisitor visitor = new MemberAnnotationVisitor(scope);
+		for (IDefinitionMember member : definition.members) {
+			member.accept(visitor);
+		}
+	}
+	
+	private Statement process(Statement statement, StatementScope scope) {
+		return statement.transform(s -> {
+			for (StatementAnnotation annotation : s.annotations) {
+				s = annotation.apply(s, scope);
+			}
+			return s;
+		});
+	}
+	
+	private class MemberAnnotationVisitor implements MemberVisitor<Void> {
+		private final DefinitionScope scope;
+		
+		public MemberAnnotationVisitor(DefinitionScope scope) {
+			this.scope = scope;
+		}
+		
+		@Override
+		public Void visitConst(ConstMember member) {
+			for (MemberAnnotation annotation : member.annotations)
+				annotation.apply(member, scope);
+			
+			return null;
+		}
+
+		@Override
+		public Void visitField(FieldMember member) {
+			for (MemberAnnotation annotation : member.annotations)
+				annotation.apply(member, scope);
+			
+			return null;
+		}
+
+		@Override
+		public Void visitConstructor(ConstructorMember member) {
+			return functional(member);
+		}
+
+		@Override
+		public Void visitDestructor(DestructorMember member) {
+			return functional(member);
+		}
+
+		@Override
+		public Void visitMethod(MethodMember member) {
+			return functional(member);
+		}
+
+		@Override
+		public Void visitGetter(GetterMember member) {
+			return functional(member);
+		}
+
+		@Override
+		public Void visitSetter(SetterMember member) {
+			return functional(member);
+		}
+
+		@Override
+		public Void visitOperator(OperatorMember member) {
+			return functional(member);
+		}
+
+		@Override
+		public Void visitCaster(CasterMember member) {
+			return functional(member);
+		}
+
+		@Override
+		public Void visitCustomIterator(CustomIteratorMember member) {
+			throw new UnsupportedOperationException("Not supported yet!");
+		}
+
+		@Override
+		public Void visitCaller(CallerMember member) {
+			return functional(member);
+		}
+
+		@Override
+		public Void visitImplementation(ImplementationMember implementation) {
+			for (IDefinitionMember member : implementation.members) {
+				member.accept(this);
+			}
+			return null;
+		}
+
+		@Override
+		public Void visitInnerDefinition(InnerDefinitionMember member) {
+			process(member.innerDefinition);
+			return null;
+		}
+
+		@Override
+		public Void visitStaticInitializer(StaticInitializerMember member) {
+			StatementScope scope = new FunctionScope(this.scope, new FunctionHeader(BasicTypeID.VOID));
+			member.body = process(member.body, scope);
+			return null;
+		}
+		
+		private Void functional(FunctionalMember member) {
+			for (MemberAnnotation annotation : member.annotations)
+				annotation.apply(member, scope);
+			
+			if (member.overrides != null) {
+				functional(member, member.overrides);
+			}
+			
+			if (member.body == null)
+				return null;
+			
+			StatementScope scope = new FunctionScope(this.scope, member.header);
+			member.body = process(member.body, scope);
+			return null;
+		}
+		
+		private void functional(FunctionalMember member, FunctionalMember overrides) {
+			for (MemberAnnotation annotation : overrides.annotations)
+				annotation.applyOnOverridingMethod(member, scope);
+			
+			if (overrides.overrides != null) {
+				functional(member, overrides.overrides);
+			}
+		}
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/DefinitionAnnotation.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.annotations;
+
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.scope.BaseScope;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface DefinitionAnnotation {
+	public static final DefinitionAnnotation[] NONE = new DefinitionAnnotation[0];
+	
+	public void apply(HighLevelDefinition definition, BaseScope scope);
+	
+	public void applyOnSubtype(HighLevelDefinition definition, BaseScope scope);
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/MemberAnnotation.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.annotations;
+
+import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.scope.BaseScope;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface MemberAnnotation {
+	public static final MemberAnnotation[] NONE = new MemberAnnotation[0];
+	
+	public void apply(IDefinitionMember member, BaseScope scope);
+	
+	public void applyOnOverridingMethod(FunctionalMember member, BaseScope scope);
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/NativeAnnotationDefinition.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.annotations;
+
+import java.util.Collections;
+import java.util.List;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.expression.CallArguments;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.scope.BaseScope;
+import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.scope.StatementScope;
+import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class NativeAnnotationDefinition implements AnnotationDefinition {
+	public static final NativeAnnotationDefinition INSTANCE = new NativeAnnotationDefinition();
+	
+	private static final List<FunctionHeader> INITIALIZERS = Collections.singletonList(
+			new FunctionHeader(BasicTypeID.VOID, BasicTypeID.STRING));
+	
+	private NativeAnnotationDefinition() {}
+
+	@Override
+	public String getAnnotationName() {
+		return "Native";
+	}
+
+	@Override
+	public List<FunctionHeader> getInitializers(BaseScope scope) {
+		return INITIALIZERS;
+	}
+
+	@Override
+	public ExpressionScope getScopeForMember(IDefinitionMember member, BaseScope scope) {
+		return new ExpressionScope(scope);
+	}
+
+	@Override
+	public ExpressionScope getScopeForType(HighLevelDefinition definition, BaseScope scope) {
+		return new ExpressionScope(scope);
+	}
+
+	@Override
+	public ExpressionScope getScopeForStatement(Statement statement, StatementScope scope) {
+		return new ExpressionScope(scope);
+	}
+
+	@Override
+	public ExpressionScope getScopeForParameter(FunctionHeader header, FunctionParameter parameter, BaseScope scope) {
+		return new ExpressionScope(scope);
+	}
+
+	@Override
+	public MemberAnnotation createForMember(CodePosition position, CallArguments arguments) {
+		Expression value = arguments.arguments[0];
+		String constant = value.evaluateStringConstant();
+		return new NativeMemberAnnotation(constant);
+	}
+
+	@Override
+	public DefinitionAnnotation createForDefinition(CodePosition position, CallArguments arguments) {
+		Expression value = arguments.arguments[0];
+		String constant = value.evaluateStringConstant();
+		return new NativeDefinitionAnnotation(constant);
+	}
+
+	@Override
+	public StatementAnnotation createForStatement(CodePosition position, CallArguments arguments) {
+		throw new UnsupportedOperationException("Not supported");
+	}
+
+	@Override
+	public Annotation createForParameter(CodePosition position, CallArguments arguments) {
+		throw new UnsupportedOperationException("Not supported");
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/NativeDefinitionAnnotation.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.annotations;
+
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.scope.BaseScope;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class NativeDefinitionAnnotation implements DefinitionAnnotation {
+	private final String identifier;
+	
+	public NativeDefinitionAnnotation(String identifier) {
+		this.identifier = identifier;
+	}
+	
+	@Override
+	public void apply(HighLevelDefinition definition, BaseScope scope) {
+		definition.setTag(NativeTag.class, new NativeTag(identifier));
+	}
+
+	@Override
+	public void applyOnSubtype(HighLevelDefinition definition, BaseScope scope) {
+		// this annotation is not inherited
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/NativeMemberAnnotation.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.annotations;
+
+import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.scope.BaseScope;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class NativeMemberAnnotation implements MemberAnnotation {
+	private final String identifier;
+	
+	public NativeMemberAnnotation(String identifier) {
+		this.identifier = identifier;
+	}
+	
+	@Override
+	public void apply(IDefinitionMember member, BaseScope scope) {
+		member.setTag(NativeTag.class, new NativeTag(identifier));
+	}
+
+	@Override
+	public void applyOnOverridingMethod(FunctionalMember member, BaseScope scope) {
+		// not inherited
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/NativeTag.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.annotations;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class NativeTag {
+	public final String value;
+	
+	public NativeTag(String value) {
+		this.value = value;
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/PreconditionAnnotationDefinition.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.annotations;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.definition.FunctionDefinition;
+import org.openzen.zenscript.codemodel.expression.CallArguments;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.scope.BaseScope;
+import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.scope.FunctionScope;
+import org.openzen.zenscript.codemodel.scope.StatementScope;
+import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class PreconditionAnnotationDefinition implements AnnotationDefinition {
+	public static final PreconditionAnnotationDefinition INSTANCE = new PreconditionAnnotationDefinition();
+	
+	private final List<GenericName> enforcementLevelName = Arrays.asList(
+			new GenericName("stdlib"),
+			new GenericName("EnforcementLevel"));
+	
+	private PreconditionAnnotationDefinition() {}
+
+	@Override
+	public String getAnnotationName() {
+		return "Precondition";
+	}
+
+	@Override
+	public List<FunctionHeader> getInitializers(BaseScope scope) {
+		return Collections.singletonList(new FunctionHeader(
+				BasicTypeID.VOID,
+				scope.getType(CodePosition.BUILTIN, enforcementLevelName),
+				BasicTypeID.BOOL,
+				BasicTypeID.STRING));
+	}
+
+	@Override
+	public ExpressionScope getScopeForMember(IDefinitionMember member, BaseScope scope) {
+		if (member instanceof FunctionalMember) {
+			FunctionHeader header = ((FunctionalMember)member).header;
+			return new ExpressionScope(new FunctionScope(scope, header));
+		} else {
+			throw new UnsupportedOperationException("Can only assign preconditions to methods");
+		}
+	}
+
+	@Override
+	public ExpressionScope getScopeForType(HighLevelDefinition definition, BaseScope scope) {
+		if (definition instanceof FunctionDefinition) {
+			FunctionHeader header = ((FunctionDefinition)definition).header;
+			return new ExpressionScope(new FunctionScope(scope, header));
+		} else {
+			throw new UnsupportedOperationException("Can only assign preconditions to functions");
+		}
+	}
+
+	@Override
+	public ExpressionScope getScopeForStatement(Statement statement, StatementScope scope) {
+		throw new UnsupportedOperationException("Not supported");
+	}
+
+	@Override
+	public ExpressionScope getScopeForParameter(FunctionHeader header, FunctionParameter parameter, BaseScope scope) {
+		throw new UnsupportedOperationException("Not supported");
+	}
+
+	@Override
+	public MemberAnnotation createForMember(CodePosition position, CallArguments arguments) {
+		String enforcement = arguments.arguments[0].evaluateEnumConstant().name;
+		Expression condition = arguments.arguments[1];
+		Expression message = arguments.arguments[2];
+		return new PreconditionForMethod(position, enforcement, condition, message);
+	}
+
+	@Override
+	public DefinitionAnnotation createForDefinition(CodePosition position, CallArguments arguments) {
+		throw new UnsupportedOperationException("Not supported");
+	}
+
+	@Override
+	public StatementAnnotation createForStatement(CodePosition position, CallArguments arguments) {
+		throw new UnsupportedOperationException("Not supported");
+	}
+
+	@Override
+	public Annotation createForParameter(CodePosition position, CallArguments arguments) {
+		throw new UnsupportedOperationException("Not supported");
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/PreconditionForMethod.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.annotations;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.expression.ExpressionBuilder;
+import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+import org.openzen.zenscript.codemodel.scope.BaseScope;
+import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.statement.BlockStatement;
+import org.openzen.zenscript.codemodel.statement.IfStatement;
+import org.openzen.zenscript.codemodel.statement.Statement;
+import org.openzen.zenscript.codemodel.statement.ThrowStatement;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class PreconditionForMethod implements MemberAnnotation {
+	private final CodePosition position;
+	private final String enforcement;
+	private final Expression condition;
+	private final Expression message;
+	
+	public PreconditionForMethod(
+			CodePosition position,
+			String enforcement,
+			Expression condition,
+			Expression message) {
+		this.position = position;
+		this.enforcement = enforcement;
+		this.condition = condition;
+		this.message = message;
+	}
+
+	@Override
+	public void apply(IDefinitionMember member, BaseScope scope) {
+		applyOnOverridingMethod((FunctionalMember)member, scope);
+	}
+
+	@Override
+	public void applyOnOverridingMethod(FunctionalMember member, BaseScope scope) {
+		if (member.body == null)
+			return;
+		
+		ExpressionScope expressionScope = new ExpressionScope(scope, BasicTypeID.BOOL);
+		List<Statement> statements = new ArrayList<>();
+		ExpressionBuilder expressionBuilder = new ExpressionBuilder(position, expressionScope);
+		Expression inverseCondition = expressionBuilder.not(condition);
+		Statement throwStatement = new ThrowStatement(CodePosition.BUILTIN, expressionBuilder.constructNew("stdlib.IllegalArgumentException", message));
+		statements.add(new IfStatement(CodePosition.BUILTIN, inverseCondition, throwStatement, null));
+		if (member.body instanceof BlockStatement) {
+			statements.addAll(((BlockStatement)member.body).statements);
+		} else {
+			statements.add(member.body);
+		}
+		member.body = new BlockStatement(position, statements);
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/StatementAnnotation.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.annotations;
+
+import org.openzen.zenscript.codemodel.scope.StatementScope;
+import org.openzen.zenscript.codemodel.statement.Statement;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface StatementAnnotation {
+	public static final StatementAnnotation[] NONE = new StatementAnnotation[0];
+	
+	public Statement apply(Statement statement, StatementScope scope);
+}

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

 				? this
 				: new CallExpression(position, tTarget, member, instancedHeader, tArguments, null);
 	}
+	
+	@Override
+	public String evaluateStringConstant() {
+		if (member.builtin == null)
+			throw new UnsupportedOperationException("Cannot evaluate to a string constant!");
+		
+		switch (member.builtin) {
+			case STRING_ADD_STRING:
+				return target.evaluateStringConstant() + arguments.arguments[0].evaluateStringConstant();
+			default:
+				throw new UnsupportedOperationException("Cannot evaluate to a string constant!");
+		}
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/ConstExpression.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.ConstMember;
+import org.openzen.zenscript.codemodel.member.EnumConstantMember;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ConstExpression extends Expression {
+	public final ConstMember constant;
+	
+	public ConstExpression(CodePosition position, ConstMember constant) {
+		super(position, constant.type, null);
+		
+		this.constant = constant;
+	}
+
+	@Override
+	public <T> T accept(ExpressionVisitor<T> visitor) {
+		return visitor.visitConst(this);
+	}
+
+	@Override
+	public Expression transform(ExpressionTransformer transformer) {
+		return this;
+	}
+	
+	@Override
+	public String evaluateStringConstant() {
+		return constant.value.evaluateStringConstant();
+	}
+	
+	@Override
+	public EnumConstantMember evaluateEnumConstant() {
+		return constant.value.evaluateEnumConstant();
+	}
+}

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

  * @author Hoofdgebruiker
  */
 public class ConstantByteExpression extends Expression {
-	public final byte value;
+	public final int value;
 	
-	public ConstantByteExpression(CodePosition position, byte value) {
+	public ConstantByteExpression(CodePosition position, int value) {
 		super(position, BasicTypeID.BYTE, null);
 		
 		this.value = value;

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

 	public Expression transform(ExpressionTransformer transformer) {
 		return this;
 	}
+	
+	@Override
+	public String evaluateStringConstant() {
+		return value;
+	}
 }

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

  * @author Hoofdgebruiker
  */
 public class ConstantUShortExpression extends Expression {
-	public final short value;
+	public final int value;
 	
-	public ConstantUShortExpression(CodePosition position, short value) {
+	public ConstantUShortExpression(CodePosition position, int value) {
 		super(position, BasicTypeID.USHORT, null);
 		
 		this.value = value;

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

 	public Expression transform(ExpressionTransformer transformer) {
 		return this;
 	}
+	
+	@Override
+	public EnumConstantMember evaluateEnumConstant() {
+		return value;
+	}
 }

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

 
 import java.util.Collections;
 import java.util.List;
-import java.util.Map;
+import java.util.function.Consumer;
 import java.util.stream.Collectors;
 import org.openzen.zenscript.codemodel.FunctionHeader;
-import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.OperatorType;
+import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.shared.CodePosition;
 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.FunctionTypeID;
 import org.openzen.zenscript.shared.CompileException;
 import org.openzen.zenscript.shared.CompileExceptionCode;
 
  * @author Hoofdgebruiker
  */
 public abstract class Expression implements IPartialExpression {
+	public static final Expression[] NONE = new Expression[0];
+	
 	public final CodePosition position;
 	public final ITypeID type;
 	public final ITypeID thrownType;
 	
 	public abstract Expression transform(ExpressionTransformer transformer);
 	
+	public final Expression transform(StatementTransformer transformer) {
+		return transform((ExpressionTransformer)expression -> {
+			if (expression instanceof FunctionExpression) {
+				FunctionExpression function = (FunctionExpression)expression;
+				Statement body = function.body.transform(transformer);
+				if (body == function.body)
+					return function;
+				
+				return new FunctionExpression(function.position, (FunctionTypeID)function.type, function.closure, body);
+			} else {
+				return expression;
+			}
+		});
+	}
+	
 	@Override
 	public List<ITypeID> getAssignHints() {
 		return Collections.singletonList(type);
 		return scope.getTypeMembers(type)
 				.getOrCreateGroup(OperatorType.CALL)
 				.getMethodMembers().stream()
-				.filter(method -> method.member.getHeader().parameters.length == arguments && !method.member.isStatic())
-				.map(method -> method.member.getHeader())
+				.filter(method -> method.member.header.parameters.length == arguments && !method.member.isStatic())
+				.map(method -> method.member.header)
 				.collect(Collectors.toList());
 	}
 	
 	@Override
 	public IPartialExpression getMember(CodePosition position, TypeScope scope, List<ITypeID> hints, GenericName name) {
 		TypeMembers members = scope.getTypeMembers(type);
-		return members.getMemberExpression(position, this, name, false);
+		IPartialExpression result = members.getMemberExpression(position, this, name, false);
+		if (result == null)
+			System.out.println("No such member: " + name.name);
+		return result;
 	}
 	
 	@Override
 		return null;
 	}
 	
+	public void forEachStatement(Consumer<Statement> consumer) {
+		
+	}
+	
+	public String evaluateStringConstant() {
+		throw new UnsupportedOperationException("Cannot evaluate this value to a string constant!");
+	}
+	
+	public EnumConstantMember evaluateEnumConstant() {
+		throw new UnsupportedOperationException("Cannot evaluate this value to an enum constant!");
+	}
+	
 	public static ITypeID binaryThrow(CodePosition position, ITypeID left, ITypeID right) {
 		if (left == right)
 			return left;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/expression/ExpressionBuilder.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 java.util.ArrayList;
+import java.util.List;
+import org.openzen.zenscript.codemodel.OperatorType;
+import org.openzen.zenscript.codemodel.member.ConstructorMember;
+import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.member.DefinitionMemberGroup;
+import org.openzen.zenscript.codemodel.type.member.TypeMembers;
+import org.openzen.zenscript.shared.CodePosition;
+import org.openzen.zenscript.shared.CompileException;
+import org.openzen.zenscript.shared.CompileExceptionCode;
+import org.openzen.zenscript.shared.StringUtils;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ExpressionBuilder {
+	public final CodePosition position;
+	public final ExpressionScope scope;
+	
+	public ExpressionBuilder(CodePosition position, ExpressionScope scope) {
+		this.position = position;
+		this.scope = scope;
+	}
+	
+	public Expression constructNew(String typename, Expression... arguments) {
+		List<String> nameParts = StringUtils.split(typename, '.');
+		List<GenericName> name = new ArrayList<>();
+		for (String namePart : nameParts)
+			name.add(new GenericName(namePart));
+		ITypeID type = scope.getType(position, name);
+		if (type == null)
+			throw new CompileException(position, CompileExceptionCode.NO_SUCH_TYPE, "No such type: " + typename);
+		
+		return constructNew(type, arguments);
+	}
+	
+	public Expression constructNew(ITypeID type, Expression... arguments) {
+		DefinitionMemberGroup constructors = scope.getTypeMembers(type).getOrCreateGroup(OperatorType.CONSTRUCTOR);
+		List<ITypeID>[] predictedTypes = constructors.predictCallTypes(scope, scope.hints, arguments.length);
+		CallArguments compiledArguments = new CallArguments(arguments);
+		FunctionalMember member = constructors.selectMethod(position, scope, compiledArguments, true, true);
+		if (member == null)
+			throw new CompileException(position, CompileExceptionCode.CALL_NO_VALID_METHOD, "No matching constructor found");
+		if (!(member instanceof ConstructorMember))
+			throw new CompileException(position, CompileExceptionCode.INTERNAL_ERROR, "COMPILER BUG: constructor is not a constructor");
+		
+		return new NewExpression(
+				position,
+				type,
+				(ConstructorMember) member,
+				compiledArguments,
+				compiledArguments.getNumberOfTypeArguments() == 0 ? member.header : member.header.withGenericArguments(scope.getTypeRegistry(), compiledArguments.typeArguments),
+				scope);
+	}
+	
+	public Expression not(Expression value) {
+		TypeMembers members = scope.getTypeMembers(value.type);
+		return members.getOrCreateGroup(OperatorType.NOT)
+				.call(position, scope, value, CallArguments.EMPTY, false);
+	}
+}

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

 	
 	public T visitConditional(ConditionalExpression expression);
 	
+	public T visitConst(ConstExpression expression);
+	
 	public T visitConstantBool(ConstantBoolExpression expression);
 	
 	public T visitConstantByte(ConstantByteExpression expression);

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

 
 import java.util.HashMap;
 import java.util.Map;
+import java.util.function.Consumer;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.statement.ExpressionStatement;
 		return tBody == body ? this : new FunctionExpression(position, (FunctionTypeID)type, closure, tBody);
 	}
 	
+	@Override
+	public void forEachStatement(Consumer<Statement> consumer) {
+		body.forEachStatement(consumer);
+	}
+	
 	/**
 	 * Checks if this is a simple function expression. A simple function
 	 * expression consists of a body with just a expression or return statement.

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

 	public final Expression[] arguments;
 	
 	public VariantValueExpression(CodePosition position, ITypeID variantType, VariantDefinition.Option option) {
-		this(position, variantType, option, null);
+		this(position, variantType, option, Expression.NONE);
 	}
 	
 	public VariantValueExpression(CodePosition position, ITypeID variantType, VariantDefinition.Option option, Expression[] arguments) {
-		super(position, variantType, arguments == null ? null : multiThrow(position, arguments));
+		super(position, variantType, multiThrow(position, arguments));
 		
 		this.option = option;
-		this.arguments = null;
+		this.arguments = arguments;
 	}
 	
 	public int getNumberOfArguments() {

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

  *
  * @author Hoofdgebruiker
  */
-public class CasterMember extends FunctionalMember implements ICasterMember {
+public class CasterMember extends FunctionalMember {
 	public final ITypeID toType;
 	
 	public CasterMember(
 				builtin);
 	}
 	
-	@Override
 	public ITypeID getTargetType() {
 		return toType;
 	}
 	public Expression call(CodePosition position, Expression target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
 		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
 	public boolean isImplicit() {
 		return Modifiers.isImplicit(modifiers);
 	}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ConstMember.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.member;
+
+import java.util.Map;
+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.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.member.BuiltinID;
+import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
+import org.openzen.zenscript.codemodel.type.member.TypeMembers;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ConstMember extends DefinitionMember {
+	public final String name;
+	public final ITypeID type;
+	public Expression value;
+	public final BuiltinID builtin;
+	
+	public ConstMember(CodePosition position, HighLevelDefinition definition, int modifiers, String name, ITypeID type, BuiltinID builtin) {
+		super(position, definition, modifiers);
+		
+		this.name = name;
+		this.type = type;
+		this.builtin = builtin;
+	}
+
+	@Override
+	public String describe() {
+		return "const " + name;
+	}
+
+	@Override
+	public BuiltinID getBuiltin() {
+		return builtin;
+	}
+
+	@Override
+	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
+		type.addConst(this);
+	}
+
+	@Override
+	public IDefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
+		return this;
+	}
+
+	@Override
+	public <T> T accept(MemberVisitor<T> visitor) {
+		return visitor.visitConst(this);
+	}
+}

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

 				modifiers,
 				header.instance(registry, mapping),
 				builtin);
-		if (definition.name.equals("NFAState"))
-			System.out.println("X");
 		return result;
 	}
 

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

 
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.shared.CodePosition;
 import org.openzen.zenscript.shared.Taggable;
 
 	public final CodePosition position;
 	public final HighLevelDefinition definition;
 	public final int modifiers;
+	public MemberAnnotation[] annotations = MemberAnnotation.NONE;
 	
 	public DefinitionMember(CodePosition position, HighLevelDefinition definition, int modifiers) {
 		this.position = position;

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

  *
  * @author Hoofdgebruiker
  */
-public abstract class FunctionalMember extends DefinitionMember implements ICallableMember {
+public abstract class FunctionalMember extends DefinitionMember {
 	public final FunctionHeader header;
 	public final String name;
 	public final BuiltinID builtin;
-	public Statement body;
+	public Statement body = null;
+	public FunctionalMember overrides = null;
 	
 	public FunctionalMember(
 			CodePosition position,
 		this.body = body;
 	}
 	
-	@Override
-	public FunctionHeader getHeader() {
-		return header;
-	}
+	public abstract String getInformalName();
 	
 	@Override
 	public BuiltinID getBuiltin() {
 		return builtin;
 	}
-
-	@Override
+	
 	public Expression call(CodePosition position, Expression target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
 		return new CallExpression(position, target, this, instancedHeader, arguments, scope);
 	}
 		return call(position, target, header, arguments, scope);
 	}
 	
-	@Override
 	public Expression callWithComparator(CodePosition position, CompareType comparison, Expression target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
 		return new CompareExpression(position, target, arguments.arguments[0], this, comparison, scope);
 	}
 	
-	@Override
 	public Expression callStatic(CodePosition position, ITypeID target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
 		return new CallStaticExpression(position, target, this, arguments, instancedHeader, scope);
 	}

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

  *
  * @author Hoofdgebruiker
  */
-public class GetterMember extends FunctionalMember implements IGettableMember {
+public class GetterMember extends FunctionalMember {
 	public final String name;
 	public final ITypeID type;
 	
 	public String getInformalName() {
 		return "getter " + name;
 	}
-
-	@Override
-	public String getName() {
-		return name;
-	}
-	
-	@Override
-	public ITypeID getType() {
-		return type;
-	}
 	
-	@Override
 	public Expression get(CodePosition position, Expression target) {
 		return new GetterExpression(position, target, this);
 	}
 	
-	@Override
 	public Expression getStatic(CodePosition position) {
 		return new StaticGetterExpression(position, this);
 	}
-
+	
 	@Override
 	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
 		type.addGetter(this, priority);

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ICallableMember.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.member;
-
-import org.openzen.zenscript.codemodel.CompareType;
-import org.openzen.zenscript.codemodel.FunctionHeader;
-import org.openzen.zenscript.codemodel.expression.CallArguments;
-import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.shared.CodePosition;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public interface ICallableMember extends IDefinitionMember {
-	public boolean isStatic();
-	
-	public String getInformalName();
-	
-	public FunctionHeader getHeader();
-	
-	public Expression call(CodePosition position, Expression target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope);
-	
-	public Expression callWithComparator(CodePosition position, CompareType operator, Expression target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope);
-	
-	public Expression callStatic(CodePosition position, ITypeID target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope);
-}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/ICasterMember.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.member;
-
-import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.shared.CodePosition;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public interface ICasterMember extends IDefinitionMember {
-	public ITypeID getTargetType();
-	
-	public Expression cast(CodePosition position, Expression value, boolean implicit);
-	
-	public boolean isImplicit();
-}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/IGettableMember.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.member;
-
-import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.shared.CodePosition;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public interface IGettableMember extends IDefinitionMember {
-	public String getName();
-	
-	public boolean isStatic();
-	
-	public ITypeID getType();
-	
-	public Expression get(CodePosition position, Expression target);
-	
-	public Expression getStatic(CodePosition position);
-}

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

  * @author Hoofdgebruiker
  */
 public interface MemberVisitor<T> {
+	public T visitConst(ConstMember member);
+	
 	public T visitField(FieldMember member);
 	
 	public T visitConstructor(ConstructorMember member);

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

 package org.openzen.zenscript.codemodel.member;
 
 import java.util.Map;
+import org.openzen.zenscript.codemodel.annotations.MemberAnnotation;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 public class StaticInitializerMember extends Taggable implements IDefinitionMember {
 	private final CodePosition position;
 	public Statement body;
+	public MemberAnnotation[] annotations = MemberAnnotation.NONE;
 	
 	public StaticInitializerMember(CodePosition position) {
 		this.position = position;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/builtin/ConstantGetterMember.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.member.builtin;
-
-import java.util.Map;
-import java.util.function.Function;
-import org.openzen.zenscript.shared.CompileException;
-import org.openzen.zenscript.shared.CompileExceptionCode;
-import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.member.IDefinitionMember;
-import org.openzen.zenscript.codemodel.member.IGettableMember;
-import org.openzen.zenscript.codemodel.member.MemberVisitor;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
-import org.openzen.zenscript.codemodel.type.ITypeID;
-import org.openzen.zenscript.codemodel.type.member.BuiltinID;
-import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
-import org.openzen.zenscript.codemodel.type.member.TypeMembers;
-import org.openzen.zenscript.shared.CodePosition;
-import org.openzen.zenscript.shared.Taggable;
-
-/**
- *
- * @author Hoofdgebruiker
- */
-public class ConstantGetterMember extends Taggable implements IGettableMember {
-	private final String name;
-	private final Function<CodePosition, Expression> value;
-	private final ITypeID type;
-	
-	public ConstantGetterMember(String name, Function<CodePosition, Expression> value) {
-		this.name = name;
-		this.value = value;
-		this.type = value.apply(CodePosition.BUILTIN).type;
-	}
-	
-	@Override
-	public CodePosition getPosition() {
-		return CodePosition.BUILTIN;
-	}
-	
-	@Override
-	public BuiltinID getBuiltin() {
-		return null;
-	}
-	
-	@Override
-	public String getName() {
-		return name;
-	}
-	
-	@Override
-	public ITypeID getType() {
-		return type;
-	}
-	
-	@Override
-	public boolean isStatic() {
-		return true;
-	}
-	
-	@Override
-	public Expression get(CodePosition position, Expression target) {
-		throw new CompileException(position, CompileExceptionCode.USING_STATIC_ON_INSTANCE, "Not an instance member");
-	}
-	
-	@Override
-	public Expression getStatic(CodePosition position) {
-		return value.apply(position);
-	}
-
-	@Override
-	public String describe() {
-		return "constant getter " + name;
-	}
-
-	@Override
-	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
-		type.addGetter(this, priority);
-	}
-
-	@Override
-	public IDefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		return this; // not instancable
-	}
-
-	@Override
-	public <T> T accept(MemberVisitor<T> visitor) {
-		throw new UnsupportedOperationException("Not a compilable member");
-	}
-}

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

 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.LambdaClosure;
-import org.openzen.zenscript.codemodel.member.ICallableMember;
+import org.openzen.zenscript.codemodel.member.FunctionalMember;
 import org.openzen.zenscript.codemodel.type.member.DefinitionMemberGroup;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 		this.allowStaticUsage = allowStaticMembers;
 	}
 	
-	public PartialMemberGroupExpression(CodePosition position, Expression target, ICallableMember member, ITypeID[] typeArguments, boolean allowStaticMembers) {
+	public PartialMemberGroupExpression(CodePosition position, Expression target, FunctionalMember member, ITypeID[] typeArguments, boolean allowStaticMembers) {
 		this.position = position;
 		this.target = target;
 		this.group = DefinitionMemberGroup.forMethod(member);
 	@Override
 	public List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<ITypeID> hints, int arguments) {
 		List<FunctionHeader> results = group.getMethodMembers().stream()
-				.filter(method -> method.member.getHeader().parameters.length == arguments && !method.member.isStatic())
-				.map(method -> method.member.getHeader())
+				.filter(method -> method.member.header.parameters.length == arguments && !method.member.isStatic())
+				.map(method -> method.member.header)
 				.collect(Collectors.toList());
 		if (results.isEmpty())
 			System.out.println("!");

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

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.member.ICallableMember;
+import org.openzen.zenscript.codemodel.member.FunctionalMember;
 import org.openzen.zenscript.codemodel.type.member.DefinitionMemberGroup;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.ITypeID;
  * @author Hoofdgebruiker
  */
 public class PartialStaticMemberGroupExpression implements IPartialExpression {
-	public static PartialStaticMemberGroupExpression forMethod(CodePosition position, ITypeID target, ICallableMember method, ITypeID[] typeArguments) {
+	public static PartialStaticMemberGroupExpression forMethod(CodePosition position, ITypeID target, FunctionalMember method, ITypeID[] typeArguments) {
 		DefinitionMemberGroup group = new DefinitionMemberGroup(true, method.getInformalName());
 		group.addMethod(method, TypeMemberPriority.SPECIFIED);
 		return new PartialStaticMemberGroupExpression(position, target, group, typeArguments);
 	@Override
 	public List<FunctionHeader> getPossibleFunctionHeaders(TypeScope scope, List<ITypeID> hints, int arguments) {
 		return group.getMethodMembers().stream()
-				.filter(method -> method.member.getHeader().parameters.length == arguments && method.member.isStatic())
-				.map(method -> method.member.getHeader())
+				.filter(method -> method.member.header.parameters.length == arguments && method.member.isStatic())
+				.map(method -> method.member.header)
 				.collect(Collectors.toList());
 	}
 

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

 		return scope.getTypeMembers(type)
 				.getOrCreateGroup(OperatorType.CALL)
 				.getMethodMembers().stream()
-				.filter(method -> method.member.getHeader().parameters.length == arguments && method.member.isStatic())
-				.map(method -> method.member.getHeader())
+				.filter(method -> method.member.header.parameters.length == arguments && method.member.isStatic())
+				.map(method -> method.member.header)
 				.collect(Collectors.toList());
 	}
 

CodeModel/src/main/java/org/openzen/zenscript/codemodel/processor/InterfaceProcessor.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.processor;
+
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.member.ImplementationMember;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface InterfaceProcessor {
+	public void apply(ImplementationMember implementation);
+
+	public void applyOnSubclass(HighLevelDefinition definition, ImplementationMember implementation);
+}

Linker/src/main/java/org/openzen/zenscript/linker/BaseScope.java → CodeModel/src/main/java/org/openzen/zenscript/codemodel/scope/BaseScope.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.linker;
+package org.openzen.zenscript.codemodel.scope;
 
 import java.util.List;
 import java.util.function.Function;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
-import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;

Linker/src/main/java/org/openzen/zenscript/linker/BlockScope.java → CodeModel/src/main/java/org/openzen/zenscript/codemodel/scope/BlockScope.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.linker;
+package org.openzen.zenscript.codemodel.scope;
 
 import java.util.List;
 import java.util.function.Function;
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 	public IPartialExpression getOuterInstance(CodePosition position) {
 		return parent.getOuterInstance(position);
 	}
+
+	@Override
+	public AnnotationDefinition getAnnotation(String name) {
+		return parent.getAnnotation(name);
+	}
 }

Linker/src/main/java/org/openzen/zenscript/linker/DefinitionScope.java → CodeModel/src/main/java/org/openzen/zenscript/codemodel/scope/DefinitionScope.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.linker;
+package org.openzen.zenscript.codemodel.scope;
 
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.function.Function;
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 import org.openzen.zenscript.shared.CompileException;
 			throw new UnsupportedOperationException("not yet supported");
 		}
 	}
+
+	@Override
+	public AnnotationDefinition getAnnotation(String name) {
+		return outer.getAnnotation(name);
+	}
 }

Linker/src/main/java/org/openzen/zenscript/linker/ExpressionScope.java → CodeModel/src/main/java/org/openzen/zenscript/codemodel/scope/ExpressionScope.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.linker;
+package org.openzen.zenscript.codemodel.scope;
 
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.function.Function;
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
 		this.genericInferenceMap = genericInferenceMap;
 	}
 	
+	private ExpressionScope(
+			BaseScope scope,
+			List<ITypeID> hints,
+			Function<CodePosition, Expression> dollar,
+			Map<TypeParameter, ITypeID> genericInferenceMap,
+			Map<String, VarStatement> innerVariables) {
+		this.outer = scope;
+		this.hints = hints;
+		this.dollar = dollar;
+		this.genericInferenceMap = genericInferenceMap;
+		this.innerVariables.putAll(innerVariables);
+	}
+	
 	public void addInnerVariable(VarStatement variable) {
 		innerVariables.put(variable.name, variable);
 	}
 	}
 	
 	public ExpressionScope withoutHints() {
-		return new ExpressionScope(outer, Collections.emptyList(), dollar, genericInferenceMap);
+		return new ExpressionScope(outer, Collections.emptyList(), dollar, genericInferenceMap, innerVariables);
 	}
 	
 	public ExpressionScope withHint(ITypeID hint) {
-		return new ExpressionScope(outer, Collections.singletonList(hint), dollar, genericInferenceMap);
+		return new ExpressionScope(outer, Collections.singletonList(hint), dollar, genericInferenceMap, innerVariables);
 	}
 	
 	public ExpressionScope withHints(List<ITypeID> hints) {
-		return new ExpressionScope(outer, hints, dollar, genericInferenceMap);
+		return new ExpressionScope(outer, hints, dollar, genericInferenceMap, innerVariables);
 	}
 	
 	public ExpressionScope createInner(List<ITypeID> hints, Function<CodePosition, Expression> dollar) {
-		return new ExpressionScope(outer, hints, dollar, genericInferenceMap);
+		return new ExpressionScope(outer, hints, dollar, genericInferenceMap, innerVariables);
 	}
 	
 	public ExpressionScope forCall(FunctionHeader header) {
 		for (TypeParameter parameter : header.typeParameters)
 			genericInferenceMap.put(parameter, null);
 		
-		return new ExpressionScope(outer, hints, dollar, genericInferenceMap);
+		return new ExpressionScope(outer, hints, dollar, genericInferenceMap, innerVariables);
 	}
 	
 	@Override
 	public IPartialExpression getOuterInstance(CodePosition position) {
 		return outer.getOuterInstance(position);
 	}
+
+	@Override
+	public AnnotationDefinition getAnnotation(String name) {
+		return outer.getAnnotation(name);
+	}
 }

Linker/src/main/java/org/openzen/zenscript/linker/FileScope.java → CodeModel/src/main/java/org/openzen/zenscript/codemodel/scope/FileScope.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.linker;
+package org.openzen.zenscript.codemodel.scope;
 
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.function.Function;
 import org.openzen.zenscript.codemodel.AccessScope;
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.PackageDefinitions;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.GenericName;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.ISymbol;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
-import org.openzen.zenscript.linker.symbol.ISymbol;
 import org.openzen.zenscript.shared.CodePosition;
 import org.openzen.zenscript.shared.CompileException;
 import org.openzen.zenscript.shared.CompileExceptionCode;
 	private final GlobalTypeRegistry globalRegistry;
 	private final Map<String, HighLevelDefinition> importedTypes = new HashMap<>();
 	private final Map<String, ISymbol> globalSymbols;
+	private final Map<String, AnnotationDefinition> annotations = new HashMap<>();
 	
 	public FileScope(
 			AccessScope access,
 			PackageDefinitions packageDefinitions,
 			GlobalTypeRegistry globalRegistry,
 			List<ExpansionDefinition> expansions,
-			Map<String, ISymbol> globalSymbols) {
+			Map<String, ISymbol> globalSymbols,
+			List<AnnotationDefinition> annotations) {
 		this.rootPackage = rootPackage;
 		this.packageDefinitions = packageDefinitions;
 		this.globalRegistry = globalRegistry;
 		this.globalSymbols = globalSymbols;
 		
 		memberCache = new LocalMemberCache(access, globalRegistry, expansions);
+		
+		for (AnnotationDefinition annotation : annotations) {
+			this.annotations.put(annotation.getAnnotationName(), annotation);
+		}
 	}
 	
 	@Override
 	public IPartialExpression getOuterInstance(CodePosition position) {
 		throw new CompileException(position, CompileExceptionCode.NO_OUTER_BECAUSE_OUTSIDE_TYPE, "Not in an inner type");
 	}
+
+	@Override
+	public AnnotationDefinition getAnnotation(String name) {
+		return annotations.get(name);
+	}
 }

Linker/src/main/java/org/openzen/zenscript/linker/ForeachScope.java → CodeModel/src/main/java/org/openzen/zenscript/codemodel/scope/ForeachScope.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.linker;
+package org.openzen.zenscript.codemodel.scope;
 
 import java.util.List;
 import java.util.function.Function;
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
 	public IPartialExpression getOuterInstance(CodePosition position) {
 		return outer.getOuterInstance(position);
 	}
+
+	@Override
+	public AnnotationDefinition getAnnotation(String name) {
+		return outer.getAnnotation(name);
+	}
 }

Linker/src/main/java/org/openzen/zenscript/linker/FunctionScope.java → CodeModel/src/main/java/org/openzen/zenscript/codemodel/scope/FunctionScope.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.linker;
+package org.openzen.zenscript.codemodel.scope;
 
 import java.util.List;
 import java.util.function.Function;
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.expression.Expression;
 	public IPartialExpression getOuterInstance(CodePosition position) {
 		return outer.getOuterInstance(position);
 	}
+
+	@Override
+	public AnnotationDefinition getAnnotation(String name) {
+		return outer.getAnnotation(name);
+	}
 }

Linker/src/main/java/org/openzen/zenscript/linker/GenericFunctionScope.java → CodeModel/src/main/java/org/openzen/zenscript/codemodel/scope/GenericFunctionScope.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.linker;
+package org.openzen.zenscript.codemodel.scope;
 
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.function.Function;
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 	public IPartialExpression getOuterInstance(CodePosition position) {
 		return outer.getOuterInstance(position);
 	}
+
+	@Override
+	public AnnotationDefinition getAnnotation(String name) {
+		return outer.getAnnotation(name);
+	}
 }

Linker/src/main/java/org/openzen/zenscript/linker/GlobalScriptScope.java → CodeModel/src/main/java/org/openzen/zenscript/codemodel/scope/GlobalScriptScope.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.linker;
+package org.openzen.zenscript.codemodel.scope;
 
 import java.util.List;
 import java.util.function.Function;
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
  * @author Hoofdgebruiker
  */
 public class GlobalScriptScope extends StatementScope {
-	private final FileScope file;
+	private final BaseScope file;
 	
-	public GlobalScriptScope(FileScope file) {
+	public GlobalScriptScope(BaseScope file) {
 		this.file = file;
 	}
 
 	public IPartialExpression getOuterInstance(CodePosition position) {
 		return null;
 	}
+
+	@Override
+	public AnnotationDefinition getAnnotation(String name) {
+		return file.getAnnotation(name);
+	}
 }

Linker/src/main/java/org/openzen/zenscript/linker/ImplementationScope.java → CodeModel/src/main/java/org/openzen/zenscript/codemodel/scope/ImplementationScope.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.linker;
+package org.openzen.zenscript.codemodel.scope;
 
 import java.util.List;
 import java.util.function.Function;
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ThisExpression;
 	public IPartialExpression getOuterInstance(CodePosition position) {
 		return new ThisExpression(position, outer.getThisType());
 	}
+
+	@Override
+	public AnnotationDefinition getAnnotation(String name) {
+		return outer.getAnnotation(name);
+	}
 }

Linker/src/main/java/org/openzen/zenscript/linker/LambdaScope.java → CodeModel/src/main/java/org/openzen/zenscript/codemodel/scope/LambdaScope.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.linker;
+package org.openzen.zenscript.codemodel.scope;
 
 import java.util.List;
 import java.util.function.Function;
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.expression.Expression;
 	public IPartialExpression getOuterInstance(CodePosition position) {
 		return outer.getOuterInstance(position);
 	}
+
+	@Override
+	public AnnotationDefinition getAnnotation(String name) {
+		return outer.getAnnotation(name);
+	}
 }

Linker/src/main/java/org/openzen/zenscript/linker/LoopScope.java → CodeModel/src/main/java/org/openzen/zenscript/codemodel/scope/LoopScope.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.linker;
+package org.openzen.zenscript.codemodel.scope;
 
 import java.util.List;
 import java.util.function.Function;
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 	public IPartialExpression getOuterInstance(CodePosition position) {
 		return outer.getOuterInstance(position);
 	}
-}
 
+	@Override
+	public AnnotationDefinition getAnnotation(String name) {
+		return outer.getAnnotation(name);
+	}
+}

Linker/src/main/java/org/openzen/zenscript/linker/StatementScope.java → CodeModel/src/main/java/org/openzen/zenscript/codemodel/scope/StatementScope.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.linker;
+package org.openzen.zenscript.codemodel.scope;
 
 import java.util.HashMap;
 import java.util.Map;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/scope/TypeScope.java

  */
 package org.openzen.zenscript.codemodel.scope;
 
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 	public LocalMemberCache getMemberCache();
 	
 	public TypeMembers getTypeMembers(ITypeID type);
+	
+	public AnnotationDefinition getAnnotation(String name);
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/BlockStatement.java

 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.Consumer;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 	public <T> T accept(StatementVisitor<T> visitor) {
 		return visitor.visitBlock(this);
 	}
+	
+	@Override
+	public void forEachStatement(Consumer<Statement> consumer) {
+		consumer.accept(this);
+		for (Statement s : statements) {
+			s.forEachStatement(consumer);
+		}
+	}
+	
+	@Override
+	public Statement transform(StatementTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
+		List<Statement> tStatements = new ArrayList<>();
+		boolean unchanged = true;
+		for (Statement statement : statements) {
+			Statement tStatement = statement.transform(transformer, modified);
+			unchanged &= statement == tStatement;
+			tStatements.add(statement);
+		}
+		return unchanged ? this : new BlockStatement(position, tStatements);
+	}
 
 	@Override
 	public Statement transform(ExpressionTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/BreakStatement.java

  */
 package org.openzen.zenscript.codemodel.statement;
 
+import java.util.function.Consumer;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.shared.CodePosition;
 import org.openzen.zenscript.shared.ConcatMap;
 	public <T> T accept(StatementVisitor<T> visitor) {
 		return visitor.visitBreak(this);
 	}
+	
+	@Override
+	public void forEachStatement(Consumer<Statement> consumer) {
+		consumer.accept(this);
+	}
+
+	@Override
+	public Statement transform(StatementTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
+		return modified.containsKey(target) ? new BreakStatement(position, modified.get(target)) : this;
+	}
 
 	@Override
 	public Statement transform(ExpressionTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/CatchClause.java

 		this.content = content;
 	}
 	
+	public CatchClause transform(StatementTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
+		Statement tContent = content.transform(transformer, modified);
+		return content == tContent ? this : new CatchClause(position, exceptionVariable, tContent);
+	}
+	
 	public CatchClause transform(ExpressionTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
 		Statement tContent = content.transform(transformer, modified);
 		return content == tContent ? this : new CatchClause(position, exceptionVariable, tContent);

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/ContinueStatement.java

  */
 package org.openzen.zenscript.codemodel.statement;
 
+import java.util.function.Consumer;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.shared.CodePosition;
 import org.openzen.zenscript.shared.ConcatMap;
 	public <T> T accept(StatementVisitor<T> visitor) {
 		return visitor.visitContinue(this);
 	}
+	
+	@Override
+	public void forEachStatement(Consumer<Statement> consumer) {
+		consumer.accept(this);
+	}
+
+	@Override
+	public Statement transform(StatementTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
+		return modified.containsKey(target) ? new ContinueStatement(position, modified.get(target)) : this;
+	}
 
 	@Override
 	public Statement transform(ExpressionTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/DoWhileStatement.java

  */
 package org.openzen.zenscript.codemodel.statement;
 
+import java.util.function.Consumer;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.shared.CodePosition;
 	public <T> T accept(StatementVisitor<T> visitor) {
 		return visitor.visitDoWhile(this);
 	}
+	
+	@Override
+	public void forEachStatement(Consumer<Statement> consumer) {
+		consumer.accept(this);
+		content.forEachStatement(consumer);
+	}
+
+	@Override
+	public Statement transform(StatementTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
+		Expression tCondition = condition.transform(transformer);
+		Statement tContent = content.transform(transformer, modified);
+		if (tCondition == condition && tContent == content)
+			return this;
+		
+		DoWhileStatement result = new DoWhileStatement(position, label, condition);
+		result.content = content.transform(transformer, modified.concat(this, result));
+		return result;
+	}
 
 	@Override
 	public Statement transform(ExpressionTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
 		Expression tCondition = condition.transform(transformer);
+		Statement tContent = content.transform(transformer, modified);
+		if (tCondition == condition && tContent == content)
+			return this;
+		
 		DoWhileStatement result = new DoWhileStatement(position, label, tCondition);
 		result.content = content.transform(transformer, modified.concat(this, result));
 		return result;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/EmptyStatement.java

  */
 package org.openzen.zenscript.codemodel.statement;
 
+import java.util.function.Consumer;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.shared.CodePosition;
 import org.openzen.zenscript.shared.ConcatMap;
 	public <T> T accept(StatementVisitor<T> visitor) {
 		return visitor.visitEmpty(this);
 	}
+	
+	@Override
+	public void forEachStatement(Consumer<Statement> consumer) {
+		consumer.accept(this);
+	}
+
+	@Override
+	public Statement transform(StatementTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
+		return this;
+	}
 
 	@Override
 	public Statement transform(ExpressionTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/ExpressionStatement.java

  */
 package org.openzen.zenscript.codemodel.statement;
 
+import java.util.function.Consumer;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.shared.CodePosition;
 	public <T> T accept(StatementVisitor<T> visitor) {
 		return visitor.visitExpression(this);
 	}
+	
+	@Override
+	public void forEachStatement(Consumer<Statement> consumer) {
+		consumer.accept(this);
+		expression.forEachStatement(consumer);
+	}
+
+	@Override
+	public Statement transform(StatementTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
+		Expression tExpression = expression.transform(transformer);
+		return tExpression == expression ? this : new ExpressionStatement(position, tExpression);
+	}
 
 	@Override
 	public Statement transform(ExpressionTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/ForeachStatement.java

  */
 package org.openzen.zenscript.codemodel.statement;
 
+import java.util.function.Consumer;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.codemodel.member.IIteratorMember;
 	public <T> T accept(StatementVisitor<T> visitor) {
 		return visitor.visitForeach(this);
 	}
+	
+	@Override
+	public void forEachStatement(Consumer<Statement> consumer) {
+		consumer.accept(this);
+		content.forEachStatement(consumer);
+	}
+
+	@Override
+	public Statement transform(StatementTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
+		Expression tList = list.transform(transformer);
+		Statement tContent = content.transform(transformer, modified);
+		if (tList == list && tContent == content)
+			return this;
+		
+		ForeachStatement result = new ForeachStatement(position, loopVariables, iterator, tList);
+		result.content = content.transform(transformer, modified.concat(this, result));
+		return result;
+	}
 
 	@Override
 	public Statement transform(ExpressionTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
 		Expression tList = list.transform(transformer);
+		Statement tContent = content.transform(transformer, modified);
+		if (tList == list && tContent == content)
+			return this;
+		
 		ForeachStatement result = new ForeachStatement(position, loopVariables, iterator, tList);
 		result.content = content.transform(transformer, modified.concat(this, result));
 		return result;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/IfStatement.java

  */
 package org.openzen.zenscript.codemodel.statement;
 
+import java.util.function.Consumer;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 	public <T> T accept(StatementVisitor<T> visitor) {
 		return visitor.visitIf(this);
 	}
+	
+	@Override
+	public void forEachStatement(Consumer<Statement> consumer) {
+		consumer.accept(this);
+		onThen.forEachStatement(consumer);
+		if (onElse != null)
+			onElse.forEachStatement(consumer);
+	}
+
+	@Override
+	public Statement transform(StatementTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
+		Expression tCondition = condition.transform(transformer);
+		Statement tOnThen = onThen.transform(transformer, modified);
+		Statement tOnElse = onElse == null ? null : onElse.transform(transformer, modified);
+		return tCondition == condition && onThen == tOnThen && onElse == tOnElse
+				? this
+				: new IfStatement(position, tCondition, tOnThen, tOnElse);
+	}
 
 	@Override
 	public Statement transform(ExpressionTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
 		Expression tCondition = condition.transform(transformer);
 		Statement tOnThen = onThen.transform(transformer, modified);
-		Statement tOnElse = onElse.transform(transformer, modified);
+		Statement tOnElse = onElse == null ? null : onElse.transform(transformer, modified);
 		return tCondition == condition && onThen == tOnThen && onElse == tOnElse
 				? this
 				: new IfStatement(position, tCondition, tOnThen, tOnElse);

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/LockStatement.java

  */
 package org.openzen.zenscript.codemodel.statement;
 
+import java.util.function.Consumer;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.shared.CodePosition;
 	public <T> T accept(StatementVisitor<T> visitor) {
 		return visitor.visitLock(this);
 	}
+	
+	@Override
+	public void forEachStatement(Consumer<Statement> consumer) {
+		consumer.accept(this);
+		content.forEachStatement(consumer);
+	}
+
+	@Override
+	public Statement transform(StatementTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
+		Expression tObject = object.transform(transformer);
+		Statement tContent = content.transform(transformer, modified);
+		return tObject == object && tContent == content ? this : new LockStatement(position, tObject, tContent);
+	}
 
 	@Override
 	public Statement transform(ExpressionTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/ReturnStatement.java

  */
 package org.openzen.zenscript.codemodel.statement;
 
+import java.util.function.Consumer;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 		return value.type;
 	}
 	
+	@Override
+	public void forEachStatement(Consumer<Statement> consumer) {
+		consumer.accept(this);
+	}
+	
 	@Override
 	public Statement withReturnType(TypeScope scope, ITypeID returnType) {
 		return new ReturnStatement(position, value == null ? null : value.castImplicit(position, scope, returnType));
 		return visitor.visitReturn(this);
 	}
 
+	@Override
+	public Statement transform(StatementTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
+		Expression tValue = value.transform(transformer);
+		return tValue == value ? this : new ReturnStatement(position, tValue);
+	}
+
 	@Override
 	public Statement transform(ExpressionTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
 		Expression tValue = value.transform(transformer);

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/Statement.java

 package org.openzen.zenscript.codemodel.statement;
 
 import java.util.List;
+import java.util.function.Consumer;
 import java.util.stream.Collectors;
+import org.openzen.zenscript.codemodel.annotations.StatementAnnotation;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.CodePosition;
 public abstract class Statement extends Taggable {
 	public final CodePosition position;
 	public final ITypeID thrownType;
+	public StatementAnnotation[] annotations = StatementAnnotation.NONE;
 	
 	public Statement(CodePosition position, ITypeID thrownType) {
 		this.position = position;
 	
 	public abstract <T> T accept(StatementVisitor<T> visitor);
 	
+	public abstract void forEachStatement(Consumer<Statement> consumer);
+	
+	public final Statement transform(StatementTransformer transformer) {
+		return transform(transformer, ConcatMap.empty());
+	}
+	
+	public abstract Statement transform(StatementTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified);
+	
 	public abstract Statement transform(ExpressionTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified);
 	
 	public static List<Statement> withReturnType(TypeScope scope, List<Statement> statements, ITypeID returnType) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/StatementTransformer.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.statement;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface StatementTransformer {
+	Statement transform(Statement original);
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/SwitchCase.java

 		this.statements = statements;
 	}
 	
+	public SwitchCase transform(StatementTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
+		List<Statement> tStatements = new ArrayList<>();
+		for (Statement statement : statements) {
+			tStatements.add(statement.transform(transformer, modified));
+		}
+		return new SwitchCase(value, tStatements);
+	}
+	
 	public SwitchCase transform(ExpressionTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
 		List<Statement> tStatements = new ArrayList<>();
 		for (Statement statement : statements) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/SwitchStatement.java

 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.Consumer;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.shared.CodePosition;
 	public <T> T accept(StatementVisitor<T> visitor) {
 		return visitor.visitSwitch(this);
 	}
+	
+	@Override
+	public void forEachStatement(Consumer<Statement> consumer) {
+		consumer.accept(this);
+		for (SwitchCase switchCase : cases) {
+			for (Statement statement : switchCase.statements)
+				statement.forEachStatement(consumer);
+		}
+	}
+
+	@Override
+	public Statement transform(StatementTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
+		Expression tValue = value.transform(transformer);
+		SwitchStatement result = new SwitchStatement(position, label, tValue);
+		ConcatMap<LoopStatement, LoopStatement> tModified = modified.concat(this, result);
+		for (SwitchCase case_ : cases) {
+			result.cases.add(case_.transform(transformer, tModified));
+		}
+		return result;
+	}
 
 	@Override
 	public Statement transform(ExpressionTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/ThrowStatement.java

  */
 package org.openzen.zenscript.codemodel.statement;
 
+import java.util.function.Consumer;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.shared.CodePosition;
 	public <T> T accept(StatementVisitor<T> visitor) {
 		return visitor.visitThrow(this);
 	}
+	
+	@Override
+	public void forEachStatement(Consumer<Statement> consumer) {
+		consumer.accept(this);
+	}
+
+	@Override
+	public Statement transform(StatementTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
+		Expression tValue = value.transform(transformer);
+		return tValue == value ? this : new ThrowStatement(position, value);
+	}
 
 	@Override
 	public Statement transform(ExpressionTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/TryCatchStatement.java

 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.Consumer;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.shared.CodePosition;
 import org.openzen.zenscript.shared.ConcatMap;
 	public <T> T accept(StatementVisitor<T> visitor) {
 		return visitor.visitTryCatch(this);
 	}
+	
+	@Override
+	public void forEachStatement(Consumer<Statement> consumer) {
+		consumer.accept(this);
+		for (CatchClause catchClause : catchClauses) {
+			catchClause.content.forEachStatement(consumer);
+		}
+		if (finallyClause != null)
+			finallyClause.forEachStatement(consumer);
+	}
+
+	@Override
+	public Statement transform(StatementTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
+		VarStatement tResource = resource == null ? null : resource.transform(transformer, modified);
+		Statement tContent = content.transform(transformer, modified);
+		List<CatchClause> tCatchClauses = new ArrayList<>();
+		for (CatchClause clause : catchClauses)
+			tCatchClauses.add(clause.transform(transformer, modified));
+		Statement tFinallyClause = finallyClause == null ? null : finallyClause.transform(transformer, modified);
+		return new TryCatchStatement(position, tResource, tContent, tCatchClauses, tFinallyClause);
+	}
 
 	@Override
 	public Statement transform(ExpressionTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/VarStatement.java

  */
 package org.openzen.zenscript.codemodel.statement;
 
+import java.util.function.Consumer;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 	public <T> T accept(StatementVisitor<T> visitor) {
 		return visitor.visitVar(this);
 	}
+	
+	@Override
+	public void forEachStatement(Consumer<Statement> consumer) {
+		consumer.accept(this);
+	}
+
+	@Override
+	public VarStatement transform(StatementTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
+		Expression tInitializer = initializer == null ? null : initializer.transform(transformer);
+		return tInitializer == initializer ? this : new VarStatement(position, name, type, tInitializer, isFinal);
+	}
 
 	@Override
 	public VarStatement transform(ExpressionTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/statement/WhileStatement.java

  */
 package org.openzen.zenscript.codemodel.statement;
 
+import java.util.function.Consumer;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.shared.CodePosition;
 	public <T> T accept(StatementVisitor<T> visitor) {
 		return visitor.visitWhile(this);
 	}
+	
+	@Override
+	public void forEachStatement(Consumer<Statement> consumer) {
+		consumer.accept(this);
+		content.forEachStatement(consumer);
+	}
 
 	@Override
-	public Statement transform(ExpressionTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
+	public WhileStatement transform(StatementTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
 		Expression tCondition = condition.transform(transformer);
-		WhileStatement result = new WhileStatement(position, label, condition);
+		Statement tContent = content.transform(transformer, modified);
+		if (condition == tCondition && content == tContent)
+			return this;
+		
+		WhileStatement result = new WhileStatement(position, label, tCondition);
+		result.content = content.transform(transformer, modified.concat(this, result));
+		return result;
+	}
+
+	@Override
+	public WhileStatement transform(ExpressionTransformer transformer, ConcatMap<LoopStatement, LoopStatement> modified) {
+		Expression tCondition = condition.transform(transformer);
+		Statement tContent = content.transform(transformer, modified);
+		if (condition == tCondition && content == tContent)
+			return this;
+		
+		WhileStatement result = new WhileStatement(position, label, tCondition);
 		result.content = content.transform(transformer, modified.concat(this, result));
 		return result;
 	}

Linker/src/main/java/org/openzen/zenscript/linker/symbol/ISymbol.java → CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/ISymbol.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.linker.symbol;
+package org.openzen.zenscript.codemodel.type;
 
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;

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

  * @author Hoofdgebruiker
  */
 public interface ITypeID {
+	public static final ITypeID[] NONE = new ITypeID[0];
+	
 	public ITypeID getUnmodified();
 	
 	public <T> T accept(ITypeVisitor<T> visitor);

Linker/src/main/java/org/openzen/zenscript/linker/symbol/TypeSymbol.java → CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/TypeSymbol.java

  * To change this template file, choose Tools | Templates
  * and open the template in the editor.
  */
-package org.openzen.zenscript.linker.symbol;
+package org.openzen.zenscript.codemodel.type;
 
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;

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

 import org.openzen.zenscript.codemodel.expression.StaticSetterExpression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.member.FieldMember;
-import org.openzen.zenscript.codemodel.member.ICallableMember;
-import org.openzen.zenscript.codemodel.member.IGettableMember;
 import org.openzen.zenscript.codemodel.member.SetterMember;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.CompareType;
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.expression.ConstExpression;
 import org.openzen.zenscript.codemodel.expression.PostCallExpression;
+import org.openzen.zenscript.codemodel.member.ConstMember;
+import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.member.GetterMember;
 import org.openzen.zenscript.codemodel.member.OperatorMember;
 import org.openzen.zenscript.shared.CodePosition;
 import org.openzen.zenscript.shared.CompileException;
  * @author Hoofdgebruiker
  */
 public class DefinitionMemberGroup {
-	public static DefinitionMemberGroup forMethod(ICallableMember member) {
+	public static DefinitionMemberGroup forMethod(FunctionalMember member) {
 		DefinitionMemberGroup instance = new DefinitionMemberGroup(member.isStatic(), member.getInformalName());
 		instance.addMethod(member, TypeMemberPriority.SPECIFIED);
 		return instance;
 	}
 	
+	private TypeMember<ConstMember> constant;
 	private TypeMember<FieldMember> field;
-	private TypeMember<IGettableMember> getter;
+	private TypeMember<GetterMember> getter;
 	private TypeMember<SetterMember> setter;
-	private final List<TypeMember<ICallableMember>> methods = new ArrayList<>();
+	private final List<TypeMember<FunctionalMember>> methods = new ArrayList<>();
 	public final boolean isStatic;
 	public final String name;
 	
 	}
 	
 	public void merge(CodePosition position, DefinitionMemberGroup other, TypeMemberPriority priority) {
+		if (other.constant != null)
+			setConst(other.constant.member, priority);
 		if (other.field != null)
 			setField(other.field.member, priority);
 		if (other.getter != null)
 		if (other.setter != null)
 			setSetter(other.setter.member, priority);
 		
-		for (TypeMember<ICallableMember> method : other.methods)
+		for (TypeMember<FunctionalMember> method : other.methods)
 			addMethod(method.member, priority);
 	}
 	
 		return this.field == null ? null : this.field.member;
 	}
 	
-	public IGettableMember getGetter() {
+	public GetterMember getGetter() {
 		return this.getter == null ? null : this.getter.member;
 	}
 	
 	}
 	
 	public boolean hasMethod(FunctionHeader header) {
-		for (TypeMember<ICallableMember> method : methods) {
-			if (method.member.getHeader().isEquivalentTo(header))
+		for (TypeMember<FunctionalMember> method : methods) {
+			if (method.member.header.isEquivalentTo(header))
 				return true;
 		}
 		
 		return false;
 	}
 	
-	public List<TypeMember<ICallableMember>> getMethodMembers() {
+	public List<TypeMember<FunctionalMember>> getMethodMembers() {
 		return this.methods;
 	}
 	
+	public void setConst(ConstMember constant, TypeMemberPriority priority) {
+		if (this.constant != null) {
+			this.constant = this.constant.resolve(new TypeMember<>(priority, constant));
+		} else {
+			this.constant = new TypeMember<>(priority, constant);
+		}
+	}
+	
 	public void setField(FieldMember field, TypeMemberPriority priority) {
 		if (this.field != null) {
 			this.field = this.field.resolve(new TypeMember<>(priority, field));
 		}
 	}
 	
-	public void setGetter(IGettableMember getter, TypeMemberPriority priority) {
+	public void setGetter(GetterMember getter, TypeMemberPriority priority) {
 		if (this.getter != null) {
 			this.getter = this.getter.resolve(new TypeMember<>(priority, getter));
 		} else {
 		}
 	}
 	
-	public void addMethod(ICallableMember method, TypeMemberPriority priority) {
+	public void addMethod(FunctionalMember method, TypeMemberPriority priority) {
 		for (int i = 0; i < methods.size(); i++) {
-			if (methods.get(i).member.getHeader().isEquivalentTo(method.getHeader())) {
+			if (methods.get(i).member.header.isEquivalentTo(method.header)) {
 				methods.set(i, methods.get(i).resolve(new TypeMember<>(priority, method)));
 				return;
 			}
 	}
 	
 	public Expression staticGetter(CodePosition position) {
-		if (getter != null) {
+		if (constant != null) {
+			return new ConstExpression(position, constant.member);
+		} else if (getter != null) {
 			if (!getter.member.isStatic())
 				throw new CompileException(position, CompileExceptionCode.MEMBER_NOT_STATIC, "This getter is not static");
 			
 		for (int i = 0; i < result.length; i++)
 			result[i] = new ArrayList<>();
 		
-		for (TypeMember<ICallableMember> method : methods) {
-			FunctionHeader header = method.member.getHeader();
+		for (TypeMember<FunctionalMember> method : methods) {
+			FunctionHeader header = method.member.header;
 			if (header.parameters.length != arguments)
 				continue;
 			
 	}
 	
 	public Expression call(CodePosition position, TypeScope scope, Expression target, CallArguments arguments, boolean allowStaticUsage) {
-		ICallableMember method = selectMethod(position, scope, arguments, true, allowStaticUsage);
-		FunctionHeader instancedHeader = method.getHeader().withGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
+		FunctionalMember method = selectMethod(position, scope, arguments, true, allowStaticUsage);
+		FunctionHeader instancedHeader = method.header.withGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
 		for (int i = 0; i < arguments.arguments.length; i++) {
 			arguments.arguments[i] = arguments.arguments[i].castImplicit(position, scope, instancedHeader.parameters[i].type);
 		}
 		if (methods.isEmpty())
 			throw new CompileException(position, CompileExceptionCode.NO_SUCH_MEMBER, "There is no such operator");
 		
-		ICallableMember method = methods.get(0).member;
+		FunctionalMember method = methods.get(0).member;
 		if (!(method instanceof OperatorMember)) {
 			throw new CompileException(position, CompileExceptionCode.NO_SUCH_MEMBER, "Member is not an operator");
 		}
 			Expression target,
 			CallArguments arguments,
 			CompareType compareType) {
-		ICallableMember method = selectMethod(position, scope, arguments, true, false);
-		FunctionHeader instancedHeader = method.getHeader().withGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
+		FunctionalMember method = selectMethod(position, scope, arguments, true, false);
+		FunctionHeader instancedHeader = method.header.withGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
 		return method.callWithComparator(position, compareType, target, instancedHeader, arguments, scope);
 	}
 	
 	public Expression callStatic(CodePosition position, ITypeID target, TypeScope scope, CallArguments arguments) {
-		ICallableMember method = selectMethod(position, scope, arguments, false, true);
-		FunctionHeader instancedHeader = method.getHeader().withGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
+		FunctionalMember method = selectMethod(position, scope, arguments, false, true);
+		FunctionHeader instancedHeader = method.header.withGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
 		return method.callStatic(position, target, instancedHeader, arguments, scope);
 	}
 	
-	public ICallableMember selectMethod(CodePosition position, TypeScope scope, CallArguments arguments, boolean allowNonStatic, boolean allowStatic) {
+	public FunctionalMember selectMethod(CodePosition position, TypeScope scope, CallArguments arguments, boolean allowNonStatic, boolean allowStatic) {
 		// try to match with exact types
-		outer: for (TypeMember<ICallableMember> method : methods) {
+		outer: for (TypeMember<FunctionalMember> method : methods) {
 			if (!(method.member.isStatic() ? allowStatic : allowNonStatic))
 				continue;
 			
-			FunctionHeader header = method.member.getHeader();
+			FunctionHeader header = method.member.header;
 			if (header.parameters.length != arguments.arguments.length)
 				continue;
 			if (header.getNumberOfTypeParameters() != arguments.getNumberOfTypeArguments())
 		}
 		
 		// try to match with approximate types
-		ICallableMember selected = null;
-		outer: for (TypeMember<ICallableMember> method : methods) {
+		FunctionalMember selected = null;
+		outer: for (TypeMember<FunctionalMember> method : methods) {
 			if (!(method.member.isStatic() ? allowStatic : allowNonStatic))
 				continue;
 			
-			FunctionHeader header = method.member.getHeader();
+			FunctionHeader header = method.member.header;
 			if (header.parameters.length != arguments.arguments.length)
 				continue;
 			if (header.getNumberOfTypeParameters() != arguments.getNumberOfTypeArguments())
 			
 			if (selected != null) {
 				StringBuilder explanation = new StringBuilder();
-				explanation.append("Function A: ").append(selected.getHeader().toString()).append("\n");
-				explanation.append("Function B: ").append(method.member.getHeader().toString());
+				explanation.append("Function A: ").append(selected.header.toString()).append("\n");
+				explanation.append("Function B: ").append(method.member.header.toString());
 				throw new CompileException(position, CompileExceptionCode.CALL_AMBIGUOUS, "Ambiguous call; multiple methods match:\n" + explanation.toString());
 			}
 			
 				throw new CompileException(position, CompileExceptionCode.CALL_NO_VALID_METHOD, "This type has no " + name);
 			}
 			
-			outer: for (TypeMember<ICallableMember> method : methods) {
+			outer: for (TypeMember<FunctionalMember> method : methods) {
 				if (!(method.member.isStatic() ? allowStatic : allowNonStatic)) {
 					message.append(method.member.isStatic() ? "Method must not be static" : "Method must be static").append('\n');
 					continue;
 				}
 				
-				message.append(method.member.getHeader().explainWhyIncompatible(scope, arguments)).append("\n");
+				message.append(method.member.header.explainWhyIncompatible(scope, arguments)).append("\n");
 			}
 			
 			throw new CompileException(position, CompileExceptionCode.CALL_NO_VALID_METHOD, "No matching method found for " + name + ":\n" + message.toString());

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

 import org.openzen.zenscript.codemodel.definition.FunctionDefinition;
 import org.openzen.zenscript.codemodel.definition.StructDefinition;
 import org.openzen.zenscript.codemodel.definition.VariantDefinition;
+import org.openzen.zenscript.codemodel.expression.ArrayExpression;
 import org.openzen.zenscript.codemodel.expression.CallTranslator;
+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.ConstantUIntExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantULongExpression;
+import org.openzen.zenscript.codemodel.expression.ConstantUShortExpression;
+import org.openzen.zenscript.codemodel.expression.EnumConstantExpression;
+import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.generic.GenericParameterBound;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.member.CallerMember;
 import org.openzen.zenscript.codemodel.member.CasterMember;
+import org.openzen.zenscript.codemodel.member.ConstMember;
 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.FunctionalMember;
 import org.openzen.zenscript.codemodel.member.GetterMember;
-import org.openzen.zenscript.codemodel.member.ICallableMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.MethodMember;
 import org.openzen.zenscript.codemodel.member.OperatorMember;
 		if (members.hasOperator(OperatorType.EQUALS)) {
 			DefinitionMemberGroup group = members.getOrCreateGroup(OperatorType.EQUALS);
 			DefinitionMemberGroup inverse = members.getOrCreateGroup(OperatorType.NOTEQUALS);
-			for (TypeMember<ICallableMember> method : group.getMethodMembers()) {
-				if (!inverse.hasMethod(method.member.getHeader())) {
-					inverse.addMethod(notequals(definition, BuiltinID.AUTOOP_NOTEQUALS, method.member.getHeader().parameters[0].type), TypeMemberPriority.SPECIFIED);
+			for (TypeMember<FunctionalMember> method : group.getMethodMembers()) {
+				if (!inverse.hasMethod(method.member.header)) {
+					inverse.addMethod(notequals(definition, BuiltinID.AUTOOP_NOTEQUALS, method.member.header.parameters[0].type), TypeMemberPriority.SPECIFIED);
 				}
 			}
 		}
 		if (definition instanceof EnumDefinition) {
 			members.addGetter(getter(definition, ENUM_NAME, "name", STRING));
 			members.addGetter(getter(definition, ENUM_ORDINAL, "ordinal", INT));
-			members.addGetter(staticGetter(definition, ENUM_VALUES, "values", registry.getArray(type, 1)));
+			
+			List<EnumConstantMember> enumConstants = ((EnumDefinition) definition).enumConstants;
+			Expression[] constValues = new Expression[enumConstants.size()];
+			for (int i = 0; i < constValues.length; i++)
+				constValues[i] = new EnumConstantExpression(BUILTIN, type, enumConstants.get(i));
+			
+			members.addConst(constant(definition, ENUM_VALUES, "values", new ArrayExpression(BUILTIN, constValues, registry.getArray(type, 1))));
 			members.addOperator(compare(definition, ENUM_COMPARE, type));
 			
 			if (!members.canCast(BasicTypeID.STRING)) {
 		members.addMethod(staticMethod(builtin, BYTE_PARSE, "parse", BYTE, STRING));
 		members.addMethod(staticMethod(builtin, BYTE_PARSE_WITH_BASE, "parse", BYTE, STRING, INT));
 		
-		members.addGetter(staticGetter(builtin, BYTE_GET_MIN_VALUE, "MIN_VALUE", BYTE));
-		members.addGetter(staticGetter(builtin, BYTE_GET_MAX_VALUE, "MAX_VALUE", BYTE));
+		members.addConst(constant(builtin, BYTE_GET_MIN_VALUE, "MIN_VALUE", new ConstantByteExpression(BUILTIN, 0)));
+		members.addConst(constant(builtin, BYTE_GET_MAX_VALUE, "MAX_VALUE", new ConstantByteExpression(BUILTIN, 255)));
 		
 		processType(builtin, BYTE);
 	}
 		members.addMethod(staticMethod(builtin, SBYTE_PARSE, "parse", SBYTE, STRING));
 		members.addMethod(staticMethod(builtin, SBYTE_PARSE_WITH_BASE, "parse", SBYTE, STRING, INT));
 		
-		members.addGetter(staticGetter(builtin, SBYTE_GET_MIN_VALUE, "MIN_VALUE", SBYTE));
-		members.addGetter(staticGetter(builtin, SBYTE_GET_MAX_VALUE, "MAX_VALUE", SBYTE));
+		members.addConst(constant(builtin, SBYTE_GET_MIN_VALUE, "MIN_VALUE", new ConstantSByteExpression(BUILTIN, Byte.MIN_VALUE)));
+		members.addConst(constant(builtin, SBYTE_GET_MAX_VALUE, "MAX_VALUE", new ConstantSByteExpression(BUILTIN, Byte.MAX_VALUE)));
 		
 		processType(builtin, SBYTE);
 	}
 		members.addMethod(staticMethod(builtin, SHORT_PARSE, "parse", SHORT, STRING));
 		members.addMethod(staticMethod(builtin, SHORT_PARSE_WITH_BASE, "parse", SHORT, STRING, INT));
 		
-		members.addGetter(staticGetter(builtin, SHORT_GET_MIN_VALUE, "MIN_VALUE", SHORT));
-		members.addGetter(staticGetter(builtin, SHORT_GET_MAX_VALUE, "MAX_VALUE", SHORT));
+		members.addConst(constant(builtin, SHORT_GET_MIN_VALUE, "MIN_VALUE", new ConstantShortExpression(BUILTIN, Short.MIN_VALUE)));
+		members.addConst(constant(builtin, SHORT_GET_MAX_VALUE, "MAX_VALUE", new ConstantShortExpression(BUILTIN, Short.MAX_VALUE)));
 		
 		processType(builtin, SHORT);
 	}
 		members.addMethod(staticMethod(builtin, USHORT_PARSE, "parse", USHORT, STRING));
 		members.addMethod(staticMethod(builtin, USHORT_PARSE_WITH_BASE, "parse", USHORT, STRING, INT));
 		
-		members.addGetter(staticGetter(builtin, USHORT_GET_MIN_VALUE, "MIN_VALUE", USHORT));
-		members.addGetter(staticGetter(builtin, USHORT_GET_MAX_VALUE, "MAX_VALUE", USHORT));
+		members.addConst(constant(builtin, USHORT_GET_MIN_VALUE, "MIN_VALUE", new ConstantUShortExpression(BUILTIN, 0)));
+		members.addConst(constant(builtin, USHORT_GET_MAX_VALUE, "MAX_VALUE", new ConstantUShortExpression(BUILTIN, 65535)));
 		
 		processType(builtin, USHORT);
 	}
 		members.addOperator(compare(builtin, FLOAT_COMPARE, FLOAT, INT_TO_FLOAT));
 		members.addOperator(compare(builtin, DOUBLE_COMPARE, DOUBLE, INT_TO_DOUBLE));
 		
-		members.addGetter(staticGetter(builtin, INT_GET_MIN_VALUE, "MIN_VALUE", INT));
-		members.addGetter(staticGetter(builtin, INT_GET_MAX_VALUE, "MAX_VALUE", INT));
+		members.addConst(constant(builtin, INT_GET_MIN_VALUE, "MIN_VALUE", new ConstantIntExpression(BUILTIN, Integer.MIN_VALUE)));
+		members.addConst(constant(builtin, INT_GET_MAX_VALUE, "MAX_VALUE", new ConstantIntExpression(BUILTIN, Integer.MAX_VALUE)));
 		
 		members.addCaster(castExplicit(builtin, INT_TO_BYTE, BYTE));
 		members.addCaster(castExplicit(builtin, INT_TO_SBYTE, SBYTE));
 		members.addOperator(compare(builtin, FLOAT_COMPARE, FLOAT, UINT_TO_FLOAT));
 		members.addOperator(compare(builtin, DOUBLE_COMPARE, DOUBLE, UINT_TO_DOUBLE));
 		
-		members.addGetter(staticGetter(builtin, UINT_GET_MIN_VALUE, "MIN_VALUE", UINT));
-		members.addGetter(staticGetter(builtin, UINT_GET_MAX_VALUE, "MAX_VALUE", UINT));
+		members.addConst(constant(builtin, UINT_GET_MIN_VALUE, "MIN_VALUE", new ConstantUIntExpression(BUILTIN, 0)));
+		members.addConst(constant(builtin, UINT_GET_MAX_VALUE, "MAX_VALUE", new ConstantUIntExpression(BUILTIN, -1)));
 		
 		members.addCaster(castExplicit(builtin, UINT_TO_BYTE, BYTE));
 		members.addCaster(castExplicit(builtin, UINT_TO_SBYTE, SBYTE));
 		members.addOperator(compare(builtin, FLOAT_COMPARE, FLOAT, LONG_TO_FLOAT));
 		members.addOperator(compare(builtin, DOUBLE_COMPARE, DOUBLE, LONG_TO_DOUBLE));
 		
-		members.addGetter(staticGetter(builtin, LONG_GET_MIN_VALUE, "MIN_VALUE", LONG));
-		members.addGetter(staticGetter(builtin, LONG_GET_MAX_VALUE, "MAX_VALUE", LONG));
+		members.addConst(constant(builtin, LONG_GET_MIN_VALUE, "MIN_VALUE", new ConstantLongExpression(BUILTIN, Long.MIN_VALUE)));
+		members.addConst(constant(builtin, LONG_GET_MAX_VALUE, "MAX_VALUE", new ConstantLongExpression(BUILTIN, Long.MAX_VALUE)));
 		
 		members.addCaster(castExplicit(builtin, LONG_TO_BYTE, BYTE));
 		members.addCaster(castExplicit(builtin, LONG_TO_SBYTE, SBYTE));
 		members.addOperator(compare(builtin, FLOAT_COMPARE, FLOAT, ULONG_TO_FLOAT));
 		members.addOperator(compare(builtin, DOUBLE_COMPARE, DOUBLE, ULONG_TO_DOUBLE));
 		
-		members.addGetter(staticGetter(builtin, ULONG_GET_MIN_VALUE, "MIN_VALUE", ULONG));
-		members.addGetter(staticGetter(builtin, ULONG_GET_MAX_VALUE, "MAX_VALUE", ULONG));
+		members.addConst(constant(builtin, ULONG_GET_MIN_VALUE, "MIN_VALUE", new ConstantULongExpression(BUILTIN, 0)));
+		members.addConst(constant(builtin, ULONG_GET_MAX_VALUE, "MAX_VALUE", new ConstantULongExpression(BUILTIN, -1L)));
 		
 		members.addCaster(castExplicit(builtin, ULONG_TO_BYTE, BYTE));
 		members.addCaster(castExplicit(builtin, ULONG_TO_SBYTE, SBYTE));
 		members.addOperator(compare(builtin, FLOAT_COMPARE, FLOAT));
 		members.addOperator(compare(builtin, DOUBLE_COMPARE, DOUBLE, LONG_TO_DOUBLE));
 		
-		members.addGetter(staticGetter(builtin, FLOAT_GET_MIN_VALUE, "MIN_VALUE", FLOAT));
-		members.addGetter(staticGetter(builtin, FLOAT_GET_MAX_VALUE, "MAX_VALUE", FLOAT));
+		members.addConst(constant(builtin, FLOAT_GET_MIN_VALUE, "MIN_VALUE", new ConstantFloatExpression(BUILTIN, Float.MIN_VALUE)));
+		members.addConst(constant(builtin, FLOAT_GET_MAX_VALUE, "MAX_VALUE", new ConstantFloatExpression(BUILTIN, Float.MAX_VALUE)));
 		
 		members.addCaster(castExplicit(builtin, FLOAT_TO_BYTE, BYTE));
 		members.addCaster(castExplicit(builtin, FLOAT_TO_SBYTE, SBYTE));
 		members.addOperator(div(builtin, DOUBLE_DIV_DOUBLE, DOUBLE, DOUBLE));
 		members.addOperator(compare(builtin, DOUBLE_COMPARE, DOUBLE));
 		
-		members.addGetter(staticGetter(builtin, DOUBLE_GET_MIN_VALUE, "MIN_VALUE", DOUBLE));
-		members.addGetter(staticGetter(builtin, DOUBLE_GET_MAX_VALUE, "MAX_VALUE", DOUBLE));
+		members.addConst(constant(builtin, DOUBLE_GET_MIN_VALUE, "MIN_VALUE", new ConstantDoubleExpression(BUILTIN, Double.MIN_VALUE)));
+		members.addConst(constant(builtin, DOUBLE_GET_MAX_VALUE, "MAX_VALUE", new ConstantDoubleExpression(BUILTIN, Double.MAX_VALUE)));
 		
 		members.addCaster(castExplicit(builtin, DOUBLE_TO_BYTE, BYTE));
 		members.addCaster(castExplicit(builtin, DOUBLE_TO_SBYTE, SBYTE));
 	}
 	
 	private static CallTranslator castedTargetCall(HighLevelDefinition definition, FunctionalMember member, BuiltinID casterBuiltin) {
-		CasterMember caster = castImplicit(definition, casterBuiltin, member.getHeader().parameters[0].type);
+		CasterMember caster = castImplicit(definition, casterBuiltin, member.header.parameters[0].type);
 		return call -> member.call(call.position, caster.cast(call.position, call.target, true), call.arguments, call.scope);
 	}
 	
 				id);
 	}
 	
-	private static GetterMember staticGetter(HighLevelDefinition cls, BuiltinID id, String name, ITypeID type) {
-		return new GetterMember(
+	private static ConstMember constant(HighLevelDefinition cls, BuiltinID id, String name, Expression value) {
+		ConstMember result = new ConstMember(
 				BUILTIN,
 				cls,
 				Modifiers.STATIC | Modifiers.PUBLIC,
 				name,
-				type,
+				value.type,
 				id);
+		result.value = value;
+		return result;
 	}
 	
 	private static ConstructorMember constructor(

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

 import org.openzen.zenscript.codemodel.expression.InterfaceCastExpression;
 import org.openzen.zenscript.codemodel.expression.MakeConstExpression;
 import org.openzen.zenscript.codemodel.expression.NullExpression;
-import org.openzen.zenscript.codemodel.expression.SameObjectExpression;
 import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
 import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
 import org.openzen.zenscript.codemodel.member.CallerMember;
 import org.openzen.zenscript.codemodel.member.CasterMember;
+import org.openzen.zenscript.codemodel.member.ConstMember;
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
 import org.openzen.zenscript.codemodel.member.DestructorMember;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
-import org.openzen.zenscript.codemodel.member.ICallableMember;
-import org.openzen.zenscript.codemodel.member.ICasterMember;
-import org.openzen.zenscript.codemodel.member.IGettableMember;
+import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.member.GetterMember;
 import org.openzen.zenscript.codemodel.member.IIteratorMember;
 import org.openzen.zenscript.codemodel.member.ImplementationMember;
 import org.openzen.zenscript.codemodel.member.InnerDefinition;
 	private final LocalMemberCache cache;
 	public final ITypeID type;
 	
-	private final List<TypeMember<ICasterMember>> casters = new ArrayList<>();
+	private final List<TypeMember<CasterMember>> casters = new ArrayList<>();
 	private final List<TypeMember<ImplementationMember>> implementations = new ArrayList<>();
 	private final List<TypeMember<IIteratorMember>> iterators = new ArrayList<>();
 	
 	private final Map<OperatorType, DefinitionMemberGroup> operators = new HashMap<>();
 	
 	public TypeMembers(LocalMemberCache cache, ITypeID type) {
+		if (type == null)
+			throw new NullPointerException("Type must not be null!");
+		
 		this.cache = cache;
 		this.type = type;
 	}
 		casters.add(new TypeMember<>(priority, caster));
 	}
 	
+	public void addConst(ConstMember member) {
+		DefinitionMemberGroup group = getOrCreateGroup(member.name, true);
+		group.setConst(member, TypeMemberPriority.SPECIFIED);
+	}
+	
 	public void addField(FieldMember member) {
 		addField(member, TypeMemberPriority.SPECIFIED);
 	}
 		group.setField(member, priority);
 	}
 	
-	public void addGetter(IGettableMember member) {
+	public void addGetter(GetterMember member) {
 		addGetter(member, TypeMemberPriority.SPECIFIED);
 	}
 	
-	public void addGetter(IGettableMember member, TypeMemberPriority priority) {
-		DefinitionMemberGroup group = getOrCreateGroup(member.getName(), member.isStatic());
+	public void addGetter(GetterMember member, TypeMemberPriority priority) {
+		DefinitionMemberGroup group = getOrCreateGroup(member.name, member.isStatic());
 		group.setGetter(member, priority);
 	}
 	
 		group.addMethod(member, priority);
 	}
 	
-	public void addOperator(OperatorType operator, ICallableMember member, TypeMemberPriority priority) {
+	public void addOperator(OperatorType operator, FunctionalMember member, TypeMemberPriority priority) {
 		DefinitionMemberGroup group = getOrCreateGroup(operator);
 		group.addMethod(member, priority);
 	}
 	public Expression compare(CodePosition position, TypeScope scope, CompareType operator, Expression left, Expression right) {
 		if (operator == CompareType.EQ) {
 			DefinitionMemberGroup equal = getOrCreateGroup(OperatorType.EQUALS);
-			for (TypeMember<ICallableMember> member : equal.getMethodMembers()) {
-				if (member.member.getHeader().accepts(scope, right))
+			for (TypeMember<FunctionalMember> member : equal.getMethodMembers()) {
+				if (member.member.header.accepts(scope, right))
 					return equal.call(position, scope, left, new CallArguments(right), false);
 			}
 		} else if (operator == CompareType.NE) {
 			DefinitionMemberGroup equal = getOrCreateGroup(OperatorType.NOTEQUALS);
-			for (TypeMember<ICallableMember> member : equal.getMethodMembers()) {
-				if (member.member.getHeader().accepts(scope, right)) {
+			for (TypeMember<FunctionalMember> member : equal.getMethodMembers()) {
+				if (member.member.header.accepts(scope, right)) {
 					return equal.call(position, scope, left, new CallArguments(right), false);
 				}
 			}
 		if (type.isOptional() && type.unwrap() == toType)
 			return true;
 		
-		for (TypeMember<ICasterMember> caster : casters) {
+		for (TypeMember<CasterMember> caster : casters) {
 			if (caster.member.isImplicit() && toType == caster.member.getTargetType())
 				return true;
 		}
 		if (canCastImplicit(toType))
 			return true;
 		
-		for (TypeMember<ICasterMember> caster : casters) {
+		for (TypeMember<CasterMember> caster : casters) {
 			if (toType == caster.member.getTargetType())
 				return true;
 		}
 		if (type.isOptional() && type.unwrap() == toType)
 			return new CheckNullExpression(position, value);
 		
-		for (TypeMember<ICasterMember> caster : casters) {
+		for (TypeMember<CasterMember> caster : casters) {
 			if (caster.member.isImplicit() && toType == caster.member.getTargetType())
 				return caster.member.cast(position, value, implicit);
 		}
 		if (this.canCastImplicit(toType))
 			return castImplicit(position, value, toType, false);
 		
-		for (TypeMember<ICasterMember> caster : casters)
+		for (TypeMember<CasterMember> caster : casters)
 			if (toType == caster.member.getTargetType())
 				return caster.member.cast(position, value, false);
 		

CompilerShared/build.gradle

 dependencies {
 	compile 'org.json:json:20180130'
 	compile project(':CodeModel')
-	compile project(':Linker')
+	compile project(':Validator')
 }

CompilerShared/src/main/java/org/openzen/zenscript/compiler/CompileScope.java

  */
 package org.openzen.zenscript.compiler;
 
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import org.openzen.zenscript.codemodel.AccessScope;
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 	private final GlobalTypeRegistry globalRegistry;
 	private final List<ExpansionDefinition> expansions;
 	private final LocalMemberCache cache;
+	private final Map<String, AnnotationDefinition> annotations = new HashMap<>();
 	
-	public CompileScope(AccessScope access, GlobalTypeRegistry globalRegistry, List<ExpansionDefinition> expansions) {
+	public CompileScope(AccessScope access, GlobalTypeRegistry globalRegistry, List<ExpansionDefinition> expansions, List<AnnotationDefinition> annotations) {
 		this.globalRegistry = globalRegistry;
 		this.expansions = expansions;
 		this.cache = new LocalMemberCache(access, globalRegistry, expansions);
+		
+		for (AnnotationDefinition annotation : annotations) {
+			this.annotations.put(annotation.getAnnotationName(), annotation);
+		}
 	}
 
 	@Override
 	public TypeMembers getTypeMembers(ITypeID type) {
 		return cache.get(type);
 	}
+
+	@Override
+	public AnnotationDefinition getAnnotation(String name) {
+		return annotations.get(name);
+	}
 }

CompilerShared/src/main/java/org/openzen/zenscript/compiler/SemanticModule.java

  */
 package org.openzen.zenscript.compiler;
 
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.PackageDefinitions;
 import org.openzen.zenscript.codemodel.ScriptBlock;
+import org.openzen.zenscript.codemodel.annotations.AnnotationProcessor;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
-import org.openzen.zenscript.linker.symbol.ISymbol;
+import org.openzen.zenscript.codemodel.type.ISymbol;
+import org.openzen.zenscript.validator.ValidationLogEntry;
+import org.openzen.zenscript.validator.Validator;
 
 /**
  *
 	public final String name;
 	public final String[] dependencies;
 	
-	public final boolean isValid;
-	public final ZSPackage pkg;
+	private State state;
+	public final ZSPackage rootPackage;
+	public final ZSPackage modulePackage;
 	public final PackageDefinitions definitions;
 	public final List<ScriptBlock> scripts;
 	public final Map<String, ISymbol> globals = new HashMap<>();
 	
 	public final CompilationUnit compilationUnit;
 	public final List<ExpansionDefinition> expansions;
+	public final List<AnnotationDefinition> annotations;
 	
 	public SemanticModule(
 			String name,
 			String[] dependencies,
-			boolean isValid,
-			ZSPackage pkg,
+			State state,
+			ZSPackage rootPackage,
+			ZSPackage modulePackage,
 			PackageDefinitions definitions,
 			List<ScriptBlock> scripts,
 			CompilationUnit compilationUnit,
-			List<ExpansionDefinition> expansions)
+			List<ExpansionDefinition> expansions,
+			List<AnnotationDefinition> annotations)
 	{
 		this.name = name;
 		this.dependencies = dependencies;
 		
-		this.isValid = isValid;
-		this.pkg = pkg;
+		this.state = state;
+		this.rootPackage = rootPackage;
+		this.modulePackage = modulePackage;
 		this.definitions = definitions;
 		this.scripts = scripts;
 		
 		this.compilationUnit = compilationUnit;
 		this.expansions = expansions;
+		this.annotations = annotations;
+	}
+	
+	public boolean isValid() {
+		return state != State.INVALID;
+	}
+	
+	public SemanticModule normalize() {
+		if (state != State.SEMANTIC)
+			throw new IllegalStateException("Module is invalid");
+		
+		AnnotationProcessor annotationProcessor = new AnnotationProcessor(rootPackage, definitions, compilationUnit.globalTypeRegistry, expansions, annotations);
+		List<ScriptBlock> processedScripts = new ArrayList<>();
+		for (ScriptBlock block : scripts)
+			processedScripts.add(annotationProcessor.process(block));
+		for (HighLevelDefinition definition : definitions.getAll())
+			annotationProcessor.process(definition);
+		
+		return new SemanticModule(
+				name,
+				dependencies,
+				State.NORMALIZED,
+				rootPackage,
+				modulePackage,
+				definitions,
+				processedScripts,
+				compilationUnit,
+				expansions,
+				annotations);
+	}
+	
+	public boolean validate() {
+		if (state != State.NORMALIZED)
+			throw new IllegalStateException("Module is not yet normalized");
+		
+		Validator validator = new Validator();
+		boolean isValid = true;
+		for (ScriptBlock script : scripts) {
+			isValid &= validator.validate(script);
+		}
+		for (HighLevelDefinition definition : definitions.getAll()) {
+			isValid &= validator.validate(definition);
+		}
+		
+		for (ValidationLogEntry entry : validator.getLog()) {
+			System.out.println(entry.kind + " " + entry.position.toString() + ": " + entry.message);
+		}
+		state = isValid ? State.VALIDATED : State.INVALID;
+		if (!isValid && validator.getLog().isEmpty())
+			System.out.println("ERROR: module is invalid but no errors have been generated");
+		return isValid;
 	}
 	
 	public void compile(ZenCodeCompiler compiler) {
+		if (state != State.VALIDATED)
+			throw new IllegalStateException("Module is not yet validated");
+		
 		for (HighLevelDefinition definition : definitions.getAll()) {
 			compiler.addDefinition(definition, this);
 		}
 		}
 		compiler.finish();
 	}
+	
+	public enum State {
+		INVALID,
+		SEMANTIC,
+		NORMALIZED,
+		VALIDATED
+	}
 }

Constructor/build.gradle

 	compile 'org.json:json:20180130'
 	compile project(':CodeModel')
 	compile project(':Parser')
-	compile project(':Linker')
 	compile project(':Validator')
 	compile project(':CompilerShared')
 	compile project(':JavaBytecodeCompiler')

Constructor/libraries/stdlib/module.json

 		"IllegalArgumentException": {"type": "Definition", "definition": "IllegalArgumentException"},
 		"StringBuilder": {"type": "Definition", "definition": "StringBuilder"},
 		"StringBuildable": {"type": "Definition", "definition": "StringBuildable"},
-		"panic": {"type": "Definition", "definition": "panic"}
+		"panic": {"type": "Definition", "definition": "panic"},
+		"Result": {"type": "Definition", "definition": "Result"}
 	}
 }

Constructor/src/main/java/org/openzen/zenscript/constructor/Module.java

 import org.json.JSONArray;
 import org.json.JSONObject;
 import org.json.JSONTokener;
-import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.PackageDefinitions;
 import org.openzen.zenscript.codemodel.ScriptBlock;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.constructor.module.ModuleSpace;
 import org.openzen.zenscript.compiler.SemanticModule;
-import org.openzen.zenscript.linker.symbol.ISymbol;
+import org.openzen.zenscript.codemodel.type.ISymbol;
 import org.openzen.zenscript.parser.ParsedFile;
 import org.openzen.zenscript.shared.CompileException;
-import org.openzen.zenscript.validator.ValidationLogEntry;
-import org.openzen.zenscript.validator.Validator;
 
 /**
  *
 			// respective definitions, such as fields, constructors, methods...
 			// It doesn't yet compile the method contents.
 			try {
-				file.compileTypes(rootPackage, pkg, definitions, registry.compilationUnit.globalTypeRegistry, expansions, globals);
+				file.compileTypes(rootPackage, pkg, definitions, registry.compilationUnit.globalTypeRegistry, expansions, globals, registry.getAnnotations());
 			} catch (CompileException ex) {
 				System.out.println(ex.getMessage());
 				failed = true;
 		}
 		
 		if (failed)
-			return new SemanticModule(name, dependencies, false, pkg, definitions, Collections.emptyList(), registry.compilationUnit, expansions);
+			return new SemanticModule(name, dependencies, SemanticModule.State.INVALID, rootPackage, pkg, definitions, Collections.emptyList(), registry.compilationUnit, expansions, registry.getAnnotations());
 		
 		for (ParsedFile file : files) {
 			// compileMembers will register all definition members to their
 			// respective definitions, such as fields, constructors, methods...
 			// It doesn't yet compile the method contents.
 			try {
-				file.compileMembers(rootPackage, pkg, definitions, registry.compilationUnit.globalTypeRegistry, expansions, globals);
+				file.compileMembers(rootPackage, pkg, definitions, registry.compilationUnit.globalTypeRegistry, expansions, globals, registry.getAnnotations());
 			} catch (CompileException ex) {
 				System.out.println(ex.getMessage());
 				failed = true;
 		}
 		
 		if (failed)
-			return new SemanticModule(name, dependencies, false, pkg, definitions, Collections.emptyList(), registry.compilationUnit, expansions);
+			return new SemanticModule(name, dependencies, SemanticModule.State.INVALID, rootPackage, pkg, definitions, Collections.emptyList(), registry.compilationUnit, expansions, registry.getAnnotations());
 		
 		// scripts will store all the script blocks encountered in the files
 		List<ScriptBlock> scripts = new ArrayList<>();
 			// into semantic code. This semantic code can then be compiled
 			// to various targets.
 			try {
-				file.compileCode(rootPackage, pkg, definitions, registry.compilationUnit.globalTypeRegistry, expansions, scripts, globals);
+				file.compileCode(rootPackage, pkg, definitions, registry.compilationUnit.globalTypeRegistry, expansions, scripts, globals, registry.getAnnotations());
 			} catch (CompileException ex) {
 				System.out.println(ex.getMessage());
 				failed = true;
 			}
 		}
 		
-		if (failed)
-			return new SemanticModule(name, dependencies, false, pkg, definitions, Collections.emptyList(), registry.compilationUnit, expansions);
-		
-		Validator validator = new Validator();
-		boolean isValid = true;
-		for (ScriptBlock script : scripts) {
-			isValid &= validator.validate(script);
-		}
-		for (HighLevelDefinition definition : definitions.getAll()) {
-			isValid &= validator.validate(definition);
-		}
-		
-		for (ValidationLogEntry entry : validator.getLog()) {
-			System.out.println(entry.kind + " " + entry.position.toString() + ": " + entry.message);
-		}
-		
-		return new SemanticModule(name, dependencies, isValid, pkg, definitions, scripts, registry.compilationUnit, expansions);
+		return new SemanticModule(name, dependencies, SemanticModule.State.SEMANTIC, rootPackage, pkg, definitions, Collections.emptyList(), registry.compilationUnit, expansions, registry.getAnnotations());
 	}
 }

Constructor/src/main/java/org/openzen/zenscript/constructor/module/DirectoryModuleLoader.java

 import org.openzen.zenscript.constructor.JSONUtils;
 import org.openzen.zenscript.constructor.Module;
 import org.openzen.zenscript.constructor.ModuleLoader;
-import org.openzen.zenscript.linker.symbol.TypeSymbol;
+import org.openzen.zenscript.codemodel.type.TypeSymbol;
 import org.openzen.zenscript.parser.ParsedFile;
 
 /**
 				space.addModule(dependencyName, loader.getModule(dependencyName));
 
 			Module module = new Module(moduleName, directory, jsonFile);
-			ZSPackage pkg = new ZSPackage(null, module.packageName);
+			ZSPackage pkg = isStdlib ? unit.globalTypeRegistry.stdlib : new ZSPackage(null, module.packageName);
 
 			ParsedFile[] parsedFiles = module.parse(pkg);
 			SemanticModule result = Module.compileSyntaxToSemantic(module.name, module.dependencies, pkg, parsedFiles, space);

Constructor/src/main/java/org/openzen/zenscript/constructor/module/ModuleSpace.java

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
+import org.openzen.zenscript.codemodel.annotations.NativeAnnotationDefinition;
+import org.openzen.zenscript.codemodel.annotations.PreconditionAnnotationDefinition;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.compiler.CompilationUnit;
 import org.openzen.zenscript.constructor.ConstructorException;
-import org.openzen.zenscript.linker.symbol.ISymbol;
+import org.openzen.zenscript.codemodel.type.ISymbol;
 
 /**
  *
  * @author Hoofdgebruiker
  */
-public class ModuleSpace {
+public final class ModuleSpace {
 	private final ZSPackage rootPackage = new ZSPackage(null, "");
 	public final CompilationUnit compilationUnit;
 	public final ZSPackage globalsPackage = new ZSPackage(null, "");
 	private final List<ExpansionDefinition> expansions = new ArrayList<>();
 	private final Map<String, ISymbol> globals = new HashMap<>();
+	private final List<AnnotationDefinition> annotations = new ArrayList<>();
 	
 	public ModuleSpace(CompilationUnit compilationUnit) {
 		this.compilationUnit = compilationUnit;
+		
+		addAnnotation(NativeAnnotationDefinition.INSTANCE);
+		addAnnotation(PreconditionAnnotationDefinition.INSTANCE);
+	}
+	
+	public void addAnnotation(AnnotationDefinition annotation) {
+		annotations.add(annotation);
 	}
 	
 	public void addModule(String name, SemanticModule dependency) {
-		rootPackage.add(name, dependency.pkg);
+		rootPackage.add(name, dependency.modulePackage);
 		dependency.definitions.registerExpansionsTo(expansions);
 		
 		for (Map.Entry<String, ISymbol> globalEntry : dependency.globals.entrySet()) {
 	public Map<String, ISymbol> collectGlobals() {
 		return globals;
 	}
+	
+	public List<AnnotationDefinition> getAnnotations() {
+		return annotations;
+	}
 }

IDE/src/main/java/org/openzen/zenscript/ide/host/local/LocalTarget.java

 			}
 			
 			SemanticModule module = moduleLoader.getModule(target.getModule());
+			module = module.normalize();
+			module.validate();
+			
 			ZenCodeCompiler compiler = target.createCompiler(module);
-			moduleLoader.getModule("stdlib").compile(compiler);
+			if (!module.isValid())
+				return compiler;
+			
+			SemanticModule stdlib = moduleLoader.getModule("stdlib");
+			stdlib = stdlib.normalize();
+			stdlib.validate();
+			if (!stdlib.isValid())
+				return compiler;
+			stdlib.compile(compiler);
+			
+			boolean isValid = compileDependencies(moduleLoader, compiler, compiledModules, module);
+			if (!isValid)
+				return compiler;
 			
-			compileDependencies(moduleLoader, compiler, compiledModules, module);
 			module.compile(compiler);
 			return compiler;
 		} catch (IOException ex) {
 		}
 	}
 	
-	private void compileDependencies(ModuleLoader loader, ZenCodeCompiler compiler, Set<String> compiledModules, SemanticModule module) {
+	private boolean compileDependencies(ModuleLoader loader, ZenCodeCompiler compiler, Set<String> compiledModules, SemanticModule module) {
 		for (String dependency : module.dependencies) {
 			if (compiledModules.contains(module.name))
 				continue;
 			
 			SemanticModule dependencyModule = loader.getModule(dependency);
-			compileDependencies(loader, compiler, compiledModules, dependencyModule);
+			module = module.normalize();
+			module.validate();
+			if (!module.isValid())
+				return false;
+			
+			if (!compileDependencies(loader, compiler, compiledModules, dependencyModule))
+				return false;
+			
 			module.compile(compiler);
 			compiledModules.add(module.name);
 		}
+		
+		return true;
 	}
 }

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/WindowView.java

  */
 package org.openzen.zenscript.ide.ui.view;
 
-import org.openzen.drawablegui.DComponent;
 import org.openzen.drawablegui.DDimensionPreferences;
-import org.openzen.drawablegui.DDrawable;
 import org.openzen.drawablegui.DEmptyView;
 import org.openzen.drawablegui.scroll.DScrollPane;
 import org.openzen.drawablegui.DSideLayout;
-import org.openzen.drawablegui.live.LiveList;
 import org.openzen.drawablegui.style.DStyleClass;
 import org.openzen.drawablegui.tree.DTreeView;
 import org.openzen.drawablegui.tree.DTreeViewStyle;

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

         javaWriter.label(end);
         return null;
     }
+	
+	@Override
+	public Void visitConst(ConstExpression expression) {
+		BuiltinID builtin = expression.constant.builtin;
+		if (builtin == null) {
+			if (!checkAndGetFieldInfo(expression.constant, true))
+	            throw new IllegalStateException("Call target has no field info!");
+			
+			return null;
+		}
+		
+		switch (builtin) {
+			case BYTE_GET_MIN_VALUE:
+				javaWriter.iConst0();
+				break;
+			case BYTE_GET_MAX_VALUE:
+				javaWriter.constant(0xFF);
+				break;
+			case SBYTE_GET_MIN_VALUE:
+				javaWriter.getStaticField(BYTE_MIN_VALUE);
+				break;
+			case SBYTE_GET_MAX_VALUE:
+				javaWriter.getStaticField(BYTE_MAX_VALUE);
+				break;
+			case SHORT_GET_MIN_VALUE:
+				javaWriter.getStaticField(SHORT_MIN_VALUE);
+				break;
+			case SHORT_GET_MAX_VALUE:
+				javaWriter.getStaticField(SHORT_MAX_VALUE);
+				break;
+			case USHORT_GET_MIN_VALUE:
+				javaWriter.iConst0();
+				break;
+			case USHORT_GET_MAX_VALUE:
+				javaWriter.constant(0xFFFF);
+				break;
+			case INT_GET_MIN_VALUE:
+				javaWriter.getStaticField(INTEGER_MIN_VALUE);
+				break;
+			case INT_GET_MAX_VALUE:
+				javaWriter.getStaticField(INTEGER_MAX_VALUE);
+				break;
+			case UINT_GET_MIN_VALUE:
+				javaWriter.iConst0();
+				break;
+			case UINT_GET_MAX_VALUE:
+				javaWriter.constant(-1);
+				break;
+			case LONG_GET_MIN_VALUE:
+				javaWriter.getStaticField(LONG_MIN_VALUE);
+				break;
+			case LONG_GET_MAX_VALUE:
+				javaWriter.getStaticField(LONG_MAX_VALUE);
+				break;
+			case ULONG_GET_MIN_VALUE:
+				javaWriter.iConst0();
+				break;
+			case ULONG_GET_MAX_VALUE:
+				javaWriter.constant(-1L);
+				break;
+			case FLOAT_GET_MIN_VALUE:
+				javaWriter.getStaticField(FLOAT_MIN_VALUE);
+				break;
+			case FLOAT_GET_MAX_VALUE:
+				javaWriter.getStaticField(FLOAT_MAX_VALUE);
+				break;
+			case DOUBLE_GET_MIN_VALUE:
+				javaWriter.getStaticField(DOUBLE_MIN_VALUE);
+				break;
+			case DOUBLE_GET_MAX_VALUE:
+				javaWriter.getStaticField(DOUBLE_MAX_VALUE);
+				break;
+			case CHAR_GET_MIN_VALUE:
+				javaWriter.getStaticField(CHARACTER_MIN_VALUE);
+				break;
+			case CHAR_GET_MAX_VALUE:
+				javaWriter.getStaticField(CHARACTER_MAX_VALUE);
+				break;
+			case ENUM_VALUES: {
+				DefinitionTypeID type = (DefinitionTypeID) expression.type;
+				JavaClassInfo cls = type.definition.getTag(JavaClassInfo.class);
+				javaWriter.invokeStatic(new JavaMethodInfo(cls, "values", "()[L" + cls.internalClassName + ";", PUBLIC_STATIC));
+				break;
+			}
+			default:
+				throw new UnsupportedOperationException("Unknown builtin: " + builtin);
+		}
+		
+		return null;
+	}
 
     @Override
     public Void visitConstantBool(ConstantBoolExpression expression) {
 
     @Override
     public Void visitConstantByte(ConstantByteExpression expression) {
-        getJavaWriter().biPush(expression.value);
+        getJavaWriter().constant(expression.value);
         return null;
     }
 
 				throw new UnsupportedOperationException("Unknown builtin: " + builtin);
 		}
 		
-        return null;
+		throw new UnsupportedOperationException("Unknown builtin: " + builtin);
     }
 
     @Override

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

 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.ConstExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantBoolExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantByteExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantCharExpression;
 	public Void visitConditional(ConditionalExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
 	}
+	
+	@Override
+	public Void visitConst(ConstExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
 
 	@Override
 	public Void visitConstantBool(ConstantBoolExpression expression) {

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

 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.ConstExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantBoolExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantByteExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantCharExpression;
 	public Void visitConditional(ConditionalExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
 	}
+	
+	@Override
+	public Void visitConst(ConstExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
 
 	@Override
 	public Void visitConstantBool(ConstantBoolExpression expression) {

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

 import java.util.List;
 
 public class JavaMemberVisitor implements MemberVisitor<Void> {
-
     private final ClassWriter writer;
     private final JavaClassInfo toClass;
     private final HighLevelDefinition definition;
         this.clinitStatementVisitor.start();
         CompilerUtils.writeDefaultFieldInitializers(javaWriter, definition, true);
     }
+	
+	@Override
+	public Void visitConst(ConstMember member) {
+        //TODO calc signature
+        String signature = null;
+        final String descriptor = Type.getDescriptor(member.type.accept(JavaTypeClassVisitor.INSTANCE));
+        writer.visitField(CompilerUtils.calcAccess(member.modifiers), member.name, descriptor, signature, null).visitEnd();
+        member.setTag(JavaFieldInfo.class, new JavaFieldInfo(toClass, member.name, descriptor));
+        return null;
+	}
 
     @Override
     public Void visitField(FieldMember member) {