Fix access modifiers

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

 	@Override
 	public Void visitConst(ConstMember member) {
 		visit(true);
-		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		FormattingUtils.formatModifiers(output, member.getSpecifiedModifiers());
 		output.append("const")
 				.append(member.name)
 				.append(" as ")
 	@Override
 	public Void visitField(FieldMember member) {
 		visit(true);
-		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		FormattingUtils.formatModifiers(output, member.getSpecifiedModifiers());
 		output.append(member.isFinal() ? "val " : "var ")
 				.append(member.name)
 				.append(" as ")
 	@Override
 	public Void visitConstructor(ConstructorMember member) {
 		visit(false);
-		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		FormattingUtils.formatModifiers(output, member.getSpecifiedModifiers());
 		output.append("this");
 		FormattingUtils.formatHeader(output, settings, member.header, typeFormatter);
 		formatBody(member.body);
 	@Override
 	public Void visitDestructor(DestructorMember member) {
 		visit(false);
-		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		FormattingUtils.formatModifiers(output, member.getSpecifiedModifiers());
 		output.append("this");
 		formatBody(member.body);
 		return null;
 	@Override
 	public Void visitMethod(MethodMember member) {
 		visit(false);
-		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		FormattingUtils.formatModifiers(output, member.getSpecifiedModifiers());
 		output.append(member.name);
 		FormattingUtils.formatHeader(output, settings, member.header, typeFormatter);
 		formatBody(member.body);
 	@Override
 	public Void visitGetter(GetterMember member) {
 		visit(false);
-		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		FormattingUtils.formatModifiers(output, member.getSpecifiedModifiers());
 		output.append("get ");
 		output.append(member.name);
 		output.append(" as ");
 	@Override
 	public Void visitSetter(SetterMember member) {
 		visit(false);
-		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		FormattingUtils.formatModifiers(output, member.getSpecifiedModifiers());
 		output.append("set ");
 		output.append(member.name);
 		output.append(" as ");
 	@Override
 	public Void visitOperator(OperatorMember member) {
 		visit(false);
-		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		FormattingUtils.formatModifiers(output, member.getSpecifiedModifiers());
 		switch (member.operator) {
 			case ADD: output.append("+"); break;
 			case SUB: output.append("-"); break;
 	@Override
 	public Void visitCaster(CasterMember member) {
 		visit(false);
-		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		FormattingUtils.formatModifiers(output, member.getSpecifiedModifiers());
 		output.append(" as ");
 		output.append(typeFormatter.format(member.toType));
 		formatBody(member.body);
 	@Override
 	public Void visitCaller(CallerMember member) {
 		visit(false);
-		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		FormattingUtils.formatModifiers(output, member.getSpecifiedModifiers());
 		FormattingUtils.formatHeader(output, settings, member.header, typeFormatter);
 		formatBody(member.body);
 		return null;
 	@Override
 	public Void visitImplementation(ImplementationMember implementation) {
 		visit(false);
-		FormattingUtils.formatModifiers(output, implementation.modifiers & ~Modifiers.FINAL);
+		FormattingUtils.formatModifiers(output, implementation.getSpecifiedModifiers());
 		output.append("implements ");
 		output.append(implementation.type.accept(typeFormatter));
 		if (settings.classBracketOnSameLine) {

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

 	public boolean hasAccessTo(AccessScope other, int access) {
 		if (Modifiers.isPublic(access))
 			return true;
-		if (definition == other.definition)
+		if (definition == other.definition || definition.isOuterOf(other.definition) || other.definition.isOuterOf(definition))
 			return true;
 		if (Modifiers.isPrivate(access))
 			return false;

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

 		
 		return null;
 	}
+
+	public boolean isOuterOf(HighLevelDefinition definition) {
+		if (definition.outerDefinition == this)
+			return true;
+		if (definition.outerDefinition == null)
+			return false;
+		
+		return isOuterOf(definition.outerDefinition);
+	}
 }

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

 		CallArguments result = this;
 		
 		for (int i = 0; i < arguments.length; i++) {
-			arguments[i] = arguments[i].castImplicit(position, scope, header.parameters[i].type);
+			arguments[i] = arguments[i].normalize(scope).castImplicit(position, scope, header.parameters[i].type);
 		}
 		
 		if (arguments.length < header.parameters.length) {

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 
 /**
  *
 	public Expression normalize(TypeScope scope) {
 		return new GetterExpression(position, target.normalize(scope), getter);
 	}
+	
+	@Override
+	public Expression assign(CodePosition position, TypeScope scope, Expression value) throws CompileException {
+		return scope.getTypeMembers(getter.getOwnerType())
+				.getOrCreateGroup(getter.member.name, false)
+				.setter(position, scope, target, value, false);
+	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zenscript.codemodel.member.ref.ImplementationMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
  *
  */
 public class InterfaceCastExpression extends Expression {
 	public final Expression value;
+	public final ImplementationMemberRef implementation;
 	
-	public InterfaceCastExpression(CodePosition position, Expression value, StoredType toType) {
-		super(position, toType, value.thrownType);
+	public InterfaceCastExpression(CodePosition position, Expression value, ImplementationMemberRef implementation) {
+		super(position, implementation.implementsType, value.thrownType);
 		
 		this.value = value;
+		this.implementation = implementation;
 	}
 
 	@Override
 	@Override
 	public Expression transform(ExpressionTransformer transformer) {
 		Expression tValue = value.transform(transformer);
-		return value == tValue ? this : new InterfaceCastExpression(position, tValue, type);
+		return value == tValue ? this : new InterfaceCastExpression(position, tValue, implementation);
 	}
 
 	@Override
 	public Expression normalize(TypeScope scope) {
-		return new InterfaceCastExpression(position, value.normalize(scope), type.getNormalized());
+		return new InterfaceCastExpression(position, value.normalize(scope), implementation);
 	}
 }

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 
 	public Expression normalize(TypeScope scope) {
 		return this;
 	}
+	
+	@Override
+	public Expression assign(CodePosition position, TypeScope scope, Expression value) throws CompileException {
+		return scope.getTypeMembers(getter.getOwnerType())
+				.getOrCreateGroup(getter.member.name, false)
+				.staticSetter(position, scope, value);
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/CallerMember.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.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 		return visitor.visitCaller(context, this);
 	}
 	
+	@Override
+	public int getEffectiveModifiers() {
+		int result = super.getEffectiveModifiers();
+		if (overrides != null && overrides.getTarget().getDefinition().isInterface())
+			result |= Modifiers.PUBLIC;
+		
+		return result;
+	}
+	
 	public void setOverrides(GlobalTypeRegistry registry, FunctionalMemberRef overrides) {
 		this.overrides = overrides;
 		header = header.inferFromOverride(registry, overrides.getHeader());

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

 		return visitor.visitCaster(context, this);
 	}
 	
+	@Override
+	public int getEffectiveModifiers() {
+		int result = super.getEffectiveModifiers();
+		if (overrides != null && overrides.getTarget().getDefinition().isInterface())
+			result |= Modifiers.PUBLIC;
+		
+		return result;
+	}
+	
 	public void setOverrides(GlobalTypeRegistry registry, CasterMemberRef overrides) {
 		this.overrides = overrides;
 	}

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

 	public DefinitionMemberRef getOverrides() {
 		return null;
 	}
+	
+	@Override
+	public int getEffectiveModifiers() {
+		int result = modifiers;
+		if (definition.isInterface())
+			result |= Modifiers.PUBLIC;
+		if (!Modifiers.hasAccess(result))
+			result |= Modifiers.INTERNAL;
+		
+		return result;
+	}
 
 	@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 DefinitionMemberRef getOverrides() {
 		return null;
 	}
-
+	
 	@Override
-	public void normalize(TypeScope scope) {
+	public int getEffectiveModifiers() {
+		int result = modifiers;
 		if (definition instanceof EnumDefinition)
-			modifiers |= Modifiers.PRIVATE;
-		else if (!Modifiers.hasAccess(modifiers))
-			modifiers |= Modifiers.INTERNAL;
+			result |= Modifiers.PRIVATE;
+		else if (!Modifiers.hasAccess(result))
+			result |= Modifiers.INTERNAL;
 		
-		super.normalize(scope);
+		return result;
 	}
 }

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

 public abstract class DefinitionMember extends Taggable implements IDefinitionMember {
 	public final CodePosition position;
 	public final HighLevelDefinition definition;
-	public int modifiers;
+	protected final int modifiers;
 	public MemberAnnotation[] annotations = MemberAnnotation.NONE;
 	
 	public DefinitionMember(CodePosition position, HighLevelDefinition definition, int modifiers) {
 	}
 	
 	@Override
-	public int getModifiers() {
+	public int getSpecifiedModifiers() {
 		return modifiers;
 	}
 	
 	}
 	
 	public boolean isStatic() {
-		return Modifiers.isStatic(modifiers);
+		return Modifiers.isStatic(getEffectiveModifiers());
 	}
 	
 	public boolean isFinal() {
-		return Modifiers.isFinal(modifiers);
+		return Modifiers.isFinal(getEffectiveModifiers());
 	}
 	
 	public boolean isExtern() {
-		return Modifiers.isExtern(modifiers);
+		return Modifiers.isExtern(getEffectiveModifiers());
 	}
 	
 	public boolean isPrivate() {
-		return Modifiers.isPrivate(modifiers);
+		return Modifiers.isPrivate(getEffectiveModifiers());
 	}
 	
 	public boolean isPublic() {
-		return Modifiers.isPublic(modifiers);
+		return Modifiers.isPublic(getEffectiveModifiers());
 	}
 	
 	public boolean isProtected() {
-		return Modifiers.isProtected(modifiers);
+		return Modifiers.isProtected(getEffectiveModifiers());
 	}
 }

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

  */
 package org.openzen.zenscript.codemodel.member;
 
+import java.lang.reflect.Modifier;
 import org.openzen.zencode.shared.CodePosition;
 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.expression.GetFieldExpression;
 import org.openzen.zenscript.codemodel.expression.GetFunctionParameterExpression;
 	@Override
 	public void registerTo(TypeMembers members, TypeMemberPriority priority, GenericMapper mapper) {
 		members.addField(new FieldMemberRef(members.type, this, mapper), priority);
+		
+		if (autoGetter != null)
+			autoGetter.registerTo(members, priority, mapper);
+		if (autoSetter != null)
+			autoSetter.registerTo(members, priority, mapper);
 	}
 	
 	@Override
 	public DefinitionMemberRef getOverrides() {
 		return null;
 	}
+	
+	@Override
+	public int getEffectiveModifiers() {
+		return modifiers;
+	}
 
 	@Override
 	public void normalize(TypeScope scope) {

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

 	public BuiltinID getBuiltin() {
 		return builtin;
 	}
+	
+	@Override
+	public int getEffectiveModifiers() {
+		int result = modifiers;
+		if (definition.isInterface())
+			result |= Modifiers.PUBLIC;
+		if (!Modifiers.hasAccess(result))
+			result |= Modifiers.INTERNAL;
+		
+		return result;
+	}
 
 	@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

 	public GetterMemberRef getOverrides() {
 		return overrides;
 	}
+	
+	@Override
+	public int getEffectiveModifiers() {
+		int result = modifiers;
+		if (definition.isInterface() || (overrides != null && overrides.getTarget().getDefinition().isInterface()))
+			result |= Modifiers.PUBLIC;
+		if (!Modifiers.hasAccess(result))
+			result |= Modifiers.INTERNAL;
+		
+		return result;
+	}
 
 	@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

 public interface IDefinitionMember {
 	public CodePosition getPosition();
 	
-	public int getModifiers();
+	public int getSpecifiedModifiers();
+	
+	public int getEffectiveModifiers();
 	
 	public MemberAnnotation[] getAnnotations();
 	

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

 	@Override
 	public void registerTo(TypeMembers members, TypeMemberPriority priority, GenericMapper mapper) {
 		TypeID instancedType = mapper == null ? type : mapper.map(position, type.stored()).type;
-		members.addImplementation(new ImplementationMemberRef(this, members.type, instancedType), priority);
+		members.addImplementation(new ImplementationMemberRef(this, members.type, instancedType.stored(members.type.getSpecifiedStorage())), priority);
 		
 		TypeMembers interfaceTypeMembers = members.getMemberCache().get(instancedType.stored(members.type.getActualStorage()));
 		interfaceTypeMembers.copyMembersTo(position, members, TypeMemberPriority.INTERFACE);
 	public DefinitionMemberRef getOverrides() {
 		return null;
 	}
+	
+	@Override
+	public int getEffectiveModifiers() {
+		int result = modifiers;
+		if (definition.isInterface())
+			result |= Modifiers.PUBLIC;
+		if (!Modifiers.hasAccess(result))
+			result |= Modifiers.PUBLIC;
+		
+		return result;
+	}
 
 	@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/InnerDefinitionMember.java

 	public DefinitionMemberRef getOverrides() {
 		return null;
 	}
+	
+	@Override
+	public int getEffectiveModifiers() {
+		int result = modifiers;
+		if (definition.isInterface())
+			result |= Modifiers.PUBLIC;
+		if (!Modifiers.hasAccess(result))
+			result |= Modifiers.INTERNAL;
+		
+		return result;
+	}
 
 	@Override
 	public void normalize(TypeScope scope) {

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

 	public <C, R> R accept(C context, MemberVisitorWithContext<C, R> visitor) {
 		return visitor.visitMethod(context, this);
 	}
+	
+	@Override
+	public int getEffectiveModifiers() {
+		int result = super.getEffectiveModifiers();
+		if (overrides != null) {
+			if (overrides.getTarget().isPublic())
+				result |= Modifiers.PUBLIC;
+			if (overrides.getTarget().isProtected())
+				result |= Modifiers.PROTECTED;
+		}
+		return result;
+	}
 
 	@Override
 	public FunctionalMemberRef getOverrides() {
 	public void setOverrides(GlobalTypeRegistry registry, FunctionalMemberRef overrides) {
 		this.overrides = overrides;
 		header = header.inferFromOverride(registry, overrides.getHeader());
-		
-		if (overrides.getTarget().isPublic())
-			modifiers |= Modifiers.PUBLIC;
-		if (overrides.getTarget().isProtected())
-			modifiers |= Modifiers.PROTECTED;
 	}
 }

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

 	public SetterMemberRef getOverrides() {
 		return overrides;
 	}
+	
+	@Override
+	public int getEffectiveModifiers() {
+		int result = modifiers;
+		if (definition.isInterface() || (overrides != null && overrides.getTarget().getDefinition().isInterface()))
+			result |= Modifiers.PUBLIC;
+		if (!Modifiers.hasAccess(result))
+			result |= Modifiers.INTERNAL;
+		
+		return result;
+	}
 
 	@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/StaticInitializerMember.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.scope.TypeScope;
 import org.openzen.zenscript.codemodel.statement.LoopStatement;
 	public DefinitionMemberRef getOverrides() {
 		return null;
 	}
+	
+	@Override
+	public int getEffectiveModifiers() {
+		return modifiers;
+	}
 
 	@Override
 	public void normalize(TypeScope scope) {

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

 	}
 	
 	public boolean isImplicit() {
-		return Modifiers.isImplicit(member.modifiers);
+		return Modifiers.isImplicit(member.getSpecifiedModifiers());
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.ImplementationMember;
 import org.openzen.zenscript.codemodel.type.StoredType;
-import org.openzen.zenscript.codemodel.type.TypeID;
 
 /**
  *
 public class ImplementationMemberRef implements DefinitionMemberRef {
 	public final ImplementationMember member;
 	private final StoredType type;
-	public final TypeID implementsType;
+	public final StoredType implementsType;
 	
-	public ImplementationMemberRef(ImplementationMember member, StoredType owner, TypeID implementsType) {
+	public ImplementationMemberRef(ImplementationMember member, StoredType owner, StoredType implementsType) {
 		this.member = member;
 		this.type = owner;
 		this.implementsType = implementsType;

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

 			members.addConstructor(new ConstructorMember(
 					BUILTIN,
 					definition,
-					0,
+					Modifiers.PUBLIC,
 					new FunctionHeader(VOID.stored, indexGetParameters),
 					ARRAY_CONSTRUCTOR_SIZED).ref(type));
 		}
 		new ConstructorMember(
 				BUILTIN,
 				definition,
-				0,
+				Modifiers.PUBLIC,
 				initialValueConstructorHeader,
 				ARRAY_CONSTRUCTOR_INITIAL_VALUE)
 				.registerTo(members, TypeMemberPriority.SPECIFIED, null);
 		members.addConstructor(new ConstructorMember(
 				BUILTIN,
 				definition,
-				0,
+				Modifiers.PUBLIC,
 				lambdaConstructorHeader,
 				ARRAY_CONSTRUCTOR_LAMBDA).ref(type));
 		

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

 		}
 		
 		for (TypeMember<ImplementationMemberRef> implementation : implementations) {
-			if (implementation.member.implementsType.equals(other)) // TODO: for some reason duplicate types are generated
+			if (implementation.member.implementsType.type == other)
 				return true;
-			if (cache.get(implementation.member.implementsType.stored(type.getActualStorage())).extendsOrImplements(other))
+			if (cache.get(implementation.member.implementsType).extendsOrImplements(other))
 				return true;
 		}
 		
 				return castEquivalent(position, caster.member.cast(position, value, implicit), toType);
 		}
 		for (TypeMember<ImplementationMemberRef> implementation : implementations) {
-			if (implementation.member.implementsType.getNormalized() == toType.type)
-				return castEquivalent(position, new InterfaceCastExpression(position, value, toType.type.stored(type.getActualStorage())), toType);
+			if (implementation.member.implementsType.type.getNormalized() == toType.type)
+				return castEquivalent(position, new InterfaceCastExpression(position, value, implementation.member), toType);
 		}
 		if (extendsType(toType.type))
 			return new SupertypeCastExpression(position, value, toType);

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

 package org.openzen.zenscript.javabytecode.compiler.definitions;
 
-import org.openzen.zenscript.javashared.JavaTypeGenericVisitor;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Label;
 import org.objectweb.asm.Opcodes;
 	@Override
 	public Void visitConst(ConstMember member) {
 		JavaField field = member.getTag(JavaField.class);
-        writer.visitField(CompilerUtils.calcAccess(member.modifiers), field.name, field.descriptor, field.signature, null).visitEnd();
+        writer.visitField(CompilerUtils.calcAccess(member.getEffectiveModifiers()), field.name, field.descriptor, field.signature, null).visitEnd();
         return null;
 	}
 
 	@Override
 	public Void visitField(FieldMember member) {
 		JavaField field = member.getTag(JavaField.class);
-        writer.visitField(CompilerUtils.calcAccess(member.modifiers), field.name, field.descriptor, field.signature, null).visitEnd();
+        writer.visitField(CompilerUtils.calcAccess(member.getEffectiveModifiers()), field.name, field.descriptor, field.signature, null).visitEnd();
         return null;
     }
 
     public Void visitMethod(MethodMember member) {
         CompilerUtils.tagMethodParameters(context, member.header, member.isStatic());
 
-        final boolean isAbstract = member.body == null || Modifiers.isAbstract(member.modifiers);
+        final boolean isAbstract = member.body == null || Modifiers.isAbstract(member.getEffectiveModifiers());
         final JavaMethod method = member.getTag(JavaMethod.class);
 
 		final Label methodStart = new Label();

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

 					baseMethod.name,
 					true,
 					context.getMethodDescriptor(header),
-					JavaModifiers.getJavaModifiers(member.modifiers),
+					JavaModifiers.getJavaModifiers(member.getEffectiveModifiers()),
 					header.getReturnType().type instanceof GenericTypeID);
 		} else if (method == null) {
 			method = new JavaMethod(
 					name,
 					true,
 					context.getMethodDescriptor(header),
-					JavaModifiers.getJavaModifiers(member.modifiers),
+					JavaModifiers.getJavaModifiers(member.getEffectiveModifiers()),
 					header.getReturnType().type instanceof GenericTypeID);
 		}
 		

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

 		if (nativeTag != null && nativeClass != null)
 			method = nativeClass.getMethod(nativeTag.value);
 		if (method == null)
-			method = new JavaMethod(cls, getKind(member), name, true, context.getMethodDescriptor(header), JavaModifiers.getJavaModifiers(member.modifiers), header.getReturnType().type instanceof GenericTypeID); 
+			method = new JavaMethod(cls, getKind(member), name, true, context.getMethodDescriptor(header), JavaModifiers.getJavaModifiers(member.getEffectiveModifiers()), header.getReturnType().type instanceof GenericTypeID); 
 		
 		if (method.compile) {
 			if (DEBUG_EMPTY && cls.empty)

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

 		begin(ElementType.METHOD);
 		output.append(indent);
 		
-		modifiers(member.modifiers | Modifiers.STATIC);
+		modifiers(member.getEffectiveModifiers() | Modifiers.STATIC);
 		if (member.isStatic())
 			JavaSourceUtils.formatTypeParameters(scope.typeVisitor, output, header.typeParameters, true);
 		else
 	@Override
 	public Void visitConst(ConstMember member) {
 		begin(ElementType.FIELD);
-		modifiers(member.modifiers | Modifiers.STATIC | Modifiers.FINAL);
+		modifiers(member.getEffectiveModifiers() | Modifiers.STATIC | Modifiers.FINAL);
 		output.append(scope.type(member.type));
 		output.append(" ");
 		output.append(member.name);

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

 		if (isInterface && hasBody)
 			output.append("default ");
 		
-		modifiers(member.modifiers);
+		modifiers(member.getEffectiveModifiers());
 		JavaSourceUtils.formatTypeParameters(scope.typeVisitor, output, header.typeParameters, true);
 		output.append(scope.typeVisitor.process(header.getReturnType()));
 		output.append(" ");
 		begin(ElementType.FIELD);
 		
 		output.append(indent);
-		modifiers(member.modifiers | Modifiers.STATIC | Modifiers.FINAL);
+		modifiers(member.getEffectiveModifiers() | Modifiers.STATIC | Modifiers.FINAL);
 		output.append(scope.type(member.type));
 		output.append(" ");
 		output.append(member.name);
 		begin(ElementType.CONSTRUCTOR);
 		
 		output.append(indent);
-		modifiers(member.modifiers);
+		modifiers(member.getEffectiveModifiers());
 		JavaSourceUtils.formatTypeParameters(scope.typeVisitor, output, member.header.typeParameters, true);
 		output.append(scope.cls.getName());
 		formatParameters(member.isStatic(), member.header);
 			
 			begin(ElementType.FIELD);
 			output.append(indent);
-			modifiers(member.modifiers);
+			modifiers(member.getEffectiveModifiers());
 			output.append("final ").append(scope.type(member.type)).append(" as").append(interfaceName).append(" = new ").append(implementationName).append("();\n");
 			
 			begin(ElementType.INNERCLASS);

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

 	public ExpressionString visitGetter(GetterExpression expression) {
 		if (expression.getter.member.builtin != null)
 			return visitBuiltinGetter(expression, expression.getter.member.builtin);
+		if (expression.getter.member.hasTag(JavaField.class)) {
+			JavaField field = expression.getter.member.getTag(JavaField.class);
+			return expression.target.accept(this).unaryPostfix(JavaOperator.MEMBER, "." + field.name);
+		}
 		
 		JavaMethod method = expression.getter.getTag(JavaMethod.class);
 		StringBuilder result = new StringBuilder();

ModuleSerializer/src/main/java/org/openzen/zenscript/moduleserializer/encoder/DefinitionSerializer.java

 		for (InnerDefinitionMember innerDefinition : innerDefinitions) {
 			System.out.println("Inner definition: " + innerDefinition.definition.name);
 			output.serialize(innerDefinition.position);
-			output.writeUInt(innerDefinition.modifiers);
+			output.writeUInt(innerDefinition.getSpecifiedModifiers());
 			innerDefinition.innerDefinition.accept(moduleContext, this);
 		}
 		

ModuleSerializer/src/main/java/org/openzen/zenscript/moduleserializer/encoder/MemberSerializer.java

 		if ((flags & MemberEncoding.FLAG_POSITION) > 0)
 			output.serialize(member.getPosition());
 		
-		output.writeUInt(member.getModifiers());
+		output.writeUInt(member.getSpecifiedModifiers());
 		
 		if (member.getAnnotations().length > 0) {
 			output.enqueueCode(output -> {

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

 	protected void inferHeaders(BaseScope scope) throws CompileException {
 		if ((implementation != null && !Modifiers.isPrivate(modifiers))) {
 			fillOverride(scope, implementation.getCompiled().type.stored(BorrowStorageTag.THIS));
-			getCompiled().modifiers |= Modifiers.PUBLIC;
 		} else if (implementation == null && Modifiers.isOverride(modifiers)) {
 			if (definition.getSuperType() == null)
 				throw new CompileException(position, CompileExceptionCode.OVERRIDE_WITHOUT_BASE, "Override specified without base type");

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

 	private void inferHeaders(BaseScope scope) throws CompileException {
 		if ((implementation != null && !Modifiers.isPrivate(modifiers))) {
 			fillOverride(scope, implementation.getCompiled().type.stored(BorrowStorageTag.THIS));
-			compiled.modifiers |= Modifiers.PUBLIC;
 		} else if (implementation == null && Modifiers.isOverride(modifiers)) {
 			if (definition.getSuperType() == null)
 				throw new CompileException(position, CompileExceptionCode.OVERRIDE_WITHOUT_BASE, "Override specified without base type");

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

 	private void inferHeaders(BaseScope scope) throws CompileException {
 		if ((implementation != null && !Modifiers.isPrivate(modifiers))) {
 			fillOverride(scope, implementation.getCompiled().type.stored(scope.getThisType().getSpecifiedStorage()));
-			compiled.modifiers |= Modifiers.PUBLIC;
 		} else if (implementation == null && Modifiers.isOverride(modifiers)) {
 			if (definition.getSuperType() == null)
 				throw new CompileException(position, CompileExceptionCode.OVERRIDE_WITHOUT_BASE, "Override specified without base type");

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

 	public Void visitConst(ConstMember member) {
 		ValidationUtils.validateModifiers(
 				validator,
-				member.modifiers,
+				member.getEffectiveModifiers(),
 				Modifiers.PUBLIC | Modifiers.PROTECTED | Modifiers.PRIVATE,
 				member.position,
 				"Invalid modifier");
 					member.position,
 					"Expression type doesn't match const type");
 		}
+		member.value.accept(new ExpressionValidator(validator, new FieldInitializerScope(member)));
 		return null;
 	}
 	
 	}
 	
 	private void validateFunctional(FunctionalMember member, StatementScope scope) {
-		if (Modifiers.isOverride(member.modifiers) || (context == DefinitionMemberContext.IMPLEMENTATION && !member.isPrivate())) {
+		if (Modifiers.isOverride(member.getEffectiveModifiers()) || (context == DefinitionMemberContext.IMPLEMENTATION && !member.isPrivate())) {
 			if (member.getOverrides() == null) {
 				validator.logError(ValidationLogEntry.Code.OVERRIDE_MISSING_BASE, member.position, "Overridden method not identified");
 			} else {
 	}
 	
 	private void validateGetter(GetterMember member, StatementScope scope) {
-		if (Modifiers.isOverride(member.modifiers) || (context == DefinitionMemberContext.IMPLEMENTATION && !member.isPrivate())) {
+		if (Modifiers.isOverride(member.getEffectiveModifiers()) || (context == DefinitionMemberContext.IMPLEMENTATION && !member.isPrivate())) {
 			if (member.getOverrides() == null) {
 				validator.logError(ValidationLogEntry.Code.OVERRIDE_MISSING_BASE, member.position, "Overridden method not identified");
 			}
 	}
 	
 	private void validateSetter(SetterMember member, StatementScope scope) {
-		if (Modifiers.isOverride(member.modifiers) || (context == DefinitionMemberContext.IMPLEMENTATION && !member.isPrivate())) {
+		if (Modifiers.isOverride(member.getEffectiveModifiers()) || (context == DefinitionMemberContext.IMPLEMENTATION && !member.isPrivate())) {
 			if (member.getOverrides() == null) {
 				validator.logError(ValidationLogEntry.Code.OVERRIDE_MISSING_BASE, member.position, "Overridden method not identified");
 			}
 	}
 	
 	private class FieldInitializerScope implements ExpressionScope {
-		private final FieldMember field;
+		private final DefinitionMember field;
 		
-		public FieldInitializerScope(FieldMember field) {
+		public FieldInitializerScope(DefinitionMember field) {
 			this.field = field;
 		}
 		

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

 	@Override
 	public Void visitGetter(GetterExpression expression) {
 		checkMemberAccess(expression.position, expression.getter);
-		checkStatic(expression.position, expression.getter);
+		checkNotStatic(expression.position, expression.getter);
 		return expression.target.accept(this);
 	}
 	
 	}
 	
 	private void checkMemberAccess(CodePosition position, DefinitionMemberRef member) {
-		if (!scope.getAccessScope().hasAccessTo(member.getTarget().getAccessScope(), member.getTarget().getModifiers()))
+		if (!scope.getAccessScope().hasAccessTo(member.getTarget().getAccessScope(), member.getTarget().getEffectiveModifiers())) {
 			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()))
+		if (!scope.getAccessScope().hasAccessTo(field.getTarget().getAccessScope(), Modifiers.PRIVATE))
 			validator.logError(ValidationLogEntry.Code.NO_ACCESS, position, "fields are private");
 	}
 	
 	private void checkStatic(CodePosition position, DefinitionMemberRef member) {
-		if (!Modifiers.isStatic(member.getTarget().getModifiers()))
+		if (!Modifiers.isStatic(member.getTarget().getSpecifiedModifiers()))
 			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()))
+		if (Modifiers.isStatic(member.getTarget().getSpecifiedModifiers()))
 			validator.logError(ValidationLogEntry.Code.MUST_NOT_BE_STATIC, position, "Member must not be static");
 	}