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

CodeModel/src/main/java/org/openzen/zenscript/codemodel/annotations/NativeDefinitionAnnotation.java

 	public void serialize(CodeSerializationOutput output, HighLevelDefinition definition, TypeContext context) {
 		output.writeString(identifier);
 	}
+
+	public String getIdentifier() {
+		return identifier;
+	}
 }

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

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zenscript.codemodel.FunctionHeader;
-import org.openzen.zenscript.codemodel.expression.CallArguments;
-import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.expression.GlobalCallExpression;
-import org.openzen.zenscript.codemodel.expression.GlobalExpression;
+import org.openzen.zenscript.codemodel.expression.*;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.type.StoredType;
 	public StoredType[] getTypeArguments() {
 		return typeArguments;
 	}
+
+	@Override
+	public IPartialExpression capture(CodePosition position, LambdaClosure closure) {
+		return this;
+	}
 }

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

 
 import java.util.Arrays;
 import java.util.List;
+import java.util.Objects;
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
 
 	public StoredType getReturnType() {
 		final List<StoredType> collect = Arrays.stream(statements)
 				.map(Statement::getReturnType)
+				.filter(Objects::nonNull)
 				.distinct()
 				.collect(Collectors.toList());
 		if(collect.isEmpty())

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

 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.ExpressionTransformer;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.StoredType;
 
 /**
 	
 	@Override
 	public StoredType getReturnType() {
-		return value.type;
+		return value != null ? value.type : BasicTypeID.VOID.stored();
 	}
 	
 	@Override

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

  */
 package org.openzen.zenscript.codemodel.type;
 
+import java.util.Collection;
 import java.util.HashMap;
 import java.util.Map;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 			return id;
 		}
 	}
+
+	public Collection<DefinitionTypeID> getDefinitions() {
+		return definitionTypes.keySet();
+	}
 }

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

 import org.openzen.zenscript.codemodel.CompareType;
 import org.openzen.zenscript.codemodel.GenericName;
 import org.openzen.zenscript.codemodel.OperatorType;
