Who would've thought that a 'this' can be a non-object :thinking-face:

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

 	public void addClass(String name, byte[] bytecode) {
 		if (bytecode == null)
 			return;
-		
-		classes.put(name, bytecode);
+
+		if(name.startsWith("java")) {
+			System.err.println("Invalid name " + name);
+		} else {
+			classes.put(name, bytecode);
+		}
 	}
 	
 	public void addScript(JavaScriptMethod method) {

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

 				target.addScript(method);
 
 			entry.getValue().classWriter.visitEnd();
-			target.addClass(entry.getKey(), entry.getValue().classWriter.toByteArray());
+
+			if (target.getClasses().containsKey(entry.getKey())) {
+				//TODO Scripts and definitions seem to create the same class. Bad!
+				System.err.println("Trying to register " + entry.getKey() + " a 2nd time");
+			}else{
+				target.addClass(entry.getKey(), entry.getValue().classWriter.toByteArray());
+			}
 		}
 
 		return target;

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

 				} else {
 					argument.accept(this);
 					javaWriter.dup();
-					int tmp = javaWriter.local(Type.getType("zsynthetic/IntRange"));
+					final String owner;
+					if (argument.type.type instanceof RangeTypeID) {
+						owner = context.getInternalName(argument.type);
+					} else {
+						owner = "zsynthetic/IntRange";
+					}
+					int tmp = javaWriter.local(Type.getType(owner));
 					javaWriter.storeInt(tmp);
-					javaWriter.getField("zsynthetic/IntRange", "from", "I");
+					javaWriter.getField(owner, "from", "I");
 					javaWriter.loadInt(tmp);
-					javaWriter.getField("zsynthetic/IntRange", "to", "I");
+					javaWriter.getField(owner, "to", "I");
 				}
 				javaWriter.invokeVirtual(STRING_SUBSTRING);
 				break;
 				} else {
 					argument.accept(this);
 					javaWriter.dup();
-					int tmp = javaWriter.local(Type.getType("zsynthetic/IntRange"));
+					final String owner;
+					if (argument.type.type instanceof RangeTypeID) {
+						owner = context.getInternalName(argument.type);
+					} else {
+						owner = "zsynthetic/IntRange";
+					}
+					int tmp = javaWriter.local(Type.getType(owner));
 					javaWriter.storeInt(tmp);
-					javaWriter.getField("zsynthetic/IntRange", "from", "I");
+					javaWriter.getField(owner, "from", "I");
 					javaWriter.loadInt(tmp);
-					javaWriter.getField("zsynthetic/IntRange", "to", "I");
+					javaWriter.getField(owner, "to", "I");
 				}
 
 				if (type.elementType.type instanceof BasicTypeID) {
 
 	@Override
 	public Void visitThis(ThisExpression expression) {
-		javaWriter.loadObject(0);
+		javaWriter.load(context.getType(expression.type), 0);
 		return null;
 	}
 
 			getJavaWriter().invokeStatic(methodInfo);
 		} else if (methodInfo.kind == JavaMethod.Kind.INTERFACE) {
 			getJavaWriter().invokeInterface(methodInfo);
+		} else if (methodInfo.kind == JavaMethod.Kind.EXPANSION) {
+			getJavaWriter().invokeStatic(methodInfo);
 		} else if (methodInfo.kind == JavaMethod.Kind.COMPILED) {
 			Objects.requireNonNull(methodInfo.translation).translate(expression, this);
-		} else if (methodInfo.cls.kind == JavaClass.Kind.INTERFACE) {
+		} else if (methodInfo.cls != null && methodInfo.cls.kind == JavaClass.Kind.INTERFACE) {
 			getJavaWriter().invokeInterface(methodInfo);
 		} else {
 			getJavaWriter().invokeVirtual(methodInfo);

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

 import org.objectweb.asm.Type;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
+import org.openzen.zenscript.codemodel.type.RangeTypeID;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
 import org.openzen.zenscript.javashared.JavaClass;
 import org.openzen.zenscript.javashared.JavaMethod;
         this.unboxingTypeVisitor = new JavaUnboxingTypeVisitor(this.javaWriter);
     }
 
