- Added access & static checks to validator

- Removed export access and added internal access support

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

 			output.append("protected ");
 		if (Modifiers.isPublic(modifiers))
 			output.append("public ");
-		if (Modifiers.isExport(modifiers))
-			output.append("export ");
+		if (Modifiers.isInternal(modifiers))
+			output.append("internal ");
 		if (Modifiers.isStatic(modifiers))
 			output.append("static ");
 		if (Modifiers.isAbstract(modifiers))

CodeModel/src/main/java/org/openzen/zenscript/codemodel/AccessScope.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;
+
+import java.util.Objects;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public final class AccessScope {
+	public final Module module;
+	public final HighLevelDefinition definition;
+	
+	public AccessScope(Module module, HighLevelDefinition definition) {
+		this.module = module;
+		this.definition = definition;
+	}
+	
+	public boolean hasAccessTo(AccessScope other, int access) {
+		if (Modifiers.isPublic(access))
+			return true;
+		if (definition == other.definition)
+			return true;
+		if (Modifiers.isPrivate(access))
+			return false;
+		if (Modifiers.isInternal(access))
+			return module == other.module;
+		if (Modifiers.isProtected(access))
+			return definition.isSubclassOf(other.definition);
+		
+		return false;
+	}
+
+	@Override
+	public int hashCode() {
+		int hash = 7;
+		hash = 79 * hash + Objects.hashCode(this.module);
+		hash = 79 * hash + Objects.hashCode(this.definition);
+		return hash;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null || getClass() != obj.getClass())
+			return false;
+		
+		final AccessScope other = (AccessScope) obj;
+		return module == other.module && definition == other.definition;
+	}
+}

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

 import org.openzen.zenscript.codemodel.member.ImplementationMember;
 import org.openzen.zenscript.codemodel.member.InnerDefinitionMember;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
 			isDestructible |= outerDefinition.isDestructible;
 	}
 	
+	public boolean isSubclassOf(HighLevelDefinition other) {
+		if (superType.isDefinition(other))
+			return true;
+		if (superType == null || !(superType instanceof DefinitionTypeID))
+			return false;
+		
+		DefinitionTypeID superDefinition = (DefinitionTypeID)superType;
+		return superDefinition.definition.isSubclassOf(other);
+	}
+	
 	public int getNumberOfGenericParameters() {
 		return typeParameters == null ? 0 : typeParameters.length;
 	}
 		this.typeParameters = typeParameters;
 	}
 	
+	public AccessScope getAccessScope() {
+		return new AccessScope(module, this);
+	}
+	
 	public List<FieldMember> getFields() {
 		List<FieldMember> fields = new ArrayList<>();
 		for (IDefinitionMember member : members)

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

 	private Modifiers() {}
 	
 	public static final int PUBLIC = 1;
-	public static final int EXPORT = 2;
+	public static final int INTERNAL = 2;
 	public static final int PRIVATE = 4;
 	public static final int ABSTRACT = 8;
 	public static final int FINAL = 16;
 		return (modifiers & PUBLIC) > 0;
 	}
 	
