Shader: Remove ShaderNode::GetExpressionType (replaced by visitor) and minor stuff

src/Nazara/Shader/GlslWriter.cpp

@@ -8,6 +8,7 @@
 #include <Nazara/Math/Algorithm.hpp>
 #include <Nazara/Shader/ShaderBuilder.hpp>
 #include <Nazara/Shader/ShaderAstCloner.hpp>
+#include <Nazara/Shader/ShaderAstUtils.hpp>
 #include <Nazara/Shader/ShaderAstValidator.hpp>
 #include <stdexcept>
 #include <Nazara/Shader/Debug.hpp>
@@ -349,7 +350,7 @@ namespace Nz
 
 	void GlslWriter::Visit(ShaderNodes::ExpressionPtr& expr, bool encloseIfRequired)
 	{
-		bool enclose = encloseIfRequired && (expr->GetExpressionCategory() != ShaderNodes::ExpressionCategory::LValue);
+		bool enclose = encloseIfRequired && (GetExpressionCategory(expr) != ShaderNodes::ExpressionCategory::LValue);
 
 		if (enclose)
 			Append("(");
@@ -461,7 +462,6 @@ namespace Nz
 		Append(")");
 	}
 
-
 	void GlslWriter::Visit(ShaderNodes::ConditionalExpression& node)
 	{
 		std::size_t conditionIndex = m_context.shader->FindConditionByName(node.conditionName);

src/Nazara/Shader/ShaderAstUtils.cpp

@@ -0,0 +1,73 @@
+// Copyright (C) 2020 Jérôme Leclercq
+// This file is part of the "Nazara Engine - Shader generator"
+// For conditions of distribution and use, see copyright notice in Config.hpp
+
+#include <Nazara/Shader/ShaderAstUtils.hpp>
+#include <Nazara/Shader/Debug.hpp>
+
+namespace Nz
+{
+	ShaderNodes::ExpressionCategory ShaderAstValueCategory::GetExpressionCategory(const ShaderNodes::ExpressionPtr& expression)
+	{
+		Visit(expression);
+		return m_expressionCategory;
+	}
+
+	void ShaderAstValueCategory::Visit(ShaderNodes::AccessMember& node)
+	{
+		Visit(node.structExpr);
+	}
+
+	void ShaderAstValueCategory::Visit(ShaderNodes::AssignOp& node)
+	{
+		m_expressionCategory = ShaderNodes::ExpressionCategory::RValue;
+	}
+
+	void ShaderAstValueCategory::Visit(ShaderNodes::BinaryOp& node)
+	{
+		m_expressionCategory = ShaderNodes::ExpressionCategory::RValue;
+	}
+
+	void ShaderAstValueCategory::Visit(ShaderNodes::Cast& node)
+	{
+		m_expressionCategory = ShaderNodes::ExpressionCategory::RValue;
+	}
+
+	void ShaderAstValueCategory::Visit(ShaderNodes::ConditionalExpression& node)
+	{
+		Visit(node.truePath);
+		ShaderNodes::ExpressionCategory trueExprCategory = m_expressionCategory;
+		Visit(node.falsePath);
+		ShaderNodes::ExpressionCategory falseExprCategory = m_expressionCategory;
+
+		if (trueExprCategory == ShaderNodes::ExpressionCategory::RValue || falseExprCategory == ShaderNodes::ExpressionCategory::RValue)
+			m_expressionCategory = ShaderNodes::ExpressionCategory::RValue;
+		else
+			m_expressionCategory = ShaderNodes::ExpressionCategory::LValue;
+	}
+
+	void ShaderAstValueCategory::Visit(ShaderNodes::Constant& node)
+	{
+		m_expressionCategory = ShaderNodes::ExpressionCategory::RValue;
+	}
+
+	void ShaderAstValueCategory::Visit(ShaderNodes::Identifier& node)
+	{
+		m_expressionCategory = ShaderNodes::ExpressionCategory::LValue;
+	}
+
+	void ShaderAstValueCategory::Visit(ShaderNodes::IntrinsicCall& node)
+	{
+		m_expressionCategory = ShaderNodes::ExpressionCategory::RValue;
+	}
+
+	void ShaderAstValueCategory::Visit(ShaderNodes::Sample2D& node)
+	{
+		m_expressionCategory = ShaderNodes::ExpressionCategory::RValue;
+	}
+
+	void ShaderAstValueCategory::Visit(ShaderNodes::SwizzleOp& node)
+	{
+		Visit(node.expression);
+	}
+}

src/Nazara/Shader/ShaderAstValidator.cpp

@@ -5,6 +5,7 @@
 #include <Nazara/Shader/ShaderAstValidator.hpp>
 #include <Nazara/Core/CallOnExit.hpp>
 #include <Nazara/Shader/ShaderAst.hpp>
+#include <Nazara/Shader/ShaderAstUtils.hpp>
 #include <Nazara/Shader/ShaderVariables.hpp>
 #include <vector>
 #include <Nazara/Shader/Debug.hpp>
@@ -126,7 +127,7 @@ namespace Nz
 		MandatoryNode(node.right);
 		TypeMustMatch(node.left, node.right);
 
-		if (node.left->GetExpressionCategory() != ShaderNodes::ExpressionCategory::LValue)
+		if (GetExpressionCategory(node.left) != ShaderNodes::ExpressionCategory::LValue)
 			throw AstError { "Assignation is only possible with a l-value" };
 
 		ShaderAstRecursiveVisitor::Visit(node);
@@ -221,7 +222,10 @@ namespace Nz
 	{
 		for (const auto& condStatement : node.condStatements)
 		{
-			MandatoryNode(condStatement.condition);
+			const ShaderExpressionType& condType = MandatoryExpr(condStatement.condition)->GetExpressionType();
+			if (!IsBasicType(condType) || std::get<ShaderNodes::BasicType>(condType) != ShaderNodes::BasicType::Boolean)
+				throw AstError{ "if expression must resolve to boolean type" };
+
 			MandatoryNode(condStatement.statement);
 		}
 

src/Nazara/Shader/ShaderNodes.cpp

@@ -13,11 +13,6 @@ namespace Nz::ShaderNodes
 {
 	Node::~Node() = default;
 
-	ExpressionCategory Expression::GetExpressionCategory() const
-	{
-		return ExpressionCategory::RValue;
-	}
-
 	void ExpressionStatement::Visit(ShaderAstVisitor& visitor)
 	{
 		visitor.Visit(*this);
@@ -48,11 +43,6 @@ namespace Nz::ShaderNodes
 	}
 
 
-	ExpressionCategory Identifier::GetExpressionCategory() const
-	{
-		return ExpressionCategory::LValue;
-	}
-
 	ShaderExpressionType Identifier::GetExpressionType() const
 	{
 		assert(var);
@@ -64,11 +54,6 @@ namespace Nz::ShaderNodes
 		visitor.Visit(*this);
 	}
 
-	ExpressionCategory AccessMember::GetExpressionCategory() const
-	{
-		return structExpr->GetExpressionCategory();
-	}
-
 	ShaderExpressionType AccessMember::GetExpressionType() const
 	{
 		return exprType;
@@ -231,11 +216,6 @@ namespace Nz::ShaderNodes
 	}
 
 
-	ExpressionCategory SwizzleOp::GetExpressionCategory() const
-	{
-		return expression->GetExpressionCategory();
-	}
-
 	ShaderExpressionType SwizzleOp::GetExpressionType() const
 	{
 		const ShaderExpressionType& exprType = expression->GetExpressionType();

src/Nazara/Shader/SpirvExpressionLoad.cpp

@@ -13,7 +13,7 @@ namespace Nz
 	namespace
 	{
 		template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
-		template<class... Ts> overloaded(Ts...)->overloaded<Ts...>;
+		template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;
 	}
 
 	UInt32 SpirvExpressionLoad::Evaluate(ShaderNodes::Expression& node)