-import org.openzen.zenscript.codemodel.expression.CallArguments;
-import org.openzen.zenscript.codemodel.expression.CheckNullExpression;
-import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.expression.InterfaceCastExpression;
-import org.openzen.zenscript.codemodel.expression.InvalidExpression;
-import org.openzen.zenscript.codemodel.expression.NullExpression;
-import org.openzen.zenscript.codemodel.expression.StorageCastExpression;
-import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
-import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
+import org.openzen.zenscript.codemodel.expression.*;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.InnerDefinition;
-import org.openzen.zenscript.codemodel.member.ref.CasterMemberRef;
-import org.openzen.zenscript.codemodel.member.ref.ConstMemberRef;
-import org.openzen.zenscript.codemodel.member.ref.DefinitionMemberRef;
-import org.openzen.zenscript.codemodel.member.ref.FieldMemberRef;
-import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
-import org.openzen.zenscript.codemodel.member.ref.GetterMemberRef;
-import org.openzen.zenscript.codemodel.member.ref.ImplementationMemberRef;
-import org.openzen.zenscript.codemodel.member.ref.IteratorMemberRef;
-import org.openzen.zenscript.codemodel.member.ref.SetterMemberRef;
-import org.openzen.zenscript.codemodel.member.ref.VariantOptionRef;
-import org.openzen.zenscript.codemodel.partial.IPartialExpression;
-import org.openzen.zenscript.codemodel.partial.PartialMemberGroupExpression;
-import org.openzen.zenscript.codemodel.partial.PartialStaticMemberGroupExpression;
-import org.openzen.zenscript.codemodel.partial.PartialTypeExpression;
-import org.openzen.zenscript.codemodel.partial.PartialVariantOptionExpression;
+import org.openzen.zenscript.codemodel.member.ref.*;
+import org.openzen.zenscript.codemodel.partial.*;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.*;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
+import java.util.*;
 
 /**
  *
 	
 	public boolean extendsOrImplements(TypeID other) {
 		other = other.getNormalized();
+		checkBoundaries:
+		if(this.type.type instanceof DefinitionTypeID && other instanceof DefinitionTypeID) {
+			DefinitionTypeID thisTypeId = (DefinitionTypeID) this.type.type;
+			DefinitionTypeID otherTypeId = (DefinitionTypeID) other;
+
+			if(thisTypeId.definition != otherTypeId.definition){
+				break checkBoundaries;
+			}
+
+			if(thisTypeId.definition.typeParameters.length != otherTypeId.typeArguments.length){
+				break checkBoundaries;
+			}
+
+			for (int i = 0; i < thisTypeId.definition.typeParameters.length; i++) {
+				final TypeID type = otherTypeId.typeArguments[i].type;
+				if (type == BasicTypeID.UNDETERMINED) {
+					continue;
+				}
+				if (type instanceof InvalidTypeID && ((InvalidTypeID) type).code == CompileExceptionCode.TYPE_ARGUMENTS_NOT_INFERRABLE) {
+					continue;
+				}
+				if (thisTypeId.definition.typeParameters[i].matches(cache, type)) {
+					continue;
+				}
+				break checkBoundaries;
+			}
+			return true;
+		}
+
+
 		TypeID superType = type.type.getSuperType(cache.getRegistry());
 		if (superType != null) {
 			if (superType == other)
    
 		if( getImplicitCaster(toType) != null || extendsOrImplements(toType.type))
 		    return true;
-		
+
+		if(type.type.isGeneric() && type.type instanceof GenericTypeID) {
+			final GenericTypeID genericTypeID = (GenericTypeID) type.type;
+			if(genericTypeID.parameter.matches(cache, toType.type)) {
+				return true;
+			}
+		}
+
+
         final StoredType accept = type.type.accept(new TagRemovingTypeVisitor(cache));
+
         if(!this.type.type.equals(accept.type) && cache.get(accept).canCastImplicit(toType)){
             return true;
         }

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

 			directory.mkdirs();
 
 		for (Map.Entry<String, byte[]> classEntry : classes.entrySet()) {
-			File output = new File(directory, classEntry.getKey() + ".class");
+			File output = new File(directory, classEntry.getKey().replace('.', File.separatorChar) + ".class");
+			if (!output.getParentFile().exists() && !output.getParentFile().mkdirs()) {
+				//Throw error?
+				continue;
+			}
 			try (FileOutputStream outputStream = new FileOutputStream(output)) {
 				outputStream.write(classEntry.getValue());
 			} catch (IOException ex) {

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

 		context.addModule(module.module, target);
 		
 		for (HighLevelDefinition definition : module.definitions.getAll()) {
-			String filename = getFilename(definition) + "_" + (definition.name == null ? "generated" : definition.name) + "_" + expansionCounter++;
-			JavaPrepareDefinitionVisitor definitionPreparer = new JavaPrepareDefinitionVisitor(context, target, filename, null);
+			final String className = getFilename(definition);
+			String filename = className + "_" + (definition.name == null ? "generated" : definition.name) + "_" + expansionCounter++;
+			JavaPrepareDefinitionVisitor definitionPreparer = new JavaPrepareDefinitionVisitor(context, target, filename, null, className);
 			definition.accept(definitionPreparer);
 		}
 		

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

     private final JavaBoxingTypeVisitor boxingTypeVisitor;
     private final JavaUnboxingTypeVisitor unboxingTypeVisitor;
     private final JavaCapturedExpressionVisitor capturedExpressionVisitor = new JavaCapturedExpressionVisitor(this);
-    private final JavaBytecodeContext context;
-    private final JavaCompiledModule module;
+    final JavaBytecodeContext context;
+    final JavaCompiledModule module;
 
 	public JavaExpressionVisitor(JavaBytecodeContext context, JavaCompiledModule module, JavaWriter javaWriter) {
 		this.javaWriter = javaWriter;
 		final String signature;
 		final String[] interfaces;
 		final String className = context.getLambdaCounter();
+		final String descriptor;
 		
 		{//Fill the info above
 			final StorageTag actualStorage = expression.type.getActualStorage();
 				
 				//Should be the same, should it not?
 				signature = context.getMethodSignature(expression.header);
+				descriptor = context.getMethodDescriptor(expression.header);
 				interfaces = new String[]{Type.getInternalName(functionalInterfaceMethod.getDeclaringClass())};
 			} else {
 				//Normal way, no casting to functional interface
 				signature = context.getMethodSignature(expression.header);
+				descriptor = context.getMethodDescriptor(expression.header);
 				interfaces = new String[]{context.getInternalName(new FunctionTypeID(null, expression.header).stored(UniqueStorageTag.INSTANCE))};
 			}
 		}
 		final JavaWriter functionWriter;
 		
 		//Bridge method!!!
-		if (!Objects.equals(methodInfo.descriptor, signature)) {
+		if (!Objects.equals(methodInfo.descriptor, descriptor)) {
 			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 JavaMethod actualMethod = new JavaMethod(methodInfo.cls, methodInfo.kind, methodInfo.name, methodInfo.compile, signature, methodInfo.modifiers, methodInfo.genericResult, methodInfo.typeParameterArguments);
+			final JavaMethod actualMethod = new JavaMethod(methodInfo.cls, methodInfo.kind, methodInfo.name, methodInfo.compile, context.getMethodDescriptor(expression.header), methodInfo.modifiers, methodInfo.genericResult, methodInfo.typeParameterArguments);
 			//No @Override
 			functionWriter = new JavaWriter(expression.position, lambdaCW, actualMethod, null, signature, null);
 		} else {
 		final JavaStatementVisitor CSV = new JavaStatementVisitor(context, new JavaExpressionVisitor(context, module, functionWriter) {
 			@Override
 			public Void visitGetLocalVariable(GetLocalVariableExpression varExpression) {
+				final JavaLocalVariableInfo localVariable = functionWriter.tryGetLocalVariable(varExpression.variable.variable);
+				if(localVariable != null) {
+					final Label label = new Label();
+					localVariable.end = label;
+					functionWriter.label(label);
+					functionWriter.load(localVariable);
+					return null;
+				}
+
+
+
 				final int position = calculateMemberPosition(varExpression, expression);
 				functionWriter.loadObject(0);
 				functionWriter.getField(className, "captured" + position, context.getDescriptor(varExpression.variable.type));

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

 public class JavaStatementVisitor implements StatementVisitor<Boolean> {
     private final JavaWriter javaWriter;
 	final JavaBytecodeContext context;
-    public JavaExpressionVisitor expressionVisitor;
-	public JavaNonPushingExpressionVisitor nonPushingExpressionVisitor;
+    public final JavaExpressionVisitor expressionVisitor;
+	public final JavaNonPushingExpressionVisitor nonPushingExpressionVisitor;
 
     /**
      * @param javaWriter the method writer that compiles the statement
         this.javaWriter = javaWriter;
 		this.context = context;
         this.expressionVisitor = new JavaExpressionVisitor(context, module, javaWriter);
-		nonPushingExpressionVisitor = new JavaNonPushingExpressionVisitor(context, module, javaWriter, expressionVisitor);
+		this.nonPushingExpressionVisitor = new JavaNonPushingExpressionVisitor(context, module, javaWriter, expressionVisitor);
     }
 
     public JavaStatementVisitor(JavaBytecodeContext context, JavaExpressionVisitor expressionVisitor) {
         this.javaWriter = expressionVisitor.getJavaWriter();
 		this.context = context;
         this.expressionVisitor = expressionVisitor;
+		this.nonPushingExpressionVisitor = new JavaNonPushingExpressionVisitor(expressionVisitor.context, expressionVisitor.module, expressionVisitor.javaWriter, expressionVisitor);
     }
 
 	@Override
 	@Override
 	public Boolean visitReturn(ReturnStatement statement) {
     	javaWriter.position(statement.position.fromLine);
-		statement.value.accept(expressionVisitor);
-		javaWriter.returnType(context.getType(statement.value.type));
+    	if(statement.value == null) {
+    		javaWriter.ret();
+		} else {
+			statement.value.accept(expressionVisitor);
+			javaWriter.returnType(context.getType(statement.value.type));
+		}
+
 		return true;
 	}
 

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

 import org.openzen.zenscript.javashared.JavaMethod;
 import org.openzen.zenscript.javashared.JavaParameterInfo;
 
+import javax.lang.model.element.VariableElement;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 	public void setLocalVariable(VariableID variable, JavaLocalVariableInfo info) {
 		localVariables.put(variable, info);
 	}
-	
+
+	public JavaLocalVariableInfo tryGetLocalVariable(VariableID variable) {
+		return localVariables.get(variable);
+	}
+
 	public JavaLocalVariableInfo getLocalVariable(VariableID variable) {
-		JavaLocalVariableInfo result = localVariables.get(variable);
+		JavaLocalVariableInfo result = tryGetLocalVariable(variable);
 		if (result == null)
 			throw new IllegalStateException("Local variable unknown");
 		

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

 import org.openzen.zencode.shared.LiteralSourceFile;
 import org.openzen.zenscript.codemodel.*;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
+import org.openzen.zenscript.codemodel.annotations.DefinitionAnnotation;
+import org.openzen.zenscript.codemodel.annotations.NativeDefinitionAnnotation;
 import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.context.FileResolutionContext;
 import org.openzen.zenscript.codemodel.context.ModuleTypeResolutionContext;
-import org.openzen.zenscript.codemodel.definition.ClassDefinition;
-import org.openzen.zenscript.codemodel.definition.EnumDefinition;
-import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
-import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
-import org.openzen.zenscript.codemodel.definition.StructDefinition;
-import org.openzen.zenscript.codemodel.definition.ZSPackage;
-import org.openzen.zenscript.codemodel.expression.ConstantByteExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantDoubleExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantFloatExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantIntExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantLongExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantSByteExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantShortExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantStringExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantUIntExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantULongExpression;
-import org.openzen.zenscript.codemodel.expression.ConstantUShortExpression;
-import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.expression.ExpressionSymbol;
-import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
-import org.openzen.zenscript.codemodel.expression.StorageCastExpression;
+import org.openzen.zenscript.codemodel.definition.*;
+import org.openzen.zenscript.codemodel.expression.*;
 import org.openzen.zenscript.codemodel.generic.ParameterTypeBound;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
-import org.openzen.zenscript.codemodel.member.CasterMember;
-import org.openzen.zenscript.codemodel.member.ConstructorMember;
-import org.openzen.zenscript.codemodel.member.FieldMember;
-import org.openzen.zenscript.codemodel.member.GetterMember;
-import org.openzen.zenscript.codemodel.member.ImplementationMember;
-import org.openzen.zenscript.codemodel.member.MethodMember;
-import org.openzen.zenscript.codemodel.member.OperatorMember;
-import org.openzen.zenscript.codemodel.member.SetterMember;
+import org.openzen.zenscript.codemodel.member.*;
 import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.partial.PartialStaticMemberGroupExpression;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
 import org.openzen.zenscript.codemodel.type.storage.StorageTag;
 import org.openzen.zenscript.codemodel.type.storage.StorageType;
 import org.openzen.zenscript.javashared.*;
-import org.openzen.zenscript.lexer.*;
+import org.openzen.zenscript.lexer.ParseException;
+import org.openzen.zenscript.lexer.ZSTokenParser;
 import org.openzen.zenscript.parser.BracketExpressionParser;
 import org.openzen.zenscript.parser.expression.ParsedExpression;
 import org.openzen.zenscript.parser.type.IParsedType;
 	private final GlobalTypeRegistry registry;
 	private final PackageDefinitions definitions = new PackageDefinitions();
 	private final JavaCompiledModule compiled;
-	
+
 	private final Map<Class<?>, HighLevelDefinition> definitionByClass = new HashMap<>();
 	private final Map<Class<?>, TypeID> typeByClass = new HashMap<>();
 	private final Map<Class<?>, TypeID> unsignedByClass = new HashMap<>();
-	
+	private final TypeVariableContext context = new TypeVariableContext();
+
 	public final Map<String, ISymbol> globals = new HashMap<>();
 	private BracketExpressionParser bep;
 
 		this.basePackage = basePackage;
 		module = new Module(name);
 		this.registry = registry;
-		
+
 		for (JavaNativeModule dependency : dependencies) {
 			definitionByClass.putAll(dependency.definitionByClass);
 		}
-		
+
 		compiled = new JavaCompiledModule(module, FunctionParameter.NONE);
-		
+
 		typeByClass.put(void.class, BasicTypeID.VOID);
 		typeByClass.put(boolean.class, BasicTypeID.BOOL);
 		typeByClass.put(byte.class, BasicTypeID.SBYTE);
 		typeByClass.put(Long.class, registry.getOptional(BasicTypeID.LONG));
 		typeByClass.put(Float.class, registry.getOptional(BasicTypeID.FLOAT));
 		typeByClass.put(Double.class, registry.getOptional(BasicTypeID.DOUBLE));
-		
+
 		unsignedByClass.put(byte.class, BasicTypeID.BYTE);
 		unsignedByClass.put(short.class, BasicTypeID.USHORT);
 		unsignedByClass.put(int.class, BasicTypeID.UINT);
 		unsignedByClass.put(Integer.class, registry.getOptional(BasicTypeID.INT));
 		unsignedByClass.put(Long.class, registry.getOptional(BasicTypeID.LONG));
 	}
-	
+
 	public SemanticModule toSemantic(ModuleSpace space) {
 		return new SemanticModule(
 				module,
 				space.getAnnotations(),
 				space.getStorageTypes());
 	}
-	
+
 	public JavaCompiledModule getCompiled() {
 		return compiled;
 	}
-	
+
 	public HighLevelDefinition addClass(Class<?> cls) {
-		if (definitionByClass.containsKey(cls))
+		if (definitionByClass.containsKey(cls)) {
 			return definitionByClass.get(cls);
-        
+		}
         return convertClass(cls);
 	}
-	
+
 	public void addGlobals(Class<?> cls) {
 		HighLevelDefinition definition = new ClassDefinition(CodePosition.NATIVE, module, pkg, "__globals__", Modifiers.PUBLIC);
 		JavaClass jcls = JavaClass.fromInternalName(getInternalName(cls), JavaClass.Kind.CLASS);
 		compiled.setClassInfo(definition, jcls);
 		StoredType thisType = registry.getForMyDefinition(definition).stored();
-		TypeVariableContext context = new TypeVariableContext();
-		
+		//TypeVariableContext context = new TypeVariableContext();
+
 		for (Field field : cls.getDeclaredFields()) {
 			if (!field.isAnnotationPresent(ZenCodeGlobals.Global.class))
 				continue;
 			if (!isStatic(field.getModifiers()))
 				continue;
-			
+
 			ZenCodeGlobals.Global global = field.getAnnotation(ZenCodeGlobals.Global.class);
 			StoredType type = loadStoredType(context, field.getAnnotatedType());
 			String name = global.value().isEmpty() ? field.getName() : global.value();
 			compiled.setFieldInfo(fieldMember.autoGetter, javaField);
 			globals.put(name, new ExpressionSymbol((position, scope) -> new StaticGetterExpression(CodePosition.BUILTIN, fieldMember.autoGetter.ref(thisType, GenericMapper.EMPTY))));
 		}
-		
+
 		for (Method method : cls.getDeclaredMethods()) {
 			if (!method.isAnnotationPresent(ZenCodeGlobals.Global.class))
 				continue;
 			if (!isStatic(method.getModifiers()))
 				continue;
-			
+
 			ZenCodeGlobals.Global global = method.getAnnotation(ZenCodeGlobals.Global.class);
 			String name = global.value().isEmpty() ? method.getName() : global.value();
 			MethodMember methodMember = new MethodMember(CodePosition.NATIVE, definition, Modifiers.PUBLIC | Modifiers.STATIC, name, getHeader(context, method), null);
 			definition.addMember(methodMember);
-			
+
 			boolean isGenericResult = methodMember.header.getReturnType().isGeneric();
 			compiled.setMethodInfo(methodMember, new JavaMethod(jcls, JavaMethod.Kind.STATIC, method.getName(), false, getMethodDescriptor(method), method.getModifiers(), isGenericResult));
 			globals.put(name, new ExpressionSymbol((position, scope) -> {
 			}));
 		}
 	}
-	
+
 	public FunctionalMemberRef loadStaticMethod(Method method) {
 		if (!isStatic(method.getModifiers()))
 			throw new IllegalArgumentException("Method \"" + method.toString() + "\" is not static");
-		
+
 		HighLevelDefinition definition = addClass(method.getDeclaringClass());
 		JavaClass jcls = JavaClass.fromInternalName(getInternalName(method.getDeclaringClass()), JavaClass.Kind.CLASS);
-		
-		TypeVariableContext context = new TypeVariableContext();
+
+		//TypeVariableContext context = new TypeVariableContext();
 		MethodMember methodMember = new MethodMember(CodePosition.NATIVE, definition, Modifiers.PUBLIC | Modifiers.STATIC, method.getName(), getHeader(context, method), null);
 		definition.addMember(methodMember);
 		boolean isGenericResult = methodMember.header.getReturnType().isGeneric();
 	private boolean isInBasePackage(String className) {
 		return className.startsWith(basePackage + ".");
 	}
-	
+
 	private ZSPackage getPackage(String className) {
 		//TODO validate
 		if(this.basePackage == null || this.basePackage.isEmpty())
 		//TODO make a lang package?
 		if (!className.contains(".") || className.startsWith("java.lang"))
 			return pkg;
-		
+
 		if (className.startsWith("."))
 			className = className.substring(1);
 		else if (className.startsWith(basePackage + "."))
 			className = className.substring(basePackage.length() + 1);
 		else
             throw new IllegalArgumentException("Invalid class name: \"" + className + "\" not in the given base package: \"" + basePackage + "\"");
-		
+
 		String[] classNameParts = Strings.split(className, '.');
 		ZSPackage classPkg = pkg;
 		for (int i = 0; i < classNameParts.length - 1; i++)
 			classPkg = classPkg.getOrCreatePackage(classNameParts[i]);
-		
+
 		return classPkg;
 	}
-	
+
+	private <T> HighLevelDefinition checkRegistry(Class<T> cls) {
+		String name = cls.getCanonicalName();
+		if (!name.startsWith("java.lang.") && !name.startsWith("java.util.")) {
+			return null;
+		}
+
+		name = name.substring("java.lang.".length());
+		for (DefinitionTypeID definition : registry.getDefinitions()) {
+			final HighLevelDefinition highLevelDefinition = definition.definition;
+			for (DefinitionAnnotation annotation : highLevelDefinition.annotations) {
+				if (annotation instanceof NativeDefinitionAnnotation) {
+					final String identifier = ((NativeDefinitionAnnotation) annotation).getIdentifier();
+					if (identifier.equals(name) || identifier.equals("stdlib::" + name)) {
+						return highLevelDefinition;
+					}
+				}
+			}
+		}
+
+		return null;
+	}
+
 	private <T> HighLevelDefinition convertClass(Class<T> cls) {
 		if ((cls.getModifiers() & Modifier.PUBLIC) == 0)
 			throw new IllegalArgumentException("Class \" " + cls.getName() + "\" must be public");
 
 		String className = cls.getName();
         boolean isStruct = cls.isAnnotationPresent(ZenCodeType.Struct.class);
-        
-        ZSPackage classPkg;
-        ZenCodeType.Name nameAnnotation = cls.getDeclaredAnnotation(ZenCodeType.Name.class);
-		className = className.contains(".") ? className.substring(className.lastIndexOf('.') + 1) : className;
-        if (nameAnnotation == null) {
-            classPkg = getPackage(className);
-        } else {
-            String specifiedName = nameAnnotation.value();
-			if (specifiedName.startsWith(".")) {
-				classPkg = getPackage(specifiedName);
-				className = specifiedName.substring(specifiedName.lastIndexOf('.') + 1);
-			} else if (specifiedName.indexOf('.') >= 0) {
-				if (!specifiedName.startsWith(pkg.fullName))
-					throw new IllegalArgumentException("Specified @Name as \"" + specifiedName + "\" for class: \"" + cls.toString() + "\" but it's not in the module root package: \"" + pkg.fullName + "\"");
-
-				classPkg = getPackage(basePackage + specifiedName.substring(pkg.fullName.length()));
-				className = specifiedName.substring(specifiedName.lastIndexOf('.') + 1);
-			} else {
-                classPkg = getPackage(specifiedName);
-                className = nameAnnotation.value();
-			}
-		}
 
-
-		
-		HighLevelDefinition definition;
+		HighLevelDefinition definition = checkRegistry(cls);
+		final boolean foundRegistry = definition != null;
 		String internalName = getInternalName(cls);
 		JavaClass javaClass;
-		if (cls.isInterface()) {
-			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, classPkg, className, Modifiers.PUBLIC, null);
-			javaClass = JavaClass.fromInternalName(internalName, JavaClass.Kind.ENUM);
-		} else if (isStruct) {
-			definition = new StructDefinition(CodePosition.NATIVE, module, classPkg, className, Modifiers.PUBLIC, null);
-			javaClass = JavaClass.fromInternalName(internalName, JavaClass.Kind.CLASS);
+
+		if (foundRegistry) {
+			javaClass = JavaClass.fromInternalName(internalName, definition.isInterface() ? JavaClass.Kind.INTERFACE : JavaClass.Kind.CLASS);
 		} else {
-			definition = new ClassDefinition(CodePosition.NATIVE, module, classPkg, className, Modifiers.PUBLIC);
-			javaClass = JavaClass.fromInternalName(internalName, JavaClass.Kind.CLASS);
+			ZSPackage classPkg;
+			ZenCodeType.Name nameAnnotation = cls.getDeclaredAnnotation(ZenCodeType.Name.class);
+			className = className.contains(".") ? className.substring(className.lastIndexOf('.') + 1) : className;
+			if (nameAnnotation == null) {
+				classPkg = getPackage(className);
+			} else {
+				String specifiedName = nameAnnotation.value();
+				if (specifiedName.startsWith(".")) {
+					classPkg = getPackage(specifiedName);
+					className = specifiedName.substring(specifiedName.lastIndexOf('.') + 1);
+				} else if (specifiedName.indexOf('.') >= 0) {
+					if (!specifiedName.startsWith(pkg.fullName))
+						throw new IllegalArgumentException("Specified @Name as \"" + specifiedName + "\" for class: \"" + cls
+								.toString() + "\" but it's not in the module root package");
+
+					classPkg = getPackage(basePackage + specifiedName.substring(pkg.fullName.length()));
+					className = specifiedName.substring(specifiedName.lastIndexOf('.') + 1);
+				} else {
+					classPkg = getPackage(specifiedName);
+					className = nameAnnotation.value();
+				}
+			}
 
+
+			if (cls.isInterface()) {
+				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, classPkg, className, Modifiers.PUBLIC, null);
+				javaClass = JavaClass.fromInternalName(internalName, JavaClass.Kind.ENUM);
+			} else if (isStruct) {
+				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);
+				javaClass = JavaClass.fromInternalName(internalName, JavaClass.Kind.CLASS);
+
+			}
 		}
 
 		//Moved up here so that circular dependencies are caught (hopefully)
 		definitionByClass.put(cls, definition);
 
-		TypeVariableContext context = new TypeVariableContext();
+		//TypeVariableContext context = new TypeVariableContext();
 		TypeVariable<Class<T>>[] javaTypeParameters = cls.getTypeParameters();
-        definition.typeParameters = new TypeParameter[cls.getTypeParameters().length];
+		TypeParameter[] typeParameters = new TypeParameter[cls.getTypeParameters().length];
+		definition.typeParameters = typeParameters;
+
 		for (int i = 0; i < javaTypeParameters.length; i++) {
+			//Put up here for nested parameters?
 			TypeVariable<Class<T>> typeVariable = javaTypeParameters[i];
 			TypeParameter parameter = new TypeParameter(CodePosition.NATIVE, typeVariable.getName());
+			typeParameters[i] = parameter;
+			context.put(typeVariable, parameter);
+		}
+
+		for (int i = 0; i < javaTypeParameters.length; i++) {
+			TypeVariable<Class<T>> typeVariable = javaTypeParameters[i];
+			TypeParameter parameter = typeParameters[i];
 			for (AnnotatedType bound : typeVariable.getAnnotatedBounds()) {
 				TypeID type = loadType(context, bound).type;
 				parameter.addBound(new ParameterTypeBound(CodePosition.NATIVE, type));
 			}
-            definition.typeParameters[i] = parameter;
-			context.put(typeVariable, parameter);
+			typeParameters[i] = parameter;
 		}
-  
-		if (definition instanceof ClassDefinition && cls.getAnnotatedSuperclass() != null && shouldLoadType(cls.getAnnotatedSuperclass().getType())) {
+
+		if (!foundRegistry && definition instanceof ClassDefinition && cls.getAnnotatedSuperclass() != null && shouldLoadType(cls.getAnnotatedSuperclass().getType())) {
 			definition.setSuperType(loadType(context, cls.getAnnotatedSuperclass()).type);
 		}
 
-		if (definition.getSuperType() == null && cls != Object.class) {
+		if (!foundRegistry && definition.getSuperType() == null && cls != Object.class) {
 			definition.setSuperType(loadType(context, Object.class, false, false).type);
 		}
 
 				compiled.setImplementationInfo(member, new JavaImplementation(true, javaClass));
 			}
 		}
-		
-		
+
 		compiled.setClassInfo(definition, javaClass);
-		
+
 		StoredType thisType = new StoredType(registry.getForMyDefinition(definition), AutoStorageTag.INSTANCE);
 		for (Field field : cls.getDeclaredFields()) {
 			ZenCodeType.Field annotation = field.getAnnotation(ZenCodeType.Field.class);
 				continue;
 			if (!isPublic(field.getModifiers()))
 				continue;
-			
+
 			final String fieldName = annotation.value().isEmpty() ? field.getName() : annotation.value();
-			
+
 			StoredType fieldType = loadStoredType(context, field.getAnnotatedType());
 			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())));
 		}
-		
+
 		boolean hasConstructor = false;
-		for (java.lang.reflect.Constructor constructor : cls.getConstructors()) {
+		for (java.lang.reflect.Constructor<?> constructor : cls.getConstructors()) {
 			ZenCodeType.Constructor constructorAnnotation = (ZenCodeType.Constructor) constructor.getAnnotation(ZenCodeType.Constructor.class);
 			if (constructorAnnotation != null) {
 				ConstructorMember member = asConstructor(context, definition, constructor);
 				hasConstructor = true;
 			}
 		}
-		
-		if (!hasConstructor) {
+
+		if (!hasConstructor && !foundRegistry) {
 			// no constructor! make a private constructor so the compiler doesn't add one
 			ConstructorMember member = new ConstructorMember(CodePosition.BUILTIN, definition, Modifiers.PRIVATE, new FunctionHeader(BasicTypeID.VOID), BuiltinID.CLASS_DEFAULT_CONSTRUCTOR);
 			definition.addMember(member);
 		}
-		
+
 		for (Method method : cls.getDeclaredMethods()) {
 			ZenCodeType.Method methodAnnotation = method.getAnnotation(ZenCodeType.Method.class);
 			if (methodAnnotation != null) {
 				compiled.setMethodInfo(member, getMethod(javaClass, method, member.header.getReturnType()));
 				continue;
 			}
-			
+
 			ZenCodeType.Getter getter = method.getAnnotation(ZenCodeType.Getter.class);
 			if (getter != null) {
 				GetterMember member = asGetter(context, definition, method, getter);
 				definition.addMember(member);
 				compiled.setMethodInfo(member, getMethod(javaClass, method, member.getType()));
 			}
-			
+
 			ZenCodeType.Setter setter = method.getAnnotation(ZenCodeType.Setter.class);
 			if (setter != null) {
 				SetterMember member = asSetter(context, definition, method, setter);
 				definition.addMember(member);
 				compiled.setMethodInfo(member, getMethod(javaClass, method, BasicTypeID.VOID.stored));
 			}
-			
+
 			ZenCodeType.Operator operator = method.getAnnotation(ZenCodeType.Operator.class);
 			if (operator != null) {
 				OperatorMember member = asOperator(context, definition, method, operator);
 				definition.addMember(member);
 				compiled.setMethodInfo(member, getMethod(javaClass, method, member.header.getReturnType()));
 			}
-			
+
 			ZenCodeType.Caster caster = method.getAnnotation(ZenCodeType.Caster.class);
 			if (caster != null) {
 				CasterMember member = asCaster(context, definition, method, caster);
 				definition.addMember(member);
 				compiled.setMethodInfo(member, getMethod(javaClass, method, member.toType));
 			}
-			
+
 			/*if (!annotated) {
 				MethodMember member = asMethod(definition, method, null);
 				definition.addMember(member);
 				compiled.setMethodInfo(member, getMethod(javaClass, method, member.header.getReturnType()));
 			}*/
 		}