-	public static boolean isExport(int modifiers) {
-		return (modifiers & EXPORT) > 0;
+	public static boolean isInternal(int modifiers) {
+		return (modifiers & INTERNAL) > 0;
 	}
 	
 	public static boolean isProtected(int modifiers) {
 	public static boolean isOverride(int modifiers) {
 		return (modifiers & OVERRIDE) > 0;
 	}
+	
+	public static boolean hasAccess(int modifiers) {
+		return (modifiers & (PRIVATE | PUBLIC | PROTECTED | INTERNAL)) > 0;
+	}
 }

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

  * @author Hoofdgebruiker
  */
 public class ScriptBlock extends Taggable {
+	public final Module module;
 	public final ZSPackage pkg;
 	public final List<Statement> statements;
 	
-	public ScriptBlock(ZSPackage pkg, List<Statement> statements) {
+	public ScriptBlock(Module module, ZSPackage pkg, List<Statement> statements) {
+		this.module = module;
 		this.pkg = pkg;
 		this.statements = statements;
 	}
 	
 	public ScriptBlock withStatements(List<Statement> newStatements) {
-		ScriptBlock result = new ScriptBlock(pkg, newStatements);
+		ScriptBlock result = new ScriptBlock(module, pkg, newStatements);
 		result.addAllTagsFrom(this);
 		return result;
 	}
 		for (Statement statement : statements) {
 			normalized.add(statement.normalize(scope, ConcatMap.empty(LoopStatement.class, LoopStatement.class)));
 		}
-		ScriptBlock result = new ScriptBlock(pkg, normalized);
+		ScriptBlock result = new ScriptBlock(module, pkg, normalized);
 		result.addAllTagsFrom(this);
 		return result;
 	}

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

 	
 	public void setHeader(GlobalTypeRegistry registry, FunctionHeader header) {
 		this.header = header;
-		addMember(caller = new CallerMember(position, this, modifiers | Modifiers.STATIC, header, null));
+		addMember(caller = new CallerMember(position, this, Modifiers.PUBLIC | Modifiers.STATIC, header, null));
 		callerGroup.addMethod(new FunctionalMemberRef(caller, registry.getFunction(header).stored(StaticStorageTag.INSTANCE), GenericMapper.EMPTY), TypeMemberPriority.SPECIFIED);
 	}
 	

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

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.member.ref.ConstMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 
 	@Override
 	public void normalize(TypeScope scope) {
+		if (!Modifiers.hasAccess(modifiers))
+			modifiers |= Modifiers.INTERNAL;
+		
 		type = type.getNormalized();
 		value = value.normalize(scope);
 	}

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

 	public void normalize(TypeScope scope) {
 		if (definition instanceof EnumDefinition)
 			modifiers |= Modifiers.PRIVATE;
+		else if (!Modifiers.hasAccess(modifiers))
+			modifiers |= Modifiers.INTERNAL;
 		
 		super.normalize(scope);
 	}

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

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 		return new FunctionalMemberRef(this, type, null);
 	}
 	
+	@Override
 	public FunctionalMemberRef ref(StoredType type, GenericMapper mapper) {
 		return new FunctionalMemberRef(this, type, mapper);
 	}
 
 	@Override
 	public void normalize(TypeScope scope) {
+		if (!Modifiers.hasAccess(modifiers))
+			modifiers |= Modifiers.INTERNAL;
+		
 		header = header.normalize(scope.getTypeRegistry());
 		if (body != null)
 			body = body.normalize(scope, ConcatMap.empty(LoopStatement.class, LoopStatement.class));

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

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 
 	@Override
 	public void normalize(TypeScope scope) {
+		if (!Modifiers.hasAccess(modifiers))
+			modifiers |= Modifiers.INTERNAL;
 		if (body != null)
 			body = body.normalize(scope, ConcatMap.empty(LoopStatement.class, LoopStatement.class));
 	}

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

 package org.openzen.zenscript.codemodel.member;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.AccessScope;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 	DefinitionMemberRef ref(StoredType type, GenericMapper mapper);
 	
 	FunctionHeader getHeader();
+	
+	default AccessScope getAccessScope() {
+		return getDefinition().getAccessScope();
+	}
 }

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

 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.ImplementationMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 
 	@Override
 	public void normalize(TypeScope scope) {
+		if (!Modifiers.hasAccess(modifiers))
+			modifiers |= Modifiers.PUBLIC;
+		
 		for (IDefinitionMember member : members)
 			member.normalize(scope);
 	}

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

 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.SetterMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 
 	@Override
 	public void normalize(TypeScope scope) {
+		if (!Modifiers.hasAccess(modifiers))
+			modifiers |= Modifiers.INTERNAL;
+		
 		if (body != null)
 			body = body.normalize(scope, ConcatMap.empty(LoopStatement.class, LoopStatement.class));
 	}

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

 	
 	String describe();
 	
-	<T> T getTag(Class<T> type);
+	default <T> T getTag(Class<T> type) {
+		return getTarget().getTag(type);
+	}
+	
+	default boolean hasTag(Class<?> type) {
+		return getTarget().hasTag(type);
+	}
 	
 	StoredType getOwnerType();
 	

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

 	
 	@Override
 	public Void visitString(Void context, StringTypeID string) {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "string", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "string", Modifiers.PUBLIC, null);
 		
 		constructor(builtin, STRING_CONSTRUCTOR_CHARACTERS, new StoredType(registry.getOptional(registry.getArray(CHAR.stored, 1)), BorrowStorageTag.INVOCATION));
 		
 
 	@Override
 	public Void visitArray(Void context, ArrayTypeID array) {
-		HighLevelDefinition definition = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "", Modifiers.EXPORT);
+		HighLevelDefinition definition = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "", Modifiers.PUBLIC);
 		StoredType baseType = array.elementType;
 		int dimension = array.dimension;
 		StorageTag storage = type.getActualStorage();
 		StoredType keyType = assoc.keyType;
 		StoredType valueType = assoc.valueType;
 		
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "", Modifiers.EXPORT);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "", Modifiers.PUBLIC);
 		
 		constructor(builtin, ASSOC_CONSTRUCTOR);
 
 		FunctionHeader putHeader = new FunctionHeader(new TypeParameter[] { functionParameter }, VOID.stored, null, null, new FunctionParameter(valueType));
 		FunctionHeader containsHeader = new FunctionHeader(new TypeParameter[] { functionParameter }, BOOL.stored, null, null, FunctionParameter.NONE);
 		
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "", Modifiers.EXPORT);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "", Modifiers.PUBLIC);
 		constructor(builtin, GENERICMAP_CONSTRUCTOR);
 		
 		method(builtin, "getOptional", getOptionalHeader, GENERICMAP_GETOPTIONAL);
 
 	@Override
 	public Void visitFunction(Void context, FunctionTypeID function) {
-		FunctionDefinition builtin = new FunctionDefinition(BUILTIN, Module.BUILTIN, null, "", Modifiers.EXPORT, function.header, registry);
-		new CallerMember(BUILTIN, builtin, 0, function.header, FUNCTION_CALL).registerTo(members, TypeMemberPriority.SPECIFIED, null);
+		FunctionDefinition builtin = new FunctionDefinition(BUILTIN, Module.BUILTIN, null, "", Modifiers.PUBLIC, function.header, registry);
+		new CallerMember(BUILTIN, builtin, Modifiers.PUBLIC, function.header, FUNCTION_CALL).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 		
 		same(builtin, FUNCTION_SAME, type);
 		notsame(builtin, FUNCTION_NOTSAME, type);
 	public Void visitRange(Void context, RangeTypeID range) {
 		StoredType baseType = range.baseType;
 
-		ClassDefinition definition = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "", Modifiers.EXPORT);
+		ClassDefinition definition = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "", Modifiers.PUBLIC);
 		getter(definition, RANGE_FROM, "from", baseType);
 		getter(definition, RANGE_TO, "to", baseType);
 		if (baseType.type == BYTE
 
 	@Override
 	public Void visitModified(Void context, OptionalTypeID modified) {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "modified", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "modified", Modifiers.PUBLIC, null);
 		modified.baseType.accept(context, this);
 		
 		if (modified.isOptional()) {
 	}
 	
 	private void visitBool() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "bool", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "bool", Modifiers.PUBLIC, null);
 		not(builtin, BOOL_NOT, BOOL);
 		and(builtin, BOOL_AND, BOOL, BOOL);
 		or(builtin, BOOL_OR, BOOL, BOOL);
 	}
 	
 	private void visitByte() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "byte", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "byte", Modifiers.PUBLIC, null);
 		
 		invert(builtin, BYTE_NOT, BYTE);
 		inc(builtin, BYTE_INC, BYTE);
 	}
 	
 	private void visitSByte() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "sbyte", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "sbyte", Modifiers.PUBLIC, null);
 		
 		invert(builtin, SBYTE_NOT, SBYTE);
 		neg(builtin, SBYTE_NEG, SBYTE);
 	}
 	
 	private void visitShort() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "short", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "short", Modifiers.PUBLIC, null);
 		
 		invert(builtin, SHORT_NOT, SHORT);
 		neg(builtin, SHORT_NEG, SHORT);
 	}
 	
 	private void visitUShort() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "ushort", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "ushort", Modifiers.PUBLIC, null);
 		
 		invert(builtin, USHORT_NOT, USHORT);
 		inc(builtin, USHORT_INC, USHORT);
 	}
 	
 	private void visitInt() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "int", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "int", Modifiers.PUBLIC, null);
 		
 		invert(builtin, INT_NOT, INT);
 		neg(builtin, INT_NEG, INT);
 	}
 
 	private void visitUInt() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "uint", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "uint", Modifiers.PUBLIC, null);
 		
 		invert(builtin, UINT_NOT, INT);
 		inc(builtin, UINT_DEC, INT);
 	}
 	
 	private void visitLong() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "long", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "long", Modifiers.PUBLIC, null);
 		
 		invert(builtin, LONG_NOT, LONG);
 		neg(builtin, LONG_NEG, LONG);
 	}
 	
 	private void visitULong() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "ulong", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "ulong", Modifiers.PUBLIC, null);
 		
 		invert(builtin, ULONG_NOT, ULONG);
 		inc(builtin, ULONG_DEC, ULONG);
 	}
 	
 	private void visitUSize() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "usize", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "usize", Modifiers.PUBLIC, null);
 		
 		invert(builtin, USIZE_NOT, USIZE);
 		inc(builtin, USIZE_DEC, USIZE);
 	}
 	
 	private void visitFloat() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "float", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "float", Modifiers.PUBLIC, null);
 		
 		neg(builtin, FLOAT_NEG, FLOAT);
 		inc(builtin, FLOAT_DEC, FLOAT);
 	}
 	
 	private void visitDouble() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "double", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "double", Modifiers.PUBLIC, null);
 		
 		neg(builtin, DOUBLE_NEG, DOUBLE);
 		inc(builtin, DOUBLE_DEC, DOUBLE);
 	}
 
 	private void visitChar() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "char", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "char", Modifiers.PUBLIC, null);
 		
 		add(builtin, CHAR_ADD_INT, INT, CHAR);
 		sub(builtin, CHAR_SUB_INT, INT, CHAR);

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

 	@Override
 	public Void visitGetter(GetterExpression expression) {
 		expression.target.accept(this);
-
+		
 		BuiltinID builtin = expression.getter.member.builtin;
 		if (builtin == null) {
+			if (expression.getter.hasTag(JavaField.class)) {
+				javaWriter.getField(expression.getter.getTag(JavaField.class));
+				return null;
+			}
 			if (!checkAndExecuteMethodInfo(expression.getter, expression.type))
 				throw new IllegalStateException("Call target has no method info!");
 
 	public Void visitStaticGetter(StaticGetterExpression expression) {
 		BuiltinID builtin = expression.getter.member.builtin;
 		if (builtin == null) {
+			if (expression.getter.hasTag(JavaField.class)) {
+				javaWriter.getStaticField(expression.getter.getTag(JavaField.class));
+				return null;
+			}
+			
 			if (!checkAndExecuteMethodInfo(expression.getter, expression.type))
 				throw new IllegalStateException("Call target has no method info!");
 

JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareClassMethodVisitor.java

 	
 	@Override
 	public Void visitField(FieldMember member) {
-		member.setTag(JavaField.class, new JavaField(cls, member.name, context.getDescriptor(member.type)));
-		if (member.hasAutoGetter())
+		JavaField field = new JavaField(cls, member.name, context.getDescriptor(member.type));
+		member.setTag(JavaField.class, field);
+		if (member.hasAutoGetter()) {
 			visitGetter(member.autoGetter);
-		if (member.hasAutoSetter())
+			member.autoGetter.setTag(JavaField.class, field);
+		}
+		if (member.hasAutoSetter()) {
 			visitSetter(member.autoSetter);
+		}
 		
 		return null;
 	}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaDefinitionVisitor.java

 import org.openzen.zenscript.javasource.scope.JavaSourceFileScope;
 import org.openzen.zenscript.javasource.scope.JavaSourceStatementScope;
 import org.openzen.zenscript.javashared.JavaClass;
+import org.openzen.zenscript.javashared.JavaImplementation;
 
 /**
  *
 		List<ImplementationMember> mergedImplementations = new ArrayList<>();
 		for (IDefinitionMember member : definition.members) {
 			if (member instanceof ImplementationMember) {
-				if (isImplementationMergable((ImplementationMember)member))
+				JavaImplementation implementation = ((ImplementationMember) member).getTag(JavaImplementation.class);
+				if (implementation.inline)
 					mergedImplementations.add((ImplementationMember)member);
 			}
 		}
 	}
 	
 	private void convertModifiers(int modifiers) {
-		if (Modifiers.isExport(modifiers) || Modifiers.isPublic(modifiers))
+		if (Modifiers.isPublic(modifiers) || Modifiers.isInternal(modifiers))
 			output.append("public ");
 		if (Modifiers.isPrivate(modifiers))
 			output.append("private ");
 			output.append("final ");
 	}
 	
-	private boolean isImplementationMergable(ImplementationMember implementation) {
-		return true; // TODO: check merging conflicts
-	}
-	
 	private void compileMembers(JavaSourceFileScope scope, HighLevelDefinition definition) {
 		if (definition.hasTag(JavaNativeClass.class)) {
 			StoredType[] typeParameters = new StoredType[definition.getNumberOfGenericParameters()];

Parser/src/main/java/org/openzen/zenscript/parser/ParsedFile.java

 					case K_PRIVATE:
 						modifiers |= Modifiers.PRIVATE;
 						break;
-					case K_EXPORT:
-						modifiers |= Modifiers.EXPORT;
+					case K_INTERNAL:
+						modifiers |= Modifiers.INTERNAL;
 						break;
 					case K_EXTERN:
 						modifiers |= Modifiers.EXTERN;
 				statements.add(statement.compile(statementScope));
 			}
 			
-			ScriptBlock block = new ScriptBlock(modulePackage.getPackage(), statements);
+			ScriptBlock block = new ScriptBlock(modulePackage.module, modulePackage.getPackage(), statements);
 			block.setTag(SourceFile.class, file);
 			block.setTag(WhitespacePostComment.class, postComment);
 			scripts.add(block);

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

 		int modifiers = 0;
 		outer: while (true) {
 			switch (tokens.peek().type) {
-				case K_EXPORT:
+				case K_INTERNAL:
 					tokens.next();
-					modifiers |= Modifiers.EXPORT;
+					modifiers |= Modifiers.INTERNAL;
 					break;
 				case K_PUBLIC:
 					tokens.next();

ScriptingExample/scripts/classes.zs

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

ScriptingExample/scripts/conditionals.zs

+val ternaryOperation = true ? 100 : 222;
+
+println(ternaryOperation);
+
+
+
+var coalesce_one as string? = null;
+var coalesce_tow as string? = "test";
+
+
+var coalesce = coalesce_one ?? coalesce_tow;
+
+println(coalesce);
+
+
+//if(coalesce == "test123") {
+//	println("true");
+//}
+
+if 1 == 1 {
+	println("intCompareTrue");
+}
+
+//if(1 == "1") {
+//	println("well...");
+//}
+
+
+if "1" == 1 {
+	println("...");
+}
+
+
+//var coco as int? = 10;
+//var coal as int? = 1;
+//
+//println(coal ?? coco);
+
+
+println(".....");
+println(true ? "RR" : "TT");
+
+
+println((false && true && true) ? "true" : "false");
+println((true && true) ? "true" : "false");
+println((true && false) ? "true" : "false");
+println((false && false) ? "true" : "false");
+
+println("---");
+
+println((false || true) ? "true" : "false");
+println((true || true) ? "true" : "false");
+println((true || false) ? "true" : "false");
+println((false || false) ? "true" : "false");
+
+println(":::");
+
+println((1 <= 2) ? "true" : "false");

ScriptingExample/scripts/functions.zs

+function test() as void {
+	println("functions.zs; test1");
+}
+
+
+
+function test2() as void {
+	println("functions.zs; test2");
+}
+
+
+test();
+test2();
+println(test3(1, 3));
+
+
+function test3(a as int, b as int) as int{
+	println(a+b);
+	return a + b;
+}

ScriptingExample/scripts/functions2.zs

+val outOfScope = 10;
+
+val fun = (a as int, b as int) as int => a + b * outOfScope;
+println(fun(30, 20));
+
+function apply_fn2(fn as function(value as int, othervalue as int) as int, value as int) as int {
+    return fn(value, value);
+}
+
+//function scale(value as int, scale as int) as int {
+
+//	val fun as function(value as int, othervalue as int) as int = ((v as int) as int => v * scale);
+//    return apply(fun, scale);
+//}
+
+apply_fn2(fun, 10);
+
+//println("Value: " + scale(10, 5));
+

ScriptingExample/scripts/functions3.zs

+function apply2(fn as function(value as int) as int, scale as int) as int {
    return fn(scale);
}

function scale2(value as int, scale as int) as int {
    return apply2(v => v * scale, value);
}

ScriptingExample/scripts/functions_lambdas.zs

+val outOfScope = 10;
+val fun1 = (a as int, b as int) as int => a + b * outOfScope;
+val fun2 = (a as int, c as int) as int => 13;
+
+
+
+function apply(fn as function(value as int) as int, scale as int) as int {
+    return fn(scale);
+}
+
+
+println(fun1(30, 20));
+println(fun2(30, 20));
+
+
+
+
+function scale(value as int, scale as int) as int {
+    return apply(v => v * scale, value);
+}
+
+println("Value: " + scale(10, 5));

ScriptingExample/scripts/helloworld.zs

+println("Hello \© world!");
+println(5);
+println(2 + 5);
+println(1 - 2);
+println(1 + 3 as long);
+
+println(<hello world in bracket parser>);

ScriptingExample/scripts/match.zs

+val test as int = 10;
+val tt1 = "tt";
+val tt2 = "tt3";
+val tt4 = "tt5";
+
+
+println(match 10 {
+	1 => "one",
+	10 => "yo",
+	//tt1 === "tt1" for some compiler issue it takes the variable as string input?
+	100 => match tt1 {
+		"10" => "t",
+		"tt1" => tt1,
+		"tt2" => tt1 + tt4,
+		default => tt4
+	},
+	default => tt2
+});
+
+
+println(tt1);
+
+//println(match test {
+//	case 1 : "tt",
+//	default : "kk"
+//});
+
+
+
+function myFunc (par1 as int) as void {
+
+    val v0 = par1 - 1;
+	println(match par1 {
+		10 => v0,
+		default => match(v0) {
+			10 => 99,
+			default => v0
+		}
+	});
+}
+
+
+myFunc(10);
+myFunc(11);
+myFunc(12);
+
+
+val t = (a as int) as int => a;
+
+
+println(t(10));

ScriptingExample/scripts/moreHellos.zs

+println("Hello world!");
+println(1 as string);
+
+
+var test = "test";
+println(test);
+
+
+test = "testMore";
+println(test);
+
+test = 13;
+println(test);
+
+val test2 = 14;
+println(test2);
+
+
+if true 
+    println("ifTest");
+else
+    println("elseTest");
+
+
+if false 
+    println("testIf");
+else
+    println("testElse");
+
+
+if (true) {
+
+    while :testLable true {
+        println("trueee");
+        if true
+            break testLable;
+        else
+            println("nobreak");
+    }
+    
+    
+    do {
+        println("tru"); 
+        if(false){
+        	println("brea");
+            continue;
+        }
+        else{
+            println("");
+            break;
+        }
+    } while true;
+}
+
+var testArray = ["1", "2", "3"];
+
+for item in testArray {
+	println("test");
+	println(item);
+}
+
+println("");
+
+var test3 = [1, 2, 3];
+
+for item in test3 {
+	println(item);
+}
+
+for i, item in ["5", "ttt"] {
+	println(item + i);
+}
+
+for i, item in [1, 5, 7] {
+	println(item + (i as int));
+}
+
+for myI in 10 .. 20 {
+	println(myI);
+}
+
+var lateInit as string;
+lateInit = "initialized later";
+println(lateInit);
+
+
+
+
+
+/*
+catch e as string {
+	println("noLuv");
+}
+*/

ScriptingExample/scripts/statements.zs

+//while true
+//	println("Hello!");

ScriptingExample/scripts/switch.zs

+val test as int = 10;
+
+
+switch test {
+	case 1 : println("yay"); break;
+	case 10 : println("yo");
+	case 100 : println("y");
+	default: println("yup");
+}
+
+
+val test2 as string = "hello";
+
+switch test2 {
+	case "bye" : println("hello");
+	case "hello" : println("goodbye");
+	default: println("hellogoodbye");
+}

ScriptingExample/scripts/variants.zs

+public variant Result<T, E> {
+    Ok(T),
+    Error(E),
+    Other(T, E);
+    
+    /*public then<R>(fn as function(result as T) as Result<R, E>) as Result<R, E> {
+        return match this {
+            Ok(result) => fn(result),
+            Error(error) => Error(error),
+			Other(result, error) => fn(result)
+        };
+    }*/
+    
+    //public handle<X>(handler as function(error as E) as Result<T, X>) as Result<T, X> {
+    //    return match this {
+    //        Ok(result) => Ok(result),
+    //        Error(error) => handler(error)
+    //    };
+    //}
+    
+    public expect() as T {
+        return match this {
+            Ok(result) => result,
+            Error(error) => panic "expect() called on an error value",
+			Other(result, error) => result
+        };
+    }
+    
+    public orElse(other as T) as T {
+        return match this {
+            Ok(result) => result,
+            Error(error) => other,
+			Other(result, error) => result
+        };
+    }
+    
+    public orElse(other as function(error as E) as T) as T {
+        return match this {
+            Ok(result) => result,
+            Error(error) => other(error),
+			Other(result, error) => result
+        };
+    }
+}
+
+
+
+function makeResult() as Result<string, string>
+    => Ok("10");
+
+
+function makeErrResult() as Result<string, string>
+    => Error("10");
+
+
+println(makeResult().orElse("Ten"));
+println(makeResult().expect());
+println(makeErrResult().orElse("Ten"));
+
+
+//CompileException [TYPE_ARGUMENTS_NOT_INFERRABLE] Could not infer generic type parameters [ParsedExpressionFunction.compile, line 75]
+//println(makeResult().then(tValue => Result<string, string>.Ok(tValue)).expect());
+
+//IllegalArgumentException: Cannot retrieve members of undetermined type [TypeMembers.<init>, line 71]
+//println(makeResult().then(a => Ok(a)).expect());
+//println(makeResult().then(a as string => Ok(a)).expect());
+
+//CompileException [UNEXPECTED_TOKEN] ) expected [LLparserTokenStream.required, line 97]
+//Wants to compile a call to function() instead of creating a lambda
+//println(makeResult().then((function (t as string) as Result<string, string>)(t => Ok(t))).expect());

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

 import org.openzen.zenscript.codemodel.definition.ClassDefinition;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
-import org.openzen.zenscript.codemodel.expression.GetStaticFieldExpression;
-import org.openzen.zenscript.codemodel.member.FieldMember;
+import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
+import org.openzen.zenscript.codemodel.member.GetterMember;
 import org.openzen.zenscript.codemodel.member.MethodMember;
-import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.partial.PartialMemberGroupExpression;
 import org.openzen.zenscript.codemodel.scope.BaseScope;
 		PRINTSTREAM_PRINTLN = new MethodMember(
 			CodePosition.NATIVE,
 			PRINTSTREAM,
-			Modifiers.EXPORT,
+			Modifiers.PUBLIC,
 			"println",
 			new FunctionHeader(BasicTypeID.VOID, new FunctionParameter(StringTypeID.BORROW)),
 			null);
 		
-		SYSTEM_OUT = new FieldMember(
+		SYSTEM_OUT = new GetterMember(
 			CodePosition.NATIVE,
 			SYSTEM,
-			Modifiers.EXPORT | Modifiers.FINAL,
+			Modifiers.PUBLIC | Modifiers.FINAL | Modifiers.STATIC,
 			"out",
-			null,
-			DefinitionTypeID.forType(registry, SYSTEM).stored(AutoStorageTag.INSTANCE), null, 0, 0, null);
+			DefinitionTypeID.forType(registry, SYSTEM).stored(AutoStorageTag.INSTANCE),
+			null);
 		
 		JavaClass jPrintStream = new JavaClass("java.io", "PrintStream", JavaClass.Kind.CLASS);
 		JavaMethod printstreamPrintln = JavaMethod.getNativeVirtual(jPrintStream, "println", "(Ljava/lang/String;)V");
 	}
 	
 	private final Module MODULE = new Module("scriptingExample");
-	private final ClassDefinition PRINTSTREAM = new ClassDefinition(CodePosition.NATIVE, MODULE, javaIo, "PrintStream", Modifiers.EXPORT);
-	private final ClassDefinition SYSTEM = new ClassDefinition(CodePosition.NATIVE, MODULE, javaLang, "System", Modifiers.EXPORT);
+	private final ClassDefinition PRINTSTREAM = new ClassDefinition(CodePosition.NATIVE, MODULE, javaIo, "PrintStream", Modifiers.PUBLIC);
+	private final ClassDefinition SYSTEM = new ClassDefinition(CodePosition.NATIVE, MODULE, javaLang, "System", Modifiers.PUBLIC);
 	private final MethodMember PRINTSTREAM_PRINTLN;
-	private final FieldMember SYSTEM_OUT;
+	private final GetterMember SYSTEM_OUT;
 	
 	private class PrintlnSymbol implements ISymbol {
 
 			return new PartialMemberGroupExpression(
 					position,
 					scope,
-					new GetStaticFieldExpression(position, new FieldMemberRef(scope.getTypeRegistry().getForMyDefinition(SYSTEM).stored(StaticExpressionStorageTag.INSTANCE), SYSTEM_OUT, GenericMapper.EMPTY)),
+					new StaticGetterExpression(position, new GetterMemberRef(scope.getTypeRegistry().getForMyDefinition(SYSTEM).stored(StaticExpressionStorageTag.INSTANCE), SYSTEM_OUT, GenericMapper.EMPTY)),
 					"println",
 					PRINTSTREAM_PRINTLN.ref(scope.getTypeRegistry().getForDefinition(PRINTSTREAM).stored(BorrowStorageTag.INVOCATION), GenericMapper.EMPTY),
 					null,

Validator/src/main/java/org/openzen/zenscript/validator/TypeContext.java

 	EXPANSION_TARGET_TYPE("expansion target type"),
 	OPTION_MEMBER_TYPE("option member type"),
 	CAST_TARGET_TYPE("cast target type"),
-	TYPE_CHECK_TYPE("type check type");
+	TYPE_CHECK_TYPE("type check type"),
+	CONSTRUCTOR_TYPE("constructed object type");
 	
 	public final String display;
 	

Validator/src/main/java/org/openzen/zenscript/validator/ValidationLogEntry.java

 		INVALID_CASE,
 		INVALID_STORAGE_CAST,
 		INVALID_EXPRESSION,
-		INVALID_STATEMENT
+		INVALID_STATEMENT,
+		NO_ACCESS,
+		MUST_BE_STATIC,
+		MUST_NOT_BE_STATIC
 	}
 }

Validator/src/main/java/org/openzen/zenscript/validator/Validator.java

 import java.util.Collections;
 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.AccessScope;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.ScriptBlock;
 	}
 	
 	public void validate(ScriptBlock script) {
-		StatementValidator statementValidator = new StatementValidator(this, new ScriptScope());
+		StatementValidator statementValidator = new StatementValidator(this, new ScriptScope(new AccessScope(script.module, null)));
 		for (Statement statement : script.statements) {
 			statement.accept(statementValidator);
 		}
 	}
 	
 	private class ScriptScope implements StatementScope {
+		private final AccessScope access;
+		
+		public ScriptScope(AccessScope access) {
+			this.access = access;
+		}
 
 		@Override
 		public boolean isConstructor() {
 		public HighLevelDefinition getDefinition() {
 			return null;
 		}
+
+		@Override
+		public AccessScope getAccessScope() {
+			return access;
+		}
 	}
 }

Validator/src/main/java/org/openzen/zenscript/validator/analysis/ExpressionScope.java

  */
 package org.openzen.zenscript.validator.analysis;
 
+import org.openzen.zenscript.codemodel.AccessScope;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
  * @author Hoofdgebruiker
  */
 public interface ExpressionScope {
-	public boolean isConstructor();
+	boolean isConstructor();
 	
-	public boolean isFirstStatement();
+	boolean isFirstStatement();
 	
-	public boolean hasThis();
+	boolean hasThis();
 	
-	public boolean isFieldInitialized(FieldMember field);
+	boolean isFieldInitialized(FieldMember field);
 	
-	public boolean isEnumConstantInitialized(EnumConstantMember member);
+	boolean isEnumConstantInitialized(EnumConstantMember member);
 	
-	public boolean isLocalVariableInitialized(VarStatement variable);
+	boolean isLocalVariableInitialized(VarStatement variable);
 	
-	public void markConstructorForwarded();
+	void markConstructorForwarded();
 	
-	public boolean isStaticInitializer();
+	boolean isStaticInitializer();
 	
-	public HighLevelDefinition getDefinition();
+	HighLevelDefinition getDefinition();
+	
+	AccessScope getAccessScope();
 }

Validator/src/main/java/org/openzen/zenscript/validator/analysis/StatementScope.java

  */
 package org.openzen.zenscript.validator.analysis;
 
+import org.openzen.zenscript.codemodel.AccessScope;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 
 	public boolean isStaticInitializer();
 	
 	public HighLevelDefinition getDefinition();
+	
+	public AccessScope getAccessScope();
 }

Validator/src/main/java/org/openzen/zenscript/validator/visitors/DefinitionMemberValidator.java

 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
+import org.openzen.zenscript.codemodel.AccessScope;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
 			}
 		}
 		constructors.add(member.header);
