Make constants their actual type in strict mode, auto otherwise.

This changes the declared type (not to be confused with the actual type)
of constants to auto in non-strict mode, and their actual types in
strict mode. This is necessary, because currently, code such as `'123' >
10` is supported, and needs to continue to be supported into the future.
However, adding typechecking to functions will start to break this code,
which is undesireable. Therefore, in non-strict mode, constants will be
declared as type auto.

Additionally, for functions that end up matching multiple signatures,
instead of returning the type union for possible return values, it now
returns auto, if any of the parameters are auto. This prevents further
type errors up the chain when signatures might be ambiguous. For
instance, if we have both array func(int) and int func(string), then in
non-strict mode, `func(@auto)` would be ambiguous. However, since the
parameter is auto, the user has already indicated that they are ok with
deferring typechecking until runtime anyways, so we prevent requiring a
cast in this case by returning auto, so `array @A = func(@auto)` will
also continue to work with no casts. This behavior is the same in both
strict and non-strict mode, but is more likely to be triggered in
non-strict mode due to the fact that constants are auto.

A few bugs were fixed with strict mode and centry, as well as when
unknonwn functions are found in certain cases.

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

@@ -421,15 +421,17 @@ public Target getTarget() {
 	 * be AUTO. The type may be CNull for literal nulls, but will never be java null.
 	 *
 	 * @param sa The static analysis object.
-	 * @param t The code target, used for exceptions for ambiguous matches.
 	 * @param env The environment
 	 * @param inferredType The inferred type, if this is a function call. Otherwise, can be null.
 	 * @return
 	 */
-	public LeftHandSideType getDeclaredType(StaticAnalysis sa, Target t, Environment env, LeftHandSideType inferredType) {
+	public LeftHandSideType getDeclaredType(StaticAnalysis sa, Environment env, LeftHandSideType inferredType) {
 		if(isConst()) {
-			return Auto.LHSTYPE;
-//			return getData().typeof(env).asLeftHandSideType();
+			if(!getFileOptions().isStrict()) {
+				return Auto.LHSTYPE;
+			} else {
+				return getData().typeof(env).asLeftHandSideType();
+			}
 		} else if(getData() instanceof IVariable ivar) {
 			if(sa.isLocalEnabled()) {
 				Scope scope = sa.getTermScope(this);
@@ -465,17 +467,32 @@ public LeftHandSideType getDeclaredType(StaticAnalysis sa, Target t, Environment
 			} else {
 				List<Target> argTargets = new ArrayList<>();
 				Set<ConfigCompileException> exceptions = new HashSet<>();
-				List<LeftHandSideType> argTypes = cf.getCachedFunction()
-						.getResolvedParameterTypes(sa, t, env, this.getNodeModifiers().getGenerics(),
-								inferredType, getChildren());
+				List<LeftHandSideType> argTypes;
+				try {
+					if(cf.getCachedFunction() == null) {
+						// Function doesn't exist, just make everything auto so that the rest of typechecking
+						// can continue running.
+						return Auto.LHSTYPE;
+					} else {
+						argTypes = cf.getFunction()
+								.getResolvedParameterTypes(sa, getTarget(), env, this.getNodeModifiers().getGenerics(),
+										inferredType, getChildren());
+					}
+				} catch(ConfigCompileException ex) {
+					throw new RuntimeException(getTarget().toString(), ex);
+				}
 				for(ParseTree child : getChildren()) {
 					argTargets.add(child.getTarget());
 				}
 				return cf.getCachedFunction().getReturnType(this, getTarget(),
 						argTypes, argTargets, inferredType, env, exceptions);
 			}
 		} else if(getData() instanceof Variable) {
-			return Auto.LHSTYPE;
+			if(getFileOptions().isStrict()) {
+				return CString.TYPE.asLeftHandSideType();
+			} else {
+				return Auto.LHSTYPE;
+			}
 		} else {
 			throw new Error("Unhandled type, please report this bug. Caused by code from " + getTarget());
 		}

src/main/java/com/laytonsmith/core/asm/LLVMFunction.java

@@ -113,7 +113,7 @@ public List<LeftHandSideType> getResolvedParameterTypes(StaticAnalysis analysis,
 			return generics.getLeftHandParameters();
 		}
 		for(ParseTree child : children) {
-			ret.add(child.getDeclaredType(analysis, t, env, Auto.LHSTYPE));
+			ret.add(child.getDeclaredType(analysis, env, Auto.LHSTYPE));
 		}
 		return ret;
 	}

src/main/java/com/laytonsmith/core/compiler/analysis/StaticAnalysis.java

@@ -8,6 +8,7 @@
 import com.laytonsmith.core.constructs.CFunction;
 import com.laytonsmith.core.constructs.CKeyword;
 import com.laytonsmith.core.constructs.CLabel;
+import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.IVariable;
 import com.laytonsmith.core.constructs.InstanceofUtil;
 import com.laytonsmith.core.constructs.LeftHandSideType;
@@ -427,7 +428,11 @@ public LeftHandSideType typecheck(ParseTree ast, LeftHandSideType inferredReturn
 				return LeftHandSideType.fromCClassType(CClassType.AUTO, Target.UNKNOWN);
 			}
 		} else if(node instanceof Variable) {
-			return Auto.LHSTYPE;
+			if(ast.getFileOptions().isStrict()) {
+				return CString.TYPE.asLeftHandSideType();
+			} else {
+				return Auto.LHSTYPE;
+			}
 		} else if(node instanceof CKeyword) {
 
 			// Use the more specific compile error caused during keyword processing if available.
@@ -443,7 +448,8 @@ public LeftHandSideType typecheck(ParseTree ast, LeftHandSideType inferredReturn
 		}
 
 		// The node is some other Construct, so return its type.
-		if(ast.isConst()) {
+		// In non-strict mode, constants are defined as auto, to make things like `'123' > 10` work.
+		if(ast.isConst() && !ast.getFileOptions().isStrict()) {
 			return Auto.LHSTYPE;
 		}
 		try {

src/main/java/com/laytonsmith/core/compiler/signature/FunctionSignatures.java

@@ -7,6 +7,7 @@
 
 import com.laytonsmith.PureUtilities.Common.StringUtils;
 import com.laytonsmith.core.ParseTree;
+import com.laytonsmith.core.constructs.Auto;
 import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.LeftHandSideType;
 import com.laytonsmith.core.constructs.Target;
@@ -120,21 +121,29 @@ public LeftHandSideType getReturnType(ParseTree node, Target t, List<LeftHandSid
 						typeResolutions);
 			}
 			default -> {
-				// TODO - Ideally, we'd either return a multi-type or the most specific super type of the signatures.
-				// Return the return type of all matching signatures if they are the same.
-				LeftHandSideType type = LeftHandSideType.resolveTypeFromGenerics(t, env, matches.get(0).getReturnType().getType(),
-					generics,
-					matches.get(0).getGenericDeclaration(), inferredReturnType);
-				for(int i = 1; i < matches.size(); i++) {
+				LeftHandSideType[] types = new LeftHandSideType[matches.size()];
+				for(int i = 0; i < matches.size(); i++) {
 					LeftHandSideType retType = LeftHandSideType.resolveTypeFromGenerics(t, env,
 						matches.get(i).getReturnType().getType(),
 						generics,
 						matches.get(0).getGenericDeclaration(), inferredReturnType);
-					if((retType == null ? retType != type : !retType.equals(type))) {
-						return CClassType.AUTO.asLeftHandSideType();
+					types[i] = retType;
+				}
+				LeftHandSideType ret = LeftHandSideType.createTypeUnion(t, types);
+				if(ret.isTypeUnion()) {
+					// If multiple types match, and one or more of the arguments is auto, we return auto, rather than
+					// the type union. This indicates that the user is content with runtime type verification, and so
+					// we continue that up the chain. In non-strict mode, constants (and $vars) are declared as auto,
+					// so that we get expected behavior with for instance `'123' > 10`, which causes this mode to be
+					// triggered more often than in non-strict mode. For non-ambiguous signatures even with auto arguments,
+					// this behavior is not triggered.
+					for(LeftHandSideType argType : argTypes) {
+						if(Auto.LHSTYPE.equals(argType)) {
+							return Auto.LHSTYPE;
+						}
 					}
 				}
-				return type;
+				return ret;
 			}
 		}
 	}

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

@@ -363,7 +363,11 @@ public static CClassType get(CClassType nakedType, Target t, Map<CClassType, Gen
 	 * provided, then this will be thrown.
 	 */
 	public static CClassType get(Class<? extends Mixed> type, Target t, Map<CClassType, GenericParameters> generics, Environment env) {
-		return get(FullyQualifiedClassName.forNativeClass(type), t, generics, env);
+		try {
+			return get(FullyQualifiedClassName.forNativeClass(type), t, generics, env);
+		} catch(Error e) {
+			throw new Error(e.getMessage() + " Caused by code around " + t.toString(), e);
+		}
 	}
 
 	/**

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

@@ -516,7 +516,7 @@ public CClassType typeof(Environment env) {
 	 * @return
 	 */
 	public static CClassType typeof(Mixed that, Environment env) {
-		return CClassType.get(that.getClass(), Target.UNKNOWN, that.getGenericParameters(), env);
+		return CClassType.get(that.getClass(), that.getTarget(), that.getGenericParameters(), env);
 	}
 
 	private final Map<CClassType, GenericParameters> genericParameters = new HashMap<>();

src/main/java/com/laytonsmith/core/functions/AbstractFunction.java

@@ -160,7 +160,7 @@ public List<LeftHandSideType> getResolvedParameterTypes(StaticAnalysis analysis,
 			return generics.getLeftHandParameters();
 		}
 		for(ParseTree child : children) {
-			ret.add(child.getDeclaredType(analysis, t, env, Auto.LHSTYPE));
+			ret.add(child.getDeclaredType(analysis, env, Auto.LHSTYPE));
 		}
 		return ret;
 //		if(signatures == null) {
@@ -208,7 +208,7 @@ public LeftHandSideType typecheck(StaticAnalysis analysis,
 			List<LeftHandSideType> argTypes = new ArrayList<>(children.size());
 			List<Target> argTargets = new ArrayList<>(children.size());
 			for(ParseTree child : children) {
-				LeftHandSideType inferredParameterType = child.getDeclaredType(analysis, ast.getTarget(), env, Auto.LHSTYPE);
+				LeftHandSideType inferredParameterType = child.getDeclaredType(analysis, env, Auto.LHSTYPE);
 				inferredParameterType = LeftHandSideType.resolveTypeFromGenerics(Target.UNKNOWN, env, inferredParameterType, null, null, (Map) null);
 				argTypes.add(analysis.typecheck(child, inferredParameterType, env, exceptions));
 				argTargets.add(child.getTarget());

src/main/java/com/laytonsmith/core/functions/Compiler.java

@@ -124,10 +124,26 @@ public LeftHandSideType typecheck(StaticAnalysis analysis,
 				exceptions.add(new ConfigCompileException("Expected label.", ast.getChildAt(0).getTarget()));
 			}
 			LeftHandSideType inferredParameterType = ast.getChildAt(1)
-					.getDeclaredType(analysis, ast.getTarget(), env, Auto.LHSTYPE);
+					.getDeclaredType(analysis, env, Auto.LHSTYPE);
 			inferredParameterType = LeftHandSideType.resolveTypeFromGenerics(Target.UNKNOWN, env, inferredParameterType, null, null, (Map) null);
 			return analysis.typecheck(ast.getChildAt(1), inferredParameterType, env, exceptions);
 		}
+
+		@Override
+		public List<LeftHandSideType> getResolvedParameterTypes(StaticAnalysis analysis, Target t, Environment env, GenericParameters generics, LeftHandSideType inferredReturnType, List<ParseTree> children) {
+			List<LeftHandSideType> ret = new ArrayList<>();
+			ret.add(Auto.LHSTYPE);
+			ret.add(children.get(1).getDeclaredType(analysis, env, inferredReturnType));
+			return ret;
+		}
+
+		@Override
+		public LeftHandSideType getReturnType(ParseTree node, Target t, List<LeftHandSideType> argTypes, List<Target> argTargets, LeftHandSideType inferredReturnType, Environment env, Set<ConfigCompileException> exceptions) {
+			return argTypes.get(1);
+		}
+
+
+
 	}
 
 	@api

src/test/java/com/laytonsmith/core/MethodScriptCompilerTest.java

@@ -1303,14 +1303,13 @@ public void testParseTreeHasCorrectType() throws Exception {
 		ParseTree tree = MethodScriptCompiler.compile(MethodScriptCompiler.lex("primitive @s = 'asdf'; msg(@s); int proc _a(){return(1);} _a();",
 				env, null, true), env, env.getEnvClasses(), sa);
 		ParseTree sUsage = tree.getChildAt(0).getChildAt(1).getChildAt(0);
-		Target t = Target.UNKNOWN;
-		assertTrue(sUsage.getDeclaredType(sa, t, env, null).equals(CPrimitive.TYPE.asLeftHandSideType()));
+		assertTrue(sUsage.getDeclaredType(sa, env, null).equals(CPrimitive.TYPE.asLeftHandSideType()));
 		ParseTree asdf = tree.getChildAt(0).getChildAt(0).getChildAt(2);
-		assertTrue(asdf.getDeclaredType(sa, t, env, null).equals(Auto.LHSTYPE));
+		assertTrue(asdf.getDeclaredType(sa, env, null).equals(Auto.LHSTYPE));
 		ParseTree msg = tree.getChildAt(0).getChildAt(1);
-		assertTrue(msg.getDeclaredType(sa, t, env, null).equals(CVoid.TYPE.asLeftHandSideType()));
+		assertTrue(msg.getDeclaredType(sa, env, null).equals(CVoid.TYPE.asLeftHandSideType()));
 		ParseTree _a = tree.getChildAt(0).getChildAt(3);
-		assertTrue(_a.getDeclaredType(sa, t, env, null).equals(CInt.TYPE.asLeftHandSideType()));
+		assertTrue(_a.getDeclaredType(sa, env, null).equals(CInt.TYPE.asLeftHandSideType()));
 	}
 
 	@Test

src/test/java/com/laytonsmith/core/StaticAnalysisTest.java

@@ -169,16 +169,16 @@ public void testRecursiveTypeInferrenceWorks() throws Exception {
 		ParseTree tree = saScript("string @r = 'string'; string @s = dyn(dyn(dyn(dyn(dyn(@r)))));");
 		ParseTree topDynNode = tree.getChildAt(0).getChildAt(1).getChildAt(2);
 		Assert.assertEquals(CString.TYPE.asLeftHandSideType(),
-				topDynNode.getDeclaredType(staticAnalysis, Target.UNKNOWN, env, null));
+				topDynNode.getDeclaredType(staticAnalysis, env, null));
 		Assert.assertEquals(CString.TYPE.asLeftHandSideType(),
-				topDynNode.getDeclaredType(staticAnalysis, Target.UNKNOWN, env, CString.TYPE.asLeftHandSideType()));
+				topDynNode.getDeclaredType(staticAnalysis, env, CString.TYPE.asLeftHandSideType()));
 		// This is auto, because constants are auto typed.
 		tree = saScript("string @s = dyn(dyn(dyn(dyn(dyn('string')))));");
 		topDynNode = tree.getChildAt(0).getChildAt(2);
 		Assert.assertEquals(Auto.LHSTYPE,
-				topDynNode.getDeclaredType(staticAnalysis, Target.UNKNOWN, env, null));
+				topDynNode.getDeclaredType(staticAnalysis, env, null));
 		Assert.assertEquals(Auto.LHSTYPE,
-				topDynNode.getDeclaredType(staticAnalysis, Target.UNKNOWN, env, CString.TYPE.asLeftHandSideType()));
+				topDynNode.getDeclaredType(staticAnalysis, env, CString.TYPE.asLeftHandSideType()));
 
 		saScriptExpectException("string @s = dyn(dyn(dyn(array())));");
 	}
@@ -218,4 +218,15 @@ public void testLabels() throws Exception {
 		saScript("array @a = array(label: 'goes', here: 'too'); msg(@a);");
 	}
 
+	@Test
+	public void testLabelsWithStrictMode() throws Exception {
+		saScript("<!strict> assign(@w, array('world': 'overworld', 'world_nether': 'nether', 'world_the_end': 'end'))");
+	}
+
+	@Test
+	public void testVariablesInStrictMode() throws Exception {
+		saScriptExpectException("<! strict > if($var > 1) { msg(''); }");
+		saScript("if($var > 1) { msg(''); }");
+	}
+
 }