-		
+
 		return definition;
 	}
 
             if(methodAnnotation != null) {
                 String name = !methodAnnotation.value().isEmpty() ? methodAnnotation.value() : method.getName();
 
-                TypeVariableContext context = new TypeVariableContext();
+                //TypeVariableContext context = new TypeVariableContext();
 
                 final Parameter[] parameters = getExpansionParameters(method);
 
                 if (implicit) {
                     modifiers |= Modifiers.IMPLICIT;
                 }
-                TypeVariableContext context = new TypeVariableContext();
+                //TypeVariableContext context = new TypeVariableContext();
                 StoredType toType = loadStoredType(context, method.getAnnotatedReturnType());
                 final CasterMember member = new CasterMember(CodePosition.NATIVE, expansion, modifiers, toType,  null);
 
 		return null;
 	}
 
-	
+
 	private boolean shouldLoadType(Type type) {
 		if (type instanceof Class)
 			return definitionByClass.containsKey(type) || shouldLoadClass((Class<?>)type);
 		if (type instanceof ParameterizedType)
 			return shouldLoadType(((ParameterizedType)type).getRawType());
-		
+
 		return false;
 	}
-	
+
 	private String getClassName(Class<?> cls) {
 	    return cls.isAnnotationPresent(ZenCodeType.Name.class) ? cls.getAnnotation(ZenCodeType.Name.class).value() : cls.getName();
     }
 	private boolean shouldLoadClass(Class<?> cls) {
 	    return isInBasePackage(getClassName(cls));
     }
