Updated .gitignore

The actual issue was that the type check wasn't catching the issue, so
it reached the scope before it was caught. Fixed it, anyway.

.gitignore

@@ -19,6 +19,8 @@ bin/
 *.db
 *.o
 *.a
+*.so
+*.dll
 *.exe
 *.meta
 *.log

Repl.vcxproj

@@ -113,7 +113,7 @@
       <AdditionalLibraryDirectories>$(SolutionDir)out\$(Configuration)</AdditionalLibraryDirectories>
     </Link>
     <ClCompile>
-      <AdditionalIncludeDirectories>C:\Users\kayne\Desktop\Toy\source;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
+      <AdditionalIncludeDirectories>$(SolutionDir)/source;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <LanguageStandard_C>stdc17</LanguageStandard_C>
       <PreprocessorDefinitions>
       </PreprocessorDefinitions>

repl/lib_runner.c

@@ -33,6 +33,11 @@ static int nativeLoadScript(Toy_Interpreter* interpreter, Toy_LiteralArray* argu
 		Toy_freeLiteral(drivePathLiteralIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(drivePathLiteral)) {
+		Toy_freeLiteral(drivePathLiteral);
+		return -1;
+	}
+
 	Toy_Literal filePathLiteral = Toy_getFilePathLiteral(interpreter, &drivePathLiteral);
 
 	if (TOY_IS_NULL(filePathLiteral)) {
@@ -103,6 +108,11 @@ static int nativeLoadScriptBytecode(Toy_Interpreter* interpreter, Toy_LiteralArr
 		Toy_freeLiteral(drivePathLiteralIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(drivePathLiteral)) {
+		Toy_freeLiteral(drivePathLiteral);
+		return -1;
+	}
+
 	Toy_RefString* drivePath = Toy_copyRefString(TOY_AS_STRING(drivePathLiteral));
 
 	//get the drive and path as a string (can't trust that pesky strtok - custom split) TODO: move this to refstring library
@@ -213,6 +223,11 @@ static int nativeRunScript(Toy_Interpreter* interpreter, Toy_LiteralArray* argum
 		Toy_freeLiteral(runnerIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(runnerLiteral)) {
+		Toy_freeLiteral(runnerLiteral);
+		return -1;
+	}
+
 	if (TOY_GET_OPAQUE_TAG(runnerLiteral) != TOY_OPAQUE_TAG_RUNNER) {
 		interpreter->errorOutput("Unrecognized opaque literal in runScript\n");
 		return -1;
@@ -260,6 +275,12 @@ static int nativeGetScriptVar(Toy_Interpreter* interpreter, Toy_LiteralArray* ar
 		Toy_freeLiteral(runnerIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(varName) || TOY_IS_IDENTIFIER(runnerLiteral)) {
+		Toy_freeLiteral(varName);
+		Toy_freeLiteral(runnerLiteral);
+		return -1;
+	}
+
 	if (TOY_GET_OPAQUE_TAG(runnerLiteral) != TOY_OPAQUE_TAG_RUNNER) {
 		interpreter->errorOutput("Unrecognized opaque literal in getScriptVar\n");
 		return -1;
@@ -332,6 +353,12 @@ static int nativeCallScriptFn(Toy_Interpreter* interpreter, Toy_LiteralArray* ar
 		Toy_freeLiteral(runnerIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(varName) || TOY_IS_IDENTIFIER(runnerLiteral)) {
+		Toy_freeLiteral(varName);
+		Toy_freeLiteral(runnerLiteral);
+		return -1;
+	}
+
 	if (TOY_GET_OPAQUE_TAG(runnerLiteral) != TOY_OPAQUE_TAG_RUNNER) {
 		interpreter->errorOutput("Unrecognized opaque literal in callScriptFn\n");
 		return -1;
@@ -401,6 +428,11 @@ static int nativeResetScript(Toy_Interpreter* interpreter, Toy_LiteralArray* arg
 		Toy_freeLiteral(runnerIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(runnerLiteral)) {
+		Toy_freeLiteral(runnerLiteral);
+		return -1;
+	}
+
 	if (TOY_GET_OPAQUE_TAG(runnerLiteral) != TOY_OPAQUE_TAG_RUNNER) {
 		interpreter->errorOutput("Unrecognized opaque literal in resetScript\n");
 		return -1;
@@ -437,6 +469,11 @@ static int nativeFreeScript(Toy_Interpreter* interpreter, Toy_LiteralArray* argu
 		Toy_freeLiteral(runnerIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(runnerLiteral)) {
+		Toy_freeLiteral(runnerLiteral);
+		return -1;
+	}
+
 	if (TOY_GET_OPAQUE_TAG(runnerLiteral) != TOY_OPAQUE_TAG_RUNNER) {
 		interpreter->errorOutput("Unrecognized opaque literal in freeScript\n");
 		return -1;
@@ -471,6 +508,11 @@ static int nativeCheckScriptDirty(Toy_Interpreter* interpreter, Toy_LiteralArray
 		Toy_freeLiteral(runnerIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(runnerLiteral)) {
+		Toy_freeLiteral(runnerLiteral);
+		return -1;
+	}
+
 	if (TOY_GET_OPAQUE_TAG(runnerLiteral) != TOY_OPAQUE_TAG_RUNNER) {
 		interpreter->errorOutput("Unrecognized opaque literal in checkScriptDirty\n");
 		return -1;

repl/lib_standard.c

@@ -54,6 +54,12 @@ static int nativeConcat(Toy_Interpreter* interpreter, Toy_LiteralArray* argument
 		Toy_freeLiteral(otherLiteralIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(selfLiteral) || TOY_IS_IDENTIFIER(otherLiteral)) {
+		Toy_freeLiteral(selfLiteral);
+		Toy_freeLiteral(otherLiteral);
+		return -1;
+	}
+
 	//for each self type
 	if (TOY_IS_ARRAY(selfLiteral)) {
 		if (!TOY_IS_ARRAY(otherLiteral)) {
@@ -164,6 +170,12 @@ static int nativeContainsKey(Toy_Interpreter* interpreter, Toy_LiteralArray* arg
 		Toy_freeLiteral(keyLiteralIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(selfLiteral) || TOY_IS_IDENTIFIER(keyLiteral)) {
+		Toy_freeLiteral(selfLiteral);
+		Toy_freeLiteral(keyLiteral);
+		return -1;
+	}
+
 	//check type
 	if (!(/* TOY_IS_ARRAY(selfLiteral) || */ TOY_IS_DICTIONARY(selfLiteral) )) {
 		interpreter->errorOutput("Incorrect argument type passed to containsKey\n");
@@ -209,6 +221,12 @@ static int nativeContainsValue(Toy_Interpreter* interpreter, Toy_LiteralArray* a
 		Toy_freeLiteral(valueLiteralIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(selfLiteral) || TOY_IS_IDENTIFIER(valueLiteral)) {
+		Toy_freeLiteral(selfLiteral);
+		Toy_freeLiteral(valueLiteral);
+		return -1;
+	}
+
 	//check type
 	if (!( TOY_IS_ARRAY(selfLiteral) || TOY_IS_DICTIONARY(selfLiteral) )) {
 		interpreter->errorOutput("Incorrect argument type passed to containsValue\n");
@@ -279,6 +297,12 @@ static int nativeEvery(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments
 		Toy_freeLiteral(fnLiteralIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(selfLiteral) || TOY_IS_IDENTIFIER(fnLiteral)) {
+		Toy_freeLiteral(selfLiteral);
+		Toy_freeLiteral(fnLiteral);
+		return -1;
+	}
+
 	//check type
 	if (!( TOY_IS_ARRAY(selfLiteral) || TOY_IS_DICTIONARY(selfLiteral) ) || !( TOY_IS_FUNCTION(fnLiteral) || TOY_IS_FUNCTION_NATIVE(fnLiteral) )) {
 		interpreter->errorOutput("Incorrect argument type passed to every\n");
@@ -395,6 +419,12 @@ static int nativeFilter(Toy_Interpreter* interpreter, Toy_LiteralArray* argument
 		Toy_freeLiteral(fnLiteralIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(selfLiteral) || TOY_IS_IDENTIFIER(fnLiteral)) {
+		Toy_freeLiteral(selfLiteral);
+		Toy_freeLiteral(fnLiteral);
+		return -1;
+	}
+
 	//check type
 	if (!( TOY_IS_ARRAY(selfLiteral) || TOY_IS_DICTIONARY(selfLiteral) ) || !( TOY_IS_FUNCTION(fnLiteral) || TOY_IS_FUNCTION_NATIVE(fnLiteral) )) {
 		interpreter->errorOutput("Incorrect argument type passed to filter\n");
@@ -509,6 +539,12 @@ static int nativeForEach(Toy_Interpreter* interpreter, Toy_LiteralArray* argumen
 		Toy_freeLiteral(fnLiteralIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(selfLiteral) || TOY_IS_IDENTIFIER(fnLiteral)) {
+		Toy_freeLiteral(selfLiteral);
+		Toy_freeLiteral(fnLiteral);
+		return -1;
+	}
+
 	//check type
 	if (!( TOY_IS_ARRAY(selfLiteral) || TOY_IS_DICTIONARY(selfLiteral) ) || !( TOY_IS_FUNCTION(fnLiteral) || TOY_IS_FUNCTION_NATIVE(fnLiteral) )) {
 		interpreter->errorOutput("Incorrect argument type passed to forEach\n");
@@ -581,6 +617,11 @@ static int nativeGetKeys(Toy_Interpreter* interpreter, Toy_LiteralArray* argumen
 		Toy_freeLiteral(selfLiteralIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(selfLiteral)) {
+		Toy_freeLiteral(selfLiteral);
+		return -1;
+	}
+
 	//check type
 	if (!TOY_IS_DICTIONARY(selfLiteral)) {
 		interpreter->errorOutput("Incorrect argument type passed to getKeys\n");
@@ -626,6 +667,11 @@ static int nativeGetValues(Toy_Interpreter* interpreter, Toy_LiteralArray* argum
 		Toy_freeLiteral(selfLiteralIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(selfLiteral)) {
+		Toy_freeLiteral(selfLiteral);
+		return -1;
+	}
+
 	//check type
 	if (!TOY_IS_DICTIONARY(selfLiteral)) {
 		interpreter->errorOutput("Incorrect argument type passed to getValues\n");
@@ -678,6 +724,12 @@ static int nativeIndexOf(Toy_Interpreter* interpreter, Toy_LiteralArray* argumen
 		Toy_freeLiteral(valueLiteralIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(selfLiteral) || TOY_IS_IDENTIFIER(valueLiteral)) {
+		Toy_freeLiteral(selfLiteral);
+		Toy_freeLiteral(valueLiteral);
+		return -1;
+	}
+
 	//check type
 	if (!TOY_IS_ARRAY(selfLiteral)) {
 		interpreter->errorOutput("Incorrect argument type passed to indexOf\n");
@@ -725,6 +777,12 @@ static int nativeMap(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 		Toy_freeLiteral(fnLiteralIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(selfLiteral) || TOY_IS_IDENTIFIER(fnLiteral)) {
+		Toy_freeLiteral(selfLiteral);
+		Toy_freeLiteral(fnLiteral);
+		return -1;
+	}
+
 	//check type
 	if (!( TOY_IS_ARRAY(selfLiteral) || TOY_IS_DICTIONARY(selfLiteral) ) || !( TOY_IS_FUNCTION(fnLiteral) || TOY_IS_FUNCTION_NATIVE(fnLiteral) )) {
 		interpreter->errorOutput("Incorrect argument type passed to map\n");
@@ -834,6 +892,13 @@ static int nativeReduce(Toy_Interpreter* interpreter, Toy_LiteralArray* argument
 		Toy_freeLiteral(fnLiteralIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(selfLiteral) || TOY_IS_IDENTIFIER(defaultLiteral) || TOY_IS_IDENTIFIER(fnLiteral)) {
+		Toy_freeLiteral(selfLiteral);
+		Toy_freeLiteral(defaultLiteral);
+		Toy_freeLiteral(fnLiteral);
+		return -1;
+	}
+
 	//check type
 	if (!( TOY_IS_ARRAY(selfLiteral) || TOY_IS_DICTIONARY(selfLiteral) ) || !( TOY_IS_FUNCTION(fnLiteral) || TOY_IS_FUNCTION_NATIVE(fnLiteral) )) {
 		interpreter->errorOutput("Incorrect argument type passed to reduce\n");
@@ -929,6 +994,12 @@ static int nativeSome(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 		Toy_freeLiteral(fnLiteralIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(selfLiteral) || TOY_IS_IDENTIFIER(fnLiteral)) {
+		Toy_freeLiteral(selfLiteral);
+		Toy_freeLiteral(fnLiteral);
+		return -1;
+	}
+
 	//check type
 	if (!( TOY_IS_ARRAY(selfLiteral) || TOY_IS_DICTIONARY(selfLiteral) ) || !( TOY_IS_FUNCTION(fnLiteral) || TOY_IS_FUNCTION_NATIVE(fnLiteral) )) {
 		interpreter->errorOutput("Incorrect argument type passed to some\n");
@@ -1093,6 +1164,12 @@ static int nativeSort(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 		Toy_freeLiteral(fnLiteralIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(selfLiteral) || TOY_IS_IDENTIFIER(fnLiteral)) {
+		Toy_freeLiteral(selfLiteral);
+		Toy_freeLiteral(fnLiteral);
+		return -1;
+	}
+
 	//check type
 	if (!TOY_IS_ARRAY(selfLiteral) || !( TOY_IS_FUNCTION(fnLiteral) || TOY_IS_FUNCTION_NATIVE(fnLiteral) )) {
 		interpreter->errorOutput("Incorrect argument type passed to sort\n");
@@ -1129,6 +1206,11 @@ static int nativeToLower(Toy_Interpreter* interpreter, Toy_LiteralArray* argumen
 		Toy_freeLiteral(selfLiteralIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(selfLiteral)) {
+		Toy_freeLiteral(selfLiteral);
+		return -1;
+	}
+
 	if (!TOY_IS_STRING(selfLiteral)) {
 		interpreter->errorOutput("Incorrect argument type passed to toLower\n");
 		Toy_freeLiteral(selfLiteral);
@@ -1190,6 +1272,11 @@ static int nativeToString(Toy_Interpreter* interpreter, Toy_LiteralArray* argume
 		Toy_freeLiteral(selfLiteralIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(selfLiteral)) {
+		Toy_freeLiteral(selfLiteral);
+		return -1;
+	}
+
 	//BUGFIX: probably an undefined variable
 	if (TOY_IS_IDENTIFIER(selfLiteral)) {
 		Toy_freeLiteral(selfLiteral);
@@ -1229,6 +1316,11 @@ static int nativeToUpper(Toy_Interpreter* interpreter, Toy_LiteralArray* argumen
 		Toy_freeLiteral(selfLiteralIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(selfLiteral)) {
+		Toy_freeLiteral(selfLiteral);
+		return -1;
+	}
+
 	if (!TOY_IS_STRING(selfLiteral)) {
 		interpreter->errorOutput("Incorrect argument type passed to toUpper\n");
 		Toy_freeLiteral(selfLiteral);
@@ -1289,7 +1381,13 @@ static int nativeTrim(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 		Toy_freeLiteral(selfLiteralIdn);
 	}
 
-	if (!TOY_IS_STRING(selfLiteral)) {
+	if (TOY_IS_IDENTIFIER(selfLiteral) || TOY_IS_IDENTIFIER(trimCharsLiteral)) {
+		Toy_freeLiteral(selfLiteral);
+		Toy_freeLiteral(trimCharsLiteral);
+		return -1;
+	}
+
+	if (!TOY_IS_STRING(selfLiteral) || !TOY_IS_STRING(trimCharsLiteral)) {
 		interpreter->errorOutput("Incorrect argument type passed to trim\n");
 		Toy_freeLiteral(trimCharsLiteral);
 		Toy_freeLiteral(selfLiteral);
@@ -1400,7 +1498,13 @@ static int nativeTrimBegin(Toy_Interpreter* interpreter, Toy_LiteralArray* argum
 		Toy_freeLiteral(selfLiteralIdn);
 	}
 
-	if (!TOY_IS_STRING(selfLiteral)) {
+	if (TOY_IS_IDENTIFIER(selfLiteral) || TOY_IS_IDENTIFIER(trimCharsLiteral)) {
+		Toy_freeLiteral(selfLiteral);
+		Toy_freeLiteral(trimCharsLiteral);
+		return -1;
+	}
+
+	if (!TOY_IS_STRING(selfLiteral) || !TOY_IS_STRING(trimCharsLiteral)) {
 		interpreter->errorOutput("Incorrect argument type passed to trimBegin\n");
 		Toy_freeLiteral(trimCharsLiteral);
 		Toy_freeLiteral(selfLiteral);
@@ -1488,7 +1592,13 @@ static int nativeTrimEnd(Toy_Interpreter* interpreter, Toy_LiteralArray* argumen
 		Toy_freeLiteral(selfLiteralIdn);
 	}
 
-	if (!TOY_IS_STRING(selfLiteral)) {
+	if (TOY_IS_IDENTIFIER(selfLiteral) || TOY_IS_IDENTIFIER(trimCharsLiteral)) {
+		Toy_freeLiteral(selfLiteral);
+		Toy_freeLiteral(trimCharsLiteral);
+		return -1;
+	}
+
+	if (!TOY_IS_STRING(selfLiteral) || !TOY_IS_STRING(trimCharsLiteral)) {
 		interpreter->errorOutput("Incorrect argument type passed to trimEnd\n");
 		Toy_freeLiteral(trimCharsLiteral);
 		Toy_freeLiteral(selfLiteral);

source/toy_builtin.c

@@ -279,6 +279,17 @@ int Toy_private_index(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 			Toy_freeLiteral(idn);
 		}
 
+		if (TOY_IS_IDENTIFIER(first) || TOY_IS_IDENTIFIER(second) || TOY_IS_IDENTIFIER(third)) {
+			Toy_freeLiteral(op);
+			Toy_freeLiteral(assign);
+			Toy_freeLiteral(third);
+			Toy_freeLiteral(second);
+			Toy_freeLiteral(first);
+			Toy_freeLiteral(compound);
+
+			return -1;
+		}
+
 		//second and third are bad args to dictionaries
 		if (!TOY_IS_NULL(second) || !TOY_IS_NULL(third)) {
 			interpreter->errorOutput("Index slicing not allowed for dictionaries\n");
@@ -401,6 +412,17 @@ int Toy_private_index(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 				Toy_freeLiteral(idn);
 			}
 
+			if (TOY_IS_IDENTIFIER(first) || TOY_IS_IDENTIFIER(second) || TOY_IS_IDENTIFIER(third)) {
+				Toy_freeLiteral(op);
+				Toy_freeLiteral(assign);
+				Toy_freeLiteral(third);
+				Toy_freeLiteral(second);
+				Toy_freeLiteral(first);
+				Toy_freeLiteral(compound);
+
+				return -1;
+			}
+
 			//handle each error case
 			if (!TOY_IS_INTEGER(first) || TOY_AS_INTEGER(first) < 0 || TOY_AS_INTEGER(first) >= TOY_AS_ARRAY(compound)->count) {
 				interpreter->errorOutput("Bad first indexing\n");
@@ -543,6 +565,17 @@ int Toy_private_index(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 				Toy_freeLiteral(idn);
 			}
 
+			if (TOY_IS_IDENTIFIER(first) || TOY_IS_IDENTIFIER(second) || TOY_IS_IDENTIFIER(third)) {
+				Toy_freeLiteral(op);
+				Toy_freeLiteral(assign);
+				Toy_freeLiteral(third);
+				Toy_freeLiteral(second);
+				Toy_freeLiteral(first);
+				Toy_freeLiteral(compound);
+
+				return -1;
+			}
+
 			//handle each error case
 			if (!TOY_IS_INTEGER(first) || TOY_AS_INTEGER(first) < 0 || TOY_AS_INTEGER(first) >= TOY_AS_ARRAY(compound)->count) {
 				interpreter->errorOutput("Bad first indexing assignment\n");
@@ -705,6 +738,17 @@ int Toy_private_index(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 			Toy_freeLiteral(idn);
 		}
 
+		if (TOY_IS_IDENTIFIER(first)) {
+			Toy_freeLiteral(op);
+			Toy_freeLiteral(assign);
+			Toy_freeLiteral(third);
+			Toy_freeLiteral(second);
+			Toy_freeLiteral(first);
+			Toy_freeLiteral(compound);
+
+			return -1;
+		}
+
 		Toy_Literal value = Toy_getLiteralArray(TOY_AS_ARRAY(compound), first);
 
 		if (TOY_IS_STRING(op) && Toy_equalsRefStringCString(TOY_AS_STRING(op), "+=")) {
@@ -793,6 +837,17 @@ int Toy_private_index(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 				Toy_freeLiteral(idn);
 			}
 
+			if (TOY_IS_IDENTIFIER(first) || TOY_IS_IDENTIFIER(second) || TOY_IS_IDENTIFIER(third)) {
+				Toy_freeLiteral(op);
+				Toy_freeLiteral(assign);
+				Toy_freeLiteral(third);
+				Toy_freeLiteral(second);
+				Toy_freeLiteral(first);
+				Toy_freeLiteral(compound);
+
+				return -1;
+			}
+
 			//handle each error case
 			if (!TOY_IS_INTEGER(first) || TOY_AS_INTEGER(first) < 0 || TOY_AS_INTEGER(first) >= (int)Toy_lengthRefString(TOY_AS_STRING(compound))) {
 				interpreter->errorOutput("Bad first indexing in string\n");
@@ -937,6 +992,17 @@ int Toy_private_index(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 				Toy_freeLiteral(idn);
 			}
 
+			if (TOY_IS_IDENTIFIER(first) || TOY_IS_IDENTIFIER(second) || TOY_IS_IDENTIFIER(third)) {
+				Toy_freeLiteral(op);
+				Toy_freeLiteral(assign);
+				Toy_freeLiteral(third);
+				Toy_freeLiteral(second);
+				Toy_freeLiteral(first);
+				Toy_freeLiteral(compound);
+
+				return -1;
+			}
+
 			//handle each error case
 			if (!TOY_IS_INTEGER(first) || TOY_AS_INTEGER(first) < 0 || TOY_AS_INTEGER(first) >= (int)Toy_lengthRefString(TOY_AS_STRING(compound))) {
 				interpreter->errorOutput("Bad first indexing in string assignment\n");
@@ -1064,7 +1130,7 @@ int Toy_private_index(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 int Toy_private_set(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 	//if wrong number of arguments, fail
 	if (arguments->count != 3) {
-		interpreter->errorOutput("Incorrect number of arguments to _set\n");
+		interpreter->errorOutput("Incorrect number of arguments to set\n");
 		return -1;
 	}
 
@@ -1074,12 +1140,16 @@ int Toy_private_set(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 	Toy_Literal val = arguments->literals[2];
 
 	if (!TOY_IS_IDENTIFIER(idn)) {
-		interpreter->errorOutput("Expected identifier in _set\n");
+		interpreter->errorOutput("Expected identifier in set\n");
 		return -1;
 	}
 
 	Toy_parseIdentifierToValue(interpreter, &obj);
 
+	if (TOY_IS_IDENTIFIER(obj)) {
+		return -1;
+	}
+
 	bool freeKey = false;
 	if (TOY_IS_IDENTIFIER(key)) {
 		Toy_parseIdentifierToValue(interpreter, &key);
@@ -1092,26 +1162,40 @@ int Toy_private_set(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 		freeVal = true;
 	}
 
+	if (TOY_IS_IDENTIFIER(key) || TOY_IS_IDENTIFIER(val)) {
+		if (freeKey) {
+			Toy_freeLiteral(key);
+		}
+		if (freeVal) {
+			Toy_freeLiteral(val);
+		}
+		return -1;
+	}
+
 	switch(obj.type) {
 		case TOY_LITERAL_ARRAY: {
-			Toy_Literal typeLiteral = Toy_getScopeType(interpreter->scope, key);
+			//check the subtype of the array, if there is one, against the given argument
+			Toy_Literal typeLiteral = Toy_getScopeType(interpreter->scope, idn);
 
 			if (TOY_AS_TYPE(typeLiteral).typeOf == TOY_LITERAL_ARRAY) {
 				Toy_Literal subtypeLiteral = ((Toy_Literal*)(TOY_AS_TYPE(typeLiteral).subtypes))[0];
 
 				if (TOY_AS_TYPE(subtypeLiteral).typeOf != TOY_LITERAL_ANY && TOY_AS_TYPE(subtypeLiteral).typeOf != val.type) {
-					interpreter->errorOutput("Bad argument type in _set\n");
+					interpreter->errorOutput("Bad argument type in set\n");
+					Toy_freeLiteral(typeLiteral);
 					return -1;
 				}
 			}
 
+			Toy_freeLiteral(typeLiteral);
+
 			if (!TOY_IS_INTEGER(key)) {
-				interpreter->errorOutput("Expected integer index in _set\n");
+				interpreter->errorOutput("Expected integer index in set\n");
 				return -1;
 			}
 
-			if (TOY_AS_ARRAY(obj)->count <= TOY_AS_INTEGER(key) || TOY_AS_INTEGER(key) < 0) {
-				interpreter->errorOutput("Index out of bounds in _set\n");
+			if (TOY_AS_INTEGER(key) >= TOY_AS_ARRAY(obj)->count || TOY_AS_INTEGER(key) < 0) {
+				interpreter->errorOutput("Index out of bounds in set\n");
 				return -1;
 			}
 
@@ -1120,7 +1204,7 @@ int Toy_private_set(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 			TOY_AS_ARRAY(obj)->literals[TOY_AS_INTEGER(key)] = Toy_copyLiteral(val);
 
 			if (!Toy_setScopeVariable(interpreter->scope, idn, obj, true)) {
-				interpreter->errorOutput("Incorrect type assigned to array in _set: \"");
+				interpreter->errorOutput("Incorrect type assigned to array in set: \"");
 				Toy_printLiteralCustom(val, interpreter->errorOutput);
 				interpreter->errorOutput("\"\n");
 				return -1;
@@ -1137,12 +1221,12 @@ int Toy_private_set(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 				Toy_Literal valSubtypeLiteral = ((Toy_Literal*)(TOY_AS_TYPE(typeLiteral).subtypes))[1];
 
 				if (TOY_AS_TYPE(keySubtypeLiteral).typeOf != TOY_LITERAL_ANY && TOY_AS_TYPE(keySubtypeLiteral).typeOf != key.type) {
-					interpreter->printOutput("bad argument type in _set\n");
+					interpreter->printOutput("bad argument type in set\n");
 					return -1;
 				}
 
 				if (TOY_AS_TYPE(valSubtypeLiteral).typeOf != TOY_LITERAL_ANY && TOY_AS_TYPE(valSubtypeLiteral).typeOf != val.type) {
-					interpreter->printOutput("bad argument type in _set\n");
+					interpreter->printOutput("bad argument type in set\n");
 					return -1;
 				}
 			}
@@ -1150,7 +1234,7 @@ int Toy_private_set(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 			Toy_setLiteralDictionary(TOY_AS_DICTIONARY(obj), key, val);
 
 			if (!Toy_setScopeVariable(interpreter->scope, idn, obj, true)) {
-				interpreter->errorOutput("Incorrect type assigned to dictionary in _set: \"");
+				interpreter->errorOutput("Incorrect type assigned to dictionary in set: \"");
 				Toy_printLiteralCustom(val, interpreter->errorOutput);
 				interpreter->errorOutput("\"\n");
 				return -1;
@@ -1160,7 +1244,7 @@ int Toy_private_set(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 		}
 
 		default:
-			interpreter->errorOutput("Incorrect compound type in _set: ");
+			interpreter->errorOutput("Incorrect compound type in set: ");
 			Toy_printLiteralCustom(obj, interpreter->errorOutput);
 			interpreter->errorOutput("\"\n");
 			return -1;
@@ -1182,7 +1266,7 @@ int Toy_private_set(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 int Toy_private_get(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 	//if wrong number of arguments, fail
 	if (arguments->count != 2) {
-		interpreter->errorOutput("Incorrect number of arguments to _get");
+		interpreter->errorOutput("Incorrect number of arguments to get");
 		return -1;
 	}
 
@@ -1201,15 +1285,25 @@ int Toy_private_get(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 		freeKey = true;
 	}
 
+	if (TOY_IS_IDENTIFIER(obj) || TOY_IS_IDENTIFIER(key)) {
+		if (freeObj) {
+			Toy_freeLiteral(obj);
+		}
+		if (freeKey) {
+			Toy_freeLiteral(key);
+		}
+		return -1;
+	}
+
 	switch(obj.type) {
 		case TOY_LITERAL_ARRAY: {
 			if (!TOY_IS_INTEGER(key)) {
-				interpreter->errorOutput("Expected integer index in _get\n");
+				interpreter->errorOutput("Expected integer index in get\n");
 				return -1;
 			}
 
-			if (TOY_AS_ARRAY(obj)->count <= TOY_AS_INTEGER(key) || TOY_AS_INTEGER(key) < 0) {
-				interpreter->errorOutput("Index out of bounds in _get\n");
+			if (TOY_AS_INTEGER(key) >= TOY_AS_ARRAY(obj)->count || TOY_AS_INTEGER(key) < 0) {
+				interpreter->errorOutput("Index out of bounds in get\n");
 				return -1;
 			}
 
@@ -1243,7 +1337,7 @@ int Toy_private_get(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 		}
 
 		default:
-			interpreter->errorOutput("Incorrect compound type in _get \"");
+			interpreter->errorOutput("Incorrect compound type in get \"");
 			Toy_printLiteralCustom(obj, interpreter->errorOutput);
 			interpreter->errorOutput("\"\n");
 			return -1;
@@ -1253,7 +1347,7 @@ int Toy_private_get(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 int Toy_private_push(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 	//if wrong number of arguments, fail
 	if (arguments->count != 2) {
-		interpreter->errorOutput("Incorrect number of arguments to _push\n");
+		interpreter->errorOutput("Incorrect number of arguments to push\n");
 		return -1;
 	}
 
@@ -1262,35 +1356,47 @@ int Toy_private_push(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 	Toy_Literal val = arguments->literals[1];
 
 	if (!TOY_IS_IDENTIFIER(idn)) {
-		interpreter->errorOutput("Expected identifier in _push\n");
+		interpreter->errorOutput("Expected identifier in push\n");
 		return -1;
 	}
 
 	Toy_parseIdentifierToValue(interpreter, &obj);
 
+	if (TOY_IS_IDENTIFIER(obj)) {
+		return -1;
+	}
+
 	bool freeVal = false;
 	if (TOY_IS_IDENTIFIER(val)) {
 		Toy_parseIdentifierToValue(interpreter, &val);
 		freeVal = true;
 	}
 
+	if (TOY_IS_IDENTIFIER(val)) {
+		return -1;
+	}
+
 	switch(obj.type) {
 		case TOY_LITERAL_ARRAY: {
-			Toy_Literal typeLiteral = Toy_getScopeType(interpreter->scope, val);
+			//check the subtype of the array, if there is one, against the given argument
+			Toy_Literal typeLiteral = Toy_getScopeType(interpreter->scope, idn);
 
 			if (TOY_AS_TYPE(typeLiteral).typeOf == TOY_LITERAL_ARRAY) {
 				Toy_Literal subtypeLiteral = ((Toy_Literal*)(TOY_AS_TYPE(typeLiteral).subtypes))[0];
 
 				if (TOY_AS_TYPE(subtypeLiteral).typeOf != TOY_LITERAL_ANY && TOY_AS_TYPE(subtypeLiteral).typeOf != val.type) {
-					interpreter->errorOutput("Bad argument type in _push");
+					interpreter->errorOutput("Bad argument type in push");
+					Toy_freeLiteral(typeLiteral);
 					return -1;
 				}
 			}
 
+			Toy_freeLiteral(typeLiteral);
+
 			Toy_pushLiteralArray(TOY_AS_ARRAY(obj), val);
 
 			if (!Toy_setScopeVariable(interpreter->scope, idn, obj, true)) { //TODO: could definitely be more efficient than overwriting the whole original object
-				interpreter->errorOutput("Incorrect type assigned to array in _push: \"");
+				interpreter->errorOutput("Incorrect type assigned to array in push: \"");
 				Toy_printLiteralCustom(val, interpreter->errorOutput);
 				interpreter->errorOutput("\"\n");
 				return -1;
@@ -1306,7 +1412,7 @@ int Toy_private_push(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 		}
 
 		default:
-			interpreter->errorOutput("Incorrect compound type in _push: ");
+			interpreter->errorOutput("Incorrect compound type in push: ");
 			Toy_printLiteralCustom(obj, interpreter->errorOutput);
 			interpreter->errorOutput("\n");
 			return -1;
@@ -1316,7 +1422,7 @@ int Toy_private_push(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 int Toy_private_pop(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 	//if wrong number of arguments, fail
 	if (arguments->count != 1) {
-		interpreter->errorOutput("Incorrect number of arguments to _pop\n");
+		interpreter->errorOutput("Incorrect number of arguments to pop\n");
 		return -1;
 	}
 
@@ -1324,12 +1430,16 @@ int Toy_private_pop(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 	Toy_Literal obj = arguments->literals[0];
 
 	if (!TOY_IS_IDENTIFIER(idn)) {
-		interpreter->errorOutput("Expected identifier in _pop\n");
+		interpreter->errorOutput("Expected identifier in pop\n");
 		return -1;
 	}
 
 	Toy_parseIdentifierToValue(interpreter, &obj);
 
+	if (TOY_IS_IDENTIFIER(obj)) {
+		return -1;
+	}
+
 	switch(obj.type) {
 		case TOY_LITERAL_ARRAY: {
 			Toy_Literal lit = Toy_popLiteralArray(TOY_AS_ARRAY(obj));
@@ -1337,7 +1447,7 @@ int Toy_private_pop(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 			Toy_freeLiteral(lit);
 
 			if (!Toy_setScopeVariable(interpreter->scope, idn, obj, true)) { //TODO: could definitely be more efficient than overwriting the whole original object
-				interpreter->errorOutput("Incorrect type assigned to array in _pop: ");
+				interpreter->errorOutput("Incorrect type assigned to array in pop: ");
 				Toy_printLiteralCustom(obj, interpreter->errorOutput);
 				interpreter->errorOutput("\n");
 				return -1;
@@ -1349,7 +1459,7 @@ int Toy_private_pop(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 		}
 
 		default:
-			interpreter->errorOutput("Incorrect compound type in _pop: ");
+			interpreter->errorOutput("Incorrect compound type in pop: ");
 			Toy_printLiteralCustom(obj, interpreter->errorOutput);
 			interpreter->errorOutput("\n");
 			return -1;
@@ -1359,7 +1469,7 @@ int Toy_private_pop(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 int Toy_private_length(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 	//if wrong number of arguments, fail
 	if (arguments->count != 1) {
-		interpreter->errorOutput("Incorrect number of arguments to _length\n");
+		interpreter->errorOutput("Incorrect number of arguments to length\n");
 		return -1;
 	}
 
@@ -1371,6 +1481,10 @@ int Toy_private_length(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments
 		freeObj = true;
 	}
 
+	if (TOY_IS_IDENTIFIER(obj)) {
+		return -1;
+	}
+
 	switch(obj.type) {
 		case TOY_LITERAL_ARRAY: {
 			Toy_Literal lit = TOY_TO_INTEGER_LITERAL( TOY_AS_ARRAY(obj)->count );
@@ -1394,7 +1508,7 @@ int Toy_private_length(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments
 		}
 
 		default:
-			interpreter->errorOutput("Incorrect compound type in _length: ");
+			interpreter->errorOutput("Incorrect compound type in length: ");
 			Toy_printLiteralCustom(obj, interpreter->errorOutput);
 			interpreter->errorOutput("\n");
 			return -1;
@@ -1410,7 +1524,7 @@ int Toy_private_length(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments
 int Toy_private_clear(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments) {
 	//if wrong number of arguments, fail
 	if (arguments->count != 1) {
-		interpreter->errorOutput("Incorrect number of arguments to _clear\n");
+		interpreter->errorOutput("Incorrect number of arguments to clear\n");
 		return -1;
 	}
 
@@ -1418,12 +1532,16 @@ int Toy_private_clear(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 	Toy_Literal obj = arguments->literals[0];
 
 	if (!TOY_IS_IDENTIFIER(idn)) {
-		interpreter->errorOutput("expected identifier in _clear\n");
+		interpreter->errorOutput("expected identifier in clear\n");
 		return -1;
 	}
 
 	Toy_parseIdentifierToValue(interpreter, &obj);
 
+	if (TOY_IS_IDENTIFIER(obj)) {
+		return -1;
+	}
+
 	//NOTE: just pass in new compounds
 
 	switch(obj.type) {
@@ -1434,7 +1552,7 @@ int Toy_private_clear(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 			Toy_Literal obj = TOY_TO_ARRAY_LITERAL(array);
 
 			if (!Toy_setScopeVariable(interpreter->scope, idn, obj, true)) {
-				interpreter->errorOutput("Incorrect type assigned to array in _clear: ");
+				interpreter->errorOutput("Incorrect type assigned to array in clear: ");
 				Toy_printLiteralCustom(obj, interpreter->errorOutput);
 				interpreter->errorOutput("\n");
 				return -1;
@@ -1452,7 +1570,7 @@ int Toy_private_clear(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 			Toy_Literal obj = TOY_TO_DICTIONARY_LITERAL(dictionary);
 
 			if (!Toy_setScopeVariable(interpreter->scope, idn, obj, true)) {
-				interpreter->errorOutput("Incorrect type assigned to dictionary in _clear: ");
+				interpreter->errorOutput("Incorrect type assigned to dictionary in clear: ");
 				Toy_printLiteralCustom(obj, interpreter->errorOutput);
 				interpreter->errorOutput("\n");
 				return -1;
@@ -1464,7 +1582,7 @@ int Toy_private_clear(Toy_Interpreter* interpreter, Toy_LiteralArray* arguments)
 		}
 
 		default:
-			interpreter->errorOutput("Incorrect compound type in _clear: ");
+			interpreter->errorOutput("Incorrect compound type in clear: ");
 			Toy_printLiteralCustom(obj, interpreter->errorOutput);
 			interpreter->errorOutput("\n");
 			return -1;

source/toy_common.h

@@ -6,7 +6,7 @@
 
 #define TOY_VERSION_MAJOR 1
 #define TOY_VERSION_MINOR 0
-#define TOY_VERSION_PATCH 0
+#define TOY_VERSION_PATCH 1
 #define TOY_VERSION_BUILD __DATE__ " " __TIME__
 
 //platform/compiler-specific instructions

source/toy_interpreter.c

@@ -231,6 +231,12 @@ static bool execAssert(Toy_Interpreter* interpreter) {
 		Toy_freeLiteral(lhsIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(lhs)) {
+		Toy_freeLiteral(lhs);
+		Toy_freeLiteral(rhs);
+		return false;
+	}
+
 	if (!TOY_IS_STRING(rhs)) {
 		interpreter->errorOutput("The assert keyword needs a string as the second argument, received: ");
 		Toy_printLiteralCustom(rhs, interpreter->errorOutput);
@@ -265,6 +271,11 @@ static bool execPrint(Toy_Interpreter* interpreter) {
 		Toy_freeLiteral(idn);
 	}
 
+	if (TOY_IS_IDENTIFIER(lit)) {
+		Toy_freeLiteral(lit);
+		return false;
+	}
+
 	Toy_printLiteralCustom(lit, interpreter->printOutput);
 
 	Toy_freeLiteral(lit);
@@ -297,6 +308,11 @@ static bool rawLiteral(Toy_Interpreter* interpreter) {
 		Toy_freeLiteral(idn);
 	}
 
+	if (TOY_IS_IDENTIFIER(lit)) {
+		Toy_freeLiteral(lit);
+		return false;
+	}
+
 	Toy_pushLiteralArray(&interpreter->stack, lit);
 	Toy_freeLiteral(lit);
 
@@ -312,6 +328,11 @@ static bool execNegate(Toy_Interpreter* interpreter) {
 		Toy_freeLiteral(idn);
 	}
 
+	if (TOY_IS_IDENTIFIER(lit)) {
+		Toy_freeLiteral(lit);
+		return false;
+	}
+
 	if (TOY_IS_INTEGER(lit)) {
 		lit = TOY_TO_INTEGER_LITERAL(-TOY_AS_INTEGER(lit));
 	}
@@ -343,6 +364,11 @@ static bool execInvert(Toy_Interpreter* interpreter) {
 		Toy_freeLiteral(idn);
 	}
 
+	if (TOY_IS_IDENTIFIER(lit)) {
+		Toy_freeLiteral(lit);
+		return false;
+	}
+
 	if (TOY_IS_BOOLEAN(lit)) {
 		lit = TOY_TO_BOOLEAN_LITERAL(!TOY_AS_BOOLEAN(lit));
 	}
@@ -376,6 +402,12 @@ static bool execArithmetic(Toy_Interpreter* interpreter, Toy_Opcode opcode) {
 		Toy_freeLiteral(lhsIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(lhs) || TOY_IS_IDENTIFIER(rhs)) {
+		Toy_freeLiteral(lhs);
+		Toy_freeLiteral(rhs);
+		return false;
+	}
+
 	//special case for string concatenation ONLY
 	if (TOY_IS_STRING(lhs) && TOY_IS_STRING(rhs) && (opcode == TOY_OP_ADDITION || opcode == TOY_OP_VAR_ADDITION_ASSIGN)) {
 		//check for overflow
@@ -508,6 +540,10 @@ static Toy_Literal parseTypeToValue(Toy_Interpreter* interpreter, Toy_Literal ty
 		Toy_freeLiteral(typeIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(type)) {
+		return TOY_TO_NULL_LITERAL;
+	}
+
 	//if this is an array or dictionary, continue to the subtypes
 	if (TOY_IS_TYPE(type) && (TOY_AS_TYPE(type).typeOf == TOY_LITERAL_ARRAY || TOY_AS_TYPE(type).typeOf == TOY_LITERAL_DICTIONARY)) {
 		for (int i = 0; i < TOY_AS_TYPE(type).count; i++) {
@@ -548,6 +584,12 @@ static bool execVarDecl(Toy_Interpreter* interpreter, bool lng) {
 		Toy_freeLiteral(typeIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(type)) {
+		Toy_freeLiteral(identifier);
+		Toy_freeLiteral(type);
+		return false;
+	}
+
 	//BUGFIX: because identifiers are getting embedded in type definitions
 	type = parseTypeToValue(interpreter, type);
 
@@ -565,6 +607,13 @@ static bool execVarDecl(Toy_Interpreter* interpreter, bool lng) {
 		Toy_freeLiteral(valIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(val)) {
+		Toy_freeLiteral(identifier);
+		Toy_freeLiteral(type);
+		Toy_freeLiteral(val);
+		return false;
+	}
+
 	if (TOY_IS_ARRAY(val) || TOY_IS_DICTIONARY(val)) {
 		Toy_parseCompoundToPureValues(interpreter, &val);
 	}
@@ -645,6 +694,12 @@ static bool execVarAssign(Toy_Interpreter* interpreter) {
 		Toy_freeLiteral(rhsIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(rhs)) {
+		Toy_freeLiteral(lhs);
+		Toy_freeLiteral(rhs);
+		return false;
+	}
+
 	if (TOY_IS_ARRAY(rhs) || TOY_IS_DICTIONARY(rhs)) {
 		Toy_parseCompoundToPureValues(interpreter, &rhs);
 	}
@@ -714,6 +769,12 @@ static bool execValCast(Toy_Interpreter* interpreter) {
 		Toy_freeLiteral(valueIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(value)) {
+		Toy_freeLiteral(type);
+		Toy_freeLiteral(value);
+		return false;
+	}
+
 	Toy_Literal result = TOY_TO_NULL_LITERAL;
 
 	if (TOY_IS_NULL(value)) {
@@ -848,6 +909,12 @@ static bool execCompareEqual(Toy_Interpreter* interpreter, bool invert) {
 		Toy_freeLiteral(lhsIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(lhs) || TOY_IS_IDENTIFIER(rhs)) {
+		Toy_freeLiteral(lhs);
+		Toy_freeLiteral(rhs);
+		return false;
+	}
+
 	bool result = Toy_literalsAreEqual(lhs, rhs);
 
 	if (invert) {
@@ -876,6 +943,12 @@ static bool execCompareLess(Toy_Interpreter* interpreter, bool invert) {
 		Toy_freeLiteral(lhsIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(lhs) || TOY_IS_IDENTIFIER(rhs)) {
+		Toy_freeLiteral(lhs);
+		Toy_freeLiteral(rhs);
+		return false;
+	}
+
 	//not a number, return falure
 	if (!(TOY_IS_INTEGER(lhs) || TOY_IS_FLOAT(lhs))) {
 		interpreter->errorOutput("Incorrect type in comparison, value \"");
@@ -936,6 +1009,12 @@ static bool execCompareLessEqual(Toy_Interpreter* interpreter, bool invert) {
 		Toy_freeLiteral(lhsIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(lhs) || TOY_IS_IDENTIFIER(rhs)) {
+		Toy_freeLiteral(lhs);
+		Toy_freeLiteral(rhs);
+		return false;
+	}
+
 	//not a number, return falure
 	if (!(TOY_IS_INTEGER(lhs) || TOY_IS_FLOAT(lhs))) {
 		interpreter->errorOutput("Incorrect type in comparison, value \"");
@@ -997,6 +1076,12 @@ static bool execAnd(Toy_Interpreter* interpreter) {
 		Toy_freeLiteral(lhsIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(lhs) || TOY_IS_IDENTIFIER(rhs)) {
+		Toy_freeLiteral(lhs);
+		Toy_freeLiteral(rhs);
+		return false;
+	}
+
 	if (TOY_IS_TRUTHY(lhs) && TOY_IS_TRUTHY(rhs)) {
 		Toy_pushLiteralArray(&interpreter->stack, TOY_TO_BOOLEAN_LITERAL(true));
 	}
@@ -1024,6 +1109,12 @@ static bool execOr(Toy_Interpreter* interpreter) {
 		Toy_freeLiteral(lhsIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(lhs) || TOY_IS_IDENTIFIER(rhs)) {
+		Toy_freeLiteral(lhs);
+		Toy_freeLiteral(rhs);
+		return false;
+	}
+
 	if (TOY_IS_TRUTHY(lhs) || TOY_IS_TRUTHY(rhs)) {
 		Toy_pushLiteralArray(&interpreter->stack, TOY_TO_BOOLEAN_LITERAL(true));
 	}
@@ -1067,6 +1158,11 @@ static bool execFalseJump(Toy_Interpreter* interpreter) {
 		Toy_freeLiteral(litIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(lit)) {
+		Toy_freeLiteral(lit);
+		return false;
+	}
+
 	if (TOY_IS_NULL(lit)) {
 		interpreter->errorOutput("Null detected in comparison\n");
 		Toy_freeLiteral(lit);
@@ -1183,7 +1279,7 @@ bool Toy_callLiteralFn(Toy_Interpreter* interpreter, Toy_Literal func, Toy_Liter
 		int returnsCount = TOY_AS_FUNCTION_NATIVE(func)(interpreter, arguments);
 
 		if (returnsCount < 0) {
-			interpreter->errorOutput("Unknown error from native function\n");
+			// interpreter->errorOutput("Unknown error from native function\n");
 			return false;
 		}
 
@@ -1287,6 +1383,17 @@ bool Toy_callLiteralFn(Toy_Interpreter* interpreter, Toy_Literal func, Toy_Liter
 			Toy_freeLiteral(argIdn);
 		}
 
+		if (TOY_IS_IDENTIFIER(arg)) {
+			//free, and skip out
+			Toy_freeLiteral(arg);
+			Toy_popScope(inner.scope);
+
+			Toy_freeLiteralArray(&inner.stack);
+			Toy_freeLiteralArray(&inner.literalCache);
+
+			return false;
+		}
+
 		if (!Toy_setScopeVariable(inner.scope, paramArray->literals[i], arg, false)) {
 			interpreter->errorOutput("[internal] Could not define parameter (bad type?)\n");
 
@@ -1455,6 +1562,12 @@ static bool execFnReturn(Toy_Interpreter* interpreter) {
 			Toy_freeLiteral(litIdn);
 		}
 
+		if (TOY_IS_IDENTIFIER(lit)) {
+			Toy_freeLiteralArray(&returns);
+			Toy_freeLiteral(lit);
+			return false;
+		}
+
 		if (TOY_IS_ARRAY(lit) || TOY_IS_DICTIONARY(lit)) {
 			Toy_parseCompoundToPureValues(interpreter, &lit);
 		}
@@ -1526,6 +1639,17 @@ static bool execIndex(Toy_Interpreter* interpreter, bool assignIntermediate) {
 		freeIdn = true;
 	}
 
+	if (TOY_IS_IDENTIFIER(compound)) {
+		Toy_freeLiteral(third);
+		Toy_freeLiteral(second);
+		Toy_freeLiteral(first);
+		Toy_freeLiteral(compound);
+		if (freeIdn) {
+			Toy_freeLiteral(compoundIdn);
+		}
+		return true;
+	}
+
 	if (!TOY_IS_ARRAY(compound) && !TOY_IS_DICTIONARY(compound) && !TOY_IS_STRING(compound)) {
 		interpreter->errorOutput("Unknown compound found in indexing notation: ");
 		Toy_printLiteralCustom(compound, interpreter->errorOutput);
@@ -1610,12 +1734,33 @@ static bool execIndexAssign(Toy_Interpreter* interpreter) {
 		Toy_freeLiteral(assignIdn);
 	}
 
+	if (TOY_IS_IDENTIFIER(assign)) {
+		Toy_freeLiteral(compound);
+		Toy_freeLiteral(first);
+		Toy_freeLiteral(second);
+		Toy_freeLiteral(third);
+		Toy_freeLiteral(assign);
+		return false;
+	}
+
 	Toy_Literal compoundIdn = compound;
 	bool freeIdn = false;
 	if (TOY_IS_IDENTIFIER(compound) && Toy_parseIdentifierToValue(interpreter, &compound)) {
 		freeIdn = true;
 	}
 
+	if (TOY_IS_IDENTIFIER(compound)) {
+		Toy_freeLiteral(compound);
+		Toy_freeLiteral(first);
+		Toy_freeLiteral(second);
+		Toy_freeLiteral(third);
+		Toy_freeLiteral(assign);
+		if (freeIdn) {
+			Toy_freeLiteral(compoundIdn);
+		}
+		return false;
+	}
+
 	if (!TOY_IS_ARRAY(compound) && !TOY_IS_DICTIONARY(compound) && !TOY_IS_STRING(compound)) {
 		interpreter->errorOutput("Unknown compound found in index assigning notation\n");
 		Toy_freeLiteral(assign);

source/toy_parser.c

@@ -810,13 +810,20 @@ static Toy_Opcode indexAccess(Toy_Parser* parser, Toy_ASTNode** nodeHandle) { //
 	//eat the first
 	if (!match(parser, TOY_TOKEN_COLON)) {
 		Toy_freeASTNode(first);
+		first = NULL;
 		parsePrecedence(parser, &first, PREC_TERNARY);
 		match(parser, TOY_TOKEN_COLON);
 		readFirst = true;
 	}
 
-	if (match(parser, TOY_TOKEN_BRACKET_RIGHT)) {
+	if (!first) {
+		Toy_freeASTNode(first);
+		Toy_freeASTNode(second);
+		Toy_freeASTNode(third);
+		return TOY_OP_EOF;
+	}
 
+	if (match(parser, TOY_TOKEN_BRACKET_RIGHT)) {
 		if (readFirst) {
 			Toy_freeASTNode(second);
 			second = NULL;
@@ -832,10 +839,18 @@ static Toy_Opcode indexAccess(Toy_Parser* parser, Toy_ASTNode** nodeHandle) { //
 	//eat the second
 	if (!match(parser, TOY_TOKEN_COLON)) {
 		Toy_freeASTNode(second);
+		second = NULL;
 		parsePrecedence(parser, &second, PREC_TERNARY);
 		match(parser, TOY_TOKEN_COLON);
 	}
 
+	if (!second) {
+		Toy_freeASTNode(first);
+		Toy_freeASTNode(second);
+		Toy_freeASTNode(third);
+		return TOY_OP_EOF;
+	}
+
 	if (match(parser, TOY_TOKEN_BRACKET_RIGHT)) {
 		Toy_freeASTNode(third);
 		third = NULL;
@@ -845,7 +860,16 @@ static Toy_Opcode indexAccess(Toy_Parser* parser, Toy_ASTNode** nodeHandle) { //
 
 	//eat the third
 	Toy_freeASTNode(third);
+	third = NULL;
 	parsePrecedence(parser, &third, PREC_TERNARY);
+
+	if (!third) {
+		Toy_freeASTNode(first);
+		Toy_freeASTNode(second);
+		Toy_freeASTNode(third);
+		return TOY_OP_EOF;
+	}
+
 	Toy_emitASTNodeIndex(nodeHandle, first, second, third);
 
 	consume(parser, TOY_TOKEN_BRACKET_RIGHT, "Expected ']' in index notation");

test/scripts/mustfail/index-access-bugfix.toy

@@ -0,0 +1 @@
+"a"[--];

test/test_mustfail.c

@@ -101,6 +101,7 @@ int main() {
 			"declare-types-array.toy",
 			"declare-types-dictionary-key.toy",
 			"declare-types-dictionary-value.toy",
+			"index-access-bugfix.toy",
 			"index-arrays-non-integer.toy",
 			"string-concat.toy",
 			"unary-inverted-nothing.toy",