Merge remote-tracking branch 'kindlich/development' into HEAD

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/JavaCompiler.java

  */
 package org.openzen.zenscript.javabytecode;
 
-import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.Map;
 import org.objectweb.asm.ClassWriter;
 import org.objectweb.asm.Opcodes;
 	public JavaCompiler() {}
 	
 	public JavaBytecodeModule compile(String packageName, SemanticModule module, JavaCompileSpace space) {
-		Map<String, JavaScriptFile> scriptBlocks = new HashMap<>();
+		Map<String, JavaScriptFile> scriptBlocks = new LinkedHashMap<>();
 		
 		JavaBytecodeModule target = new JavaBytecodeModule(module.module, module.parameters);
 		JavaBytecodeContext context = new JavaBytecodeContext(target, space, module.modulePackage, packageName);
 		for (HighLevelDefinition definition : module.definitions.getAll()) {
 			String className = getClassName(definition.position.getFilename());
 			JavaScriptFile scriptFile = getScriptFile(scriptBlocks, definition.pkg.fullName + "/" + className);
+			scriptFile.classWriter.visitSource(definition.position.getFilename(), null);
 			
 			JavaClass cls = definition instanceof ExpansionDefinition ? context.getJavaExpansionClass(definition) : context.getJavaClass(definition);
 			target.addClass(cls.internalName, definition.accept(new JavaDefinitionVisitor(context, scriptFile.classWriter)));
 			final SourceFile sourceFile = script.file;
 			final String className = getClassName(sourceFile == null ? null : sourceFile.getFilename());
 			JavaScriptFile scriptFile = getScriptFile(scriptBlocks, script.pkg.fullName + "/" + className);
+			scriptFile.classWriter.visitSource(script.file.getFilename(), null);
 
 			String methodName = scriptFile.scriptMethods.isEmpty() ? "run" : "run" + scriptFile.scriptMethods.size();
 

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

 	}
 
 	/**
-	 * Checks if an expression can be inlined
+	 * Checks if an expression can be inLined
 	 *
 	 * @param expression Expression to check for.
-	 * @return can expression be inlined
+	 * @return can expression be inLined
 	 */
-	static boolean canBeInlined(Expression expression) {
+	static boolean canBeInLined(Expression expression) {
 		while (expression instanceof StorageCastExpression)
 			expression = ((StorageCastExpression) expression).value;
 
 	 * @param currentArrayType  The current type of the array, reduced during the recursions of the functions
 	 * @param innermostFunction The function that will decide what to add to the array, needs to increase the stack size by one and may not touch the other stacks!
 	 */
-	private static void visitMultiDimArray(JavaWriter javaWriter, int[] sizeLocations, int[] counterLocations, int dim, Type currentArrayType, InnermostFunction innermostFunction) {
+	static void visitMultiDimArray(JavaWriter javaWriter, int[] sizeLocations, int[] counterLocations, int dim, Type currentArrayType, InnermostFunction innermostFunction) {
 		final Label begin = new Label();
 		final Label end = new Label();
 		javaWriter.label(begin);

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

 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.expression.*;
 import org.openzen.zenscript.codemodel.expression.switchvalue.VariantOptionSwitchValue;
-import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
 import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
 import org.openzen.zenscript.codemodel.statement.ReturnStatement;
 		final JavaWriter functionWriter;
 		
 		//Bridge method!!!
-		if(!Objects.equals(methodInfo.descriptor, signature)) {
+		if (!Objects.equals(methodInfo.descriptor, signature)) {
 			final JavaMethod bridgeMethodInfo = new JavaMethod(methodInfo.cls, methodInfo.kind, methodInfo.name, methodInfo.compile, methodInfo.descriptor, methodInfo.modifiers | JavaModifiers.BRIDGE | JavaModifiers.SYNTHETIC, methodInfo.genericResult, methodInfo.typeParameterArguments);
 			final JavaWriter bridgeWriter = new JavaWriter(expression.position, lambdaCW, bridgeMethodInfo, null, methodInfo.descriptor, null, "java/lang/Override");
 			bridgeWriter.start();
 				final FunctionParameter functionParameter = expression.header.parameters[i];
 				final Type type = context.getType(functionParameter.type);
 				bridgeWriter.load(type, i + 1);
-				bridgeWriter.checkCast(type);
+				if (!CompilerUtils.isPrimitive(functionParameter.type.type)) {
+					bridgeWriter.checkCast(type);
+				}
 			}
 			
-			bridgeWriter.invokeVirtual(methodInfo);
+			bridgeWriter.invokeVirtual(new JavaMethod(JavaClass.fromInternalName(className, JavaClass.Kind.CLASS), methodInfo.kind, methodInfo.name, methodInfo.compile, signature, methodInfo.modifiers, methodInfo.genericResult));
 			if(expression.header.getReturnType().type != BasicTypeID.VOID) {
 				bridgeWriter.returnType(context.getType(expression.header.getReturnType()));
 			}
 
 
 				if (builtin == BuiltinID.ARRAY_CONSTRUCTOR_SIZED) {
-					type.elementType.type.accept(JavaDefaultExpressionTypeVisitor.INSTANCE).accept(this);
+					type.elementType.type.getDefaultValue().accept(this);
 				} else {
 					expression.arguments.arguments[expression.arguments.arguments.length - 1].accept(this);
 				}
 				return;
 			}
 			case ARRAY_CONSTRUCTOR_LAMBDA: {
-				ArrayTypeID type = (ArrayTypeID) expression.type.type;
-
-				if (type.dimension == 1) {
-					// array = new T[arguments[0]]
-					// lambda = arguments[1]
-					// for (int i = 0; i < array.length; i++)
-					//    array[i] = lambda.invoke(i);
-					//
-					// NOTE: arguments[1] can be a FunctionExpression; this can be optimized by running it inline
-					throw new UnsupportedOperationException("Not yet supported!");
-				} else {
-					// TODO: implement
-					throw new UnsupportedOperationException("Not yet supported!");
-				}
+				
+				//Labels
+				final Label begin = new Label();
+				final Label end = new Label();
+				javaWriter.label(begin);
+				
+				final Type ASMElementType = context.getType(expression.type);
+				final int dimension = ((ArrayTypeID) expression.type.type).dimension;
+				final int[] arraySizes = ArrayInitializerHelper.getArraySizeLocationsFromConstructor(dimension, expression.arguments.arguments, this);
+				ArrayInitializerHelper.visitMultiDimArray(javaWriter, arraySizes, new int[dimension], dimension, ASMElementType, (elementType, counterLocations) -> {
+					expression.arguments.arguments[dimension].accept(this);
+					for (int counterLocation : counterLocations) {
+						javaWriter.loadInt(counterLocation);
+					}
+					javaWriter.invokeInterface(context.getFunctionalInterface(expression.arguments.arguments[dimension].type));
+				});
+				javaWriter.label(end);
+				return;
 			}
-			case ARRAY_CONSTRUCTOR_PROJECTED: {
-
-
+			case ARRAY_CONSTRUCTOR_PROJECTED:
+			case ARRAY_CONSTRUCTOR_PROJECTED_INDEXED: {
 				ArrayTypeID type = (ArrayTypeID) expression.type.type;
-
+				
+				//Labels
 				final Label begin = new Label();
 				final Label end = new Label();
-
 				javaWriter.label(begin);
-				expression.arguments.arguments[0].accept(this); //Origin array
+				
+				//Origin Array
+				expression.arguments.arguments[0].accept(this);
 				final Type originArrayType = context.getType(expression.arguments.arguments[0].type);
 				final int originArrayLocation = javaWriter.local(originArrayType);
 				javaWriter.storeObject(originArrayLocation);
 				Type destinationArrayType = context.getType(expression.type);
-
-
-				final boolean canBeInlined = ArrayInitializerHelper.canBeInlined(expression.arguments.arguments[1]);
-				final Type functionType;    //Only used if not inline able
-				final int functionLocation; //Only used if not inline able
-				if (!canBeInlined) {
-					expression.arguments.arguments[1].accept(this); //Projection Function
-					functionType = context.getType(expression.arguments.arguments[1].type);
-					functionLocation = javaWriter.local(functionType);
-					javaWriter.storeObject(functionLocation);
-					javaWriter.addVariableInfo(new JavaLocalVariableInfo(functionType, functionLocation, begin, "projectionFunction", end));
-				}
-
-				final int[] arraySizes = ArrayInitializerHelper.getArraySizeLocationsProjected(type.dimension, originArrayType, originArrayLocation, javaWriter);
-				ArrayInitializerHelper.visitProjected(javaWriter, arraySizes, type.dimension, originArrayLocation, originArrayType, destinationArrayType,
-						(elementType, counterLocations) -> {
-							if (canBeInlined) {
+				
+				final boolean indexed = builtin == BuiltinID.ARRAY_CONSTRUCTOR_PROJECTED_INDEXED;
+				final boolean canBeInLined = ArrayInitializerHelper.canBeInLined(expression.arguments.arguments[1]);
+				if (canBeInLined) {
+					//We can inline, so do it
+					final int[] arraySizes = ArrayInitializerHelper.getArraySizeLocationsProjected(type.dimension, originArrayType, originArrayLocation, javaWriter);
+					final Type projectedElementType = Type.getType(originArrayType.getDescriptor().substring(type.dimension));
+					ArrayInitializerHelper.visitProjected(javaWriter, arraySizes, type.dimension, originArrayLocation, originArrayType, destinationArrayType,
+							(elementType, counterLocations) -> {
 								Label inlineBegin = new Label();
 								Label inlineEnd = new Label();
 								javaWriter.label(inlineBegin);
-								final Type projectedElementType = Type.getType(originArrayType.getDescriptor().substring(type.dimension));
+								
 								final int projectedElementLocal = javaWriter.local(projectedElementType);
 								javaWriter.store(projectedElementType, projectedElementLocal);
-
-
+								
+								
 								JavaExpressionVisitor visitor = new JavaExpressionVisitor(context, module, javaWriter) {
 									@Override
 									public Void visitGetFunctionParameter(GetFunctionParameterExpression expression) {
+										if(indexed) {
+											final JavaParameterInfo parameterInfo = module.getParameterInfo(expression.parameter);
+											if (parameterInfo != null && parameterInfo.index <= type.dimension) {
+												javaWriter.loadInt(counterLocations[parameterInfo.index - 1]);
+												return null;
+											}
+										}
+										
 										javaWriter.load(projectedElementType, projectedElementLocal);
 										return null;
 									}
 								};
-
+								
 								Expression funcExpression = expression.arguments.arguments[1];
 								while (funcExpression instanceof StorageCastExpression) {
 									funcExpression = ((StorageCastExpression) funcExpression).value;
 								}
-
+								
 								if (funcExpression instanceof FunctionExpression && ((FunctionExpression) funcExpression).body instanceof ReturnStatement) {
+									CompilerUtils.tagMethodParameters(context, module, ((FunctionExpression) funcExpression).header, false);
 									((ReturnStatement) ((FunctionExpression) funcExpression).body).value.accept(visitor);
 									javaWriter.addVariableInfo(new JavaLocalVariableInfo(projectedElementType, projectedElementLocal, inlineBegin, ((FunctionExpression) funcExpression).header.parameters[0].name, inlineEnd));
+									
 								} else throw new IllegalStateException("Trying to inline a non-inlineable expression");
-
-
+								
+								
 								javaWriter.label(inlineEnd);
-							} else {
+							});
+				} else {
+					//We cannot inline, so get a hold of the function expression and apply it to every
+					expression.arguments.arguments[1].accept(this); //Projection Function
+					final Type functionType = context.getType(expression.arguments.arguments[1].type);
+					final int functionLocation = javaWriter.local(functionType);
+					javaWriter.storeObject(functionLocation);
+					javaWriter.addVariableInfo(new JavaLocalVariableInfo(functionType, functionLocation, begin, "projectionFunction", end));
+					final int[] arraySizes = ArrayInitializerHelper.getArraySizeLocationsProjected(type.dimension, originArrayType, originArrayLocation, javaWriter);
+					ArrayInitializerHelper.visitProjected(javaWriter, arraySizes, type.dimension, originArrayLocation, originArrayType, destinationArrayType,
+							(elementType, counterLocations) -> {
 								//Apply function here
-								//javaWriter.loadObject(functionLocation);
-								//javaWriter.swap();
-
-								//TODO invoke?
-								//javaWriter.invokeVirtual(new JavaMethod(JavaClass.fromInternalName("lambda1", JavaClass.Kind.CLASS), JavaMethod.Kind.INSTANCE, "accept", true, "(Ljava/lang/String;)Ljava/lang/String;", 0, false));
-
-								//FIXME Critical! Currently returning the same object!
-								//throw new UnsupportedOperationException("Cannot use projection functions yet!");
-							}
-						});
-
-
+								javaWriter.loadObject(functionLocation);
+								javaWriter.swap();
+								
+								if(indexed) {
+									for (int counterLocation : counterLocations) {
+										javaWriter.loadInt(counterLocation);
+										javaWriter.swap();
+									}
+								}
+								
+								javaWriter.invokeInterface(context.getFunctionalInterface(expression.arguments.arguments[1].type));
+							});
+				}
+				
+				
 				javaWriter.label(end);
 				return;
-
-			}
-			case ARRAY_CONSTRUCTOR_PROJECTED_INDEXED: {
-				ArrayTypeID type = (ArrayTypeID) expression.type.type;
-
-				if (type.dimension == 1) {
-					// original = arguments[0] (this is an array)
-					// projector = arguments[1] (this is a lambda with 2 parameters)
-					// array = new T[original.length]
-					// for (int i = 0; i < array.length; i++)
-					//   array[i] = projector(i, original[i]);
-					//
-					// NOTE: arguments[1] can be a FunctionExpression; this can be optimized by running it inline
-
-					// TODO: implement in bytecode
-
-					return;
-				} else {
-					// TODO: implement
-					throw new UnsupportedOperationException("Not yet supported!");
-				}
+				
 			}
 			case ARRAY_INDEXGET:
 				break;

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

 
 	@Override
 	public Boolean visitBlock(BlockStatement statement) {
+    	javaWriter.position(statement.position.fromLine);
 		Boolean returns = false;
 		for (Statement statement1 : statement.statements) {
 			returns = statement1.accept(this);
 
 	@Override
 	public Boolean visitBreak(BreakStatement statement) {
+    	javaWriter.position(statement.position.fromLine);
 		javaWriter.goTo(javaWriter.getNamedLabel(statement.target.label + "_end"));
 		return false;
 	}
 
 	@Override
 	public Boolean visitContinue(ContinueStatement statement) {
+    	javaWriter.position(statement.position.fromLine);
 		javaWriter.goTo(javaWriter.getNamedLabel(statement.target.label + "_start"));
 		return false;
 	}
 
 	@Override
 	public Boolean visitDoWhile(DoWhileStatement statement) {
+    	javaWriter.position(statement.position.fromLine);
 		Label start = new Label();
 		Label end = new Label();
 		if (statement.label == null)
 
 	@Override
 	public Boolean visitExpression(ExpressionStatement statement) {
+    	javaWriter.position(statement.position.fromLine);
 		statement.expression.accept(nonPushingExpressionVisitor);
 		return false;
 	}
 
 	@Override
 	public Boolean visitForeach(ForeachStatement statement) {
+    	javaWriter.position(statement.position.fromLine);
 		//Create Labels
 		Label start = new Label();
 		Label end = new Label();
 
 	@Override
 	public Boolean visitIf(IfStatement statement) {
+    	javaWriter.position(statement.position.fromLine);
 		statement.condition.accept(expressionVisitor);
 		Label onElse = null;
 		Label end = new Label();
 	public Boolean visitLock(LockStatement statement) {
 		return false;
 	}
-
+	
+	@Override
+	public Boolean visitInvalid(InvalidStatement statement) {
+		throw new UnsupportedOperationException("Invalid Statement: " + statement.message);
+	}
+	
 	@Override
 	public Boolean visitReturn(ReturnStatement statement) {
+    	javaWriter.position(statement.position.fromLine);
 		statement.value.accept(expressionVisitor);
 		javaWriter.returnType(context.getType(statement.value.type));
 		return true;
 
 	@Override
 	public Boolean visitSwitch(SwitchStatement statement) {
+    	javaWriter.position(statement.position.fromLine);
 
 		final Label start = new Label();
 		final Label end = new Label();
 
 	@Override
 	public Boolean visitThrow(ThrowStatement statement) {
+    	javaWriter.position(statement.position.fromLine);
 		statement.value.accept(expressionVisitor);
 		javaWriter.aThrow();
 		return false;
 
 	@Override
 	public Boolean visitTryCatch(TryCatchStatement statement) {
+    	javaWriter.position(statement.position.fromLine);
 		final Label tryCatchStart = new Label();
 		final Label tryFinish = new Label();
 		final Label tryCatchFinish = new Label();
 
 	@Override
 	public Boolean visitVar(VarStatement statement) {
+    	javaWriter.position(statement.position.fromLine);
 		if (statement.initializer != null) {
 			statement.initializer.accept(expressionVisitor);
 		}
 
 	@Override
 	public Boolean visitWhile(WhileStatement statement) {
+    	javaWriter.position(statement.position.fromLine);
 		Label start = new Label();
 		Label end = new Label();
 

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

  */
 package org.openzen.zencode.java;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.function.Consumer;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 public class JavaNativeLoader {
 	private final Class<?>[] classes;
 	private final Class<?>[] globals;
-	private final Map<String, LoadingModule> modulesByBasePackage = new HashMap<>();
 	private final Map<String, LoadingModule> modulesByName = new HashMap<>();
 	private boolean loaded = false;
 	
 			throw new IllegalArgumentException("Module already exists: " + name);
 		
 		LoadingModule module = new LoadingModule(pkg, name, basePackage, dependencies);
-		modulesByBasePackage.put(name, module);
 		modulesByName.put(name, module);
 		
 		return module;
 		sortClasses();
 		
 		ScriptingEngine engine = new ScriptingEngine();
-		for (LoadingModule module : modulesByBasePackage.values()) {
+		for (LoadingModule module : modulesByName.values()) {
 			load(engine, module);
 		}
 		return engine;

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

 import java.lang.reflect.AnnotatedType;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
+import java.lang.reflect.Member;
 import java.lang.reflect.Modifier;
 import java.lang.reflect.Parameter;
 import java.lang.reflect.ParameterizedType;
 	}
 	
 	private ZSPackage getPackage(String className) {
+		//TODO validate
+		if(this.basePackage == null || this.basePackage.isEmpty())
+			return pkg;
 		//TODO make a lang package?
 		if (!className.contains(".") || className.startsWith("java.lang"))
 			return pkg;
 			} else if (specifiedName.indexOf('.') >= 0) {
 				if (!specifiedName.startsWith(pkg.fullName))
 					throw new IllegalArgumentException("Specified @Name as " + specifiedName + " but it's not in the module root package");
-				
+
 				classPkg = getPackage(basePackage + specifiedName.substring(pkg.fullName.length()));
 				className = className.substring(className.lastIndexOf('.') + 1);
 			} else {
                 className = nameAnnotation.value();
 			}
 		}
-		
+
 		TypeVariableContext context = new TypeVariableContext();
 		TypeVariable<Class<T>>[] javaTypeParameters = cls.getTypeParameters();
 		TypeParameter[] typeParameters = new TypeParameter[cls.getTypeParameters().length];
 			definition = new InterfaceDefinition(CodePosition.NATIVE, module, classPkg, className, Modifiers.PUBLIC, null);
 			javaClass = JavaClass.fromInternalName(internalName, JavaClass.Kind.INTERFACE);
 		} else if (cls.isEnum()) {
-			definition = new EnumDefinition(CodePosition.NATIVE, module, pkg, className, Modifiers.PUBLIC, null);
+			definition = new EnumDefinition(CodePosition.NATIVE, module, classPkg, className, Modifiers.PUBLIC, null);
 			javaClass = JavaClass.fromInternalName(internalName, JavaClass.Kind.ENUM);
 		} else if (isStruct) {
-			definition = new StructDefinition(CodePosition.NATIVE, module, pkg, className, Modifiers.PUBLIC, null);
+			definition = new StructDefinition(CodePosition.NATIVE, module, classPkg, className, Modifiers.PUBLIC, null);
 			javaClass = JavaClass.fromInternalName(internalName, JavaClass.Kind.CLASS);
 		} else {
 			definition = new ClassDefinition(CodePosition.NATIVE, module, classPkg, className, Modifiers.PUBLIC);
 			final String fieldName = annotation.value().isEmpty() ? field.getName() : annotation.value();
 			
 			StoredType fieldType = loadStoredType(context, field.getAnnotatedType());
-			FieldMember member = new FieldMember(CodePosition.NATIVE, definition, Modifiers.PUBLIC, fieldName, thisType, fieldType, registry, 0, 0, null);
+			FieldMember member = new FieldMember(CodePosition.NATIVE, definition, getMethodModifiers(field), fieldName, thisType, fieldType, registry, 0, 0, null);
 			definition.addMember(member);
 			compiled.setFieldInfo(member, new JavaField(javaClass, field.getName(), getDescriptor(field.getType())));
 		}
 			return null;
 		}
 	}
-	
+
 	private FunctionHeader getHeader(
 			TypeVariableContext context,
 			AnnotatedType javaReturnType,
 		FunctionParameter[] parameters = new FunctionParameter[javaParameters.length];
 		for (int i = 0; i < parameters.length; i++) {
 			Parameter parameter = javaParameters[i];
-			
+
 			AnnotatedType parameterType = parameter.getAnnotatedType();
 			StoredType type = loadStoredType(context, parameter.getAnnotatedType());
 			Expression defaultValue = getDefaultValue(parameter, type);
 		return null;
 	}
 	
-	private int getMethodModifiers(Method method) {
+	private int getMethodModifiers(Member method) {
 		int result = Modifiers.PUBLIC;
 		if (isStatic(method.getModifiers()))
 			result |= Modifiers.STATIC;

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

 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
+import java.util.function.Consumer;
+
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.SourceFile;
 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.parser.BracketExpressionParser;
 import org.openzen.zenscript.parser.ParsedFile;
 import org.openzen.zenscript.parser.ZippedPackage;
+import org.openzen.zenscript.validator.ValidationLogEntry;
 import org.openzen.zenscript.validator.Validator;
 
 /**
 			BracketExpressionParser bracketParser,
 			FunctionParameter[] scriptParameters,
 			String... dependencies) throws ParseException
+	{
+		return createScriptedModule(name, sources, bracketParser, scriptParameters, Throwable::printStackTrace, System.out::println, sourceFile -> System.out.println("Loading " + sourceFile.getFilename()), dependencies);
+	}
+	
+	public SemanticModule createScriptedModule(
+			String name,
+			SourceFile[] sources,
+			BracketExpressionParser bracketParser,
+			FunctionParameter[] scriptParameters,
+			Consumer<CompileException> compileExceptionConsumer,
+			Consumer<ValidationLogEntry> validatorErrorConsumer,
+			Consumer<SourceFile> sourceFileConsumer,
+			String... dependencies) throws ParseException
 	{
 		Module scriptModule = new Module(name);
 		CompilingPackage scriptPackage = new CompilingPackage(new ZSPackage(space.rootPackage, name), scriptModule);
 		
 		ParsedFile[] files = new ParsedFile[sources.length];
-		for (int i = 0; i < sources.length; i++)
+		for (int i = 0; i < sources.length; i++) {
+			sourceFileConsumer.accept(sources[i]);
 			files[i] = ParsedFile.parse(scriptPackage, bracketParser, sources[i]);
+		}
 		
 		SemanticModule[] dependencyModules = new SemanticModule[dependencies.length + 1];
 		dependencyModules[0] = space.getModule("stdlib");
 				files,
 				space,
 				scriptParameters,
-				ex -> ex.printStackTrace());
+				compileExceptionConsumer);
 		if (!scripts.isValid())
 			return scripts;
 		
 		return Validator.validate(
 				scripts.normalize(),
-				error -> System.out.println(error.toString()));
+				validatorErrorConsumer);
 	}
 	
 	public void registerCompiled(SemanticModule module) {
 			runUnit.dump(new File("classes"));
 		runUnit.run(arguments, parentClassLoader);
 	}
+	
+	public List<JavaNativeModule> getNativeModules() {
+		return Collections.unmodifiableList(this.nativeModules);
+	}
 }

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaDefaultExpressionTypeVisitor.java

-package org.openzen.zenscript.javashared;
-
-import org.openzen.zencode.shared.CodePosition;
-import org.openzen.zenscript.codemodel.expression.*;
-import org.openzen.zenscript.codemodel.type.*;
-
-public class JavaDefaultExpressionTypeVisitor implements TypeVisitor<Expression> {
-
-	public static final JavaDefaultExpressionTypeVisitor INSTANCE = new JavaDefaultExpressionTypeVisitor();
-
-	private JavaDefaultExpressionTypeVisitor(){}
-
-	@Override
-	public Expression visitBasic(BasicTypeID basic) {
-
-
-		if (basic == null)
-			throw new IllegalStateException("Null basic type!");
-
-		switch (basic) {
-			case UNDETERMINED:
-			case VOID:
-				throw new IllegalStateException("Void and Undetermined have no default type");
-			case NULL:
-				return new NullExpression(CodePosition.UNKNOWN);
-			case BOOL:
-				return new ConstantBoolExpression(CodePosition.UNKNOWN, false);
-			case BYTE:
-				return new ConstantByteExpression(CodePosition.UNKNOWN, 0);
-			case SBYTE:
-				return new ConstantSByteExpression(CodePosition.UNKNOWN, (byte) 0);
-			case SHORT:
-				return new ConstantShortExpression(CodePosition.UNKNOWN, (short) 0);
-			case USHORT:
-				return new ConstantUShortExpression(CodePosition.UNKNOWN, 0);
-			case INT:
-				return new ConstantIntExpression(CodePosition.UNKNOWN, 0);
-			case UINT:
-				return new ConstantUIntExpression(CodePosition.UNKNOWN, 0);
-			case LONG:
-				return new ConstantLongExpression(CodePosition.UNKNOWN, 0L);
-			case ULONG:
-				return new ConstantULongExpression(CodePosition.UNKNOWN, 0L);
-			case USIZE:
-				return new ConstantUSizeExpression(CodePosition.UNKNOWN, 0L);
-			case FLOAT:
-				return new ConstantFloatExpression(CodePosition.UNKNOWN, 0.0f);
-			case DOUBLE:
-				return new ConstantDoubleExpression(CodePosition.UNKNOWN, 0.0d);
-			case CHAR:
-				return new ConstantCharExpression(CodePosition.UNKNOWN, '\0');
-			default:
-				throw new IllegalStateException("Unknown basic type!");
-		}
-
-
-	}
-
-	@Override
-	public Expression visitString(StringTypeID string) {
-		return new NullExpression(CodePosition.UNKNOWN);
-	}
-
-	@Override
-	public Expression visitArray(ArrayTypeID array) {
-		return new NullExpression(CodePosition.UNKNOWN);
-	}
-
-	@Override
-	public Expression visitAssoc(AssocTypeID assoc) {
-		return new NullExpression(CodePosition.UNKNOWN);
-	}
-
-	@Override
-	public Expression visitGenericMap(GenericMapTypeID map) {
-		return new NullExpression(CodePosition.UNKNOWN);
-	}
-
-	@Override
-	public Expression visitIterator(IteratorTypeID iterator) {
-		return new NullExpression(CodePosition.UNKNOWN);
-	}
-
-	@Override
-	public Expression visitFunction(FunctionTypeID function) {
-		return new NullExpression(CodePosition.UNKNOWN);
-	}
-
-	@Override
-	public Expression visitDefinition(DefinitionTypeID definition) {
-		return new NullExpression(CodePosition.UNKNOWN);
-	}
-
-	@Override
-	public Expression visitGeneric(GenericTypeID generic) {
-		return new NullExpression(CodePosition.UNKNOWN);
-	}
-
-	@Override
-	public Expression visitRange(RangeTypeID range) {
-		return new NullExpression(CodePosition.UNKNOWN);
-	}
-
-	@Override
-	public Expression visitOptional(OptionalTypeID type) {
-		return new NullExpression(CodePosition.UNKNOWN);
-	}
-
-	@Override
-	public Expression visitInvalid(InvalidTypeID type) {
-		return new NullExpression(CodePosition.UNKNOWN);
-	}
-}

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

 				scope.hints,
 				new GenericName(this.member, typeArguments));
 		if (member == null) {
-			TypeMembers members = scope.getTypeMembers(cValue.eval().type);
+			//TypeMembers members = scope.getTypeMembers(cValue.eval().type);
 			throw new CompileException(position, CompileExceptionCode.NO_SUCH_MEMBER, "Member not found: " + this.member);
 		}
 		

ScriptingExample/scripts/arrays.zs

 );
 
 
-//val a = new string[](5, "HelloWorld");
-//val b = new string[]<string>(a, projection);
+val aSomeArray = new string[](5, "HelloWorld");
+val bSomeArray = new string[]<string>(aSomeArray, projection);
+println("HelloWorldProjectedArray");
+println(bSomeArray[1]);
+
+println(e[2,3,4]);
+
+
+val constructorLambdaArray = new string[](5, i => "No" + i);
+println(constructorLambdaArray[1]);
+
+val constructorLambdaArrayMulti = new string[,](5, 5, (i1, i2) => "No" + i1 + i2);
+println(constructorLambdaArrayMulti[1, 2]);
+
+
+val testArray = new string[,](5, 5, "helloWorld");
+
+val indexedProjectionWithLambdaNonInlined = new string[,]<string>(testArray as string[,], (index1, index2, value) => {
+    return value + "" + index1 + index2;
+} as function(index1 as usize, index2 as usize, value as string`borrow) as string);
+
+val indexedProjectionWithLambdaInlined = new string[,]<string>(testArray, ((i as usize, j as usize, s as string`borrow) => (s + "" + i + j) as string) as function(i as usize, j as usize, s as string`borrow) as string);
 
-println(e[2,3,4]);
+println(indexedProjectionWithLambdaNonInlined[1, 2]);
+println(indexedProjectionWithLambdaInlined[1, 2]);

ScriptingExample/scripts/functionalInterfaces.zs

 invokeFunctionalInt(y);
 
 
-println(((x as int) => x)(10));
+println(((x as int) => x)(10));
+
+//TODO: Globals can't be "captured"
+//invokeFunctionalInt((a, b) => {
+//	println("a");
+//	return a + b;
+//});

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

 	}
 
 	private void checkFieldAccess(CodePosition position, FieldMemberRef field) {
-		if (!scope.getAccessScope().hasAccessTo(field.getTarget().getAccessScope(), Modifiers.PRIVATE))
-			validator.logError(ValidationLogEntry.Code.NO_ACCESS, position, "fields are private");
+		if (!scope.getAccessScope().hasAccessTo(field.getTarget().getAccessScope(), field.getTarget().getEffectiveModifiers()))
+			validator.logError(ValidationLogEntry.Code.NO_ACCESS, position, "no field access to " + field.describe());
 	}
 	
 	private void checkStatic(CodePosition position, DefinitionMemberRef member) {