-	
+
 	private boolean isGetterName(String name) {
 		return name.startsWith("get") || name.startsWith("is") || name.startsWith("has");
 	}
-	
+
 	private String translateGetterName(String name) {
 		if (name.startsWith("get"))
 			return name.substring(3, 4).toLowerCase() + name.substring(4);
-		
+
 		return name;
 	}
-	
+
 	private String translateSetterName(String name) {
 		if (name.startsWith("set"))
 			return name.substring(3, 4).toLowerCase() + name.substring(4);
-		
+
 		return name;
 	}
-	
+
 	private ConstructorMember asConstructor(TypeVariableContext context, HighLevelDefinition definition, java.lang.reflect.Constructor method) {
 		FunctionHeader header = getHeader(context, method);
 		return new ConstructorMember(
 				header,
 				null);
 	}
-	
+
 	private MethodMember asMethod(TypeVariableContext context, HighLevelDefinition definition, Method method, ZenCodeType.Method annotation) {
 		String name = annotation != null && !annotation.value().isEmpty() ? annotation.value() : method.getName();
 		FunctionHeader header = getHeader(context, method);
 				header,
 				null);
 	}
-	
+
 	private OperatorMember asOperator(TypeVariableContext context, HighLevelDefinition definition, Method method, ZenCodeType.Operator annotation) {
 		FunctionHeader header = getHeader(context, method);
 		if (isStatic(method.getModifiers()))
 			throw new IllegalArgumentException("operator method \"" + method.toString() + "\"cannot be static");
-		
+
 		// TODO: check number of parameters
 		//if (header.parameters.length != annotation.value().parameters)
-		
+
 		return new OperatorMember(
 				CodePosition.NATIVE,
 				definition,
 				header,
 				null);
 	}
