Shader: Add import statement (not doing anything for now)

src/Nazara/Shader/Ast/AstCloner.cpp

@@ -215,6 +215,14 @@ namespace Nz::ShaderAst
 		return clone;
 	}
 
+	StatementPtr AstCloner::Clone(ImportStatement& node)
+	{
+		auto clone = std::make_unique<ImportStatement>();
+		clone->modulePath = node.modulePath;
+
+		return clone;
+	}
+
 	StatementPtr AstCloner::Clone(MultiStatement& node)
 	{
 		auto clone = std::make_unique<MultiStatement>();

src/Nazara/Shader/Ast/AstRecursiveVisitor.cpp

@@ -185,6 +185,11 @@ namespace Nz::ShaderAst
 			node.statement->Visit(*this);
 	}
 
+	void AstRecursiveVisitor::Visit(ImportStatement& /*node*/)
+	{
+		/* nothing to do */
+	}
+
 	void AstRecursiveVisitor::Visit(MultiStatement& node)
 	{
 		for (auto& statement : node.statements)

src/Nazara/Shader/Ast/AstSerializer.cpp

@@ -301,6 +301,13 @@ namespace Nz::ShaderAst
 		Node(node.statement);
 	}
 
+	void AstSerializerBase::Serialize(ImportStatement& node)
+	{
+		Container(node.modulePath);
+		for (auto& path : node.modulePath)
+			Value(path);
+	}
+
 	void AstSerializerBase::Serialize(MultiStatement& node)
 	{
 		Container(node.statements);

src/Nazara/Shader/Ast/SanitizeVisitor.cpp

@@ -1308,6 +1308,11 @@ namespace Nz::ShaderAst
 		}
 	}
 
+	StatementPtr SanitizeVisitor::Clone(ImportStatement& node)
+	{
+			return static_unique_pointer_cast<ImportStatement>(AstCloner::Clone(node));
+	}
+
 	StatementPtr SanitizeVisitor::Clone(MultiStatement& node)
 	{
 		auto clone = std::make_unique<MultiStatement>();

src/Nazara/Shader/LangWriter.cpp

@@ -954,6 +954,20 @@ namespace Nz
 		ScopeVisit(*node.statement);
 	}
 
+	void LangWriter::Visit(ShaderAst::ImportStatement& node)
+	{
+		bool first = true;
+		for (const std::string& path : node.modulePath)
+		{
+			if (!first)
+				Append("/");
+
+			Append(path);
+
+			first = false;
+		}
+	}
+
 	void LangWriter::Visit(ShaderAst::IntrinsicExpression& node)
 	{
 		bool method = false;

src/Nazara/Shader/ShaderLangLexer.cpp

@@ -49,6 +49,7 @@ namespace Nz::ShaderLang
 			{ "fn",           TokenType::FunctionDeclaration },
 			{ "for",          TokenType::For },
 			{ "if",           TokenType::If },
+			{ "import",       TokenType::Import },
 			{ "in",           TokenType::In },
 			{ "let",          TokenType::Let },
 			{ "module",       TokenType::Module },

src/Nazara/Shader/ShaderLangParser.cpp

@@ -649,14 +649,23 @@ namespace Nz::ShaderLang
 		return { parameterName, std::move(parameterType) };
 	}
 
+	ShaderAst::StatementPtr Parser::ParseImportStatement()
 	{
+		Expect(Advance(), TokenType::Import);
 
+		std::vector<std::string> modulePath;
+		modulePath.push_back(ParseIdentifierAsName());
 
+		while (Peek().type == TokenType::Divide) //< /
 		{
+			Consume();
 
+			modulePath.push_back(ParseIdentifierAsName());
 		}
 
 		Expect(Advance(), TokenType::Semicolon);
+
+		return ShaderBuilder::Import(std::move(modulePath));
 	}
 
 	ShaderAst::StatementPtr Parser::ParseOptionDeclaration()
@@ -715,6 +724,12 @@ namespace Nz::ShaderLang
 			case TokenType::External:
 				return ParseExternalBlock(std::move(attributes));
 
+			case TokenType::Import:
+				if (!attributes.empty())
+					throw UnexpectedToken{};
+
+				return ParseImportStatement();
+
 			case TokenType::OpenSquareBracket:
 				assert(attributes.empty());
 				return ParseRootStatement(ParseAttributes());

src/Nazara/Shader/SpirvAstVisitor.cpp

@@ -726,6 +726,11 @@ namespace Nz
 		PopResultId();
 	}
 
+	void SpirvAstVisitor::Visit(ShaderAst::ImportStatement& node)
+	{
+		/* nothing to do */
+	}
+
 	void SpirvAstVisitor::Visit(ShaderAst::IntrinsicExpression& node)
 	{
 		switch (node.intrinsic)