-		ValidationUtils.validateHeader(validator, member.position, member.header);
+		ValidationUtils.validateHeader(validator, member.position, member.header, member.getAccessScope());
 		
 		if (member.body == null && !member.isExtern()) {
 			validator.logError(ValidationLogEntry.Code.BODY_REQUIRED, member.position, "Constructors must have a body");
 			return null;
 		} else {
-			StatementValidator statementValidator = new StatementValidator(validator, new ConstructorStatementScope(member.header));
+			StatementValidator statementValidator = new StatementValidator(validator, new ConstructorStatementScope(member.header, member.getAccessScope()));
 			member.body.accept(statementValidator);
 			validateThrow(member, member.header, member.body);
 			
 		if (member.header.thrownType != null)
 			validator.logError(ValidationLogEntry.Code.DESTRUCTOR_CANNOT_THROW, member.position, "Destructor cannot throw");
 		
-		validateFunctional(member, new MethodStatementScope(member.header));
+		validateFunctional(member, new MethodStatementScope(member.header, member.getAccessScope()));
 		return null;
 	}
 
 	@Override
 	public Void visitMethod(MethodMember member) {
 		ValidationUtils.validateIdentifier(validator, member.position, member.name);
-		ValidationUtils.validateHeader(validator, member.position, member.header);
-		validateFunctional(member, new MethodStatementScope(member.header));
+		ValidationUtils.validateHeader(validator, member.position, member.header, member.getAccessScope());
+		validateFunctional(member, new MethodStatementScope(member.header, member.getAccessScope()));
 		return null;
 	}
 
 	public Void visitGetter(GetterMember member) {
 		ValidationUtils.validateIdentifier(validator, member.position, member.name);
 		new TypeValidator(validator, member.position).validate(TypeContext.GETTER_TYPE, member.type);
-		validateGetter(member, new MethodStatementScope(new FunctionHeader(member.type)));
+		validateGetter(member, new MethodStatementScope(new FunctionHeader(member.type), member.getAccessScope()));
 		return null;
 	}
 
 	public Void visitSetter(SetterMember member) {
 		ValidationUtils.validateIdentifier(validator, member.position, member.name);
 		new TypeValidator(validator, member.position).validate(TypeContext.SETTER_TYPE, member.type);
-		validateSetter(member, new MethodStatementScope(new FunctionHeader(BasicTypeID.VOID, member.parameter)));
+		validateSetter(member, new MethodStatementScope(new FunctionHeader(BasicTypeID.VOID, member.parameter), member.getAccessScope()));
 		return null;
 	}
 	
 
 	@Override
 	public Void visitOperator(OperatorMember member) {
-		ValidationUtils.validateHeader(validator, member.position, member.header);
-		validateFunctional(member, new MethodStatementScope(member.header));
+		ValidationUtils.validateHeader(validator, member.position, member.header, member.getAccessScope());
+		validateFunctional(member, new MethodStatementScope(member.header, member.getAccessScope()));
 		return null;
 	}
 
 	@Override
 	public Void visitCaster(CasterMember member) {
 		new TypeValidator(validator, member.position).validate(TypeContext.CASTER_TYPE, member.toType);
-		validateFunctional(member, new MethodStatementScope(member.header));
+		validateFunctional(member, new MethodStatementScope(member.header, member.getAccessScope()));
 		return null;
 	}
 
 		for (StoredType type : member.getLoopVariableTypes())
 			typeValidator.validate(TypeContext.ITERATOR_TYPE, type);
 		
