Further generics fixes

Author: LadyCailin

.gitignore

@@ -17,6 +17,7 @@ nbactions.xml
 /preferences.*
 .DS_Store
 /test-backend/
+.mvn/
 /nbproject/
 dependency-reduced-pom.xml
 

pom.xml

@@ -1071,7 +1071,7 @@
 			<plugin>
 				<groupId>org.jacoco</groupId>
 				<artifactId>jacoco-maven-plugin</artifactId>
-				<version>0.8.7</version>
+				<version>0.8.14</version>
 				<executions>
 					<execution>
 						<id>default-prepare-agent</id>
@@ -1177,7 +1177,7 @@
 					<plugin>
 						<groupId>org.jacoco</groupId>
 						<artifactId>jacoco-maven-plugin</artifactId>
-						<version>0.8.7</version>
+						<version>0.8.14</version>
 						<configuration>
 							<skip>true</skip>
 						</configuration>
@@ -1242,7 +1242,7 @@
 			<plugin>
 				<groupId>org.jacoco</groupId>
 				<artifactId>jacoco-maven-plugin</artifactId>
-				<version>0.8.7</version>
+				<version>0.8.14</version>
 				<reportSets>
 					<reportSet>
 						<reports>

src/main/java/com/laytonsmith/core/MethodScriptCompiler.java

@@ -21,6 +21,7 @@
 import com.laytonsmith.core.compiler.TokenStream;
 import com.laytonsmith.core.compiler.analysis.StaticAnalysis;
 import com.laytonsmith.core.constructs.CBareString;
+import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.CDecimal;
 import com.laytonsmith.core.constructs.CDouble;
 import com.laytonsmith.core.constructs.CFunction;
@@ -36,7 +37,7 @@
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.IVariable;
-import com.laytonsmith.core.constructs.SourceType;
+import com.laytonsmith.core.constructs.LeftHandSideType;
 import com.laytonsmith.core.constructs.Target;
 import com.laytonsmith.core.constructs.Token;
 import com.laytonsmith.core.constructs.Token.TType;
