Add support for vector bitwise ops (close #56)

Author: SirLynix

include/NZSL/Ast/ExpressionType.inl

@@ -396,13 +396,15 @@ namespace nzsl::Ast
 
 	inline ExpressionType UnwrapExternalType(const ExpressionType& exprType)
 	{
-		if (IsStorageType(exprType))
-			return std::get<StorageType>(exprType).containedType;
-		else if (IsUniformType(exprType))
-			return std::get<UniformType>(exprType).containedType;
-		else if (IsArrayType(exprType))
+		const ExpressionType& resolvedExprType = ResolveAlias(exprType);
+
+		if (IsStorageType(resolvedExprType))
+			return std::get<StorageType>(resolvedExprType).containedType;
+		else if (IsUniformType(resolvedExprType))
+			return std::get<UniformType>(resolvedExprType).containedType;
+		else if (IsArrayType(resolvedExprType))
 		{
-			const ArrayType& arrayType = std::get<ArrayType>(exprType);
+			const ArrayType& arrayType = std::get<ArrayType>(resolvedExprType);
 			if (arrayType.isWrapped)
 			{
 				ArrayType unwrappedArrayType;

include/NZSL/Ast/Transformations/TransformerContext.hpp

@@ -85,7 +85,7 @@ namespace nzsl::Ast
 		{
 			ExpressionType type;
 		};
-		
+
 		TransformerContext();
 
 		void Reset();

include/NZSL/Ast/Utils.hpp

@@ -78,6 +78,7 @@ namespace nzsl::Ast
 	NZSL_API StatementPtr Unscope(StatementPtr&& statement);
 
 	NZSL_API ExpressionType ValidateBinaryOp(BinaryType op, const ExpressionType& leftExprType, const ExpressionType& rightExprType, const SourceLocation& sourceLocation, const Stringifier& typeStringifier = {});
+	NZSL_API void ValidateUnaryOp(UnaryType op, const ExpressionType& exprType, const SourceLocation& sourceLocation, const Stringifier& typeStringifier = {});
 
 	NZSL_API bool ValidateMatchingTypes(const ExpressionPtr& left, const ExpressionPtr& right);
 	NZSL_API bool ValidateMatchingTypes(const ExpressionType& left, const ExpressionType& right);

src/NZSL/Ast/Transformations/ResolveTransformer.cpp

@@ -2038,7 +2038,7 @@ namespace nzsl::Ast
 		if (!rightExprType)
 			return DontVisitChildren{};
 
-		binaryExpression.cachedExpressionType = ValidateBinaryOp(binaryExpression.op, ResolveAlias(*leftExprType), ResolveAlias(*rightExprType), binaryExpression.sourceLocation, BuildStringifier(binaryExpression.sourceLocation));
+		binaryExpression.cachedExpressionType = ValidateBinaryOp(binaryExpression.op, *leftExprType, *rightExprType, binaryExpression.sourceLocation, BuildStringifier(binaryExpression.sourceLocation));
 		return DontVisitChildren{};
 	}
 
@@ -2381,55 +2381,6 @@ namespace nzsl::Ast
 		if (!exprType)
 			return DontVisitChildren{};
 
-		const ExpressionType& resolvedExprType = ResolveAlias(*exprType);
-
-		switch (node.op)
-		{
-			case UnaryType::BitwiseNot:
-			{
-				if (resolvedExprType != ExpressionType(PrimitiveType::Int32) && resolvedExprType != ExpressionType(PrimitiveType::UInt32))
-					throw CompilerUnaryUnsupportedError{ node.sourceLocation, ToString(*exprType, node.sourceLocation) };
-
-				break;
-			}
-
-			case UnaryType::LogicalNot:
-			{
-				if (resolvedExprType != ExpressionType(PrimitiveType::Boolean))
-					throw CompilerUnaryUnsupportedError{ node.sourceLocation, ToString(*exprType, node.sourceLocation) };
-
-				break;
-			}
-
-			case UnaryType::Minus:
-			case UnaryType::Plus:
-			{
-				PrimitiveType basicType;
-				if (IsPrimitiveType(resolvedExprType))
-					basicType = std::get<PrimitiveType>(resolvedExprType);
-				else if (IsVectorType(resolvedExprType))
-					basicType = std::get<VectorType>(resolvedExprType).type;
-				else
-					throw CompilerUnaryUnsupportedError{ node.sourceLocation, ToString(*exprType, node.sourceLocation) };
-
-				switch (basicType)
-				{
-					case PrimitiveType::Float32:
-					case PrimitiveType::Float64:
-					case PrimitiveType::Int32:
-					case PrimitiveType::UInt32:
-					case PrimitiveType::FloatLiteral:
-					case PrimitiveType::IntLiteral:
-						break;
-
-					default:
-						throw CompilerUnaryUnsupportedError{ node.sourceLocation, ToString(*exprType, node.sourceLocation) };
-				}
-
-				break;
-			}
-		}
-
 		node.cachedExpressionType = *exprType;
 		return DontVisitChildren{};
 	}
@@ -2847,7 +2798,7 @@ namespace nzsl::Ast
 		{
 			ConstantValue& optionValue = optionValueIt->second;
 			EnsureLiteralValue(optType, optionValue, declOption.sourceLocation);
-		
+
 			declOption.optIndex = RegisterConstant(declOption.optName, TransformerContext::ConstantData{ m_states->currentModuleId, optionValue }, declOption.optIndex, declOption.sourceLocation);
 		}
 		else

src/NZSL/Ast/Transformations/ValidationTransformer.cpp

@@ -507,7 +507,7 @@ namespace nzsl::Ast
 		{
 			case AssignType::Simple:
 			{
-				if (!ValidateMatchingTypes(*leftExprType, UnwrapExternalType(ResolveAlias(*rightExprType))))
+				if (!ValidateMatchingTypes(*leftExprType, UnwrapExternalType(*rightExprType)))
 					throw CompilerUnmatchingTypesError{ node.sourceLocation, ToString(*leftExprType, node.sourceLocation), ToString(*rightExprType, node.sourceLocation) };
 
 				break;
@@ -524,7 +524,7 @@ namespace nzsl::Ast
 
 		if (binaryType)
 		{
-			ExpressionType expressionType = ValidateBinaryOp(*binaryType, ResolveAlias(*leftExprType), UnwrapExternalType(ResolveAlias(*rightExprType)), node.sourceLocation);
+			ExpressionType expressionType = ValidateBinaryOp(*binaryType, *leftExprType, UnwrapExternalType(*rightExprType), node.sourceLocation);
 			if (!ValidateMatchingTypes(UnwrapExternalType(*leftExprType), expressionType))
 				throw CompilerUnmatchingTypesError{ node.sourceLocation, ToString(*leftExprType, node.sourceLocation), ToString(expressionType, node.sourceLocation) };
 		}
@@ -1009,6 +1009,11 @@ namespace nzsl::Ast
 	{
 		HandleChildren(node);
 
+		const ExpressionType* exprType = GetExpressionType(MandatoryExpr(node.expression, node.sourceLocation));
+		if (!exprType)
+			return DontVisitChildren{};
+
+		ValidateUnaryOp(node.op, *exprType, node.sourceLocation, BuildStringifier(node.sourceLocation));
 		return DontVisitChildren{};
 	}