Added Typemember check without storage tags.

Only WIP, tries to check the same type without storage tags and see if it can cast then.

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

@@ -0,0 +1,70 @@
+package org.openzen.zenscript.codemodel.type.member;
+
+import org.openzen.zenscript.codemodel.type.*;
+
+import java.util.Arrays;
+
+public class TagRemovingTypeVisitor implements TypeVisitor<StoredType> {
+    
+    private final LocalMemberCache cache;
+    
+    public TagRemovingTypeVisitor(LocalMemberCache cache) {
+        
+        this.cache = cache;
+    }
+    
+    @Override
+    public StoredType visitBasic(BasicTypeID basic) {
+        return basic.stored;
+    }
+    
+    @Override
+    public StoredType visitString(StringTypeID string) {
+        return string.stored();
+    }
+    
+    @Override
+    public StoredType visitArray(ArrayTypeID array) {
+        return new ArrayTypeID(cache.getRegistry(), array.elementType.type.accept(this), array.dimension).stored();
+    }
+    
+    @Override
+    public StoredType visitAssoc(AssocTypeID assoc) {
+        return new AssocTypeID(cache.getRegistry(), assoc.keyType.type.accept(this), assoc.valueType.type.accept(this)).stored();
+    }
+    
+    @Override
+    public StoredType visitGenericMap(GenericMapTypeID map) {
+        return new GenericMapTypeID(cache.getRegistry(), map.value.type.accept(this), map.key).stored();
+    }
+    
+    @Override
+    public StoredType visitIterator(IteratorTypeID iterator) {
+        return new IteratorTypeID(cache.getRegistry(), Arrays.stream(iterator.iteratorTypes).map(storedType -> storedType.type).map(typeID -> typeID.accept(this)).toArray(StoredType[]::new)).stored();
+    }
+    
+    @Override
+    public StoredType visitFunction(FunctionTypeID function) {
+        return function.stored();
+    }
+    
+    @Override
+    public StoredType visitDefinition(DefinitionTypeID definition) {
+        return definition.stored();
+    }
+    
+    @Override
+    public StoredType visitGeneric(GenericTypeID generic) {
+        return generic.stored();
+    }
+    
+    @Override
+    public StoredType visitRange(RangeTypeID range) {
+        return new RangeTypeID(cache.getRegistry(), range.baseType.type.accept(this)).stored;
+    }
+    
+    @Override
+    public StoredType visitOptional(OptionalTypeID type) {
+        return new OptionalTypeID(cache.getRegistry(), type.baseType.accept(this).type).stored();
+    }
+}

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

@@ -411,8 +411,15 @@ public final class TypeMembers {
 			return true;
 		if (type.isOptional() && areEquivalent(type.withoutOptional(), toType))
 			return true;
+   
+		if( getImplicitCaster(toType) != null || extendsOrImplements(toType.type))
+		    return true;
 		
-		return getImplicitCaster(toType) != null || extendsOrImplements(toType.type);
+        final StoredType accept = type.type.accept(new TagRemovingTypeVisitor(cache));
+        if(!this.type.type.equals(accept.type) && cache.get(accept).canCastImplicit(toType)){
+            return true;
+        }
+        return false;
 	}
 	
 	private boolean areEquivalent(StoredType fromType, StoredType toType) {
@@ -571,7 +578,12 @@ public final class TypeMembers {
 		if (this.canCastImplicit(toType))
 			return castImplicit(position, value, toType, false);
 		
-		for (TypeMember<CasterMemberRef> caster : casters)
+        final TypeMembers typeMembers = cache.get(type.type.accept(new TagRemovingTypeVisitor(cache)));
+        if(this.type.type != typeMembers.type.type && typeMembers.canCast(toType)) {
+            return typeMembers.castExplicit(position, value, toType, optional);
+        }
+        
+        for (TypeMember<CasterMemberRef> caster : casters)
 			if (areEquivalent(caster.member.toType, toType))
 				return castEquivalent(position, caster.member.cast(position, value, false), toType);
 		

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

@@ -81,16 +81,16 @@ public class ParsedExpressionMap extends ParsedExpression {
 			return new NewExpression(position, usedHint, constructor, CallArguments.EMPTY);
 		}
 		
-		if (!hasAssocHint && scope.hints.size() == 1) {
-			// compile as constructor call
-			StoredType hint = scope.hints.get(0);
-			for (int i = 0; i < keys.size(); i++) {
-				if (keys.get(i) != null)
-					throw new CompileException(position, CompileExceptionCode.UNSUPPORTED_NAMED_ARGUMENTS, "Named constructor arguments not yet supported");
-			}
-			ParsedCallArguments arguments = new ParsedCallArguments(null, values);
-			return ParsedNewExpression.compile(position, hint, arguments, scope);
-		}
+		//if (!hasAssocHint && scope.hints.size() == 1) {
+		//	// compile as constructor call
+		//	StoredType hint = scope.hints.get(0);
+		//	for (int i = 0; i < keys.size(); i++) {
+		//		if (keys.get(i) != null)
+		//			throw new CompileException(position, CompileExceptionCode.UNSUPPORTED_NAMED_ARGUMENTS, "Named constructor arguments not yet supported");
+		//	}
+		//	ParsedCallArguments arguments = new ParsedCallArguments(null, values);
+		//	return ParsedNewExpression.compile(position, hint, arguments, scope);
+		//}
 		
 		Expression[] cKeys = new Expression[keys.size()];
 		Expression[] cValues = new Expression[values.size()];