@@ -1754,7 +1755,7 @@ public static ParseTree compile(TokenStream stream, Environment env,
 				if(!(previous.getData() instanceof SourceType st)) {
 					throw new ConfigCompileException("Unexpected varargs token (\"...\"). This can only be used with types.", t.target);
 				}
-				previous.setData(st.asVariadicType(env));
+				previous.setData(st.asLeftHandSideType().asVariadicType(t.getTarget(), env));
 				continue;
 			} else if(t.type == TType.LIT) {
 				Construct c;

src/main/java/com/laytonsmith/core/Procedure.java

@@ -52,9 +52,8 @@ public class Procedure implements Cloneable {
 	private Map<String, IVariable> varList;
 	private final Map<String, Mixed> originals = new HashMap<>();
 	private final List<IVariable> varIndex = new ArrayList<>();
-	private final List<Boolean> isVarArg;
 	private ParseTree tree;
-	private CClassType returnType;
+	private LeftHandSideType returnType;
 	private boolean possiblyConstant = false;
 	private SmartComment procComment;
 
@@ -64,7 +63,7 @@ public class Procedure implements Cloneable {
 	 */
 	private final Target definedAt;
 
-	public Procedure(String name, CClassType returnType, List<IVariable> varList, List<Boolean> isVarArg,
+	public Procedure(String name, LeftHandSideType returnType, List<IVariable> varList,
 			SmartComment procComment,
 			ParseTree tree, Target t) {
 		this.name = name;
@@ -96,7 +95,6 @@ public Procedure(String name, CClassType returnType, List<IVariable> varList, Li
 		//we can be sure that we cannot inline this in any way.
 		this.possiblyConstant = checkPossiblyConstant(tree);
 		this.returnType = returnType;
-		this.isVarArg = isVarArg;
 	}
 
 	private boolean checkPossiblyConstant(ParseTree tree) {
@@ -222,7 +220,7 @@ public Mixed execute(List<Mixed> args, Environment oldEnv, Target t) {
 		CArray vararg = null;
 		for(varInd = 0; varInd < args.size(); varInd++) {
 			Mixed c = args.get(varInd);
-			arguments.push(c, t);
+			arguments.push(c, t, env);
 			if(this.varIndex.size() > varInd
 					|| (!this.varIndex.isEmpty()
 						&& this.varIndex.get(this.varIndex.size() - 1).getDefinedType().isVariadicType())) {
@@ -234,7 +232,8 @@ public Mixed execute(List<Mixed> args, Environment oldEnv, Target t) {
 					var = this.varIndex.get(this.varIndex.size() - 1);
 					if(vararg == null) {
 						vararg = new CArray(t, GenericParameters.emptyBuilder(CArray.TYPE)
-								.addParameter(var.getDefinedType()).build(t, env), env);
+								.addParameter(var.getDefinedType().getVarargsBaseType(env))
+								.build(t, env), env);
 						try {
 							env.getEnv(GlobalEnv.class).GetVarList().set(new IVariable(CArray.TYPE,
 									var.getVariableName(), vararg, c.getTarget()));
@@ -254,7 +253,7 @@ public Mixed execute(List<Mixed> args, Environment oldEnv, Target t) {
 
 				// Type check vararg parameter.
 				if(var.getDefinedType().isVariadicType()) {
-					if(InstanceofUtil.isInstanceof(c.typeof(env), var.getDefinedType().getVarargsBaseType(), env)) {
+					if(InstanceofUtil.isInstanceof(c, var.getDefinedType().getVarargsBaseType(env), env)) {
 						vararg.push(c, t, env);
 						continue;
 					} else {
@@ -265,7 +264,7 @@ public Mixed execute(List<Mixed> args, Environment oldEnv, Target t) {
 				}
 
 				// Type check non-vararg parameter.
-				if(InstanceofUtil.isInstanceof(c.typeof(env), var.getDefinedType(), env)) {
+				if(InstanceofUtil.isInstanceof(c, var.getDefinedType(), env)) {
 					try {
 						env.getEnv(GlobalEnv.class).GetVarList().set(new IVariable(var.getDefinedType(),
 								var.getVariableName(), c, c.getTarget(), env));
@@ -321,12 +320,12 @@ public Mixed execute(List<Mixed> args, Environment oldEnv, Target t) {
 		} catch (FunctionReturnException e) {
 			// Normal exit
 			Mixed ret = e.getReturn();
-			if(returnType.equals(Auto.TYPE)) {
+			if(returnType.equals(Auto.LHSTYPE)) {
 				return ret;
 			}
-			if(returnType.equals(CVoid.TYPE) != ret.equals(CVoid.VOID)
+			if(returnType.equals(CVoid.TYPE.asLeftHandSideType()) != ret.equals(CVoid.VOID)
 					|| !ret.equals(CNull.NULL) && !ret.equals(CVoid.VOID)
-					&& !InstanceofUtil.isInstanceof(ret.typeof(env), returnType, env)) {
+					&& !InstanceofUtil.isInstanceof(ret, returnType, env)) {
 				throw new CRECastException("Expected procedure \"" + name + "\" to return a value of type "
 						+ returnType.val() + " but a value of type " + ret.typeof(env) + " was returned instead",
 						ret.getTarget());
@@ -351,7 +350,7 @@ public Mixed execute(List<Mixed> args, Environment oldEnv, Target t) {
 		// If we got here, then there was no return value. This is fine, but only for returnType void or auto.
 		// TODO: Once strong typing is implemented at a compiler level, this should be removed to increase runtime
 		// performance.
-		if(!(returnType.equals(Auto.TYPE) || returnType.equals(CVoid.TYPE))) {
+		if(!(returnType.equals(Auto.LHSTYPE) || returnType.equals(CVoid.TYPE.asLeftHandSideType()))) {
 			throw new CRECastException("Expecting procedure \"" + name + "\" to return a value of type " + returnType.val() + ","
 					+ " but no value was returned.", tree.getTarget());
 		}
@@ -379,7 +378,7 @@ public void definitelyNotConstant() {
 	}
 
 	public LeftHandSideType getReturnType() {
-		return returnType.asLeftHandSideType();
+		return returnType;
 	}
 
 	public List<LeftHandSideType> getParameterTypes() {

src/main/java/com/laytonsmith/core/SourceType.java

@@ -0,0 +1,32 @@
+package com.laytonsmith.core;
+
+import com.laytonsmith.core.constructs.CClassType;
+import com.laytonsmith.core.constructs.LeftHandSideType;
+import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.exceptions.CRE.CREIllegalArgumentException;
+
+/**
+ * A SourceType is a type that can be represented in code.
+ * @author Cailin
+ */
+public interface SourceType {
+
+	/**
+	 * Returns this type as a LeftHandSideType.
+	 * @return
+	 */
+	LeftHandSideType asLeftHandSideType();
+
+	/**
+	 * If and only if this was constructed in such a way that it could have been a CClassType to begin with, this
+	 * function will return the CClassType. This is generally useful when converting initially from a CClassType, and
+	 * then getting that value back, however, it can be used anyways if the parameters are such that it's allowed. In
+	 * particular, this cannot be a type union, and the LeftHandGenericUse statement must be null. (There may be
+	 * concrete generic parameters attached to the underlying CClassType though.) If these requirements are not met, a
+	 * CREIllegalArgumentException is thrown.
+	 *
+	 * @param t
+	 * @return
+	 */
+	CClassType asConcreteType(Target t) throws CREIllegalArgumentException;
+}

src/main/java/com/laytonsmith/core/constructs/Auto.java

@@ -1,5 +1,7 @@
 package com.laytonsmith.core.constructs;
 
+import com.laytonsmith.core.exceptions.ConfigCompileException;
+
 /**
  * Auto is not a real type, but we need a placeholder for a few meta things, such as the CClassType for it.
  *
@@ -9,4 +11,12 @@ public class Auto {
 
 	public static final CClassType TYPE = CClassType.AUTO;
 	public static final LeftHandSideType LHSTYPE = TYPE.asLeftHandSideType();
+	public static final LeftHandSideType LHSTYPE_VARIADIC;
+	static {
+		try {
+			LHSTYPE_VARIADIC = LHSTYPE.asVariadicType(Target.UNKNOWN, null);
+		} catch(ConfigCompileException ex) {
+			throw new Error();
+		}
+	}
 }

src/main/java/com/laytonsmith/core/constructs/CClassType.java

@@ -39,6 +39,7 @@
 import com.laytonsmith.core.objects.ObjectType;
 import com.laytonsmith.core.objects.UserObject;
 import com.laytonsmith.PureUtilities.Common.Annotations.AggressiveDeprecation;
+import com.laytonsmith.core.SourceType;
 
 import java.net.URL;
 import java.util.ArrayList;
@@ -58,6 +59,13 @@
 /**
  * A CClassType represents a reference to a MethodScript class, which is generally used on the right hand side. See
  * {@link LeftHandSideType} for the left hand side equivalent.
+ * <p>
+ * There are major differences in how CClassTypes are handled, compared to for instance LeftHandSideTypes.
+ * For any given class, there can only be one CClassType instance, for any given set of generic parameters.
+ * CClassType can always be represented as a LeftHandSideType, but there can be multiple LeftHandSideTypes that
+ * represent the same type - these represent specific usages of the type in certain places in the code, not the
+ * type itself. For this reason, CClassType cannot represent variadic types, because that is a call site specific
+ * concept.
  */
 @typeof("ms.lang.ClassType")
 @SuppressWarnings("checkstyle:overloadmethodsdeclarationorder")
@@ -248,8 +256,6 @@ public Class<? extends Documentation>[] seeAlso() {
 	private final FullyQualifiedClassName fqcn;
 	@StandardField
 	private final GenericTypeParameters genericParameters;
-	@StandardField
-	private boolean isVariadicType = false;
 
 	/**
 	 * This is an invalid instance of the underlying type that can only be used for Documentation purposes or finding
@@ -848,6 +854,11 @@ public Set<ObjectModifier> getObjectModifiers() {
 		return EnumSet.of(ObjectModifier.FINAL);
 	}
 
+	public Set<ObjectModifier> getTypeObjectModifiers(Environment env) {
+		instantiateInvalidType(env);
+		return invalidType.getObjectModifiers();
+	}
+
 	@Override
 	public Version since() {
 		return MSVersion.V3_3_1;
@@ -1068,10 +1079,16 @@ public GenericParameters getGenericParameters() {
 	 * Converts this concrete type into a LHS type. This will always work, since all concrete types can be
 	 * represented as LHS types.
 	 */
+	@Override
 	public LeftHandSideType asLeftHandSideType() {
 		return LeftHandSideType.fromHardCodedType(this);
 	}
 
+	@Override
+	public CClassType asConcreteType(Target t) {
+		return this;
+	}
+
 	/**
 	 * Returns the set of generic parameters for the given superclass, perhaps using the parameters provided to the
 	 * specific subclass. For instance, if we have {@code class A<T, U> extends B<U>}, and we want to see if the value
@@ -1294,22 +1311,4 @@ private boolean containsNakedClassType(FullyQualifiedClassName fqcn) {
 			return contains(fqcn, null);
 		}
 	}
-
-	@Override
-	public boolean isVariadicType() {
-		return isVariadicType;
-	}
-
-	@Override
-	public SourceType asVariadicType(Environment env) {
-		CClassType newType;
-		try {
-			newType = new CClassType(this.fqcn.asVariadicType(), getTarget(), false,
-					this.genericDeclaration, env, this.nativeClass);
-		} catch(ClassNotFoundException ex) {
-			throw new Error(ex);
-		}
-		newType.isVariadicType = true;
-		return newType;
-	}
 }

src/main/java/com/laytonsmith/core/constructs/CClosure.java

@@ -55,7 +55,6 @@ public class CClosure extends Construct implements Callable, Booleanish {
 	protected final Mixed[] defaults;
 	protected final LeftHandSideType[] types;
 	protected final LeftHandSideType returnType;
-	protected final Boolean[] isVarArgs;
 
 	private static final Constraints RETURN_TYPE = new Constraints(Target.UNKNOWN, ConstraintLocation.DEFINITION, new UnboundedConstraint(Target.UNKNOWN, "ReturnType"));
 	private static final Constraints PARAMETERS = new Constraints(Target.UNKNOWN, ConstraintLocation.DEFINITION, new VariadicTypeConstraint(Target.UNKNOWN, "Parameters"));
@@ -68,14 +67,13 @@ public class CClosure extends Construct implements Callable, Booleanish {
 				.addParameter("Parameters", PARAMETERS));
 
 	public CClosure(ParseTree node, Environment env, LeftHandSideType returnType, String[] names, Mixed[] defaults,
-			Boolean[] isVarArgs, LeftHandSideType[] types, Target t) {
+			LeftHandSideType[] types, Target t) {
 		super(node != null ? node.toString() : "", ConstructType.CLOSURE, t);
 		this.node = node;
 		this.env = env;
 		this.names = names;
 		this.defaults = defaults;
 		this.types = types;
-		this.isVarArgs = isVarArgs;
 		if(types.length > 0) {
 			for(int i = 0; i < types.length - 1; i++) {
 				if(types[i].isVariadicType()) {
@@ -262,21 +260,21 @@ protected void execute(Mixed... values) throws ConfigRuntimeException, ProgramFl
 						} else {
 							name = this.names[this.names.length - 1];
 							if(vararg == null) {
-								// TODO: Once generics are added, add the type
+								varargType = this.types[this.types.length - 1].getVarargsBaseType(env);
 								vararg = new CArray(value.getTarget(), GenericParameters.emptyBuilder(CArray.TYPE)
-									.addParameter(varargType).build(getTarget(), env), env);
+									.addParameter(varargType)
+									.build(getTarget(), env), env);
 								try {
 									env.getEnv(GlobalEnv.class).GetVarList().set(new IVariable(CArray.TYPE,
 											name, vararg, value.getTarget()));
 								} catch(ConfigCompileException ex) {
 									throw new CREError(ex.getMessage(), getTarget(), ex);
 								}
-								varargType = this.types[this.types.length - 1];
 							}
 							isVarArg = true;
 						}
 						if(isVarArg) {
-							if(!InstanceofUtil.isInstanceof(value.typeof(env), varargType.getVarargsBaseType(), env)) {
+							if(!InstanceofUtil.isInstanceof(value, varargType, env)) {
 								throw new CRECastException("Expected type " + varargType + " but found " + value.typeof(env),
 										getTarget());
 							}

src/main/java/com/laytonsmith/core/constructs/CIClosure.java

@@ -31,8 +31,8 @@ public class CIClosure extends CClosure {
 				.addParameter("Parameters", PARAMETERS));
 
 	public CIClosure(ParseTree node, Environment env, LeftHandSideType returnType, String[] names, Mixed[] defaults,
-			Boolean[] isVarArgs, LeftHandSideType[] types, Target t) {
-		super(node, env, returnType, names, defaults, isVarArgs, types, t);
+			LeftHandSideType[] types, Target t) {
+		super(node, env, returnType, names, defaults, types, t);
 	}
 
 	@Override