- Added destructors

- Added === and !== operator support
- Fixed some cases where arguments aren't casted properly during call
- Continued some work on stdlib

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

 import org.openzen.zenscript.codemodel.expression.OrOrExpression;
 import org.openzen.zenscript.codemodel.expression.PostCallExpression;
 import org.openzen.zenscript.codemodel.expression.RangeExpression;
+import org.openzen.zenscript.codemodel.expression.SameObjectExpression;
 import org.openzen.zenscript.codemodel.expression.SetFieldExpression;
 import org.openzen.zenscript.codemodel.expression.SetFunctionParameterExpression;
 import org.openzen.zenscript.codemodel.expression.SetLocalVariableExpression;
 import org.openzen.zenscript.codemodel.expression.SetterExpression;
 import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
 import org.openzen.zenscript.codemodel.expression.StaticSetterExpression;
+import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
 import org.openzen.zenscript.codemodel.expression.ThisExpression;
 import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
 import org.openzen.zenscript.codemodel.member.OperatorMember;
 	public ExpressionString visitRange(RangeExpression expression) {
 		return binary(expression.from, expression.to, OperatorPriority.RANGE, " .. ");
 	}
+	
+	@Override
+	public ExpressionString visitSameObject(SameObjectExpression expression) {
+		return binary(expression.left, expression.right, OperatorPriority.COMPARE, expression.inverted ? " !== " : " === ");
+	}
 
 	@Override
 	public ExpressionString visitSetField(SetFieldExpression expression) {
 				expression.type.accept(typeFormatter) + "." + expression.setter.name + " = " + expression.setter.name,
 				OperatorPriority.ASSIGN);
 	}
+	
+	@Override
+	public ExpressionString visitSupertypeCast(SupertypeCastExpression expression) {
+		return expression.value.accept(this);
+	}
 
 	@Override
 	public ExpressionString visitThis(ThisExpression expression) {

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

 import org.openzen.zenscript.codemodel.member.CasterMember;
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
 import org.openzen.zenscript.codemodel.member.CustomIteratorMember;
+import org.openzen.zenscript.codemodel.member.DestructorMember;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.codemodel.member.GetterMember;
 		return null;
 	}
 