-	public void visitIntRange() {
+	public void visitIntRange(RangeTypeID type) {
+		final String owner = statementVisitor.context.getInternalName(type);
 		javaWriter.dup();
-		javaWriter.getField("zsynthetic/IntRange", "to", "I");
+		javaWriter.getField(owner, "to", "I");
 		javaWriter.swap();
-		javaWriter.getField("zsynthetic/IntRange", "from", "I");
+		javaWriter.getField(owner, "from", "I");
 
 		final int z = javaWriter.getLocalVariable(variables[0].variable).local;
 		javaWriter.storeInt(z);

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

 import org.objectweb.asm.Label;
 import org.objectweb.asm.Type;
 import org.openzen.zenscript.codemodel.statement.*;
+import org.openzen.zenscript.codemodel.type.RangeTypeID;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
 
 import java.util.Arrays;
 
 public class JavaStatementVisitor implements StatementVisitor<Boolean> {
     private final JavaWriter javaWriter;
-	private final JavaBytecodeContext context;
+	final JavaBytecodeContext context;
     public JavaExpressionVisitor expressionVisitor;
 	public JavaNonPushingExpressionVisitor nonPushingExpressionVisitor;
 
 		} else {
 			switch (statement.iterator.target.getBuiltin()) {
 				case ITERATOR_INT_RANGE:
-					iteratorWriter.visitIntRange();
+					iteratorWriter.visitIntRange(((RangeTypeID) statement.iterator.getOwnerType().type));
 					break;
 				case ITERATOR_ARRAY_VALUES:
 					iteratorWriter.visitArrayValueIterator();

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

 				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");
+					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);

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

 	}
 	
 	public String getMethodDescriptor(FunctionHeader header) {
-		return getMethodDescriptor(header, false);
+		return getMethodDescriptor(header, false, "");
+	}
+
+	public String getMethodDescriptorExpansion(FunctionHeader header, StoredType expandedType) {
+		return getMethodDescriptor(header, false, getDescriptor(expandedType));
 	}
 	
     public String getMethodSignature(FunctionHeader header) {
     }
 	
 	public String getEnumConstructorDescriptor(FunctionHeader header) {
-		return getMethodDescriptor(header, true);
+		return getMethodDescriptor(header, true, "");
 	}
 	
 	public JavaSynthesizedFunctionInstance getFunction(FunctionTypeID type) {
 			return new JavaSynthesizedClass(range.cls, new TypeID[] { type.baseType.type });
 		}
 	}
-	
-	private String getMethodDescriptor(FunctionHeader header, boolean isEnumConstructor) {
+
+	/**
+	 * @param header Function Header
+	 * @param isEnumConstructor If this is an enum constructor, add String, int as parameters
+	 * @param expandedType If this is for an expanded type, add the type at the beginning.
+	 *                        Can be null or an empty string if this is not an expansion method header
+	 * @return Method descriptor {@code (<LClass;*No.TypeParameters><LString;I if enum><expandedType><headerTypes>)<retType> }
+	 */
+	private String getMethodDescriptor(FunctionHeader header, boolean isEnumConstructor, String expandedType) {
         StringBuilder descBuilder = new StringBuilder("(");
 		for (int i = 0; i < header.getNumberOfTypeParameters(); i++)
 			descBuilder.append("Ljava/lang/Class;");
 		
         if (isEnumConstructor)
             descBuilder.append("Ljava/lang/String;I");
+
+        //TODO: Put this earlier? We'd need to agree on one...
+        if(expandedType != null)
+        	descBuilder.append(expandedType);
 		
         for (FunctionParameter parameter : header.parameters) {
 			descBuilder.append(getDescriptor(parameter.type));

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

  */
 package org.openzen.zenscript.javashared.prepare;
 
+import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.javashared.JavaNativeClass;
 import org.openzen.zencode.shared.StringExpansion;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 		JavaMethod method = null;
 		if (nativeTag != null && nativeClass != null)
 			method = nativeClass.getMethod(nativeTag.value);
-		if (method == null)
+		if (method == null) {
+			final JavaMethod.Kind kind = getKind(member);
+			final String descriptor;
+			if (kind == JavaMethod.Kind.EXPANSION && member.definition instanceof ExpansionDefinition) {
+				descriptor = context.getMethodDescriptorExpansion(header, ((ExpansionDefinition) member.definition).target);
+			} else {
+				descriptor = context.getMethodDescriptor(header);
+			}
 			method = new JavaMethod(
 					cls,
-					getKind(member),
+					kind,
 					name,
 					true,
-					context.getMethodDescriptor(header),
+					descriptor,
 					JavaModifiers.getJavaModifiers(member.getEffectiveModifiers()),
 					header.getReturnType().type instanceof GenericTypeID,
-					header.useTypeParameters()); 
+					header.useTypeParameters());
+		}
 		
 		if (method.compile) {
 			if (DEBUG_EMPTY && cls.empty)