-		validateFunctional(member, new MethodStatementScope(new FunctionHeader(scope.getTypeRegistry().getIterator(member.getLoopVariableTypes()).stored(UniqueStorageTag.INSTANCE))));
+		validateFunctional(member, new MethodStatementScope(
+				new FunctionHeader(scope.getTypeRegistry().getIterator(member.getLoopVariableTypes()).stored(UniqueStorageTag.INSTANCE)),
+				member.getAccessScope()));
 		return null;
 	}
 
 	@Override
 	public Void visitCaller(CallerMember member) {
-		ValidationUtils.validateHeader(validator, member.position, member.header);
-		validateFunctional(member, new MethodStatementScope(member.header));
+		ValidationUtils.validateHeader(validator, member.position, member.header, member.getAccessScope());
+		validateFunctional(member, new MethodStatementScope(member.header, member.getAccessScope()));
 		return null;
 	}
 
 
 	@Override
 	public Void visitStaticInitializer(StaticInitializerMember member) {
-		member.body.accept(new StatementValidator(validator, new StaticInitializerScope()));
+		member.body.accept(new StatementValidator(validator, new StaticInitializerScope(member.getAccessScope())));
 		if (member.body.thrownType != null)
 			validator.logError(ValidationLogEntry.Code.STATIC_INITIALIZER_CANNOT_THROW, member.position, "Static initializer cannot throw");
 		return null;
 		public HighLevelDefinition getDefinition() {
 			return definition;
 		}
+
+		@Override
+		public AccessScope getAccessScope() {
+			return field.getAccessScope();
+		}
 	}
 	
 	private class ConstructorStatementScope implements StatementScope {
 		private final FunctionHeader header;
+		private final AccessScope access;
 		
-		public ConstructorStatementScope(FunctionHeader header) {
+		public ConstructorStatementScope(FunctionHeader header, AccessScope access) {
 			this.header = header;
+			this.access = access;
 		}
 
 		@Override
 		public HighLevelDefinition getDefinition() {
 			return definition;
 		}
+
+		@Override
+		public AccessScope getAccessScope() {
+			return access;
+		}
 	}
 	
 	private class MethodStatementScope implements StatementScope {
 		private final FunctionHeader header;
+		private final AccessScope access;
 		
-		public MethodStatementScope(FunctionHeader header) {
+		public MethodStatementScope(FunctionHeader header, AccessScope access) {
 			this.header = header;
+			this.access = access;
 		}
 
 		@Override
 		public HighLevelDefinition getDefinition() {
 			return definition;
 		}
+
+		@Override
+		public AccessScope getAccessScope() {
+			return access;
+		}
 	}
 	
 	private class StaticInitializerScope implements StatementScope {
 		private final FunctionHeader header = new FunctionHeader(BasicTypeID.VOID);
+		private final AccessScope access;
+		
+		public StaticInitializerScope(AccessScope access) {
+			this.access = access;
+		}
 		
 		@Override
 		public boolean isConstructor() {
 		public HighLevelDefinition getDefinition() {
 			return definition;
 		}
+
+		@Override
+		public AccessScope getAccessScope() {
+			return access;
+		}
 	}
 	
 	private class EnumConstantInitializerScope implements ExpressionScope {
 		public HighLevelDefinition getDefinition() {
 			return definition;
 		}
+
+		@Override
+		public AccessScope getAccessScope() {
+			return definition.getAccessScope();
+		}
 	}
 }

Validator/src/main/java/org/openzen/zenscript/validator/visitors/DefinitionValidator.java

 import java.util.List;
 import java.util.Map;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.AccessScope;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 		ValidationUtils.validateModifiers(
 				validator,
 				definition.modifiers,
-				PUBLIC | EXPORT | PRIVATE | ABSTRACT | STATIC | PROTECTED | VIRTUAL,
+				PUBLIC | INTERNAL | PRIVATE | ABSTRACT | STATIC | PROTECTED | VIRTUAL,
 				definition.position,
 				"Invalid class modifier");
 		ValidationUtils.validateIdentifier(
 		ValidationUtils.validateModifiers(
 				validator,
 				definition.modifiers,
-				PUBLIC | EXPORT | PROTECTED | PRIVATE,
+				PUBLIC | INTERNAL | PROTECTED | PRIVATE,
 				definition.position,
 				"Invalid interface modifier");
 		ValidationUtils.validateIdentifier(
 		ValidationUtils.validateModifiers(
 				validator,
 				definition.modifiers,
-				PUBLIC | EXPORT | PROTECTED | PRIVATE,
+				PUBLIC | INTERNAL | PROTECTED | PRIVATE,
 				definition.position,
 				"Invalid enum modifier");
 		ValidationUtils.validateIdentifier(
 
 	@Override
 	public Void visitStruct(StructDefinition definition) {
-		int validModifiers = PUBLIC | EXPORT | PROTECTED | PRIVATE;
+		int validModifiers = PUBLIC | INTERNAL | PROTECTED | PRIVATE;
 		if (definition.outerDefinition != null)
 			validModifiers |= STATIC;
 		
 		ValidationUtils.validateModifiers(
 				validator,
 				definition.modifiers,
-				PUBLIC | EXPORT | PROTECTED | PRIVATE,
+				PUBLIC | INTERNAL | PROTECTED | PRIVATE,
 				definition.position,
 				"Invalid function modifier");
 		ValidationUtils.validateIdentifier(
 				definition.position,
 				definition.name);
 				
-		StatementValidator statementValidator = new StatementValidator(validator, new FunctionStatementScope(definition.header));
+		StatementValidator statementValidator = new StatementValidator(validator, new FunctionStatementScope(definition.header, definition.getAccessScope()));
 		definition.caller.body.accept(statementValidator);
 		return null;
 	}
 		ValidationUtils.validateModifiers(
 				validator,
 				definition.modifiers,
-				PUBLIC | EXPORT | PROTECTED | PRIVATE,
+				PUBLIC | INTERNAL | PROTECTED | PRIVATE,
 				definition.position,
 				"Invalid expansion modifier");
 		
 		ValidationUtils.validateModifiers(
 				validator,
 				definition.modifiers,
-				PUBLIC | EXPORT | PROTECTED | PRIVATE,
+				PUBLIC | INTERNAL | PROTECTED | PRIVATE,
 				definition.position,
 				"Invalid alias modifier");
 		ValidationUtils.validateIdentifier(
 		ValidationUtils.validateModifiers(
 				validator,
 				variant.modifiers,
-				PUBLIC | EXPORT | PROTECTED | PRIVATE,
+				PUBLIC | INTERNAL | PROTECTED | PRIVATE,
 				variant.position,
 				"Invalid variant modifier");
 		ValidationUtils.validateIdentifier(
 	
 	private class FunctionStatementScope implements StatementScope {
 		private final FunctionHeader header;
+		private final AccessScope access;
 		
-		public FunctionStatementScope(FunctionHeader header) {
+		public FunctionStatementScope(FunctionHeader header, AccessScope access) {
 			this.header = header;
+			this.access = access;
 		}
 
 		@Override
 		public HighLevelDefinition getDefinition() {
 			return null;
 		}
+
+		@Override
+		public AccessScope getAccessScope() {
+			return access;
+		}
 	}
 }

Validator/src/main/java/org/openzen/zenscript/validator/visitors/ExpressionValidator.java

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
+import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.definition.EnumDefinition;
 import org.openzen.zenscript.codemodel.definition.VariantDefinition;
 import org.openzen.zenscript.codemodel.expression.*;
 import org.openzen.zenscript.codemodel.expression.switchvalue.EnumConstantSwitchValue;
 import org.openzen.zenscript.codemodel.expression.switchvalue.VariantOptionSwitchValue;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
+import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
+import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
 import org.openzen.zenscript.codemodel.type.ArrayTypeID;
 import org.openzen.zenscript.codemodel.type.AssocTypeID;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 		if (!expression.right.type.equals(expression.operator.getHeader().parameters[0].type))
 			validator.logError(ValidationLogEntry.Code.INVALID_OPERAND_TYPE, expression.position, "comparison has invalid right type!");
 		
+		checkMemberAccess(expression.position, expression.operator);
+		checkNotStatic(expression.position, expression.operator);
+		
 		expression.left.accept(this);
 		expression.right.accept(this);
 		return null;
 	@Override
 	public Void visitCall(CallExpression expression) {
 		expression.target.accept(this);
+		
+		checkMemberAccess(expression.position, expression.member);
 		checkCallArguments(expression.position, expression.member.getHeader(), expression.instancedHeader, expression.arguments);
+		checkNotStatic(expression.position, expression.member);
 		return null;
 	}
 
 	@Override
 	public Void visitCallStatic(CallStaticExpression expression) {
+		checkMemberAccess(expression.position, expression.member);
 		checkCallArguments(expression.position, expression.member.getHeader(), expression.instancedHeader, expression.arguments);
+		checkStatic(expression.position, expression.member);
 		return null;
 	}
 	
 	@Override
 	public Void visitConst(ConstExpression expression) {
+		checkMemberAccess(expression.position, expression.constant);
 		return null;
 	}
 
 
 	@Override
 	public Void visitCast(CastExpression expression) {
+		checkMemberAccess(expression.position, expression.member);
 		return expression.target.accept(this);
 	}
 
 
 	@Override
 	public Void visitConstructorSuperCall(ConstructorSuperCallExpression expression) {
+		checkMemberAccess(expression.position, expression.constructor);
+		
 		if (!scope.isConstructor()) {
 			validator.logError(ValidationLogEntry.Code.CONSTRUCTOR_FORWARD_OUTSIDE_CONSTRUCTOR, expression.position, "Can only forward constructors inside constructors");
 		}
 
 	@Override
 	public Void visitGetField(GetFieldExpression expression) {
+		checkFieldAccess(expression.position, expression.field);
+		checkNotStatic(expression.position, expression.field);
+		
 		expression.target.accept(this);
 		if (expression.target instanceof ThisExpression && !scope.isFieldInitialized(expression.field.member)) {
 			validator.logError(
 
 	@Override
 	public Void visitGetStaticField(GetStaticFieldExpression expression) {
+		checkFieldAccess(expression.position, expression.field);
+		checkStatic(expression.position, expression.field);
 		return null;
 	}
 
 	@Override
 	public Void visitGetter(GetterExpression expression) {
+		checkMemberAccess(expression.position, expression.getter);
+		checkStatic(expression.position, expression.getter);
 		return expression.target.accept(this);
 	}
 	
 
 	@Override
 	public Void visitNew(NewExpression expression) {
+		new TypeValidator(validator, expression.position).validate(TypeContext.CONSTRUCTOR_TYPE, expression.constructor.getOwnerType().type);
+		checkMemberAccess(expression.position, expression.constructor);
 		checkCallArguments(
 				expression.position,
 				expression.constructor.getHeader(),
 	
 	@Override
 	public Void visitPostCall(PostCallExpression expression) {
+		checkMemberAccess(expression.position, expression.member);
+		checkNotStatic(expression.position, expression.member);
+		
 		expression.target.accept(this);
 		// TODO: is target a valid increment target?
 		return null;
 
 	@Override
 	public Void visitSetField(SetFieldExpression expression) {
+		checkFieldAccess(expression.position, expression.field);
+		checkNotStatic(expression.position, expression.field);
+		
 		expression.target.accept(this);
 		expression.value.accept(this);
 		if (!expression.value.type.equals(expression.field.getType())) {
 
 	@Override
 	public Void visitSetStaticField(SetStaticFieldExpression expression) {
+		checkFieldAccess(expression.position, expression.field);
+		checkStatic(expression.position, expression.field);
+		
 		expression.value.accept(this);
 		if (!expression.value.type.equals(expression.field.getType())) {
 			validator.logError(
 
 	@Override
 	public Void visitSetter(SetterExpression expression) {
+		checkMemberAccess(expression.position, expression.setter);
+		checkNotStatic(expression.position, expression.setter);
+		
 		expression.target.accept(this);
 		expression.value.accept(this);
 		if (!expression.value.type.equals(expression.setter.getType())) {
 
 	@Override
 	public Void visitStaticGetter(StaticGetterExpression expression) {
+		checkMemberAccess(expression.position, expression.getter);
+		checkStatic(expression.position, expression.getter);
 		return null;
 	}
 
 	@Override
 	public Void visitStaticSetter(StaticSetterExpression expression) {
+		checkMemberAccess(expression.position, expression.setter);
+		checkStatic(expression.position, expression.setter);
+		
 		expression.value.accept(this);
 		if (!expression.value.type.equals(expression.setter.getType())) {
 			validator.logError(
 		return null;
 	}
 	
+	private void checkMemberAccess(CodePosition position, DefinitionMemberRef member) {
+		if (!scope.getAccessScope().hasAccessTo(member.getTarget().getAccessScope(), member.getTarget().getModifiers()))
+			validator.logError(ValidationLogEntry.Code.NO_ACCESS, position, "no access to " + member.describe());
+	}
+
+	private void checkFieldAccess(CodePosition position, FieldMemberRef field) {
+		if (!scope.getAccessScope().equals(field.getTarget().getAccessScope()))
+			validator.logError(ValidationLogEntry.Code.NO_ACCESS, position, "fields are private");
+	}
+	
+	private void checkStatic(CodePosition position, DefinitionMemberRef member) {
+		if (!Modifiers.isStatic(member.getTarget().getModifiers()))
+			validator.logError(ValidationLogEntry.Code.MUST_BE_STATIC, position, "Member is not static");
+	}
+	
+	private void checkNotStatic(CodePosition position, DefinitionMemberRef member) {
+		if (Modifiers.isStatic(member.getTarget().getModifiers()))
+			validator.logError(ValidationLogEntry.Code.MUST_NOT_BE_STATIC, position, "Member must not be static");
+	}
+	
 	private void checkCallArguments(CodePosition position, FunctionHeader originalHeader, FunctionHeader instancedHeader, CallArguments arguments) {
 		ValidationUtils.validateTypeArguments(validator, position, originalHeader.typeParameters, arguments.typeArguments);
 		

Validator/src/main/java/org/openzen/zenscript/validator/visitors/StatementValidator.java

 
 import java.util.HashSet;
 import java.util.Set;
+import org.openzen.zenscript.codemodel.AccessScope;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 		public HighLevelDefinition getDefinition() {
 			return scope.getDefinition();
 		}
+
+		@Override
+		public AccessScope getAccessScope() {
+			return scope.getAccessScope();
+		}
 	}
 }

Validator/src/main/java/org/openzen/zenscript/validator/visitors/TypeValidator.java

 package org.openzen.zenscript.validator.visitors;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.AccessScope;
 import org.openzen.zenscript.codemodel.type.ArrayTypeID;
 import org.openzen.zenscript.codemodel.type.AssocTypeID;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 
 	@Override
 	public Void visitFunction(TypeContext context, FunctionTypeID function) {
-		ValidationUtils.validateHeader(validator, position, function.header);
+		ValidationUtils.validateHeader(validator, position, function.header, new AccessScope(null, null));
 		return null;
 	}
 

Validator/src/main/java/org/openzen/zenscript/validator/visitors/ValidationUtils.java

 import java.util.Set;
 import java.util.regex.Pattern;
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.AccessScope;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 		}
 	}
 	
-	public static void validateHeader(Validator target, CodePosition position, FunctionHeader header) {
+	public static void validateHeader(Validator target, CodePosition position, FunctionHeader header, AccessScope access) {
 		TypeValidator typeValidator = new TypeValidator(target, position);
 		typeValidator.validate(TypeContext.RETURN_TYPE, header.getReturnType());
 		
 			typeValidator.validate(TypeContext.PARAMETER_TYPE, parameter.type);
 			
 			if (parameter.defaultValue != null) {
-				parameter.defaultValue.accept(new ExpressionValidator(target, new DefaultParameterValueExpressionScope()));
+				parameter.defaultValue.accept(new ExpressionValidator(target, new DefaultParameterValueExpressionScope(access)));
 				if (parameter.defaultValue.type != parameter.type) {
 					target.logError(INVALID_TYPE, position, "default value does not match parameter type");
 				}
 			CodePosition position,
 			String error)
 	{
-		if (Modifiers.isPublic(modifiers) && Modifiers.isExport(modifiers))
-			target.logError(INVALID_MODIFIER, position, error + ": cannot combine public and export");
+		if (Modifiers.isPublic(modifiers) && Modifiers.isInternal(modifiers))
+			target.logError(INVALID_MODIFIER, position, error + ": cannot combine public and internal");
 		if (Modifiers.isPublic(modifiers) && Modifiers.isPrivate(modifiers))
 			target.logError(INVALID_MODIFIER, position, error + ": cannot combine public and private");
 		if (Modifiers.isPublic(modifiers) && Modifiers.isProtected(modifiers))
 			target.logError(INVALID_MODIFIER, position, error + ": cannot combine public and protected");
-		if (Modifiers.isExport(modifiers) && Modifiers.isPrivate(modifiers))
-			target.logError(INVALID_MODIFIER, position, error + ": cannot combine export and private");
-		if (Modifiers.isExport(modifiers) && Modifiers.isProtected(modifiers))
-			target.logError(INVALID_MODIFIER, position, error + ": cannot combine export and protected");
+		if (Modifiers.isInternal(modifiers) && Modifiers.isPrivate(modifiers))
+			target.logError(INVALID_MODIFIER, position, error + ": cannot combine internal and private");
+		if (Modifiers.isInternal(modifiers) && Modifiers.isProtected(modifiers))
+			target.logError(INVALID_MODIFIER, position, error + ": cannot combine internal and protected");
 		if (Modifiers.isPrivate(modifiers) && Modifiers.isProtected(modifiers))
 			target.logError(INVALID_MODIFIER, position, error + ": cannot combine private and protected");
 		
 		
 		if (Modifiers.isPublic(invalid))
 			target.logError(INVALID_MODIFIER, position, error + ": public");
-		if (Modifiers.isExport(invalid))
-			target.logError(INVALID_MODIFIER, position, error + ": export");
+		if (Modifiers.isInternal(invalid))
+			target.logError(INVALID_MODIFIER, position, error + ": internal");
 		if (Modifiers.isProtected(invalid))
 			target.logError(INVALID_MODIFIER, position, error + ": protected");
 		if (Modifiers.isPrivate(invalid))
 	}
 	
 	private static class DefaultParameterValueExpressionScope implements ExpressionScope {
+		private final AccessScope access;
+		
+		public DefaultParameterValueExpressionScope(AccessScope access) {
+			this.access = access;
+		}
 		
 		@Override
 		public boolean isConstructor() {
 		public HighLevelDefinition getDefinition() {
 			return null;
 		}
+
+		@Override
+		public AccessScope getAccessScope() {
+			return access;
+		}
 	}
 }