+	@Override
+	public Void visitDestructor(DestructorMember member) {
+		visit(false);
+		FormattingUtils.formatModifiers(output, member.modifiers & ~Modifiers.FINAL);
+		output.append("this");
+		formatBody(member.body);
+		return null;
+	}
+
 	@Override
 	public Void visitMethod(MethodMember member) {
 		visit(false);

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

 import org.openzen.zenscript.codemodel.statement.TryCatchStatement;
 import org.openzen.zenscript.codemodel.statement.VarStatement;
 import org.openzen.zenscript.codemodel.statement.WhileStatement;
-import org.openzen.zenscript.codemodel.type.BasicTypeID;
 
 /**
  *
 		
 		for (CatchClause catchClause : statement.catchClauses) {
 			output.append(indent).append("catch ");
-			if (catchClause.exceptionName != null)
-				output.append(catchClause.exceptionName);
-			if (catchClause.exceptionType != BasicTypeID.ANY) {
-				output.append(" as ");
-				catchClause.exceptionType.accept(expressionFormatter.typeFormatter);
-			}
+			if (catchClause.exceptionVariable != null)
+				output.append(catchClause.exceptionVariable.name).append(" as ").append(catchClause.exceptionVariable.type.accept(expressionFormatter.typeFormatter));
 			
 			format(ParentStatementType.CATCH, catchClause.content);
 		}

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

 		if (this.parameters.length != arguments.arguments.length)
 			return parameters.length + " parameters expected but " + arguments.arguments.length + " given.";
 		
-		if (typeParameters.length != arguments.typeArguments.length)
+		if (getNumberOfTypeParameters() != arguments.getNumberOfTypeArguments())
 			return typeParameters.length + " type parameters expected but " + arguments.typeArguments.length + " given.";
 		
 		for (int i = 0; i < parameters.length; i++) {

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

 	RANGE("..", "rangeTo"),
 	
 	CONSTRUCTOR("this", "construct"),
+	DESTRUCTOR("~this", "destruct"),
 	CALL("()", "call"),
 	CAST("as", "cast");
 	

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

  */
 package org.openzen.zenscript.codemodel.definition;
 
-import java.util.List;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
 	public FunctionHeader header;
 	public Statement statement;
 	public OperatorMember caller;
-	public DefinitionMemberGroup callerGroup = new DefinitionMemberGroup(true);
+	public final DefinitionMemberGroup callerGroup;
 	
 	public FunctionDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
 		super(position, pkg, name, modifiers, outerDefinition);
+		callerGroup = new DefinitionMemberGroup(true, name);
 	}
 	
 	public FunctionDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, FunctionHeader header) {

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

  */
 package org.openzen.zenscript.codemodel.expression;
 
+import java.util.Arrays;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.shared.CodePosition;
+import org.openzen.zenscript.shared.CompileException;
+import org.openzen.zenscript.shared.CompileExceptionCode;
 
 /**
  *
 	public int getNumberOfTypeArguments() {
 		return typeArguments.length;
 	}
+	
+	public CallArguments normalize(CodePosition position, TypeScope scope, FunctionHeader header) {
+		CallArguments result = this;
+		
+		for (int i = 0; i < arguments.length; i++) {
+			arguments[i] = arguments[i].castImplicit(position, scope, header.parameters[i].type);
+		}
+		
+		if (arguments.length < header.parameters.length) {
+			Expression[] newArguments = Arrays.copyOf(arguments, header.parameters.length);
+			for (int i = arguments.length; i < header.parameters.length; i++) {
+				if (header.parameters[i].defaultValue == null)
+					throw new CompileException(position, CompileExceptionCode.MISSING_PARAMETER, "Parameter missing and no default value specified");
+				newArguments[i] = header.parameters[i].defaultValue;
+			}
+			result = new CallArguments(typeArguments, newArguments);
+		}
+		return result;
+	}
 }

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

  */
 package org.openzen.zenscript.codemodel.expression;
 
-import java.util.Arrays;
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.shared.CodePosition;
-import org.openzen.zenscript.shared.CompileException;
-import org.openzen.zenscript.shared.CompileExceptionCode;
 
 /**
  *
 	public final CallArguments arguments;
 	public final FunctionHeader instancedHeader;
 	
-	public CallExpression(CodePosition position, Expression target, FunctionalMember member, FunctionHeader instancedHeader, CallArguments arguments) {
+	public CallExpression(CodePosition position, Expression target, FunctionalMember member, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
 		super(position, instancedHeader.returnType);
 		
-		if (arguments.arguments.length < instancedHeader.parameters.length) {
-			Expression[] newArguments = Arrays.copyOf(arguments.arguments, instancedHeader.parameters.length);
-			for (int i = arguments.arguments.length; i < instancedHeader.parameters.length; i++) {
-				if (instancedHeader.parameters[i].defaultValue == null)
-					throw new CompileException(position, CompileExceptionCode.MISSING_PARAMETER, "Parameter missing and no default value specified");
-				newArguments[i] = instancedHeader.parameters[i].defaultValue;
-			}
-			arguments = new CallArguments(arguments.typeArguments, newArguments);
-		}
-		
 		this.target = target;
 		this.member = member;
-		this.arguments = arguments;
+		this.arguments = arguments.normalize(position, scope, instancedHeader);
 		this.instancedHeader = instancedHeader;
 	}
 	

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

 
 import org.openzen.zenscript.codemodel.FunctionHeader;
 import org.openzen.zenscript.codemodel.member.FunctionalMember;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.CodePosition;
 
 	public final CallArguments arguments;
 	public final FunctionHeader instancedHeader;
 	
-	public CallStaticExpression(CodePosition position, ITypeID target, FunctionalMember member, CallArguments arguments, FunctionHeader instancedHeader) {
+	public CallStaticExpression(CodePosition position, ITypeID target, FunctionalMember member, CallArguments arguments, FunctionHeader instancedHeader, TypeScope scope) {
 		super(position, member.header.returnType);
 		
 		this.member = member;
 		this.target = target;
-		this.arguments = arguments;
+		this.arguments = arguments.normalize(position, scope, instancedHeader);
 		this.instancedHeader = instancedHeader;
 	}
 

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.shared.CodePosition;
 
 /**
 		public final Expression target;
 		public final FunctionHeader instancedHeader;
 		public final CallArguments arguments;
+		public final TypeScope scope;
 		
-		public Call(CodePosition position, Expression target, FunctionHeader instancedHeader, CallArguments arguments) {
+		public Call(CodePosition position, Expression target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
 			this.position = position;
 			this.target = target;
 			this.instancedHeader = instancedHeader;
 			this.arguments = arguments;
+			this.scope = scope;
 		}
 	}
 	

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.CodePosition;
 	public final ConstructorMember constructor;
 	public final CallArguments arguments;
 	
-	public ConstructorSuperCallExpression(CodePosition position, ITypeID type, ConstructorMember constructor, CallArguments arguments) {
+	public ConstructorSuperCallExpression(CodePosition position, ITypeID type, ConstructorMember constructor, CallArguments arguments, TypeScope scope) {
 		super(position, BasicTypeID.VOID);
 		
 		this.objectType = type;
 		this.constructor = constructor;
-		this.arguments = arguments;
+		this.arguments = arguments.normalize(position, scope, constructor.header);
 	}
 
 	@Override

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

 package org.openzen.zenscript.codemodel.expression;
 
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.CodePosition;
 	public final ConstructorMember constructor;
 	public final CallArguments arguments;
 	
-	public ConstructorThisCallExpression(CodePosition position, ITypeID type, ConstructorMember constructor, CallArguments arguments) {
+	public ConstructorThisCallExpression(CodePosition position, ITypeID type, ConstructorMember constructor, CallArguments arguments, TypeScope scope) {
 		super(position, BasicTypeID.VOID);
 		
+		arguments = arguments.normalize(position, scope, constructor.header);
+		
 		this.objectType = type;
 		this.constructor = constructor;
 		this.arguments = arguments;

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

 	
 	public T visitRange(RangeExpression expression);
 	
+	public T visitSameObject(SameObjectExpression expression);
+	
 	public T visitSetField(SetFieldExpression expression);
 	
 	public T visitSetFunctionParameter(SetFunctionParameterExpression expression);
 	
 	public T visitStaticSetter(StaticSetterExpression expression);
 	
+	public T visitSupertypeCast(SupertypeCastExpression expression);
+	
 	public T visitThis(ThisExpression expression);
 	
 	public T visitWrapOptional(WrapOptionalExpression expression);

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

 import java.util.Collections;
 import java.util.List;
 import org.openzen.zenscript.codemodel.member.FieldMember;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.CodePosition;
+import org.openzen.zenscript.shared.CompileException;
+import org.openzen.zenscript.shared.CompileExceptionCode;
 
 /**
  *
 	public CapturedExpression capture(CodePosition position, LambdaClosure closure) {
 		return new CapturedDirectExpression(position, closure, this);
 	}
+	
+	@Override
+	public Expression assign(CodePosition position, TypeScope scope, Expression value) {
+		return new SetFieldExpression(position, target, field, value);
+	}
 
 	@Override
 	public <T> T accept(ExpressionVisitor<T> visitor) {

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.expression;
+
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class SameObjectExpression extends Expression {
+	public final Expression left;
+	public final Expression right;
+	public final boolean inverted;
+	
+	public SameObjectExpression(CodePosition position, Expression left, Expression right, boolean inverted) {
+		super(position, BasicTypeID.BOOL);
+		
+		this.left = left;
+		this.right = right;
+		this.inverted = inverted;
+	}
+
+	@Override
+	public <T> T accept(ExpressionVisitor<T> visitor) {
+		return visitor.visitSameObject(this);
+	}
+}

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.expression;
+
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ * Using to cast a class type to a base type.
+ * 
+ * @author Hoofdgebruiker
+ */
+public class SupertypeCastExpression extends Expression {
+	public final Expression value;
+	
+	public SupertypeCastExpression(CodePosition position, Expression value, ITypeID type) {
+		super(position, type);
+		
+		this.value = value;
+	}
+
+	@Override
+	public <T> T accept(ExpressionVisitor<T> visitor) {
+		return visitor.visitSupertypeCast(this);
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/generic/GenericParameterBound.java

  * @author Hoofdgebruiker
  */
 public abstract class GenericParameterBound {
+	public abstract boolean isObjectType();
+	
 	public abstract <T> T accept(GenericParameterBoundVisitor<T> visitor);
 	
 	public abstract void registerMembers(LocalMemberCache cache, TypeMembers type);

CodeModel/src/main/java/org/openzen/zenscript/codemodel/generic/ParameterSuperBound.java

 	public <T> T accept(GenericParameterBoundVisitor<T> visitor) {
 		return visitor.visitSuper(this);
 	}
+
+	@Override
+	public boolean isObjectType() {
+		return true;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/generic/ParameterTypeBound.java

 	public <T> T accept(GenericParameterBoundVisitor<T> visitor) {
 		return visitor.visitType(this);
 	}
+
+	@Override
+	public boolean isObjectType() {
+		return true;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/generic/TypeParameter.java

 		bounds.add(bound);
 	}
 	
+	public boolean isObjectType() {
+		for (GenericParameterBound bound : bounds)
+			if (bound.isObjectType())
+				return true;
+		
+		return false;
+	}
+	
 	public boolean matches(LocalMemberCache cache, ITypeID type) {
 		for (GenericParameterBound bound : bounds) {
 			if (!bound.matches(cache, type))

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

 	public CallerMember(CodePosition position, HighLevelDefinition definition, int modifiers, FunctionHeader header) {
 		super(position, definition, modifiers, "()", header);
 	}
+	
+	@Override
+	public String getInformalName() {
+		return "caller";
+	}
 
 	@Override
 	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
 
 	@Override
 	public DefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
+		return new CallerMember(position, definition, modifiers, header.instance(registry, mapping));
 	}
 
 	@Override

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

 import org.openzen.zenscript.codemodel.expression.CastExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 		
 		this.toType = toType;
 	}
+	
+	@Override
+	public String getInformalName() {
+		return "caster to " + toType.toString();
+	}
 
 	@Override
 	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
 	}
 
 	@Override
-	public Expression call(CodePosition position, Expression target, FunctionHeader instancedHeader, CallArguments arguments) {
+	public Expression call(CodePosition position, Expression target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
 		throw new UnsupportedOperationException("Cannot call a caster!");
 	}
 

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

 				firstExpression.expression instanceof ConstructorSuperCallExpression
 				|| firstExpression.expression instanceof ConstructorThisCallExpression);
 	}
+	
+	@Override
+	public String getInformalName() {
+		return "constructor";
+	}
 
 	@Override
 	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
 
 	@Override
 	public DefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
-		return new ConstructorMember(position, definition, modifiers, header.instance(registry, mapping));
+		ConstructorMember result = new ConstructorMember(position, definition, modifiers, header.instance(registry, mapping));
+		if (definition.name.equals("NFAState"))
+			System.out.println("X");
+		return result;
 	}
 
 	@Override

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

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.member;
+
+import java.util.Map;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.type.BasicTypeID;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.member.TypeMemberPriority;
+import org.openzen.zenscript.codemodel.type.member.TypeMembers;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class DestructorMember extends FunctionalMember {
+	private static final FunctionHeader HEADER = new FunctionHeader(BasicTypeID.VOID);
+	
+	public DestructorMember(CodePosition position, HighLevelDefinition definition, int modifiers) {
+		super(position, definition, modifiers, "~this", HEADER);
+	}
+	
+	@Override
+	public String getInformalName() {
+		return "destructor";
+	}
+
+	@Override
+	public void registerTo(TypeMembers type, TypeMemberPriority priority) {
+		if (priority == TypeMemberPriority.SPECIFIED)
+			type.addDestructor(this, priority);
+	}
+
+	@Override
+	public DefinitionMember instance(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> mapping) {
+		return this;
+	}
+
+	@Override
+	public String describe() {
+		return "destructor";
+	}
+
+	@Override
+	public <T> T accept(MemberVisitor<T> visitor) {
+		return visitor.visitDestructor(this);
+	}
+}

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

 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 		this.header = new FunctionHeader(BasicTypeID.BOOL, new FunctionParameter(type));
 	}
 	
+	@Override
+	public String getInformalName() {
+		return "equals operator";
+	}
+	
 	@Override
 	public boolean isStatic() {
 		return false;
 	}
 
 	@Override
-	public Expression call(CodePosition position, Expression target, FunctionHeader instancedHeader, CallArguments arguments) {
+	public Expression call(CodePosition position, Expression target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
 		return new BasicCompareExpression(position, target, arguments.arguments[0], CompareType.EQ);
 	}
 
 	@Override
-	public Expression callWithComparator(CodePosition position, CompareType operator, Expression target, FunctionHeader instancedHeader, CallArguments arguments) {
+	public Expression callWithComparator(CodePosition position, CompareType operator, Expression target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
 		throw new UnsupportedOperationException("Comparator not supported here");
 	}
 
 	@Override
-	public Expression callStatic(CodePosition position, ITypeID target, FunctionHeader instancedHeader, CallArguments arguments) {
+	public Expression callStatic(CodePosition position, ITypeID target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
 		throw new UnsupportedOperationException("Cannot be called statically");
 	}
 
 	@Override
-	public Expression callStaticWithComparator(CodePosition position, ITypeID target, CompareType operator, FunctionHeader instancedHeader, CallArguments arguments) {
+	public Expression callStaticWithComparator(CodePosition position, ITypeID target, CompareType operator, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
 		throw new UnsupportedOperationException("Cannot be called statically");
 	}
 

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

 import org.openzen.zenscript.codemodel.expression.CallStaticExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.GenericCompareExpression;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.statement.Statement;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.CodePosition;
 	}
 
 	@Override
-	public Expression call(CodePosition position, Expression target, FunctionHeader instancedHeader, CallArguments arguments) {
-		return new CallExpression(position, target, this, instancedHeader, arguments);
+	public Expression call(CodePosition position, Expression target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
+		return new CallExpression(position, target, this, instancedHeader, arguments, scope);
 	}
 	
-	public final Expression call(CodePosition position, Expression target, CallArguments arguments) {
-		return call(position, target, header, arguments);
+	public final Expression call(CodePosition position, Expression target, CallArguments arguments, TypeScope scope) {
+		return call(position, target, header, arguments, scope);
 	}
 	
 	@Override
-	public Expression callWithComparator(CodePosition position, CompareType operator, Expression target, FunctionHeader instancedHeader, CallArguments arguments) {
-		return new GenericCompareExpression(position, call(position, target, instancedHeader, arguments), operator);
+	public Expression callWithComparator(CodePosition position, CompareType operator, Expression target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
+		return new GenericCompareExpression(position, call(position, target, instancedHeader, arguments, scope), operator);
 	}
 	
 	@Override
-	public Expression callStatic(CodePosition position, ITypeID target, FunctionHeader instancedHeader, CallArguments arguments) {
-		return new CallStaticExpression(position, target, this, arguments, instancedHeader);
+	public Expression callStatic(CodePosition position, ITypeID target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
+		return new CallStaticExpression(position, target, this, arguments, instancedHeader, scope);
 	}
 	
 	@Override
-	public Expression callStaticWithComparator(CodePosition position, ITypeID target, CompareType operator, FunctionHeader instancedHeader, CallArguments arguments) {
-		return new GenericCompareExpression(position, callStatic(position, target, instancedHeader, arguments), operator);
+	public Expression callStaticWithComparator(CodePosition position, ITypeID target, CompareType operator, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
+		return new GenericCompareExpression(position, callStatic(position, target, instancedHeader, arguments, scope), operator);
 	}
 }

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

 		this.name = name;
 		this.type = type;
 	}
+	
+	@Override
+	public String getInformalName() {
+		return "getter " + name;
+	}
 
 	@Override
 	public String getName() {

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

 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.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.shared.CodePosition;
 
 public interface ICallableMember extends IDefinitionMember {
 	public boolean isStatic();
 	
+	public String getInformalName();
+	
 	public FunctionHeader getHeader();
 	
-	public Expression call(CodePosition position, Expression target, FunctionHeader instancedHeader, CallArguments arguments);
+	public Expression call(CodePosition position, Expression target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope);
 	
-	public Expression callWithComparator(CodePosition position, CompareType operator, Expression target, FunctionHeader instancedHeader, CallArguments arguments);
+	public Expression callWithComparator(CodePosition position, CompareType operator, Expression target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope);
 	
-	public Expression callStatic(CodePosition position, ITypeID target, FunctionHeader instancedHeader, CallArguments arguments);
+	public Expression callStatic(CodePosition position, ITypeID target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope);
 	
-	public Expression callStaticWithComparator(CodePosition position, ITypeID target, CompareType operator, FunctionHeader instancedHeader, CallArguments arguments);
+	public Expression callStaticWithComparator(CodePosition position, ITypeID target, CompareType operator, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope);
 }

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

 	
 	public T visitConstructor(ConstructorMember member);
 	
+	public T visitDestructor(DestructorMember member);
+	
 	public T visitMethod(MethodMember member);
 	
 	public T visitGetter(GetterMember member);

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

 	public MethodMember(CodePosition position, HighLevelDefinition definition, int modifiers, String name, FunctionHeader header) {
 		super(position, definition, modifiers, name, header);
 	}
+	
+	@Override
+	public String getInformalName() {
+		return name + " method";
+	}
 
 	@Override
 	public void registerTo(TypeMembers type, TypeMemberPriority priority) {

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

 		
 		this.operator = operator;
 	}
+	
+	@Override
+	public String getInformalName() {
+		return operator.operator + " operator";
+	}
 
 	@Override
 	public void registerTo(TypeMembers type, TypeMemberPriority priority) {

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

 		this.name = name;
 		this.type = type;
 	}
+	
+	@Override
+	public String getInformalName() {
+		return "setter " + name;
+	}
 
 	@Override
 	public void registerTo(TypeMembers type, TypeMemberPriority priority) {

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

 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.CallTranslator;
 import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.shared.CodePosition;
 
 /**
 	}
 
 	@Override
-	public Expression call(CodePosition position, Expression target, FunctionHeader instancedHeader, CallArguments arguments) {
-		return translator.translate(new CallTranslator.Call(position, target, instancedHeader, arguments));
+	public Expression call(CodePosition position, Expression target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
+		return translator.translate(new CallTranslator.Call(position, target, instancedHeader, arguments, scope));
 	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/member/builtin/ComparatorMember.java

 import org.openzen.zenscript.codemodel.member.ICallableMember;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 import org.openzen.zenscript.codemodel.member.MemberVisitor;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 	public ComparatorMember(ITypeID type) {
 		header = new FunctionHeader(BasicTypeID.BOOL, new FunctionParameter(type));
 	}
+	
+	@Override
+	public String getInformalName() {
+		return "comparator";
+	}
 
 	@Override
 	public boolean isStatic() {
 	}
 
 	@Override
-	public Expression call(CodePosition position, Expression target, FunctionHeader instancedHeader, CallArguments arguments) {
+	public Expression call(CodePosition position, Expression target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
 		throw new UnsupportedOperationException("Can't call a comparator");
 	}
 
 	@Override
-	public Expression callWithComparator(CodePosition position, CompareType operator, Expression target, FunctionHeader instancedHeader, CallArguments arguments) {
+	public Expression callWithComparator(CodePosition position, CompareType operator, Expression target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
 		return new BasicCompareExpression(position, target, arguments.arguments[0], operator);
 	}
 
 	@Override
-	public Expression callStatic(CodePosition position, ITypeID target, FunctionHeader instancedHeader, CallArguments arguments) {
+	public Expression callStatic(CodePosition position, ITypeID target, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
 		throw new UnsupportedOperationException("Can't call a comparator");
 	}
 
 	@Override
-	public Expression callStaticWithComparator(CodePosition position, ITypeID target, CompareType operator, FunctionHeader instancedHeader, CallArguments arguments) {
+	public Expression callStaticWithComparator(CodePosition position, ITypeID target, CompareType operator, FunctionHeader instancedHeader, CallArguments arguments, TypeScope scope) {
 		throw new UnsupportedOperationException("Can't call a comparator statically");
 	}
 

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

  */
 public class PartialStaticMemberGroupExpression implements IPartialExpression {
 	public static PartialStaticMemberGroupExpression forMethod(CodePosition position, ITypeID target, ICallableMember method, ITypeID[] typeArguments) {
-		DefinitionMemberGroup group = new DefinitionMemberGroup(true);
+		DefinitionMemberGroup group = new DefinitionMemberGroup(true, method.getInformalName());
 		group.addMethod(method, TypeMemberPriority.SPECIFIED);
 		return new PartialStaticMemberGroupExpression(position, target, group, typeArguments);
 	}

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

  */
 package org.openzen.zenscript.codemodel.statement;
 
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.shared.CodePosition;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class CatchClause {
-	public final String exceptionName;
-	public final ITypeID exceptionType;
 	public final Statement content;
+	public final VarStatement exceptionVariable;
 	
-	public CatchClause(String exceptionName, ITypeID exceptionType, Statement content) {
-		this.exceptionName = exceptionName;
-		this.exceptionType = exceptionType;
+	public CatchClause(CodePosition position, VarStatement exceptionVariable, Statement content) {
+		this.exceptionVariable = exceptionVariable;
 		this.content = content;
 	}
 }

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

 		return false;
 	}
 	
+	@Override
+	public boolean isObjectType() {
+		return true;
+	}
+	
 	@Override
 	public ArrayTypeID withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments) {
 		return registry.getArray(elementType.withGenericArguments(registry, arguments), dimension);

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

 		return false;
 	}
 	
+	@Override
+	public boolean isObjectType() {
+		return true;
+	}
+	
 	@Override
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {
 		return keyType.hasInferenceBlockingTypeParameters(parameters) || valueType.hasInferenceBlockingTypeParameters(parameters);

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

 	public boolean isConst() {
 		return false;
 	}
+	
+	@Override
+	public boolean isObjectType() {
+		return this == ANY || this == STRING;
+	}
 
 	@Override
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {

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

 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {
 		return baseType.hasInferenceBlockingTypeParameters(parameters);
 	}
+	
+	@Override
+	public boolean isObjectType() {
+		return baseType.isObjectType();
+	}
 
 	@Override
 	public int hashCode() {

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

 			Arrays.sort(outerTypeEntries, (a, b) -> a.parameter.name.compareTo(b.parameter.name));
 		}
 		
-		if ((typeParameters == null ? 0 : typeParameters.length) != definition.getNumberOfGenericParameters())
-			throw new RuntimeException("Invalid number of type parameters");
+		//if ((typeParameters == null ? 0 : typeParameters.length) != definition.getNumberOfGenericParameters())
+		//	throw new RuntimeException("Invalid number of type parameters");
 	}
 	
 	public boolean hasTypeParameters() {
 		if (typeParameters != null) {
 			instancedArguments = new ITypeID[typeParameters.length];
 			for (int i = 0; i < typeParameters.length; i++) {
-				instancedArguments[i] = arguments.containsKey(definition.genericParameters[i]) ? arguments.get(definition.genericParameters[i]) : typeParameters[i].withGenericArguments(registry, arguments);
+				// TODO: why was this line written like this?
+				//instancedArguments[i] = arguments.containsKey(definition.genericParameters[i]) ? arguments.get(definition.genericParameters[i]) : typeParameters[i].withGenericArguments(registry, arguments);
+				instancedArguments[i] = typeParameters[i].withGenericArguments(registry, arguments);
 			}
 		}
 		
 	public boolean isConst() {
 		return false;
 	}
+	
+	@Override
+	public boolean isObjectType() {
+		return true;
+	}
 
 	@Override
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {

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

 	public boolean isConst() {
 		return false;
 	}
+	
+	@Override
+	public boolean isObjectType() {
+		return true;
+	}
 
 	@Override
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {

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

 		return true;
 	}
 	
+	@Override
+	public boolean isObjectType() {
+		return true;
+	}
+	
 	@Override
 	public String toString() {
 		StringBuilder result = new StringBuilder();

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

 	public boolean isConst() {
 		return false;
 	}
+	
+	@Override
+	public boolean isObjectType() {
+		return parameter.isObjectType();
+	}
 
 	@Override
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {

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

 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import static org.openzen.zenscript.codemodel.type.member.TypeMembers.MODIFIER_CONST;
 import static org.openzen.zenscript.codemodel.type.member.TypeMembers.MODIFIER_OPTIONAL;
-import static org.openzen.zenscript.codemodel.type.member.TypeMembers.MODIFIER_SHARED;
-import static org.openzen.zenscript.codemodel.type.member.TypeMembers.MODIFIER_WEAK;
 
 /**
  *
 			return getModified(modifiers & ~MODIFIER_OPTIONAL, getOptional(type));
 		if ((modifiers & MODIFIER_CONST) > 0)
 			return getModified(modifiers & ~MODIFIER_CONST, getConst(type));
-		if ((modifiers & MODIFIER_SHARED) > 0)
-			throw new UnsupportedOperationException();
-		if ((modifiers & MODIFIER_WEAK) > 0)
-			throw new UnsupportedOperationException();
 		
 		throw new UnsupportedOperationException();
 	}

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

 	
 	public boolean hasDefaultValue();
 	
+	public boolean isObjectType();
+	
 	public ITypeID withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments);
 	
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters);

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

 	public boolean isConst() {
 		return false;
 	}
+	
+	@Override
+	public boolean isObjectType() {
+		return true;
+	}
 
 	@Override
 	public ITypeID withGenericArguments(GlobalTypeRegistry registry, Map<TypeParameter, ITypeID> arguments) {

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

 		return false;
 	}
 	
+	@Override
+	public boolean isObjectType() {
+		return baseType.isObjectType();
+	}
+	
 	@Override
 	public ITypeID unwrap() {
 		return baseType;

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

 	public boolean isConst() {
 		return false;
 	}
+	
+	@Override
+	public boolean isObjectType() {
+		return false;
+	}
 
 	@Override
 	public boolean hasInferenceBlockingTypeParameters(TypeParameter[] parameters) {

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

  */
 public class DefinitionMemberGroup {
 	public static DefinitionMemberGroup forMethod(ICallableMember member) {
-		DefinitionMemberGroup instance = new DefinitionMemberGroup(member.isStatic());
+		DefinitionMemberGroup instance = new DefinitionMemberGroup(member.isStatic(), member.getInformalName());
 		instance.addMethod(member, TypeMemberPriority.SPECIFIED);
 		return instance;
 	}
 	private TypeMember<SetterMember> setter;
 	private final List<TypeMember<ICallableMember>> methods = new ArrayList<>();
 	public final boolean isStatic;
+	public final String name;
 	
-	public DefinitionMemberGroup(boolean isStatic) {
+	public DefinitionMemberGroup(boolean isStatic, String name) {
 		this.isStatic = isStatic;
+		this.name = name;
 	}
 	
 	public void merge(CodePosition position, DefinitionMemberGroup other, TypeMemberPriority priority) {
 			arguments.arguments[i] = arguments.arguments[i].castImplicit(position, scope, instancedHeader.parameters[i].type);
 		}
 		
-		return method.call(position, target, instancedHeader, arguments);
+		return method.call(position, target, instancedHeader, arguments, scope);
 	}
 	
 	public Expression callPostfix(CodePosition position, TypeScope scope, Expression target) {
 			CompareType compareType) {
 		ICallableMember method = selectMethod(position, scope, arguments, true, false);
 		FunctionHeader instancedHeader = method.getHeader().withGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
-		return method.callWithComparator(position, compareType, target, instancedHeader, arguments);
+		return method.callWithComparator(position, compareType, target, instancedHeader, arguments, scope);
 	}
 	
 	public Expression callStatic(CodePosition position, ITypeID target, TypeScope scope, CallArguments arguments) {
 		ICallableMember method = selectMethod(position, scope, arguments, false, true);
 		FunctionHeader instancedHeader = method.getHeader().withGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
-		return method.callStatic(position, target, instancedHeader, arguments);
+		return method.callStatic(position, target, instancedHeader, arguments, scope);
 	}
 	
 	public Expression callStaticWithComparator(
 			CompareType compareType) {
 		ICallableMember method = selectMethod(position, scope, arguments, false, true);
 		FunctionHeader instancedHeader = method.getHeader().withGenericArguments(scope.getTypeRegistry(), arguments.typeArguments);
-		return method.callStaticWithComparator(position, target, compareType, instancedHeader, arguments);
+		return method.callStaticWithComparator(position, target, compareType, instancedHeader, arguments, scope);
 	}
 	
 	public ICallableMember selectMethod(CodePosition position, TypeScope scope, CallArguments arguments, boolean allowNonStatic, boolean allowStatic) {
 		if (selected == null) {
 			// let's figure out why this didn't work out
 			StringBuilder message = new StringBuilder();
+			if (methods.isEmpty()) {
+				throw new CompileException(position, CompileExceptionCode.CALL_NO_VALID_METHOD, "This type has no " + name);
+			}
+			
 			outer: for (TypeMember<ICallableMember> method : methods) {
 				if (!(method.member.isStatic() ? allowStatic : allowNonStatic)) {
 					message.append(method.member.isStatic() ? "Method must not be static" : "Method must be static").append('\n');
 				message.append(method.member.getHeader().explainWhyIncompatible(scope, arguments)).append("\n");
 			}
 			
-			throw new CompileException(position, CompileExceptionCode.CALL_NO_VALID_METHOD, "No matching method found:\n" + message.toString());
+			throw new CompileException(position, CompileExceptionCode.CALL_NO_VALID_METHOD, "No matching method found for " + name + ":\n" + message.toString());
 		}
 		
 		return selected;

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

 import org.openzen.zenscript.codemodel.member.builtin.ConstantGetterMember;
 import org.openzen.zenscript.codemodel.member.builtin.RangeIterator;
 import org.openzen.zenscript.codemodel.member.builtin.StringCharIterator;
+import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ArrayTypeID;
 import org.openzen.zenscript.codemodel.type.AssocTypeID;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 		}
 
 		members.addGetter(new GetterMember(BUILTIN, definition, 0, "empty", BOOL), TypeMemberPriority.SPECIFIED);
+		members.addGetter(new GetterMember(BUILTIN, definition, Modifiers.PUBLIC | Modifiers.EXTERN, "objectHashCode", BasicTypeID.INT));
 		members.addIterator(new ArrayIteratorKeyValues(array), TypeMemberPriority.SPECIFIED);
 		members.addIterator(new ArrayIteratorValues(array), TypeMemberPriority.SPECIFIED);
 		members.addMethod(new MethodMember(BUILTIN, definition, 0, "clear", new FunctionHeader(VOID)), TypeMemberPriority.SPECIFIED);
 		members.addField(new FieldMember(BUILTIN, definition, Modifiers.FINAL, "size", INT));
 		members.addGetter(new GetterMember(BUILTIN, definition, 0, "empty", BOOL));
 		members.addGetter(new GetterMember(BUILTIN, definition, 0, "keys", cache.getRegistry().getArray(keyType, 1)));
+		members.addGetter(new GetterMember(BUILTIN, definition, Modifiers.PUBLIC | Modifiers.EXTERN, "objectHashCode", BasicTypeID.INT));
 		
 		members.addIterator(new AssocIterator(assoc), TypeMemberPriority.SPECIFIED);
 		return null;
 		members.addMethod(new MethodMember(BUILTIN, definition, 0, "getOptional", new FunctionHeader(map.keys, registry.getOptional(valueType), new FunctionParameter[0])));
 		members.addMethod(new MethodMember(BUILTIN, definition, 0, "put", new FunctionHeader(map.keys, BasicTypeID.VOID, new FunctionParameter(valueType))));
 		members.addMethod(new MethodMember(BUILTIN, definition, 0, "contains", new FunctionHeader(map.keys, BasicTypeID.BOOL, new FunctionParameter[0])));
+		members.addGetter(new GetterMember(BUILTIN, definition, Modifiers.PUBLIC | Modifiers.EXTERN, "objectHashCode", BasicTypeID.INT));
 		return null;
 	}
 	
 				for (int i = 0; i < type.typeParameters.length; i++)
 					mapping.put(definition.genericParameters[i], type.typeParameters[i]);
 			
-			for (Map.Entry<TypeParameter, ITypeID> entry : type.outerTypeParameters.entrySet())
-				mapping.put(entry.getKey(), entry.getValue());
+			if (!type.definition.isStatic())
+				for (Map.Entry<TypeParameter, ITypeID> entry : type.outerTypeParameters.entrySet())
+					mapping.put(entry.getKey(), entry.getValue());
 			
 			for (IDefinitionMember member : definition.members) {
 				member.instance(cache.getRegistry(), mapping).registerTo(members, TypeMemberPriority.SPECIFIED);
 			}
 		}
 		
+		members.addGetter(new GetterMember(BUILTIN, definition, Modifiers.PUBLIC | Modifiers.EXTERN, "objectHashCode", BasicTypeID.INT));
 		return null;
 	}
 
 	}
 	
 	private static CallTranslator castedTargetCall(FunctionalMember member, CasterMember caster) {
-		return call -> member.call(call.position, caster.cast(call.position, call.target, true), call.arguments);
+		return call -> member.call(call.position, caster.cast(call.position, call.target, true), call.arguments, call.scope);
 	}
 }

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

 import org.openzen.zenscript.codemodel.expression.InterfaceCastExpression;
 import org.openzen.zenscript.codemodel.expression.MakeConstExpression;
 import org.openzen.zenscript.codemodel.expression.NullExpression;
+import org.openzen.zenscript.codemodel.expression.SameObjectExpression;
+import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
 import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
 import org.openzen.zenscript.codemodel.member.CallerMember;
 import org.openzen.zenscript.codemodel.member.CasterMember;
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
+import org.openzen.zenscript.codemodel.member.DestructorMember;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.codemodel.member.ICallableMember;
 public final class TypeMembers {
 	public static final int MODIFIER_OPTIONAL = 1;
 	public static final int MODIFIER_CONST = 2;
-	public static final int MODIFIER_SHARED = 4;
-	public static final int MODIFIER_WEAK = 8;
 	
 	private final LocalMemberCache cache;
 	public final ITypeID type;
 		}
 		
 		for (TypeMember<ImplementationMember> implementation : implementations) {
-			if (implementation.member.type == other)
+			if (implementation.member.type.equals(other)) // TODO: for some reason duplicate types are generated
 				return true;
 			if (cache.get(implementation.member.type).extendsOrImplements(other))
 				return true;
 		return false;
 	}
 	
+	public boolean extendsType(ITypeID other) {
+		ITypeID superType = type.getSuperType();
+		if (superType != null) {
+			if (superType == other)
+				return true;
+			if (cache.get(superType).extendsType(other))
+				return true;
+		}
+		
+		return false;
+	}
+	
 	public GlobalTypeRegistry getTypeRegistry() {
 		return cache.getRegistry();
 	}
 		getOrCreateGroup(OperatorType.CONSTRUCTOR).addMethod(constructor, TypeMemberPriority.SPECIFIED);
 	}
 	
+	public void addDestructor(DestructorMember destructor, TypeMemberPriority priority) {
+		getOrCreateGroup(OperatorType.DESTRUCTOR).addMethod(destructor, priority);
+	}
+	
 	public void addCaller(CallerMember caller, TypeMemberPriority priority) {
 		getOrCreateGroup(OperatorType.CALL).addMethod(caller, priority);
 	}
 	
 	public DefinitionMemberGroup getOrCreateGroup(String name, boolean isStatic) {
 		if (!members.containsKey(name))
-			members.put(name, new DefinitionMemberGroup(isStatic));
+			members.put(name, new DefinitionMemberGroup(isStatic, name));
 		
 		return members.get(name);
 	}
 	
 	public DefinitionMemberGroup getOrCreateGroup(OperatorType operator) {
 		if (!operators.containsKey(operator))
-			operators.put(operator, new DefinitionMemberGroup(false));
+			operators.put(operator, new DefinitionMemberGroup(false, operator.operator + " operator"));
 		
 		return operators.get(operator);
 	}
 	}
 	
 	public Expression compare(CodePosition position, TypeScope scope, CompareType operator, Expression left, Expression right) {
-		if (operator == CompareType.EQ) {
+		if (operator == CompareType.SAME) {
+			if (left.type.isObjectType() && right.type.isObjectType())
+				return new SameObjectExpression(position, left, right, false);
+			else
+				return compare(position, scope, CompareType.EQ, left, right);
+		} else if (operator == CompareType.NOTSAME) {
+			if (left.type.isObjectType() && right.type.isObjectType())
+				return new SameObjectExpression(position, left, right, true);
+			else
+				return compare(position, scope, CompareType.NE, left, right);
+		} else if (operator == CompareType.EQ) {
 			DefinitionMemberGroup equal = getOrCreateGroup(OperatorType.EQUALS);
 			for (TypeMember<ICallableMember> member : equal.getMethodMembers()) {
 				if (member.member.getHeader().accepts(scope, right))
 			for (TypeMember<ICallableMember> member : equal.getMethodMembers()) {
 				if (member.member.getHeader().accepts(scope, right)) {
 					Expression equalExpression = equal.call(position, scope, left, new CallArguments(right), false);
-					return new CallExpression(position, equalExpression, BuiltinTypeMembers.BOOL_NOT, BuiltinTypeMembers.BOOL_NOT.header, CallArguments.EMPTY);
+					return new CallExpression(position, equalExpression, BuiltinTypeMembers.BOOL_NOT, BuiltinTypeMembers.BOOL_NOT.header, CallArguments.EMPTY, scope);
 				}
 			}
 		}
 			if (caster.member.isImplicit() && toType == caster.member.getTargetType())
 				return true;
 		}
-		for (TypeMember<ImplementationMember> implementation : implementations) {
-			if (implementation.member.type == toType)
-				return true;
-		}
 		
-		return false;
+		return extendsOrImplements(toType);
 	}
 	
 	public boolean canCast(ITypeID toType) {
 				return caster.member.cast(position, value, implicit);
 		}
 		for (TypeMember<ImplementationMember> implementation : implementations) {
-			if (implementation.member.type == toType)
+			if (implementation.member.type.equals(toType))
 				return new InterfaceCastExpression(position, value, toType);
 		}
+		if (extendsType(toType))
+			return new SupertypeCastExpression(position, value, toType);
 		
 		throw new CompileException(position, CompileExceptionCode.INVALID_CAST, "Could not cast " + toString() + " to " + toType);
 	}

Constructor/libraries/collections/src/HashSet.zs

 		add(value as T) as bool;
 		remove(value as T) as bool;
 		
+		get size as int;
+		
 		in(value as T) as bool;
 		for(x as T);
 	}

Constructor/libraries/collections/src/LinkedList.zs

 export class LinkedList<T> {
 	var first as Node?;
 	var last as Node?;
+	var size as int : get;
 	
 	public get empty as bool
 		=> first == null;
 			node.prev = last;
 			last = node;
 		}
+		size++;
 	}
 	
-	public implements Queue<T> {
-		poll() as T?
-			=> first == null ? null : first.value;
+	public clear() as void {
+		first = last = null;
+		size = 0;
+	}
+	
+	public [](index as int) as T {
+		var node = first;
+		while index > 0 {
+			if node == null
+				throw new NoSuchElementException("index out of bounds");
+			
+			node = node.next;
+		}
+		
+		if node == null
+			throw new NoSuchElementException("index out of bounds");
 		
-		peek() as T {
+		return node.value;
+	}
+	
+	public implements Queue<T> {
+		poll() as T {
 			if first == null
-				throw new NoSuchElementException("Cannot peek an empty queue");
+				throw new NoSuchElementException("Cannot poll an empty queue");
 			
+			val result = first.value;
+			first = first.next;
+			if first == null
+				last = null;
+			else
+				first.prev = null;
+				
+			size--;
+		}
+		
+		peek() as T? {
 			return first.value;
 		}
 		

Constructor/libraries/collections/src/Set.zs

 	add(value as T) as bool;
 	remove(value as T) as bool;
 	
-	in(value as T) as bool;
+	get size as int;
+	
+	toArray();
+	toArray(comparator as function(a as T, b as T) as int);
 	
+	in(value as T) as bool;
 	for(x as T);
 }

Constructor/libraries/collections/src/Stack.zs

+export class Stack<T> {
+	var values as T[] = new T[](8);
+	var size as int : get = 0;
+	
+	public push(value as T) as void {
+		if size == values.length
+			values = values.copy(values.length * 2);
+			
+		values[size++] = value;
+	}
+	
+	public pop() as T {
+		if size == 0
+			throw new NoSuchElementException("Stack is empty!");
+		
+		return values[--size];
+	}
+	
+	public get empty as bool
+		=> size == 0;
+}

Constructor/libraries/io/module.json

+{
+	"package": "collections",
+	"host": "universal"
+}

Constructor/libraries/io/src/Reader.zs

+export interface Reader {
+	~this;
+	
+	read() as int;
+	
+	read(buffer as char[]) as int
+		=> read(buffer, 0, buffer.length);
+	
+	read(buffer as char[], offset as int, length as int) as int;
+}

Constructor/libraries/io/src/StringReader.zs

+export class StringReader {
+	val data as char[];
+	var offset as int;
+	
+	public this(value as string) {
+		data = value.characters;
+	}
+	
+	public implements Reader {
+		~this {}
+	
+		read() as int
+			=> offset == data.length ? -1 : data[offset++];
+	
+		read(buffer as char[], offset as int, length as int) as int {
+			length = int.min(data.length - this.offset, length);
+			data.copyTo(buffer, this.offset, offset, length);
+			this.offset += length;
+			return length;
+		}
+	}
+}

Constructor/libraries/stdlib/module.json

 	"globals": {
 		"Comparable": {"type": "Definition", "definition": "Comparable"},
 		"Exception": {"type": "Definition", "definition": "Exception"},
+		"Hashable": {"type": "Definition", "definition": "Hashable"},
 		"IllegalArgumentException": {"type": "Definition", "definition": "IllegalArgumentException"},
 		"StringBuilder": {"type": "Definition", "definition": "StringBuilder"},
 		"StringBuildable": {"type": "Definition", "definition": "StringBuildable"}

Constructor/libraries/stdlib/src/Arrays.zs

+export expand <T : Comparable<T>> T[] {
+	public extern sort() as void;
+	public extern sorted() as T[];
+}
+
+export expand <T : Hashable<T>> T[] {
+	public implements Hashable<T[]> {
+		public extern hashCode() as int;
+		public extern == (other as T) as bool;
+	}
+}
+
+export expand <T> T[] {
+	public extern sort(comparator as function(a as T, b as T) as int) as void;
+	public extern sorted(comparator as function(a as T, b as T) as int) as T[];
+	public extern copy() as T[];
+	public extern copy(newSize as int) as T[];
+	public extern copyTo(target as T[], sourceOffset as int, targetOffset as int, length as int) as void;
+}

Constructor/libraries/stdlib/src/Exception.zs

 export virtual class Exception {
-	public this(message as string) {
-	}
+	public this(message as string) {}
+	public this(message as string, cause as Exception) {}
 }

Constructor/libraries/stdlib/src/Hashable.zs

+public interface Hashable<T> {
+	hashCode() as int;
+	== (other as T) as bool;
+}

Constructor/libraries/stdlib/src/Integers.zs

 	public extern toHexString() as string;
 	public static extern parse(value as string) as int;
 	public static extern parse(value as string, radix as int) as int;
+	
+	public static min(a as int, b as int) as int
+		=> a < b ? a : b;
+	public static max(a as int, b as int) as int
+		=> a > b ? a : b;
 }

Constructor/libraries/stdlib/src/StringBuilder.zs

 	public extern this(capacity as int);
 	public extern this(value as string);
 	
+	public extern get empty as bool;
+	
 	public extern <<(value as bool) as StringBuilder;
 	public extern <<(value as char) as StringBuilder;
 	public extern <<(value as byte) as StringBuilder;

Constructor/src/main/java/org/openzen/zenscript/constructor/Module.java

 import org.openzen.zenscript.codemodel.ScriptBlock;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
-import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.constructor.module.ModuleSpace;
 import org.openzen.zenscript.constructor.module.SemanticModule;
 import org.openzen.zenscript.linker.symbol.ISymbol;
 		Map<String, ISymbol> globals = registry.collectGlobals();
 		boolean failed = false;
 		
-		GlobalTypeRegistry globalRegistry = new GlobalTypeRegistry();
 		for (ParsedFile file : files) {
 			// compileMembers will register all definition members to their
 			// respective definitions, such as fields, constructors, methods...
 			// It doesn't yet compile the method contents.
 			try {
-				file.compileTypes(rootPackage, definitions, globalRegistry, expansions, globals);
+				file.compileTypes(rootPackage, definitions, registry.typeRegistry, expansions, globals);
 			} catch (CompileException ex) {
 				System.out.println(ex.getMessage());
 				failed = true;
 			// respective definitions, such as fields, constructors, methods...
 			// It doesn't yet compile the method contents.
 			try {
-				file.compileMembers(rootPackage, definitions, globalRegistry, expansions, globals);
+				file.compileMembers(rootPackage, definitions, registry.typeRegistry, expansions, globals);
 			} catch (CompileException ex) {
 				System.out.println(ex.getMessage());
 				failed = true;
 			// into semantic code. This semantic code can then be compiled
 			// to various targets.
 			try {
-				file.compileCode(rootPackage, definitions, globalRegistry, expansions, scripts, globals);
+				file.compileCode(rootPackage, definitions, registry.typeRegistry, expansions, scripts, globals);
 			} catch (CompileException ex) {
 				System.out.println(ex.getMessage());
 				failed = true;

Constructor/src/main/java/org/openzen/zenscript/constructor/module/ModuleSpace.java

 import java.util.Map;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
+import org.openzen.zenscript.codemodel.type.GlobalTypeRegistry;
 import org.openzen.zenscript.constructor.ConstructorException;
 import org.openzen.zenscript.linker.symbol.ISymbol;
 
  * @author Hoofdgebruiker
  */
 public class ModuleSpace {
+	public final GlobalTypeRegistry typeRegistry = new GlobalTypeRegistry();
 	public final ZSPackage globalsPackage = new ZSPackage("");
 	private final ZSPackage rootPackage = new ZSPackage("");
 	private final List<ExpansionDefinition> expansions = new ArrayList<>();

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

 
     @Override
     public Void visitRange(RangeExpression expression) {
+		// TODO: there are other kinds of ranges also; there should be a Range<T, T> type with creation of synthetic types
         if (expression.from.type.accept(JavaTypeClassVisitor.INSTANCE) != int.class)
             throw new CompileException(expression.position, CompileExceptionCode.INTERNAL_ERROR, "Only integer ranges supported");
+		
         javaWriter.newObject(IntRange.class);
         javaWriter.dup();
         expression.from.accept(this);
 
         return null;
     }
+	
+	@Override
+	public Void visitSameObject(SameObjectExpression expression) {
+		expression.left.accept(this);
+		expression.right.accept(this);
+		
+		Label end = new Label();
+		Label equal = new Label();
+		
+		if (expression.inverted)
+			javaWriter.ifACmpNe(equal);
+		else
+			javaWriter.ifACmpEq(equal);
+		javaWriter.iConst0();
+		javaWriter.goTo(end);
+		javaWriter.label(equal);
+		javaWriter.iConst1();
+		javaWriter.label(end);
+		return null;
+	}
 
     @Override
     public Void visitSetField(SetFieldExpression expression) {
     public Void visitStaticSetter(StaticSetterExpression expression) {
         return null;
     }
+	
+	@Override
+	public Void visitSupertypeCast(SupertypeCastExpression expression) {
+		return null; // nothing to do
+	}
 
     @Override
     public Void visitThis(ThisExpression expression) {

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

 import org.openzen.zenscript.codemodel.expression.OrOrExpression;
 import org.openzen.zenscript.codemodel.expression.PostCallExpression;
 import org.openzen.zenscript.codemodel.expression.RangeExpression;
+import org.openzen.zenscript.codemodel.expression.SameObjectExpression;
 import org.openzen.zenscript.codemodel.expression.SetFieldExpression;
 import org.openzen.zenscript.codemodel.expression.SetFunctionParameterExpression;
 import org.openzen.zenscript.codemodel.expression.SetLocalVariableExpression;
 import org.openzen.zenscript.codemodel.expression.SetterExpression;
 import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
 import org.openzen.zenscript.codemodel.expression.StaticSetterExpression;
+import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
 import org.openzen.zenscript.codemodel.expression.ThisExpression;
 import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
 	public Void visitRange(RangeExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
 	}
+	
+	@Override
+	public Void visitSameObject(SameObjectExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
 
 	@Override
 	public Void visitSetField(SetFieldExpression expression) {
 	public Void visitStaticSetter(StaticSetterExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
 	}
+	
+	@Override
+	public Void visitSupertypeCast(SupertypeCastExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
 
 	@Override
 	public Void visitThis(ThisExpression expression) {

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

 import org.openzen.zenscript.codemodel.expression.OrOrExpression;
 import org.openzen.zenscript.codemodel.expression.PostCallExpression;
 import org.openzen.zenscript.codemodel.expression.RangeExpression;
+import org.openzen.zenscript.codemodel.expression.SameObjectExpression;
 import org.openzen.zenscript.codemodel.expression.SetFieldExpression;
 import org.openzen.zenscript.codemodel.expression.SetFunctionParameterExpression;
 import org.openzen.zenscript.codemodel.expression.SetLocalVariableExpression;
 import org.openzen.zenscript.codemodel.expression.SetterExpression;
 import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
 import org.openzen.zenscript.codemodel.expression.StaticSetterExpression;
+import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
 import org.openzen.zenscript.codemodel.expression.ThisExpression;
 import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
 import org.openzen.zenscript.javabytecode.JavaLocalVariableInfo;
 	public Void visitRange(RangeExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
 	}
+	
+	@Override
+	public Void visitSameObject(SameObjectExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
 
 	@Override
 	public Void visitSetField(SetFieldExpression expression) {
 	public Void visitStaticSetter(StaticSetterExpression expression) {
 		throw new UnsupportedOperationException("Invalid increment target");
 	}
+	
+	@Override
+	public Void visitSupertypeCast(SupertypeCastExpression expression) {
+		throw new UnsupportedOperationException("Invalid increment target");
+	}
 
 	@Override
 	public Void visitThis(ThisExpression expression) {

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

             javaWriter.label(catchStart);
 
             //final Type exceptionType = Type.getType(RuntimeException.class);
-            final Type exceptionType = Type.getType(catchClause.exceptionType.accept(JavaTypeClassVisitor.INSTANCE));
+            final Type exceptionType = Type.getType(catchClause.exceptionVariable.type.accept(JavaTypeClassVisitor.INSTANCE));
             final int local = javaWriter.local(exceptionType);
             javaWriter.store(exceptionType, local);
 

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

         statementVisitor.end();
         return null;
     }
+	
+	@Override
+	public Void visitDestructor(DestructorMember member) {
+		final JavaMethodInfo method = new JavaMethodInfo(toClass, "close", "()V", Opcodes.ACC_PUBLIC);
+
+        final Label constructorStart = new Label();
+        final Label constructorEnd = new Label();
+        final JavaWriter destructorWriter = new JavaWriter(writer, method, definition, null, null);
+        destructorWriter.label(constructorStart);
+
+        final JavaStatementVisitor statementVisitor = new JavaStatementVisitor(destructorWriter);
+        statementVisitor.start();
+		// TODO: destruction of members (to be done when memory tags are implemented)
+        member.body.accept(statementVisitor);
+        destructorWriter.label(constructorEnd);
+        statementVisitor.end();
+        return null;
+	}
 
     @Override
     public Void visitMethod(MethodMember member) {

Parser/src/main/java/org/openzen/zenscript/lexer/ZSTokenStream.java

 		KEYWORDS.put("final", K_FINAL);
 		KEYWORDS.put("override", K_OVERRIDE);
 		KEYWORDS.put("const", K_CONST);
-		KEYWORDS.put("shared", K_SHARED);
-		KEYWORDS.put("weak", K_WEAK);
 		KEYWORDS.put("private", K_PRIVATE);
 		KEYWORDS.put("public", K_PUBLIC);
 		KEYWORDS.put("export", K_EXPORT);

Parser/src/main/java/org/openzen/zenscript/lexer/ZSTokenType.java

 	K_FINAL,
 	K_OVERRIDE,
 	K_CONST,
-	K_SHARED,
-	K_WEAK,
 	K_PRIVATE,
 	K_PUBLIC,
 	K_EXPORT,

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

 		for (ITypeID hint : scope.hints) {
 			// TODO: what if multiple hints fit?
 			if (hint.getUnmodified() instanceof ArrayTypeID) {
-				ArrayTypeID arrayHint = (ArrayTypeID) hint;
+				ArrayTypeID arrayHint = (ArrayTypeID) hint.getUnmodified();
 				if (arrayHint.dimension == 1) {
 					asBaseType = arrayHint.elementType;
 					asType = arrayHint;

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

 			if (!(member instanceof ConstructorMember))
 				throw new CompileException(position, CompileExceptionCode.INTERNAL_ERROR, "Constructor is not a constructor!");
 			
-			return new ConstructorThisCallExpression(position, scope.getThisType().getSuperType(), (ConstructorMember) member, callArguments);
+			return new ConstructorThisCallExpression(position, scope.getThisType().getSuperType(), (ConstructorMember) member, callArguments, scope);
 		} else if (receiver instanceof ParsedExpressionThis) {
 			// this call (intended as first call in constructor)
 			ITypeID targetType = scope.getThisType();
 			if (!(member instanceof ConstructorMember))
 				throw new CompileException(position, CompileExceptionCode.INTERNAL_ERROR, "Constructor is not a constructor!");
 			
-			return new ConstructorThisCallExpression(position, scope.getThisType(), (ConstructorMember) member, callArguments);
+			return new ConstructorThisCallExpression(position, scope.getThisType(), (ConstructorMember) member, callArguments, scope);
 		}
 
 		List<FunctionHeader> headers = cReceiver.getPossibleFunctionHeaders(scope, scope.hints, arguments.arguments.size());

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

 
 	@Override
 	public IPartialExpression compile(ExpressionScope scope) {
+		AssocTypeID assocHint = null;
 		List<ITypeID> keyHints = new ArrayList<>();
 		List<ITypeID> valueHints = new ArrayList<>();
 		
 		boolean hasAssocHint = false;
 		for (ITypeID hint : scope.hints) {
 			if (hint instanceof AssocTypeID) {
-				AssocTypeID assocHint = (AssocTypeID) hint;
+				assocHint = (AssocTypeID) hint;
 				if (!keyHints.contains(assocHint.keyType))
 					keyHints.add(assocHint.keyType);
 				if (!valueHints.contains(assocHint.valueType))
 			}
 		}
 		
+		if (keys.isEmpty() && keyHints.size() == 1) {
+			ICallableMember constructor = scope
+						.getTypeMembers(assocHint)
+						.getOrCreateGroup(OperatorType.CONSTRUCTOR)
+						.selectMethod(position, scope, CallArguments.EMPTY, true, true);
+				return new NewExpression(position, assocHint, (ConstructorMember) constructor, CallArguments.EMPTY);
+		}
+		
 		if (!hasAssocHint && scope.hints.size() == 1 && scope.hints.get(0) != BasicTypeID.ANY) {
 			// compile as constructor call
 			ITypeID hint = scope.hints.get(0);

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

 
 	@Override
 	public IPartialExpression compile(ExpressionScope scope) {
-		if (scope.hints.contains(BasicTypeID.CHAR) && value.length() == 1) {
-			return new ConstantCharExpression(position, value.charAt(0));
+		if (value.length() == 1) {
+			if (scope.hints.contains(BasicTypeID.CHAR)) {
+				return new ConstantCharExpression(position, value.charAt(0));
+			} else if (!scope.hints.contains(BasicTypeID.STRING)) {
+				if (scope.hints.contains(BasicTypeID.INT))
+					return new ConstantCharExpression(position, value.charAt(0));
+			}
 		}
 		
 		return new ConstantStringExpression(position, value);

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

 		if (!(member instanceof ConstructorMember))
 			throw new CompileException(position, CompileExceptionCode.INTERNAL_ERROR, "COMPILER BUG: constructor is not a constructor");
 		
+		for (int i = 0; i < compiledArguments.arguments.length; i++) {
+			compiledArguments.arguments[i] = compiledArguments.arguments[i].castImplicit(position, scope, member.getHeader().parameters[i].type);
+		}
 		return new NewExpression(position, type, (ConstructorMember) member, compiledArguments);
 	}
 }

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

 				return new ParsedCaller(start, forDefinition, modifiers, header, body);
 			}
 			case T_SQOPEN: {
+				tokens.next();
 				tokens.required(ZSTokenType.T_SQCLOSE, "] expected");
 				OperatorType operator = OperatorType.INDEXGET;
 				if (tokens.optional(ZSTokenType.T_ASSIGN) != null) {
 				ParsedFunctionBody body = ParsedStatement.parseFunctionBody(tokens);
 				return new ParsedOperator(start, forDefinition, modifiers, operator, header, body);
 			}
+			case T_CAT:
+				tokens.pushMark();
+				tokens.next();
+				if (tokens.optional(ZSTokenType.K_THIS) != null) {
+					tokens.popMark();
+					
+					// destructor
+					ParsedFunctionBody body = ParsedStatement.parseFunctionBody(tokens);
+					return new ParsedDestructor(start, forDefinition, modifiers, body);
+				}
+				tokens.reset();
+				// else it is a ~ operator, continue...
 			case T_ADD:
 			case T_SUB:
-			case T_CAT:
 			case T_MUL:
 			case T_DIV:
 			case T_MOD:

Parser/src/main/java/org/openzen/zenscript/parser/member/ParsedDestructor.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.member;
+
+import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.member.DestructorMember;
+import org.openzen.zenscript.linker.BaseScope;
+import org.openzen.zenscript.parser.statements.ParsedFunctionBody;
+import org.openzen.zenscript.shared.CodePosition;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class ParsedDestructor extends ParsedFunctionalMember {
+	public ParsedDestructor(CodePosition position, HighLevelDefinition definition, int modifiers, ParsedFunctionBody body) {
+		super(position, definition, modifiers, body);
+	}
+
+	@Override
+	public void linkTypes(BaseScope scope) {
+		compiled = new DestructorMember(position, definition, modifiers);
+	}
+}

Parser/src/main/java/org/openzen/zenscript/parser/statements/ParsedCatchClause.java

  */
 package org.openzen.zenscript.parser.statements;
 
+import java.util.List;
+import java.util.function.Function;
+import org.openzen.zenscript.codemodel.FunctionHeader;
+import org.openzen.zenscript.codemodel.expression.Expression;
+import org.openzen.zenscript.codemodel.expression.GetLocalVariableExpression;
+import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.statement.CatchClause;
+import org.openzen.zenscript.codemodel.statement.LoopStatement;
+import org.openzen.zenscript.codemodel.statement.VarStatement;
+import org.openzen.zenscript.codemodel.type.GenericName;
+import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.type.member.LocalMemberCache;
 import org.openzen.zenscript.linker.StatementScope;
 import org.openzen.zenscript.parser.type.IParsedType;
+import org.openzen.zenscript.shared.CodePosition;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class ParsedCatchClause {
+	public final CodePosition position;
 	public final String exceptionName;
 	public final IParsedType exceptionType;
 	public final ParsedStatement content;
 	
-	public ParsedCatchClause(String exceptionName, IParsedType exceptionType, ParsedStatement content) {
+	public ParsedCatchClause(CodePosition position, String exceptionName, IParsedType exceptionType, ParsedStatement content) {
+		this.position = position;
 		this.exceptionName = exceptionName;
 		this.exceptionType = exceptionType;
 		this.content = content;
 	}
 	
 	public CatchClause compile(StatementScope scope) {
-		return new CatchClause(exceptionName, exceptionType.compile(scope), content.compile(scope));
+		VarStatement exceptionVariable = new VarStatement(position, exceptionName, exceptionType.compile(scope), null, true);
+		CatchScope localScope = new CatchScope(scope, exceptionVariable);
+		return new CatchClause(position, exceptionVariable, content.compile(localScope));
+	}
+	
+	private class CatchScope extends StatementScope {
+		private final StatementScope outer;
+		private final VarStatement exceptionVariable;
+		
+		public CatchScope(StatementScope outer, VarStatement exceptionVariable) {
+			this.outer = outer;
+			this.exceptionVariable = exceptionVariable;
+		}
+	
+		@Override
+		public IPartialExpression get(CodePosition position, GenericName name) {
+			if (name.hasNoArguments() && exceptionVariable.name.equals(name.name))
+				return new GetLocalVariableExpression(position, exceptionVariable);
+
+			return outer.get(position, name);
+		}
+
+		@Override
+		public LocalMemberCache getMemberCache() {
+			return outer.getMemberCache();
+		}
+
+		@Override
+		public ITypeID getType(CodePosition position, List<GenericName> name) {
+			return outer.getType(position, name);
+		}
+
+		@Override
+		public LoopStatement getLoop(String name) {
+			return outer.getLoop(name);
+		}
+
+		@Override
+		public FunctionHeader getFunctionHeader() {
+			return outer.getFunctionHeader();
+		}
+
+		@Override
+		public ITypeID getThisType() {
+			return outer.getThisType();
+		}
+
+		@Override
+		public Function<CodePosition, Expression> getDollar() {
+			return outer.getDollar();
+		}
+
+		@Override
+		public IPartialExpression getOuterInstance(CodePosition position) {
+			return outer.getOuterInstance(position);
+		}
 	}
 }

Parser/src/main/java/org/openzen/zenscript/parser/statements/ParsedStatement.java

 				ParsedStatement content = parse(parser);
 				List<ParsedCatchClause> catchClauses = new ArrayList<>();
 				while (parser.optional(K_CATCH) != null) {
+					CodePosition position = parser.getPosition();
+					
 					String catchName = null;
 					if (parser.isNext(ZSTokenType.T_IDENTIFIER))
 						catchName = parser.next().content;
 						catchType = IParsedType.parse(parser);
 					
 					ParsedStatement catchContent = ParsedStatement.parse(parser);
-					catchClauses.add(new ParsedCatchClause(catchName, catchType, catchContent));
+					catchClauses.add(new ParsedCatchClause(position, catchName, catchType, catchContent));
 				}
 				
 				ParsedStatement finallyClause = null;

Parser/src/main/java/org/openzen/zenscript/parser/statements/ParsedStatementTryCatch.java

 		Expression resourceInitializer = this.resourceInitializer == null ? null : this.resourceInitializer.compile(new ExpressionScope(scope)).eval();
 		Statement statement = this.statement.compile(scope);
 		List<CatchClause> catches = new ArrayList<>();
-		for (ParsedCatchClause catchClause : catchClauses)
+		for (ParsedCatchClause catchClause : catchClauses) {
 			catches.add(catchClause.compile(scope));
+		}
 		
 		Statement finallyClause = this.finallyClause == null ? null : this.finallyClause.compile(scope);
 		VarStatement resource = null;

Parser/src/main/java/org/openzen/zenscript/parser/type/IParsedType.java

 		while (true) {
 			if (tokens.optional(ZSTokenType.K_CONST) != null) {
 				modifiers |= TypeMembers.MODIFIER_CONST;
-			} else if (tokens.optional(ZSTokenType.K_SHARED) != null) {
-				modifiers |= TypeMembers.MODIFIER_SHARED;
-			} else if (tokens.optional(ZSTokenType.K_WEAK) != null) {
-				modifiers |= TypeMembers.MODIFIER_WEAK;
 			} else {
 				break;
 			}

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

 		INVALID_SOURCE_TYPE,
 		SETTING_FINAL_FIELD,
 		SETTING_FINAL_VARIABLE,
-		INVALID_SUPERTYPE
+		INVALID_SUPERTYPE,
+		MULTIPLE_DESTRUCTORS
 	}
 }

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

 import org.openzen.zenscript.codemodel.member.CasterMember;
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
 import org.openzen.zenscript.codemodel.member.CustomIteratorMember;
+import org.openzen.zenscript.codemodel.member.DestructorMember;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 import org.openzen.zenscript.codemodel.member.FieldMember;
 import org.openzen.zenscript.codemodel.member.GetterMember;
 	private final HighLevelDefinition definition;
 	private final Set<EnumConstantMember> initializedEnumConstants = new HashSet<>();
 	private final Set<ITypeID> implementedTypes = new HashSet<>();
+	private boolean hasDestructor = false;
 	
 	public DefinitionMemberValidator(Validator validator, HighLevelDefinition definition) {
 		this.validator = validator;
 		
 		return isValid;
 	}
+	
+	@Override
+	public Boolean visitDestructor(DestructorMember member) {
+		boolean isValid = true;
+		if (hasDestructor) {
+			validator.logError(ValidationLogEntry.Code.MULTIPLE_DESTRUCTORS, member.position, "A type have only a single destructor");
+			isValid = false;
+		}
+		hasDestructor = true;
+		if (member.body != null) {
+			StatementValidator statementValidator = new StatementValidator(validator, new ConstructorStatementScope(member.header));
+			isValid &= member.body.accept(statementValidator);
+		}
+		return isValid;
+	}
 
 	@Override
 	public Boolean visitMethod(MethodMember member) {

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

 
 	@Override
 	public Boolean visitStruct(StructDefinition definition) {
+		int validModifiers = PUBLIC | EXPORT | PROTECTED | PRIVATE;
+		if (definition.outerDefinition != null)
+			validModifiers |= STATIC;
+		
 		boolean isValid = true;
 		isValid &= ValidationUtils.validateModifiers(
 				validator,
 				definition.modifiers,
-				PUBLIC | EXPORT | PROTECTED | PRIVATE,
+				validModifiers,
 				definition.position,
 				"Invalid struct modifier");
 		isValid &= ValidationUtils.validateIdentifier(

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

 import org.openzen.zenscript.codemodel.expression.OrOrExpression;
 import org.openzen.zenscript.codemodel.expression.PostCallExpression;
 import org.openzen.zenscript.codemodel.expression.RangeExpression;
+import org.openzen.zenscript.codemodel.expression.SameObjectExpression;
 import org.openzen.zenscript.codemodel.expression.SetFieldExpression;
 import org.openzen.zenscript.codemodel.expression.SetFunctionParameterExpression;
 import org.openzen.zenscript.codemodel.expression.SetLocalVariableExpression;
 import org.openzen.zenscript.codemodel.expression.SetterExpression;
 import org.openzen.zenscript.codemodel.expression.StaticGetterExpression;
 import org.openzen.zenscript.codemodel.expression.StaticSetterExpression;
+import org.openzen.zenscript.codemodel.expression.SupertypeCastExpression;
 import org.openzen.zenscript.codemodel.expression.ThisExpression;
 import org.openzen.zenscript.codemodel.expression.WrapOptionalExpression;
 import org.openzen.zenscript.codemodel.type.ArrayTypeID;
 		}
 		return isValid;
 	}
+	
+	@Override
+	public Boolean visitSameObject(SameObjectExpression expression) {
+		boolean isValid = true;
+		isValid &= expression.left.accept(this);
+		isValid &= expression.right.accept(this);
+		return isValid;
+	}
 
 	@Override
 	public Boolean visitSetField(SetFieldExpression expression) {
 		return isValid;
 	}
 
+	@Override
+	public Boolean visitSupertypeCast(SupertypeCastExpression expression) {
+		boolean isValid = expression.value.accept(this);
+		return isValid;
+	}
+
 	@Override
 	public Boolean visitThis(ThisExpression expression) {
 		if (!scope.hasThis()) {