-	
+
 	private GetterMember asGetter(TypeVariableContext context, HighLevelDefinition definition, Method method, ZenCodeType.Getter annotation) {
 		StoredType type = loadStoredType(context, method.getAnnotatedReturnType());
 		String name = null;
 			name = annotation.value();
 		if (name == null)
 			name = translateGetterName(method.getName());
-		
+
 		return new GetterMember(CodePosition.NATIVE, definition, getMethodModifiers(method), name, type, null);
 	}
-	
+
 	private SetterMember asSetter(TypeVariableContext context, HighLevelDefinition definition, Method method, ZenCodeType.Setter annotation) {
 		if (method.getParameterCount() != 1)
 			throw new IllegalArgumentException("Illegal setter: \"" + method.toString() + "\"must have exactly 1 parameter");
-		
+
 		StoredType type = loadStoredType(context, method.getAnnotatedParameterTypes()[0]);
 		String name = null;
 		if (annotation != null && !annotation.value().isEmpty())
 			name = annotation.value();
 		if (name == null)
 			name = translateSetterName(method.getName());
-		
+
 		return new SetterMember(CodePosition.NATIVE, definition, getMethodModifiers(method), name, type, null);
 	}
-	
+
 	private CasterMember asCaster(TypeVariableContext context, HighLevelDefinition definition, Method method, ZenCodeType.Caster annotation) {
 		boolean implicit = annotation != null && annotation.implicit();
 		int modifiers = Modifiers.PUBLIC;
 		if (implicit)
 			modifiers |= Modifiers.IMPLICIT;
-		
+
 		StoredType toType = loadStoredType(context, method.getAnnotatedReturnType());
 		return new CasterMember(CodePosition.NATIVE, definition, modifiers, toType, null);
 	}
-	
+
 	private FunctionHeader getHeader(TypeVariableContext context, java.lang.reflect.Constructor constructor) {
 		return getHeader(
 				context,
 				constructor.getTypeParameters(),
 				constructor.getAnnotatedExceptionTypes());
 	}
-	
+
 	private FunctionHeader getHeader(TypeVariableContext context, Method method) {
 		return getHeader(
 				context,
 				method.getTypeParameters(),
 				method.getAnnotatedExceptionTypes());
 	}
-	
+
 	protected Expression getDefaultValue(Parameter parameter, StoredType type) {
 		if (parameter.isAnnotationPresent(ZenCodeType.Optional.class)) {
 				final String s = parameter.getAnnotation(ZenCodeType.Optional.class).value();
 			TypeVariable<Method>[] javaTypeParameters,
 			AnnotatedType[] exceptionTypes) {
 		StoredType returnType = javaReturnType == null ? BasicTypeID.VOID.stored : loadStoredType(context, javaReturnType);
-		
+
+
+		TypeParameter[] typeParameters = new TypeParameter[javaTypeParameters.length];
+		for (int i = 0; i < javaTypeParameters.length; i++) {
+			//Put up here for nested parameters?
+			TypeVariable<Method> typeVariable = javaTypeParameters[i];
+			TypeParameter parameter = new TypeParameter(CodePosition.NATIVE, typeVariable.getName());
+			typeParameters[i] = parameter;
+			context.put(typeVariable, parameter);
+		}
+
+		for (int i = 0; i < javaTypeParameters.length; i++) {
+			TypeVariable<Method> javaTypeParameter = javaTypeParameters[i];
+
+			for (AnnotatedType bound : javaTypeParameter.getAnnotatedBounds())
+				typeParameters[i].addBound(new ParameterTypeBound(CodePosition.NATIVE, loadType(context, bound).type));
+		}
+
 		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);
+ 			StoredType type = loadStoredType(context, parameter);
 			Expression defaultValue = getDefaultValue(parameter, type);
 			parameters[i] = new FunctionParameter(type, parameter.getName(), defaultValue, parameter.isVarArgs());
 		}
-		
-		TypeParameter[] typeParameters = new TypeParameter[javaTypeParameters.length];
-		for (int i = 0; i < javaTypeParameters.length; i++) {
-			TypeVariable<Method> javaTypeParameter = javaTypeParameters[i];
-			typeParameters[i] = new TypeParameter(CodePosition.UNKNOWN, javaTypeParameter.getName());
-			context.put(javaTypeParameter, typeParameters[i]);
-			
-			for (AnnotatedType bound : javaTypeParameter.getAnnotatedBounds())
-				typeParameters[i].addBound(new ParameterTypeBound(CodePosition.NATIVE, loadType(context, bound).type));
-		}
-		
+
 		if (exceptionTypes.length > 1)
 			throw new IllegalArgumentException("A method can only throw a single exception type!");
-		
+
 		StoredType thrownType = exceptionTypes.length == 0 ? null : loadStoredType(context, exceptionTypes[0]);
 		return new FunctionHeader(typeParameters, returnType, thrownType, AutoStorageTag.INSTANCE, parameters);
 	}
-	
+
 	private StoredType loadStoredType(TypeVariableContext context, AnnotatedType annotatedType) {
 		return loadType(context, annotatedType);
 	}
 			return new StoredType(registry.getOptional(type.type), type.getSpecifiedStorage());
 		return type;
 	}
-	
+
 	private StoredType loadType(TypeVariableContext context, AnnotatedType annotatedType) {
 		if (annotatedType.isAnnotationPresent(ZenCodeType.USize.class))
 			return BasicTypeID.USIZE.stored;
 		else if (annotatedType.isAnnotationPresent(ZenCodeType.NullableUSize.class))
 			return registry.getOptional(BasicTypeID.USIZE).stored();
-		
+
 		boolean nullable = annotatedType.isAnnotationPresent(ZenCodeType.Nullable.class);
 		boolean unsigned = annotatedType.isAnnotationPresent(ZenCodeType.Unsigned.class);
-		
+
 		return loadType(context, annotatedType, nullable, unsigned);
 	}
-	
+
 	private StoredType loadType(TypeVariableContext context, AnnotatedElement type, boolean nullable, boolean unsigned) {
 		StoredType result = loadType(context, type, unsigned);
 		if (nullable)
 			result = new StoredType(registry.getOptional(result.type), result.getSpecifiedStorage());
-		
+
 		return result;
 	}
-	
+
 	@SuppressWarnings("ChainOfInstanceofChecks")
     private StoredType loadType(TypeVariableContext context, AnnotatedElement type, boolean unsigned) {
 		if (type instanceof Class) {
 			} else if (classType.isAnnotationPresent(FunctionalInterface.class)) {
 				return loadFunctionalInterface(context, classType, new AnnotatedElement[0]);
 			}
-			
+
 			if (typeByClass.containsKey(classType))
 				return typeByClass.get(classType).stored();
-			
+
 			HighLevelDefinition definition = addClass(classType);
-			return registry.getForDefinition(definition).stored();
+			final List<StoredType> s = new ArrayList<>();
+			for (TypeVariable<? extends Class<?>> typeParameter : classType.getTypeParameters()) {
+				s.add(registry.getGeneric(context.get(typeParameter)).stored());
+			}
+
+			return registry.getForDefinition(definition, s.toArray(StoredType.NONE)).stored();
 		} else if (type instanceof ParameterizedType) {
 			ParameterizedType parameterizedType = (ParameterizedType) type;
-			Class<?> rawType = (Class) parameterizedType.getRawType();
+			Class<?> rawType = (Class<?>) parameterizedType.getRawType();
 			if (rawType.isAnnotationPresent(FunctionalInterface.class))
 				return loadFunctionalInterface(context, rawType, (AnnotatedElement[]) parameterizedType.getActualTypeArguments());
-			
+
 			Type[] parameters = parameterizedType.getActualTypeArguments();
 			StoredType[] codeParameters = new StoredType[parameters.length];
 			for (int i = 0; i < parameters.length; i++)
 			    codeParameters[i] = loadType(context, (AnnotatedElement) parameters[i], false, false);
-       
+
 			if(rawType == Map.class) {
                 return registry.getAssociative(codeParameters[0], codeParameters[1]).stored();
             }
-            
+
             HighLevelDefinition definition = addClass(rawType);
             return registry.getForDefinition(definition, codeParameters).stored();
-		} else if (type instanceof TypeVariable) {
-            TypeVariable variable = (TypeVariable) type;
+		} else if (type instanceof TypeVariable<?>) {
+            TypeVariable<?> variable = (TypeVariable<?>) type;
             return registry.getGeneric(context.get(variable)).stored();
         }else if(type instanceof AnnotatedType){
-		    final StoredType storedType;
+		    StoredType storedType;
 		    if(type instanceof AnnotatedParameterizedType) {
                 AnnotatedParameterizedType parameterizedType = (AnnotatedParameterizedType) type;
+
                 final Type rawType = ((ParameterizedType) parameterizedType.getType()).getRawType();
                 final AnnotatedType[] actualTypeArguments = parameterizedType.getAnnotatedActualTypeArguments();
                 final StoredType[] codeParameters = new StoredType[actualTypeArguments.length];
                 for(int i = 0; i < actualTypeArguments.length; i++) {
                     codeParameters[i] = loadType(context, actualTypeArguments[i], false, false);
                 }
-            
+
                 if(rawType == Map.class) {
                     storedType = registry.getAssociative(codeParameters[0], codeParameters[1]).stored();
-                } else {
-                    HighLevelDefinition definition = addClass((Class<?>) rawType);
-                    storedType = registry.getForDefinition(definition, codeParameters).stored();
+                } else if(rawType instanceof Class<?>){
+                	final Map<TypeParameter, StoredType> map = new HashMap<>();
+					final TypeVariable<? extends Class<?>>[] typeParameters = ((Class<?>) rawType).getTypeParameters();
+					final StoredType loadType = loadType(context, (AnnotatedElement) rawType, unsigned);
+					for (int i = 0; i < typeParameters.length; i++) {
+						final TypeParameter typeParameter = context.get(typeParameters[i]);
+						map.put(typeParameter, codeParameters[i]);
+					}
+					storedType = loadType.instance(new GenericMapper(CodePosition.NATIVE, registry, map));
+				} else {
+                    storedType = loadType(context, (AnnotatedElement) rawType, unsigned);
                 }
             } else {
-		        storedType = loadType(context, (AnnotatedElement) ((AnnotatedType) type).getType(), unsigned);
+				if (((AnnotatedType) type).getType() instanceof WildcardType) {
+					storedType = BasicTypeID.UNDETERMINED.stored();
+				} else {
+					storedType = loadType(context, (AnnotatedElement) ((AnnotatedType) type).getType(), unsigned);
+				}
             }
-            
+
 		    if(type.isAnnotationPresent(ZenCodeStorageTag.class)) {
 		        //Replace with switch if more StorageTagTypes are added
                 if(type.getAnnotation(ZenCodeStorageTag.class).value() == StorageTagType.STATIC) {
                 }
             }
 		    return storedType;
-		    
+
         } else {
 			throw new IllegalArgumentException("Could not analyze type: " + type);
 		}
 	}
