Add version checks for implicit types and type constants

SirLynix · SirLynix · commit d741383efd2d · 2025-08-28T16:31:44.000+02:00
diff --git a/include/NZSL/Ast/Transformations/TransformerContext.hpp b/include/NZSL/Ast/Transformations/TransformerContext.hpp
@@ -79,6 +79,7 @@ namespace nzsl::Ast
 		{
 			std::string name;
 			std::variant<ExpressionType, PartialType> content;
+			std::function<void(const SourceLocation& sourceLocation)> check;
 		};
 
 		struct VariableData
diff --git a/include/NZSL/Lang/Constants.hpp b/include/NZSL/Lang/Constants.hpp
@@ -16,6 +16,8 @@ namespace nzsl::Version
 	constexpr std::uint32_t MinVersion = Build(1, 0, 0);
 
 	// Features
+	constexpr std::uint32_t ImplicitTypes = Build(1, 1, 0);
+	constexpr std::uint32_t TypeConstants = Build(1, 1, 0);
 	constexpr std::uint32_t UntypedLiterals = Build(1, 1, 0);
 }
 
diff --git a/include/NZSL/Lang/ErrorList.hpp b/include/NZSL/Lang/ErrorList.hpp
@@ -140,6 +140,7 @@ NZSL_SHADERLANG_COMPILER_ERROR(MissingOptionValue, "option {} requires a value (
 NZSL_SHADERLANG_COMPILER_ERROR(MissingWorkgroupAttribute, "compute shader requires a workgroup attribute")
 NZSL_SHADERLANG_COMPILER_ERROR(ModuleCompilationFailed, "module {} compilation failed: {}", std::string, std::string)
 NZSL_SHADERLANG_COMPILER_ERROR(ModuleFeatureMismatch, "module {} requires feature {}", std::string, Ast::ModuleFeature)
+NZSL_SHADERLANG_COMPILER_ERROR(ModuleFeatureNotEnabled, "using {} requires module feature {} to be enabled", std::string, Ast::ModuleFeature)
 NZSL_SHADERLANG_COMPILER_ERROR(ModuleNotFound, "module {} not found", std::string)
 NZSL_SHADERLANG_COMPILER_ERROR(MultiplePushConstant, "there can be only one push constant external in a shader stage", std::string)
 NZSL_SHADERLANG_COMPILER_ERROR(NoModuleResolver, "import statement found but no module resolver has been set (and partial compilation is not enabled)")
@@ -170,6 +171,7 @@ NZSL_SHADERLANG_COMPILER_ERROR(UnknownIdentifier, "unknown identifier {}", std::
 NZSL_SHADERLANG_COMPILER_ERROR(UnknownMethod, "type {} has no method {}", std::string, std::string)
 NZSL_SHADERLANG_COMPILER_ERROR(UnmatchingTypes, "left expression type ({}) doesn't match right expression type ({})", std::string, std::string)
 NZSL_SHADERLANG_COMPILER_ERROR(UnsupportedAttributeOnStage, "{} entry-point doesn't support {} attribute", std::string, std::string)
+NZSL_SHADERLANG_COMPILER_ERROR(UnsupportedFeature, "\"{}\" feature requires NZSL {} (current module version is {})", std::string, VersionTag, VersionTag)
 NZSL_SHADERLANG_COMPILER_ERROR(VarDeclarationMissingTypeAndValue, "variable must either have a type or an initial value")
 NZSL_SHADERLANG_COMPILER_ERROR(VarDeclarationOutsideOfFunction, "global variables outside of external blocks are forbidden")
 NZSL_SHADERLANG_COMPILER_ERROR(VarDeclarationTypeUnmatching, "initial expression type ({}) doesn't match specified type ({})", std::string, std::string)
diff --git a/include/NZSL/Lang/Errors.hpp b/include/NZSL/Lang/Errors.hpp
@@ -11,6 +11,7 @@
 #include <NZSL/Parser.hpp>
 #include <NZSL/Ast/Enums.hpp>
 #include <NZSL/Lang/SourceLocation.hpp>
+#include <NZSL/Lang/Version.hpp>
 #include <exception>
 #include <memory>
 #include <string>
diff --git a/include/NZSL/Lang/Version.hpp b/include/NZSL/Lang/Version.hpp
@@ -11,17 +11,25 @@
 #include <cstdint>
 #include <string>
 
-namespace nzsl::Version
+namespace nzsl
 {
-	// Functions
-	constexpr std::uint32_t Build(std::uint32_t majorVersion, std::uint32_t minorVersion, std::uint32_t patchVersion);
-	constexpr void Decompose(std::uint32_t version, std::uint32_t& majorVersion, std::uint32_t& minorVersion, std::uint32_t& patchVersion);
-	std::string ToString(std::uint32_t version);
-
-	// Constants
-	constexpr std::uint32_t MaxMajorVersion = 1u << 10;
-	constexpr std::uint32_t MaxMinorVersion = 1u << 10;
-	constexpr std::uint32_t MaxPatchVersion = 1u << 12;
+	struct VersionTag
+	{
+		std::uint32_t version;
+	};
+
+	namespace Version
+	{
+		// Functions
+		constexpr std::uint32_t Build(std::uint32_t majorVersion, std::uint32_t minorVersion, std::uint32_t patchVersion);
+		constexpr void Decompose(std::uint32_t version, std::uint32_t& majorVersion, std::uint32_t& minorVersion, std::uint32_t& patchVersion);
+		std::string ToString(std::uint32_t version);
+
+		// Constants
+		constexpr std::uint32_t MaxMajorVersion = 1u << 10;
+		constexpr std::uint32_t MaxMinorVersion = 1u << 10;
+		constexpr std::uint32_t MaxPatchVersion = 1u << 12;
+	}
 }
 
 #include <NZSL/Lang/Version.inl>
diff --git a/src/NZSL/Ast/Transformations/ResolveTransformer.cpp b/src/NZSL/Ast/Transformations/ResolveTransformer.cpp
@@ -614,20 +614,22 @@ namespace nzsl::Ast
 
 	void ResolveTransformer::RegisterBuiltin()
 	{
-		auto RegisterFullType = [this](std::string name, ExpressionType&& expressionType)
+		auto RegisterFullType = [this](std::string name, ExpressionType&& expressionType, std::function<void(const SourceLocation& sourceLocation)> check = nullptr)
 		{
 			TransformerContext::TypeData typeData;
 			typeData.content = std::move(expressionType);
 			typeData.name = name;
+			typeData.check = std::move(check);
 
 			RegisterType(std::move(name), std::move(typeData), std::nullopt, {});
 		};
 
-		auto RegisterPartialType = [this](std::string name, PartialType&& partialType)
+		auto RegisterPartialType = [this](std::string name, PartialType&& partialType, std::function<void(const SourceLocation& sourceLocation)> check = nullptr)
 		{
 			TransformerContext::TypeData typeData;
 			typeData.content = std::move(partialType);
 			typeData.name = name;
+			typeData.check = std::move(check);
 
 			RegisterType(std::move(name), std::move(typeData), std::nullopt, {});
 		};
@@ -638,8 +640,10 @@ namespace nzsl::Ast
 		RegisterFullType("i32",  PrimitiveType::Int32);
 		RegisterFullType("u32",  PrimitiveType::UInt32);
 
-		if (IsFeatureEnabled(ModuleFeature::Float64))
-			RegisterFullType("f64", PrimitiveType::Float64);
+		RegisterFullType("f64", PrimitiveType::Float64, IsFeatureEnabled(ModuleFeature::Float64) ? nullptr : [](const SourceLocation& sourceLocation)
+		{
+			throw CompilerModuleFeatureNotEnabledError{ sourceLocation, "f64", ModuleFeature::Float64 };
+		});
 
 		// Partial types
 
@@ -651,7 +655,12 @@ namespace nzsl::Ast
 				assert(parameterCount <= 2);
 
 				if (parameterCount == 0)
+				{
+					if (m_states->currentModule->metadata->shaderLangVersion < Version::ImplicitTypes)
+						throw CompilerUnsupportedFeatureError{ sourceLocation, "implicit types", VersionTag{ Version::ImplicitTypes }, VersionTag{ m_states->currentModule->metadata->shaderLangVersion }};
+
 					return ImplicitArrayType{};
+				}
 
 				assert(std::holds_alternative<ExpressionType>(parameters[0]));
 				const ExpressionType& exprType = std::get<ExpressionType>(parameters[0]);
@@ -733,10 +742,15 @@ namespace nzsl::Ast
 
 				RegisterPartialType(std::move(name), PartialType{
 					{}, { TypeParameterCategory::PrimitiveType },
-					[=](const TypeParameter* parameters, [[maybe_unused]] std::size_t parameterCount, const SourceLocation& sourceLocation) -> ExpressionType
+					[=](const TypeParameter* parameters, std::size_t parameterCount, const SourceLocation& sourceLocation) -> ExpressionType
 					{
 						if (parameterCount == 0)
+						{
+							if (m_states->currentModule->metadata->shaderLangVersion < Version::ImplicitTypes)
+								throw CompilerUnsupportedFeatureError{ sourceLocation, "implicit types", VersionTag{ Version::ImplicitTypes }, VersionTag{ m_states->currentModule->metadata->shaderLangVersion } };
+
 							return ImplicitMatrixType{ columnCount, rowCount };
+						}
 
 						assert(parameterCount == 1);
 						assert(std::holds_alternative<ExpressionType>(*parameters));
@@ -761,10 +775,15 @@ namespace nzsl::Ast
 		{
 			RegisterPartialType(fmt::format("vec{}", componentCount), PartialType {
 				{}, { TypeParameterCategory::PrimitiveType },
-				[=](const TypeParameter* parameters, [[maybe_unused]] std::size_t parameterCount, const SourceLocation& /*sourceLocation*/) -> ExpressionType
+				[=](const TypeParameter* parameters, std::size_t parameterCount, const SourceLocation& sourceLocation) -> ExpressionType
 				{
 					if (parameterCount == 0)
+					{
+						if (m_states->currentModule->metadata->shaderLangVersion < Version::ImplicitTypes)
+							throw CompilerUnsupportedFeatureError{ sourceLocation, "implicit types", VersionTag{ Version::ImplicitTypes }, VersionTag{ m_states->currentModule->metadata->shaderLangVersion } };
+
 						return ImplicitVectorType{ componentCount };
+					}
 
 					assert(parameterCount == 1);
 					assert(std::holds_alternative<ExpressionType>(*parameters));
@@ -1400,6 +1419,9 @@ namespace nzsl::Ast
 		std::size_t typeIndex = std::get<Type>(exprType).typeIndex;
 
 		const auto& typeData = m_context->types.Retrieve(typeIndex, sourceLocation);
+		if (typeData.check)
+			typeData.check(sourceLocation);
+
 		if (!std::holds_alternative<ExpressionType>(typeData.content))
 			throw CompilerFullTypeExpectedError{ sourceLocation, ToString(typeData, sourceLocation) };
 
@@ -1425,12 +1447,12 @@ namespace nzsl::Ast
 		if (!exprType)
 			return std::nullopt;
 
-		Transform(*expression->cachedExpressionType, sourceLocation);
+		Transform(*expression->cachedExpressionType, expression->sourceLocation);
 
 		//if (!IsTypeType(exprType))
 		//  throw AstError{ "type expected" };
 
-		return ResolveType(*exprType, resolveAlias, sourceLocation);
+		return ResolveType(*exprType, resolveAlias, expression->sourceLocation);
 	}
 
 	auto ResolveTransformer::Transform(AccessIdentifierExpression&& accessIdentifier) -> ExpressionTransformation
@@ -1728,6 +1750,9 @@ namespace nzsl::Ast
 					indexedExpr = ShaderBuilder::TypeConstant(std::move(indexedType), TypeConstant::NaN);
 				else
 					throw CompilerUnexpectedAccessedTypeError{ accessIdentifier.sourceLocation };
+
+				if (m_states->currentModule->metadata->shaderLangVersion < Version::TypeConstants)
+					throw CompilerUnsupportedFeatureError{ accessIdentifier.sourceLocation, "type constant", VersionTag{ Version::TypeConstants }, VersionTag{ m_states->currentModule->metadata->shaderLangVersion } };
 			}
 			else
 				throw CompilerUnexpectedAccessedTypeError{ accessIdentifier.sourceLocation };
@@ -1817,6 +1842,9 @@ namespace nzsl::Ast
 			std::size_t typeIndex = std::get<Type>(resolvedExprType).typeIndex;
 			const auto& typeData = m_context->types.Retrieve(typeIndex, accessIndexExpr.sourceLocation);
 
+			if (typeData.check)
+				typeData.check(accessIndexExpr.sourceLocation);
+
 			if (!std::holds_alternative<PartialType>(typeData.content))
 				throw CompilerExpectedPartialTypeError{ accessIndexExpr.sourceLocation, ToString(typeData, accessIndexExpr.sourceLocation) };
 
@@ -2176,6 +2204,9 @@ namespace nzsl::Ast
 			std::size_t typeIndex = std::get<Type>(resolvedType).typeIndex;
 			const auto& type = m_context->types.Retrieve(typeIndex, callFuncExpr.sourceLocation);
 
+			if (type.check)
+				type.check(callFuncExpr.sourceLocation);
+
 			return std::visit(Nz::Overloaded{
 				[&](const ExpressionType& expressionType) -> ExpressionTransformation
 				{
diff --git a/src/NZSL/Lang/Errors.cpp b/src/NZSL/Lang/Errors.cpp
@@ -5,6 +5,7 @@
 #include <NZSL/Lang/Errors.hpp>
 #include <NZSL/Parser.hpp>
 #include <NZSL/Lang/LangData.hpp>
+#include <NZSL/Lang/Version.hpp>
 #include <fmt/format.h>
 #include <string>
 #include <utility>
@@ -94,6 +95,16 @@ struct fmt::formatter<nzsl::TokenType> : formatter<string_view>
 	}
 };
 
+template<>
+struct fmt::formatter<nzsl::VersionTag> : formatter<string_view>
+{
+	template<typename FormatContext>
+	auto format(const nzsl::VersionTag& p, FormatContext& ctx) const -> decltype(ctx.out())
+	{
+		return formatter<string_view>::format(nzsl::Version::ToString(p.version), ctx);
+	}
+};
+
 namespace nzsl
 {
 	std::string_view ToString(ErrorCategory errorCategory)
diff --git a/tests/src/Tests/ErrorsTests.cpp b/tests/src/Tests/ErrorsTests.cpp
@@ -731,7 +731,7 @@ fn main()
 {
 	let x: f64 = 0.0;
 }
-)"), "(7,9 -> 11): CUnknownIdentifier error: unknown identifier f64");
+)"), "(7,9 -> 11): CModuleFeatureNotEnabled error: using f64 requires module feature float64 to be enabled");
 
 			// Primitive externals
 			CHECK_THROWS_WITH(Compile(R"(
@@ -745,6 +745,30 @@ external
 )"), "(7,15 -> 29): CExtTypeNotAllowed error: external variable data has unauthorized type (mat4[f32]): only storage buffers, samplers, push constants and uniform buffers (and primitives, vectors and matrices if primitive external feature is enabled) are allowed in external blocks");
 		}
 
+		// NZSL 1.1 features
+
+		// Implicit types
+		CHECK_THROWS_WITH(Compile(R"(
+[nzsl_version("1.0")]
+module;
+
+fn main()
+{
+	let v = vec3(1, 2, 3);
+}
+)"), "(7,10 -> 22): CUnsupportedFeature error: \"implicit types\" feature requires NZSL 1.1 (current module version is 1.0)");
+
+		// Type constants
+		CHECK_THROWS_WITH(Compile(R"(
+[nzsl_version("1.0")]
+module;
+
+fn main()
+{
+	let x = u32.Max;
+}
+)"), "(7,10 -> 16): CUnsupportedFeature error: \"type constant\" feature requires NZSL 1.1 (current module version is 1.0)");
+
 		/************************************************************************/
 
 		SECTION("Functions")

Original file line number	Diff line number	Diff line change
`@@ -79,6 +79,7 @@ namespace nzsl::Ast`
`79`	`79`	`{`
`80`	`80`	`std::string name;`
`81`	`81`	`std::variant<ExpressionType, PartialType> content;`
	`82`	`+ std::function<void(const SourceLocation& sourceLocation)> check;`
`82`	`83`	`};`
`83`	`84`
`84`	`85`	`struct VariableData`
Original file line number	Diff line number	Diff line change
`@@ -16,6 +16,8 @@ namespace nzsl::Version`
`16`	`16`	`constexpr std::uint32_t MinVersion = Build(1, 0, 0);`
`17`	`17`
`18`	`18`	`// Features`
	`19`	`+ constexpr std::uint32_t ImplicitTypes = Build(1, 1, 0);`
	`20`	`+ constexpr std::uint32_t TypeConstants = Build(1, 1, 0);`
`19`	`21`	`constexpr std::uint32_t UntypedLiterals = Build(1, 1, 0);`
`20`	`22`	`}`
`21`	`23`