Add return type validation

NazaraEngine · Nov 30, 2024 · 835e3b0 · 835e3b0
1 parent d8c0fa9
commit 835e3b0
Show file tree

Hide file tree

Showing 5 changed files with 84 additions and 4 deletions.
diff --git a/include/NZSL/Ast/SanitizeVisitor.hpp b/include/NZSL/Ast/SanitizeVisitor.hpp
@@ -111,6 +111,7 @@ namespace nzsl::Ast
 			StatementPtr Clone(ForEachStatement& node) override;
 			StatementPtr Clone(ImportStatement& node) override;
 			StatementPtr Clone(MultiStatement& node) override;
+			StatementPtr Clone(ReturnStatement& node) override;
 			StatementPtr Clone(ScopedStatement& node) override;
 			StatementPtr Clone(WhileStatement& node) override;
 
@@ -171,6 +172,7 @@ namespace nzsl::Ast
 			ValidationResult TypeMustMatch(const ExpressionPtr& left, const ExpressionPtr& right, const SourceLocation& sourceLocation);
 
 			ValidationResult Validate(DeclareAliasStatement& node);
+			ValidationResult Validate(ReturnStatement& node);
 			ValidationResult Validate(WhileStatement& node);
 
 			ValidationResult Validate(AccessIndexExpression& node);

diff --git a/include/NZSL/Lang/ErrorList.hpp b/include/NZSL/Lang/ErrorList.hpp
@@ -100,6 +100,8 @@ NZSL_SHADERLANG_COMPILER_ERROR(FunctionCallUnexpectedEntryFunction, "{} is an en
 NZSL_SHADERLANG_COMPILER_ERROR(FunctionCallUnmatchingParameterCount, "function {} expects {} parameter(s), but got {}", std::string, std::uint32_t, std::uint32_t)
 NZSL_SHADERLANG_COMPILER_ERROR(FunctionCallUnmatchingParameterType, "function {} parameter #{} type mismatch (expected {}, got {})", std::string, std::uint32_t, std::string, std::string)
 NZSL_SHADERLANG_COMPILER_ERROR(FunctionDeclarationInsideFunction, "a function cannot be defined inside another function")
+NZSL_SHADERLANG_COMPILER_ERROR(FunctionReturnStatementWithAValue, "return-statement with a value, in function returning no value")
+NZSL_SHADERLANG_COMPILER_ERROR(FunctionReturnStatementWithNoValue, "return-statement with no value, in function returning {}", std::string)
 NZSL_SHADERLANG_COMPILER_ERROR(IdentifierAlreadyUsed, "identifier {} is already used", std::string)
 NZSL_SHADERLANG_COMPILER_ERROR(ImportIdentifierAlreadyPresent, "{} identifier was already imported", std::string)
 NZSL_SHADERLANG_COMPILER_ERROR(ImportIdentifierNotFound, "identifier {} not found in module {}", std::string, std::string)

diff --git a/src/NZSL/Ast/SanitizeVisitor.cpp b/src/NZSL/Ast/SanitizeVisitor.cpp
@@ -2738,6 +2738,15 @@ NAZARA_WARNING_POP()
 		return clone;
 	}
 
+	StatementPtr SanitizeVisitor::Clone(ReturnStatement& node)
+	{
+		auto clone = Nz::StaticUniquePointerCast<ReturnStatement>(Cloner::Clone(node));
+
+		Validate(*clone);
+
+		return clone;
+	}
+
 	StatementPtr SanitizeVisitor::Clone(ScopedStatement& node)
 	{
 		MandatoryStatement(node.statement, node.sourceLocation);
@@ -4162,6 +4171,38 @@ NAZARA_WARNING_POP()
 		return ValidationResult::Validated;
 	}
 
+	auto SanitizeVisitor::Validate(ReturnStatement& node) -> ValidationResult
+	{
+		Nz::Assert(m_context->currentFunction);
+
+		auto& function = m_context->currentFunction;
+		if (!function->node->returnType.IsResultingValue())
+			return ValidationResult::Unresolved;
+
+		const bool functionHasNoReturnType = std::holds_alternative<NoType>(function->node->returnType.GetResultingValue());
+
+		if (!node.returnExpr)
+		{
+			if (!functionHasNoReturnType)
+				throw CompilerFunctionReturnStatementWithNoValueError{ node.sourceLocation, ToString(function->node->returnType.GetResultingValue(), node.sourceLocation) };
+
+			//If node doesn't have an expression and function doesn't have return type, then we can directly validate
+			return ValidationResult::Validated;
+		}
+
+		if (functionHasNoReturnType)
+			throw CompilerFunctionReturnStatementWithAValueError{ node.sourceLocation };
+
+		const ExpressionType* returnTypeOpt = GetExpressionType(MandatoryExpr(node.returnExpr, node.sourceLocation));
+		if (!returnTypeOpt)
+			return ValidationResult::Unresolved;
+
+		ExpressionType returnType = ResolveType(*returnTypeOpt, true, node.sourceLocation);
+		TypeMustMatch(returnType, function->node->returnType.GetResultingValue(), node.sourceLocation);
+
+		return ValidationResult::Validated;
+	}
+
 	auto SanitizeVisitor::Validate(WhileStatement& node) -> ValidationResult
 	{
 		const ExpressionType* conditionType = GetExpressionType(MandatoryExpr(node.condition, node.sourceLocation));

diff --git a/tests/src/Tests/ErrorsTests.cpp b/tests/src/Tests/ErrorsTests.cpp
@@ -594,7 +594,7 @@ external
 	data: uniform[Outer]
 }
 
-fn GetValue(data: Inner) -> i32
+fn GetValue(data: Inner) -> f32
 {
 	return data.value;
 }
@@ -625,9 +625,9 @@ external
 	data: uniform[Outer]
 }
 
-fn GetValue(data: array[Inner, 3]) -> i32
+fn GetValue(data: array[Inner, 3]) -> f32
 {
-	return data[1];
+	return data[1].value;
 }
 
 fn main()
@@ -667,6 +667,41 @@ external
 
 		/************************************************************************/
 
+		SECTION("Functions")
+		{
+			CHECK_THROWS_WITH(Compile(R"(
+[nzsl_version("1.0")]
+module;
+
+fn test() -> i32
+{
+	return 42.666;
+}
+)"), "(7,2 -> 15): CUnmatchingTypes error: left expression type (f32) doesn't match right expression type (i32)");
+
+			CHECK_THROWS_WITH(Compile(R"(
+[nzsl_version("1.0")]
+module;
+
+fn test() -> i32
+{
+	return;
+}
+)"), "(7,2 -> 8): CFunctionReturnStatementWithNoValue error: return-statement with no value, in function returning i32");
+
+			CHECK_THROWS_WITH(Compile(R"(
+[nzsl_version("1.0")]
+module;
+
+fn test()
+{
+	return 10;
+}
+)"), "(7,2 -> 11): CFunctionReturnStatementWithAValue error: return-statement with a value, in function returning no value");
+		}
+
+		/************************************************************************/
+
 		SECTION("Import")
 		{
 			CHECK_THROWS_WITH(Compile(R"(

diff --git a/tests/src/Tests/SerializationsTests.cpp b/tests/src/Tests/SerializationsTests.cpp
@@ -447,7 +447,7 @@ struct FragOut
 }
 
 [entry(frag)]
-fn main(input: FragIn)
+fn main(input: FragIn) -> FragOut
 {
 	let output: FragOut;
 	output.color = tex2D(texture, input.uv);