Give a more descriptive error for invalid constant sizes

Author: jaredlll08

CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/CastedEval.java

@@ -109,4 +109,8 @@ public CastedExpression of(CastedExpression.Level level, Expression value) {
 	public CastedExpression invalid(CompileError error) {
 		return CastedExpression.invalid(position, error);
 	}
+
+	public boolean isExplicit() {
+		return explicit;
+	}
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/compilation/CompileErrors.java

@@ -170,6 +170,10 @@ public static CompileError cannotCast(TypeID fromType, TypeID toType, boolean ex
 		}
 	}
 
+	public static CompileError constantSize(long value, TypeID toType) {
+		return new CompileError(CompileExceptionCode.INVALID_CAST, "Cannot fit " + value + " in type " + toType);
+	}
+
 	public static CompileError bracketMultipleExpressions() {
 		return new CompileError(CompileExceptionCode.BRACKET_MULTIPLE_EXPRESSIONS, "Bracket expression may have only one expression");
 	}

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

@@ -12,8 +12,10 @@
 import org.openzen.zenscript.codemodel.type.TypeID;
 
 import java.util.Optional;
+import java.util.function.BiFunction;
+import java.util.function.Supplier;
 
-public class 	ParsedExpressionInt extends ParsedExpression {
+public class ParsedExpressionInt extends ParsedExpression {
 	public final boolean negative;
 	public final long value;
 	public final String suffix;
@@ -164,23 +166,23 @@ private CastedExpression asInt(CastedEval cast, BasicTypeID type) {
 			long signed = negative ? -value : value;
 			switch (type) {
 				case SBYTE:
-					return cast.of(level(signed >= Byte.MIN_VALUE && signed <= Byte.MAX_VALUE), new ConstantSByteExpression(position, (byte)value));
+					return castIfFits(cast, signed >= Byte.MIN_VALUE && signed <= Byte.MAX_VALUE, (position, value) -> new ConstantSByteExpression(position, value.byteValue()));
 				case BYTE:
-					return cast.of(level(!negative && value <= 0xFF), new ConstantByteExpression(position, (int)value));
+					return castIfFits(cast, !negative && value <= 0xFF, (position, value) -> new ConstantByteExpression(position, value.intValue()));
 				case SHORT:
-					return cast.of(level(signed >= Short.MIN_VALUE && signed <= Short.MAX_VALUE), new ConstantShortExpression(position, (short) value));
+					return castIfFits(cast, signed >= Short.MIN_VALUE && signed <= Short.MAX_VALUE, (position, value) -> new ConstantShortExpression(position, value.shortValue()));
 				case USHORT:
-					return cast.of(level(!negative && value <= 0xFFFF), new ConstantUShortExpression(position, (int)value));
+					return castIfFits(cast, !negative && value <= 0xFFFF, (position, value) -> new ConstantUShortExpression(position, value.intValue()));
 				case INT:
-					return cast.of(level(signed >= Integer.MIN_VALUE && signed <= Integer.MAX_VALUE), new ConstantIntExpression(position, (int)value));
+					return castIfFits(cast, signed >= Integer.MIN_VALUE && signed <= Integer.MAX_VALUE, (position, value) -> new ConstantIntExpression(position, value.intValue()));
 				case UINT:
-					return cast.of(level(!negative && value <= 0xFFFFFFFFL), new ConstantUIntExpression(position, (int)value));
+					return castIfFits(cast, !negative && value <= 0xFFFFFFFFL, (position, value) -> new ConstantUIntExpression(position, value.intValue()));
 				case USIZE:
-					return cast.of(level(!negative && value <= 0xFFFFFFFFL), new ConstantUSizeExpression(position, value));
+					return castIfFits(cast, !negative && value <= 0xFFFFFFFFL, ConstantUSizeExpression::new);
 				case LONG:
 					return cast.of(new ConstantLongExpression(position, value));
 				case ULONG:
-					return cast.of(level(!negative), new ConstantULongExpression(position, value));
+					return castIfFits(cast, !negative, ConstantULongExpression::new);
 				case FLOAT:
 					return cast.of(new ConstantFloatExpression(position, value));
 				case DOUBLE:
@@ -190,6 +192,15 @@ private CastedExpression asInt(CastedEval cast, BasicTypeID type) {
 			return cast.of(eval());
 		}
 
+		private CastedExpression castIfFits(CastedEval cast, boolean fits, BiFunction<CodePosition, Long, Expression> expr){
+			if(fits) {
+				return cast.of(CastedExpression.Level.EXACT, expr.apply(this.position, this.value));
+			} else if(cast.isExplicit()) {
+				return cast.of(CastedExpression.Level.EXPLICIT, expr.apply(this.position, this.value));
+			}
+			return cast.invalid(CompileErrors.constantSize(this.value,cast.type));
+		}
+
 		private boolean isIntegerType(TypeID type) {
 			return type == BasicTypeID.BYTE
 					|| type == BasicTypeID.SBYTE
@@ -202,9 +213,6 @@ private boolean isIntegerType(TypeID type) {
 					|| type == BasicTypeID.USIZE;
 		}
 
-		private CastedExpression.Level level(boolean fits) {
-			return fits ? CastedExpression.Level.EXACT : CastedExpression.Level.EXPLICIT;
-		}
 	}
 
 	@Override

ScriptingEngineTester/src/main/resources/zencode_tests/types/invalid_constant_size.zc

@@ -0,0 +1,6 @@
+#error: 6:INVALID_CAST
+function foo(i: int) {
+	println(i);
+}
+
+foo(0xFFFFFFFF);