-	
+
 	private StoredType loadFunctionalInterface(TypeVariableContext loadContext, Class<?> cls, AnnotatedElement[] parameters) {
 		Method functionalInterfaceMethod = getFunctionalInterfaceMethod(cls);
 		TypeVariableContext context = convertTypeParameters(cls);
 		FunctionHeader header = getHeader(context, functionalInterfaceMethod);
-		
+
 		Map<TypeParameter, StoredType> mapping = new HashMap<>();
 		TypeVariable[] javaParameters = cls.getTypeParameters();
-		for (int i = 0; i < javaParameters.length; i++)
+		for (int i = 0; i < parameters.length; i++)
 			mapping.put(context.get(javaParameters[i]), loadType(loadContext, parameters[i], false, false));
-		
+
 		JavaMethod method = new JavaMethod(
 				JavaClass.fromInternalName(getInternalName(cls), JavaClass.Kind.INTERFACE),
 				JavaMethod.Kind.INTERFACE,
 		StorageTag tag = new JavaFunctionalInterfaceStorageTag(functionalInterfaceMethod, method);
 		return registry.getFunction(header).stored(tag);
 	}
-	
+
 	private <T> TypeVariableContext convertTypeParameters(Class<T> cls) {
-		TypeVariableContext context = new TypeVariableContext();
+		//TypeVariableContext context = new TypeVariableContext();
 		TypeVariable<Class<T>>[] javaTypeParameters = cls.getTypeParameters();
 		TypeParameter[] typeParameters = new TypeParameter[cls.getTypeParameters().length];
+
 		for (int i = 0; i < javaTypeParameters.length; i++) {
 			TypeVariable<Class<T>> typeVariable = javaTypeParameters[i];
 			TypeParameter parameter = new TypeParameter(CodePosition.NATIVE, typeVariable.getName());
-			for (AnnotatedType bound : typeVariable.getAnnotatedBounds()) {
-				TypeID type = loadType(context, bound).type;
-				parameter.addBound(new ParameterTypeBound(CodePosition.NATIVE, type));
-			}
 			typeParameters[i] = parameter;
+
+			//Put up here so that Nested Type parameters may work..?
 			context.put(typeVariable, parameter);
 		}
+
+		for (int i = 0; i < javaTypeParameters.length; i++) {
+			for (AnnotatedType bound : javaTypeParameters[i].getAnnotatedBounds()) {
+				TypeID type = loadType(context, bound).type;
+				typeParameters[i].addBound(new ParameterTypeBound(CodePosition.NATIVE, type));
+			}
+		}
 		return context;
 	}
-	
+
 	private Method getFunctionalInterfaceMethod(Class<?> functionalInterface) {
 		for (Method method : functionalInterface.getDeclaredMethods()) {
 			if (!method.isDefault())
 				return method;
 		}
-		
+
 		return null;
 	}
-	
+
 	private int getMethodModifiers(Member method) {
 		int result = Modifiers.PUBLIC;
 		if (isStatic(method.getModifiers()))
 			result |= Modifiers.STATIC;
 		if (isFinal(method.getModifiers()))
 			result |= Modifiers.FINAL;
-		
+
 		return result;
 	}
-	
+
 	private static boolean isPublic(int modifiers) {
 		return (modifiers & Modifier.PUBLIC) > 0;
 	}
-	
+
 	private static boolean isStatic(int modifiers) {
 		return (modifiers & Modifier.STATIC) > 0;
 	}
-	
+
 	private static boolean isFinal(int modifiers) {
 		return (modifiers & Modifier.FINAL) > 0;
 	}
-	
+
 	private static String getInternalName(Class<?> cls) {
 		return org.objectweb.asm.Type.getInternalName(cls);
 	}
-	
+
 	private static String getDescriptor(Class<?> cls) {
 		return org.objectweb.asm.Type.getDescriptor(cls);
 	}
-	
+
 	private static String getMethodDescriptor(java.lang.reflect.Constructor constructor) {
 		return org.objectweb.asm.Type.getConstructorDescriptor(constructor);
 	}
-	
+
 	private static String getMethodDescriptor(Method method) {
 		return org.objectweb.asm.Type.getMethodDescriptor(method);
 	}
-	
+
 	private static JavaMethod getMethod(JavaClass cls, java.lang.reflect.Constructor constructor) {
 		return new JavaMethod(
 				cls,
 				constructor.getModifiers(),
 				false);
 	}
-	
+
 	private static JavaMethod getMethod(JavaClass cls, Method method, StoredType result) {
 		JavaMethod.Kind kind;
 		if (method.getName().equals("<init>"))
 			kind = JavaMethod.Kind.STATIC;
 		else
 			kind = JavaMethod.Kind.INSTANCE;
-		
+
 		return new JavaMethod(cls, kind, method.getName(), false, getMethodDescriptor(method), method.getModifiers(), result.isGeneric());
 	}
 
 
 	private static class TypeVariableContext {
 		private final Map<TypeVariable, TypeParameter> typeVariables = new HashMap<>();
-		
+
 		public void put(TypeVariable variable, TypeParameter parameter) {
 			typeVariables.put(variable, parameter);
 		}
-		
+
 		public TypeParameter get(TypeVariable variable) {
 			if (!typeVariables.containsKey(variable))
 				throw new IllegalStateException("Could not find type variable " + variable.getName());
-			
+
 			return typeVariables.get(variable);
 		}
 	}

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

 	
 	public static String getNameFromFile(String filename) {
 		if (filename.indexOf('.') > 0)
-			return filename.substring(0, filename.indexOf('.'));
+			return filename.substring(0, filename.lastIndexOf('.'));
 		else
 			return filename;
 	}

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

 			JavaNativeClass list = new JavaNativeClass(new JavaClass("java.util", "List", JavaClass.Kind.INTERFACE));
 			JavaClass arrayList = new JavaClass("java.util", "ArrayList", JavaClass.Kind.CLASS);
 			list.addMethod("constructor", JavaMethod.getNativeConstructor(arrayList, "()V"));
-			list.addInstanceMethod("add", "add", "(Ljava/lang/Object;)Z"); List<?> l;
+			list.addInstanceMethod("add", "add", "(Ljava/lang/Object;)Z");
 			list.addInstanceMethod("insert", "add", "(Ljava/lang/Object;I)V");
 			list.addInstanceMethod("remove", "remove", "(Ljava/lang/Object;)Z");
 			list.addInstanceMethod("indexOf", "indexOf", "(Ljava/lang/Object;)I");
 	
 	private final JavaContext context;
 	private final String filename;
+	private final String className;
 	private final JavaClass outerClass;
 	private final JavaCompiledModule module;
-	
+
 	public JavaPrepareDefinitionVisitor(JavaContext context, JavaCompiledModule module, String filename, JavaClass outerClass) {
+		this(context, module, filename, outerClass, JavaClass.getNameFromFile(filename));
+	}
+
+	public JavaPrepareDefinitionVisitor(JavaContext context, JavaCompiledModule module, String filename, JavaClass outerClass, String className) {
 		this.context = context;
 		this.filename = filename;
 		this.outerClass = outerClass;
 		this.module = module;
+		this.className = className;
 	}
 	
 	private boolean isPrepared(HighLevelDefinition definition) {
 		if (isPrepared(definition))
 			return context.getJavaClass(definition);
 		
-		JavaClass cls = new JavaClass(context.getPackageName(definition.pkg), JavaClass.getNameFromFile(filename), JavaClass.Kind.CLASS);
+		JavaClass cls = new JavaClass(context.getPackageName(definition.pkg), className, JavaClass.Kind.CLASS);
 		context.setJavaClass(definition, cls);
 		return cls;
 	}
 			context.setJavaNativeClass(definition, nativeClasses.get(nativeTag.value));
 		}
 		
