feat(zscript): 'auto' variable declarations

Author: EmilyV99

resources/docs/ZScript_Additions.txt

@@ -1344,8 +1344,21 @@ cases where you are not using the base function in an assign.
 	In this example, if the GetClosestNPC() function finds an enemy (i.e. does not return NULL), then
 		the 'then' block will run, doing something with the enemy's position.
 	If no enemy is found (the function returned NULL), then the else block will run instead.
-	
-	
+
+///////////////////////
+// Auto Declarations //
+///////////////////////
+
+By declaring a single variable using the type 'auto', it will inherit its
+	type from its initializer.
+
+Example:
+	auto x = 5; //x is int
+	auto n = Screen->LoadNPC(1); //n is npc
+	auto l = Screen->CreateLWeapon(LW_FIRE); //l is lweapon
+	//auto a = 1, b = 2; //ERROR: cannot use 'auto' to declare multiple variables at once
+	//auto c; //ERROR: must use an initializer when using 'auto'
+
 ////////////
 // Repeat //
 ////////////

src/parser/AST.cpp

@@ -1253,6 +1253,18 @@ DataType const& ASTDataDecl::resolveType(ZScript::Scope* scope, CompileErrorHand
 	return *type;
 }
 
+DataType const* ASTDataDecl::resolve_ornull(ZScript::Scope* scope, CompileErrorHandler* errorHandler)
+{
+	DataType const& ty = resolveType(scope, errorHandler);
+	return ty.isResolved() ? &ty : nullptr;
+}
+
+void ASTDataDecl::replaceType(DataType const& newty)
+{
+	ASTDataType* baseTypeNode = list ? list->baseType.get() : baseType.get();
+	baseTypeNode->replace(newty);
+}
+
 bool ZScript::hasSize(ASTDataDecl const& decl)
 {
 	for (auto it = decl.extraArrays.cbegin(); it != decl.extraArrays.cend(); ++it)
@@ -2635,16 +2647,16 @@ DataType const& ASTDataType::resolve(ZScript::Scope& scope, CompileErrorHandler*
 {
 	if(!wasResolved_)
 	{
-		DataType* resolved = type->resolve(scope, errorHandler);
+		DataType const* resolved = type->resolve(scope, errorHandler);
 		if(resolved && constant_)
 		{
 			string name = resolved->getName();
-			resolved = resolved->getConstType();
-			if(constant_>1 || !resolved)
+			if(constant_>1 || resolved->isConstant())
 			{
 				errorHandler->handleError(CompileError::ConstAlreadyConstant(this, name));
 				return DataType::ZVOID;
 			}
+			resolved = resolved->getConstType();
 		}
 		if(resolved)
 		{
@@ -2666,4 +2678,11 @@ DataType const* ASTDataType::resolve_ornull(ZScript::Scope& scope, CompileErrorH
 	DataType const& ty = resolve(scope, errorHandler);
 	return ty.isResolved() ? &ty : nullptr;
 }
+void ASTDataType::replace(DataType const& newty)
+{
+	wasResolved_ = false;
+	constant_ = false;
+	becomeArray = false;
+	type.reset(newty.clone());
+}
 

src/parser/AST.h

@@ -951,7 +951,10 @@ namespace ZScript
 		// Resolves the type, using either the list's or this node's own base type
 		// as appropriate.
 		DataType const& resolveType(Scope* scope, CompileErrorHandler* errorHandler);
+		DataType const* resolve_ornull(Scope* scope, CompileErrorHandler* errorHandler);
 
+		void replaceType(DataType const& newty);
+		
 		// The list containing this declaration. Should be set by that list when
 		// this is added.
 		ASTDataDeclList* list;
@@ -2142,6 +2145,7 @@ namespace ZScript
 		void execute(ASTVisitor& visitor, void* param = NULL);
 		DataType const& resolve(Scope& scope, CompileErrorHandler* errorHandler);
 		DataType const* resolve_ornull(Scope& scope, CompileErrorHandler* errorHandler);
+		void replace(DataType const& newty);
 		inline bool wasResolved() const { return wasResolved_; }
 
 		owning_ptr<DataType> type;

src/parser/BuildVisitors.cpp

@@ -1337,7 +1337,7 @@ void BuildOpcodes::caseExprCall(ASTExprCall& host, void* param)
 		else
 		{
 			DataType const& retType = *func.returnType;
-			if(retType != DataType::ZVOID)
+			if(!retType.isVoid())
 			{
 				int32_t retval = 0;
 				if (std::optional<int32_t> val = func.defaultReturn->getCompileTimeValue(NULL, scope))

src/parser/CompileError.xtable

@@ -29,9 +29,9 @@ X(	CantParseImport,			P,	A,	E,	STR,	VOID,	"Included file '%s' encountered an err
 X(	ImportRecursion,		P,	A,	E,	INT,	VOID,	"Recursion limit of %d hit while preprocessing. Perhaps you have circular imports?"	)
 X(	ImportBadScope,			P,	D	                                                                                  				)
 X(	FunctionRedef,			S,	A,	E,	STR,	VOID,	"Function %s was already declared with that type signature."                            )
-X(	FunctionVoidParam,		S,	A,	E,	STR,	VOID,	"Function parameter %s cannot have void type."	 					)
+X(	FunctionBadParamType,		S,	A,	E,	STR,	STR,	"Function parameter %s cannot have %s type."	 					)
 X(	ScriptRedef,			S,	A,	E,	STR,	VOID,	"Duplicate script with name %s already exists."						)
-X(	VoidVar,			S,	A,	E,	STR,	VOID,	"Variable %s can't have type void."    							)
+X(	BadVarType,			S,	A,	E,	STR,	STR,	"Variable %s can't have type %s."    							)
 X(	VarRedef,			S,	A,	E,	STR,	VOID,	"There is already a variable with name %s in this scope."				)
 X(	VarUndeclared,			S,	A,	E,	STR,	VOID,	"Variable %s has not been declared."   	     	  					)
 X(	FuncUndeclared,			S,	D					     	     	  								)
@@ -63,7 +63,7 @@ X(	ConstRedef,			S,	D				       	  	      		       	  						)
 X(	LValConst,			C,	A,	E,	STR,	VOID,	"Variable %s is constant and cannot be changed."					)
 X(	BadGlobalInit,			T,	D					     		     	       							)
 X(	DeprecatedGlobal,		S,	D															)
-X(	VoidArr,			S,	A,	E,	STR,	VOID,	"Array %s cannot have base type void."							)
+X(	BadArrType,			S,	A,	E,	STR,	STR,	"Array %s cannot have base type %s."							)
 X(	RefArr,				S,	A,	E,	STR,	VOID,	"Arrays of type %s are not allowed to be global."					)
 X(	ArrRedef,			S,	D					   	       	   	      	 						)
 X(	ArrayTooSmall,			A,	A,	E,	VOID,	VOID,	"Arrays must have a size of at least 1."						)
@@ -122,6 +122,9 @@ X(	BadDelete,			T,	A,	E,	VOID,	VOID,	"'delete' may only be used on objects of cl
 X(	DeprecatedWarn,			S,	A,	W,	STR,	STR,	"%s '%s' is deprecated, and should not be used."								)
 X(	DeprecatedError,			S,	A,	E,	STR,	STR,	"%s '%s' is deprecated, and cannot be used due to current compiler settings."								)
 X(	BadAnnotation,			P,	A,	E,	STR,	STR,	"Annotation @%s invalid: %s"						)
+X(	BadAutoType,			S,	A,	E,	VOID,	VOID,	"'auto' must have an initializer with valid type to mimic."							)
+X(	GroupAuto,			S,	A,	E,	VOID,	VOID,	"'auto' cannot apply to a group declaration."							)
+X(	BadReturnType,			S,	A,	E,	STR,	VOID,	"Cannot return type '%s'."							)
 
 
 #undef STR

src/parser/RegistrationVisitor.cpp

@@ -442,22 +442,28 @@ void RegistrationVisitor::caseScriptTypeDef(ASTScriptTypeDef& host, void* param)
 void RegistrationVisitor::caseDataDeclList(ASTDataDeclList& host, void* param)
 {
 	// Resolve the base type.
-	DataType const& baseType = host.baseType->resolve(*scope, this);
+	DataType const* baseType = host.baseType->resolve_ornull(*scope, this);
     if (breakRecursion(*host.baseType.get())) return;
-	if (!host.baseType->wasResolved()) return;
+	if (!host.baseType->wasResolved() || !baseType) return;
 
 	// Don't allow void type.
-	if (baseType == DataType::ZVOID)
+	if (baseType->isVoid())
 	{
-		handleError(CompileError::VoidVar(&host, host.asString()));
+		handleError(CompileError::BadVarType(&host, host.asString(), baseType->getName()));
 		doRegister(host);
 		return;
 	}
-
+	
+	if (baseType->isAuto() && host.getDeclarations().size() > 1)
+	{
+		handleError(CompileError::GroupAuto(&host));
+		return;
+	}
+	
 	// Check for disallowed global types.
-	if (scope->isGlobal() && !baseType.canBeGlobal())
+	if (scope->isGlobal() && !baseType->canBeGlobal())
 	{
-		handleError(CompileError::RefVar(&host, baseType.getName()));
+		handleError(CompileError::RefVar(&host, baseType->getName()));
 		doRegister(host);
 		return;
 	}
@@ -471,22 +477,22 @@ void RegistrationVisitor::caseDataDeclList(ASTDataDeclList& host, void* param)
 void RegistrationVisitor::caseDataEnum(ASTDataEnum& host, void* param)
 {
 	// Resolve the base type.
-	DataType const& baseType = host.baseType->resolve(*scope, this);
+	DataType const* baseType = host.baseType->resolve_ornull(*scope, this);
     if (breakRecursion(*host.baseType.get())) return;
-	if (!baseType.isResolved()) return;
+	if (!baseType) return;
 
-	// Don't allow void type.
-	if (baseType == DataType::ZVOID)
+	// Don't allow void/auto types.
+	if (baseType->isVoid() || baseType->isAuto())
 	{
-		handleError(CompileError::VoidVar(&host, host.asString()));
+		handleError(CompileError::BadVarType(&host, host.asString(), baseType->getName()));
 		doRegister(host);
 		return;
 	}
 
 	// Check for disallowed global types.
-	if (scope->isGlobal() && !baseType.canBeGlobal())
+	if (scope->isGlobal() && !baseType->canBeGlobal())
 	{
-		handleError(CompileError::RefVar(&host, baseType.getName()));
+		handleError(CompileError::RefVar(&host, baseType->getName()));
 		doRegister(host);
 		return;
 	}
@@ -532,29 +538,51 @@ void RegistrationVisitor::caseDataDecl(ASTDataDecl& host, void* param)
 	if (breakRecursion(host)) return;
 	if(!(registered(host, host.extraArrays) && (!host.getInitializer() || registered(host.getInitializer())))) return;
 	// Then resolve the type.
-	DataType const& type = host.resolveType(scope, this);
+	DataType const* type = host.resolve_ornull(scope, this);
 	if (breakRecursion(host)) return;
-	if (!type.isResolved()) return;
+	if (!type) return;
 
 	doRegister(host);
 
 	// Don't allow void type.
-	if (type == DataType::ZVOID)
+	if (type->isVoid())
 	{
-		handleError(CompileError::VoidVar(&host, host.name));
+		handleError(CompileError::BadVarType(&host, host.name, type->getName()));
 		return;
 	}
+	
+	if (type->isAuto())
+	{
+		bool good = false;
+		auto init = host.getInitializer();
+		if(init)
+		{
+			auto readty = init->getReadType(scope, this);
+			if(readty && readty->isResolved() && !readty->isVoid() && !readty->isAuto())
+			{
+				auto newty = type->isConstant() ? readty->getConstType() : readty->getMutType();
+				host.replaceType(*newty);
+				type = host.resolve_ornull(scope, this);
+				good = true;
+			}
+		}
+		if(!good)
+		{
+			handleError(CompileError::BadAutoType(&host));
+			return;
+		}
+	}
 
 	// Check for disallowed global types.
-	if (scope->isGlobal() && !type.canBeGlobal())
+	if (scope->isGlobal() && !type->canBeGlobal())
 	{
 		handleError(CompileError::RefVar(
-				            &host, type.getName() + " " + host.name));
+				            &host, type->getName() + " " + host.name));
 		return;
 	}
 
 	// Currently disabled syntaxes:
-	if (getArrayDepth(type) > 1)
+	if (getArrayDepth(*type) > 1)
 	{
 		handleError(CompileError::UnimplementedFeature(
 				            &host, "Nested Array Declarations"));
@@ -563,7 +591,7 @@ void RegistrationVisitor::caseDataDecl(ASTDataDecl& host, void* param)
 
 	// Is it a constant?
 	bool isConstant = false;
-	if (type.isConstant())
+	if (type->isConstant())
 	{
 		// A constant without an initializer doesn't make sense.
 		if (!host.getInitializer())
@@ -599,13 +627,13 @@ void RegistrationVisitor::caseDataDecl(ASTDataDecl& host, void* param)
 		}
 
 		int32_t value = *host.getInitializer()->getCompileTimeValue(this, scope);
-		Constant::create(*scope, host, type, value, this);
+		Constant::create(*scope, host, *type, value, this);
 	}
 	else
 	{
 		if(parsing_user_class == puc_vars)
 		{
-			UserClassVar::create(*scope, host, type, this);
+			UserClassVar::create(*scope, host, *type, this);
 		}
 		else
 		{
@@ -615,7 +643,7 @@ void RegistrationVisitor::caseDataDecl(ASTDataDecl& host, void* param)
 				return;
 			}
 
-			Variable::create(*scope, host, type, this);
+			Variable::create(*scope, host, *type, this);
 		}
 	}
 }
@@ -701,6 +729,12 @@ void RegistrationVisitor::caseFuncDecl(ASTFuncDecl& host, void* param)
 	DataType const& returnType = host.returnType->resolve(*scope, this);
 	if (breakRecursion(*host.returnType.get())) {scope = oldScope; return;}
 	if (!returnType.isResolved()) {scope = oldScope; return;}
+	if(returnType.isAuto())
+	{
+		handleError(CompileError::BadReturnType(&host, returnType.getName()));
+		scope = oldScope;
+		return;
+	}
 
 	// Gather the parameter types.
 	vector<DataType const*> paramTypes;
@@ -712,20 +746,20 @@ void RegistrationVisitor::caseFuncDecl(ASTFuncDecl& host, void* param)
 		ASTDataDecl& decl = **it;
 
 		// Resolve the parameter type under current scope.
-		DataType const& type = decl.resolveType(scope, this);
+		DataType const* type = decl.resolve_ornull(scope, this);
 		if (breakRecursion(decl)) {scope = oldScope; return;}
-		if (!type.isResolved()) {scope = oldScope; return;}
+		if (!type) {scope = oldScope; return;}
 
-		// Don't allow void params.
-		if (type == DataType::ZVOID)
+		// Don't allow void/auto params.
+		if (type->isVoid() || type->isAuto())
 		{
-			handleError(CompileError::FunctionVoidParam(&decl, decl.name));
+			handleError(CompileError::FunctionBadParamType(&decl, decl.name, type->getName()));
 			doRegister(host);
 			scope = oldScope;
 			return;
 		}
 		paramNames.push_back(new string(decl.name));
-		paramTypes.push_back(&type);
+		paramTypes.push_back(type);
 	}
 	if(host.prototype)
 	{