-		JavaClass cls = new JavaClass(context.getPackageName(definition.pkg), JavaClass.getNameFromFile(filename), JavaClass.Kind.CLASS);
+		JavaClass cls = new JavaClass(context.getPackageName(definition.pkg), className, JavaClass.Kind.CLASS);
 		context.setJavaClass(definition, cls);
 		return cls;
 	}

Parser/src/main/java/org/openzen/zenscript/parser/EscapableBracketParser.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.parser;
+
+import org.openzen.zencode.shared.CodePosition;
+import org.openzen.zencode.shared.CompileException;
+import org.openzen.zenscript.codemodel.OperatorType;
+import org.openzen.zenscript.codemodel.expression.CallArguments;
+import org.openzen.zenscript.codemodel.expression.CallStaticExpression;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
+import org.openzen.zenscript.codemodel.partial.IPartialExpression;
+import org.openzen.zenscript.codemodel.scope.ExpressionScope;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.StringTypeID;
+import org.openzen.zenscript.codemodel.type.TypeID;
+import org.openzen.zenscript.lexer.ParseException;
+import org.openzen.zenscript.lexer.ZSToken;
+import org.openzen.zenscript.lexer.ZSTokenParser;
+import org.openzen.zenscript.lexer.ZSTokenType;
+import org.openzen.zenscript.parser.expression.ParsedExpression;
+import org.openzen.zenscript.parser.expression.ParsedExpressionBinary;
+import org.openzen.zenscript.parser.expression.ParsedExpressionString;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author Hoofdgebruiker and kindlich
+ */
+public class EscapableBracketParser implements BracketExpressionParser {
+    private final FunctionalMemberRef method;
+    private final TypeID targetType;
+
+    public EscapableBracketParser(GlobalTypeRegistry registry, FunctionalMemberRef method) {
+        if (!method.isStatic())
+            throw new IllegalArgumentException("Method must be static");
+        if (method.getHeader().getNumberOfTypeParameters() > 0)
+            throw new IllegalArgumentException("Method cannot have type parameters");
+
+        this.method = method;
+        this.targetType = registry.getForDefinition(method.getTarget().definition);
+    }
+
+    @Override
+    public ParsedExpression parse(CodePosition position, ZSTokenParser tokens) throws ParseException {
+        StringBuilder string = new StringBuilder();
+
+        //This list will contain the BEP calls
+        //If this is only a normal BEP, then it will contain exactly one String ParsedExpression.
+        final List<ParsedExpression> expressionList = new ArrayList<>();
+
+        while (tokens.optional(ZSTokenType.T_GREATER) == null) {
+            ZSToken next = tokens.next();
+
+            if (next.type != ZSTokenType.T_DOLLAR) {
+                string.append(next.content);
+                string.append(tokens.getLastWhitespace());
+                continue;
+            }
+
+            //We found a $, now check that it has a { directly after it.
+            final String ws = tokens.getLastWhitespace();
+            if (!ws.isEmpty()) {
+                //$  {..} is not ${..} so we print it as literal
+                string.append(next.content).append(ws);
+                continue;
+            }
+
+            next = tokens.next();
+            //Now we check if it is a {
+            if (next.type == ZSTokenType.T_AOPEN) {
+                if (string.length() != 0) {
+                    expressionList.add(new ParsedExpressionString(position, string.toString(), false));
+                    string = new StringBuilder();
+                }
+                expressionList.add(ParsedExpression.parse(tokens));
+                tokens.required(ZSTokenType.T_ACLOSE, "} expected.");
+                string.append(tokens.getLastWhitespace());
+            } else {
+                //No { after the $, so we treat them both as literal
+                string.append("$").append(ws); //Technically, the whitespace here is empty, but let's be sure
+                string.append(next.content).append(tokens.getLastWhitespace());
+            }
+
+        }
+
+        if (string.length() != 0) {
+            expressionList.add(new ParsedExpressionString(position, string.toString(), false));
+        }
+
+        return new StaticMethodCallExpression(position, expressionList);
+    }
+
+    private class StaticMethodCallExpression extends ParsedExpression {
+
+        private final ParsedExpression call;
+
+        public StaticMethodCallExpression(CodePosition position, List<ParsedExpression> expressions) {
+            super(position);
+            ParsedExpression p = null;
+            for (ParsedExpression expression : expressions) {
+                p = p == null ? expression : new ParsedExpressionBinary(expression.position, p, expression, OperatorType.ADD);
+            }
+
+            this.call = p;
+        }
+
+        @Override
+        public IPartialExpression compile(ExpressionScope scope) throws CompileException {
+            final Expression methodCall = call.compile(scope.withHint(StringTypeID.AUTO)).eval();
+            final CallArguments arguments = new CallArguments(methodCall);
+            return new CallStaticExpression(position, targetType, method, method.getHeader(), arguments);
+        }
+
+        @Override
+        public boolean hasStrongType() {
+            return true;
+        }
+    }
+}

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

 			
 			header.setReturnType(returnType);
 		}
-		
-		if (!scope.genericInferenceMap.isEmpty()) {
+
+
+		if (genericHeader.typeParameters.length > 0 && !scope.genericInferenceMap.isEmpty()) {
 			// perform type parameter inference
 			StoredType returnType = statements.getReturnType();
-			Map<TypeParameter, StoredType> inferredTypes = returnType.type.inferTypeParameters(scope.getMemberCache(), genericHeader.getReturnType());
-			if (inferredTypes == null)
-				throw new CompileException(position, CompileExceptionCode.TYPE_ARGUMENTS_NOT_INFERRABLE, "Could not infer generic type parameters");
-			
-			scope.genericInferenceMap.putAll(inferredTypes);
+			if (returnType != null) {
+				Map<TypeParameter, StoredType> inferredTypes = returnType.type.inferTypeParameters(scope.getMemberCache(), genericHeader
+						.getReturnType());
+				if (inferredTypes == null) {
+					throw new CompileException(position, CompileExceptionCode.TYPE_ARGUMENTS_NOT_INFERRABLE, "Could not infer generic type parameters");
+				}
+
+				scope.genericInferenceMap.putAll(inferredTypes);
+			}
+
+		}
+
+		final FunctionHeader thatOtherHeader = genericHeader.withGenericArguments(new GenericMapper(position, scope.getTypeRegistry(), scope.genericInferenceMap));
+		if(thatOtherHeader.getReturnType().isBasic(BasicTypeID.UNDETERMINED)) {
+			thatOtherHeader.setReturnType(header.getReturnType());
 		}
-		
 		StoredType functionType = scope.getTypeRegistry()
-				.getFunction(genericHeader.withGenericArguments(new GenericMapper(position, scope.getTypeRegistry(), scope.genericInferenceMap)))
+				.getFunction(thatOtherHeader)
 				.stored(storage);
 		return new FunctionExpression(position, functionType, closure, header, statements);
 	}

ScriptingExample/scripts/arithmetic.zs

-var j = 0;
-println(j);
-j++;
-println(j);

ScriptingExample/scripts/arrays.zs

-//val a  = new int[](3, 10);
-//
-//for i in a {
-//	println(i);
-//}
-//
-//println(a[1]);
-////
-////
-val multiDim = new int[,,](1,2,3, 130);
-println(multiDim[0,1,2]);
-
-val t = multiDim;
-//
-//
-val b = new int[](3);
-for i in b {
-	println(i);
-}
-
-
-val c = new int[,,](1,2,3);
-println(c[0,1,2]);
-//
-//
-//val d = new string[,,](5,5,5, "HelloWorld");
-//println(d[2,2,2]);
-//
-//
-////val e = new int[](a, value => value);
-//
-//
-//var projection = (value => value) as function(value as string`borrow) as string;
-//val e = new string[](5, "HelloWorld");
-//val f = new string[]<string>(e, projection);
-//var projection = (value => value) as function(value as string`borrow) as string;
-//val a = new string[](5, "HelloWorld");
-//val b = new string[]<string>(a, projection);
-
-val d = new string[,,](3,4,5, "HelloWorld");
-
-val someString = "someString";
-
-var projection = (value => "" + value) as function(value as string`borrow) as string;
-val e = new string[,,]<string>(
-    d, 
-    (value => "137" + value + someString) as function(value as string`borrow) as string
-);
-
-
-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(indexedProjectionWithLambdaNonInlined[1, 2]);
-println(indexedProjectionWithLambdaInlined[1, 2]);

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/functionalInterfaces.zs

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

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>);
-
-
-var a = null as string?;
-if (a == null)
-	println("A is null!");

ScriptingExample/scripts/integration.zs

-import example.TestClass;
-import example.TestInterface;
-
-val instance = new TestClass("Instance");
-println("Name: " + instance.name);
-instance.dump();
-instance.withDefaultParameter("Hello");
-instance.withDefaultParameter("Hello", "moon");
-
-var generated = instance.generate();
-println(generated.getValue());
-
-class TestOperators {
-	public (name as string) as void {
-		println("MyTestClass: " + name);
-	}
-	
-	//.(key as string) as string
-	//	=> "key " + key;
-}
-
-/*class TestImplementation {
-	public implements TestInterface {
-		interfaceMethod() => "TestImplementation";
-	}
-}*/
-
-val testInstance = new TestOperators();
-//testInstance("something");
-
-something.dump();
-
-val objects = makeArray(5);
-printMany(objects);
-
-
-println(<test string>);
-println(<test string>.name);
-println(<test string>.interfaceMethod());
-//println(new TestImplementation().interfaceMethod());
-
-var diamond = <item:minecraft:diamond>;
-var dirt = <item:minecraft:dirt>;
-addShapedRecipe("TestRecipe", diamond, [[dirt, dirt, dirt],[dirt, dirt, dirt],[dirt, dirt, dirt]]);
-
-var count = 10;
-floatMethod(5f * count);
-
-invokeFunctional(name => "Hello " + name);
-
-//val x = (a as string) => "hello" + a;
-//invokeFunctional(x);
-
-testOptional(value => value == null ? 0 : value.length as int);

ScriptingExample/scripts/interfaces.zs

-public interface MyInterface {
-	interfaceMethod() as string;
-}
-
-public class MyClass {
-	val name as string;
-	
-	public this(name as string) {
-		this.name = name;
-	}
-
-	public implements MyInterface {
-		interfaceMethod() => "InterfaceMethod " + name;
-	}
-}
-
-println(new MyClass("hello").interfaceMethod());

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/scriptparameters.zs

-println("Arguments:");
-for i, arg in args
-	println("- " + i + ": " + arg);

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/Globals.java

 	public static TestClass bracket(String value) {
 		return new TestClass(value);
 	}
+
+	public static String staticToString(String value) {
+		return value;
+	}
 	
 	@FunctionalInterface
 	public static interface MyFunctionalInterface {

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

 import org.openzen.zenscript.codemodel.type.StringTypeID;
 import org.openzen.zenscript.lexer.ParseException;
 import org.openzen.zenscript.parser.BracketExpressionParser;
+import org.openzen.zenscript.parser.EscapableBracketParser;
+import org.openzen.zenscript.parser.PrefixedBracketParser;
 import org.openzen.zenscript.parser.SimpleBracketParser;
+import org.openzen.zenscript.scriptingexample.events.EventManager;
+import org.openzen.zenscript.scriptingexample.events.IEvent;
+import org.openzen.zenscript.scriptingexample.events.impl.CTStringedEvent;
 
 public class Main {
 	public static void main(String[] args) throws CompileException, ParseException, IOException, NoSuchMethodException {
 		ScriptingEngine scriptingEngine = new ScriptingEngine();
 		scriptingEngine.debug = true;
-		
+
 		JavaNativeModule example = scriptingEngine.createNativeModule("example", "org.openzen.zenscript.scriptingexample");
 		example.addGlobals(Globals.class);
 		example.addClass(TestBaseInterface.class);
 		example.addClass(TestGenericInterface.class);
 		example.addClass(TestClass.class);
 		example.addClass(TestInterface.class);
+		example.addClass(IEvent.class);
+		example.addClass(EventManager.class);
+		example.addClass(CTStringedEvent.class);
 		scriptingEngine.registerNativeProvided(example);
-		
+
 		File inputDirectory = new File("scripts");
 		File[] inputFiles = Optional.ofNullable(inputDirectory.listFiles((dir, name) -> name.endsWith(".zs"))).orElseGet(() -> new File[0]);
 		SourceFile[] sourceFiles = new SourceFile[inputFiles.length];
 		for (int i = 0; i < inputFiles.length; i++)
 			sourceFiles[i] = new FileSourceFile(inputFiles[i].getName(), inputFiles[i]);
-		
-		BracketExpressionParser bracketParser = new SimpleBracketParser(scriptingEngine.registry, example.loadStaticMethod(Globals.class.getMethod("bracket", String.class)));
+
+		final PrefixedBracketParser parser = new PrefixedBracketParser(null);
+		BracketExpressionParser testParser = new SimpleBracketParser(scriptingEngine.registry, example.loadStaticMethod(Globals.class.getMethod("bracket", String.class)));
+		parser.register("test", testParser);
+		BracketExpressionParser toStringParser = new EscapableBracketParser(scriptingEngine.registry, example.loadStaticMethod(Globals.class.getMethod("staticToString", String.class)));
+		parser.register("toString", toStringParser);
 		FunctionParameter parameter = new FunctionParameter(scriptingEngine.registry.getArray(StringTypeID.AUTO, 1).stored(), "args");
-		SemanticModule scripts = scriptingEngine.createScriptedModule("script", sourceFiles, bracketParser, new FunctionParameter[] { parameter });
+		SemanticModule scripts = scriptingEngine.createScriptedModule("script", sourceFiles, parser, new FunctionParameter[] { parameter });
 		if (!scripts.isValid())
 			return;
-		
+
 		scriptingEngine.registerCompiled(scripts);
-		
+
 		Map<FunctionParameter, Object> scriptArgs = new HashMap<>();
 		scriptArgs.put(parameter, new String[] { "hello", "world", "example" });
 		scriptingEngine.run(scriptArgs);

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/events/EventManager.java

+package org.openzen.zenscript.scriptingexample.events;
+
+import org.openzen.zencode.java.ZenCodeType;
+import org.openzen.zenscript.scriptingexample.events.impl.CTStringedEvent;
+import org.openzen.zenscript.scriptingexample.events.impl.StringedEvent;
+
+@ZenCodeType.Name("example.org.openzen.scripting_example.events.EventManager")
+public class EventManager {
+    @ZenCodeType.Method
+    public static void register(IEvent<?, ?> event) {
+    //public static <EVE extends IEvent<EVE, VA>, VA extends SomeMCEvent> void register(IEvent<EVE, VA> event) {
+        System.out.println("HIT!!!");
+
+        if(event instanceof CTStringedEvent) {
+            ((CTStringedEvent)event).getHandler().accept(new CTStringedEvent(null));
+        }
+    }
+
+    //@ZenCodeType.Method
+    //public static void register(CTStringedEvent event) {
+    //    System.out.println("HIT!!!");
+    //    event.getConsumer().accept(new StringedEvent("Abcdef"));
+    //}
+}

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/events/IEvent.java

+package org.openzen.zenscript.scriptingexample.events;
+
+import org.openzen.zencode.java.ZenCodeType;
+
+import java.util.function.Consumer;
+
+@ZenCodeType.Name("example.org.openzen.scripting_example.events.IEvent")
+public abstract class IEvent<E extends IEvent<E, V>, V extends SomeMCEvent> {
+
+    private V internal;
+
+    private Consumer<E> handler;
+
+    public IEvent(V internal) {
+        this.internal = internal;
+    }
+
+    @ZenCodeType.Constructor
+    public IEvent(Consumer<E> handler) {
+        this.handler = handler;
+    }
+
+    public void setInternal(V internal) {
+        this.internal = internal;
+    }
+
+    public abstract Consumer<V> getConsumer();
+
+
+    public V getInternal() {
+        return internal;
+    }
+
+    public Consumer<E> getHandler() {
+        return handler;
+    }
+
+    public void setHandler(Consumer<E> handler) {
+        this.handler = handler;
+    }
+}

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/events/SomeMCEvent.java

+package org.openzen.zenscript.scriptingexample.events;
+
+public interface SomeMCEvent {
+}

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/events/impl/CTStringedEvent.java

+package org.openzen.zenscript.scriptingexample.events.impl;
+
+import org.openzen.zencode.java.ZenCodeType;
+import org.openzen.zenscript.scriptingexample.events.IEvent;
+
+import java.util.function.Consumer;
+
+@ZenCodeType.Name("example.org.openzen.scripting_example.events.CTStringedEvent")
+public class CTStringedEvent extends IEvent<CTStringedEvent, StringedEvent> {
+
+    @ZenCodeType.Getter("blub")
+    public String getBlub() {
+        return "ASDF";
+    }
+
+    @ZenCodeType.Constructor
+    public CTStringedEvent(Consumer<CTStringedEvent> handler) {
+        super(handler);
+    }
+
+    @Override
+    public Consumer<StringedEvent> getConsumer() {
+        return stringedEvent -> getHandler().accept(new CTStringedEvent(null));
+    }
+}

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/events/impl/StringedEvent.java

+package org.openzen.zenscript.scriptingexample.events.impl;
+
+import org.openzen.zenscript.scriptingexample.events.SomeMCEvent;
+
+public class StringedEvent implements SomeMCEvent {
+    private final String text;
+
+    public StringedEvent(String text) {
+
+        this.text = text;
+    }
+}