Shader: Add SourceLocation members

TODO: Fill from Parser and use them for error throwing in SanitizeVisitor

src/Nazara/Shader/Ast/AstSerializer.cpp

@@ -26,12 +26,14 @@ namespace Nz::ShaderAst
 #define NAZARA_SHADERAST_EXPRESSION(Node) void Visit(Node& node) override \
 				{ \
 					m_serializer.Serialize(node); \
+					m_serializer.SerializeNodeCommon(node); \
 					m_serializer.SerializeExpressionCommon(node); \
 				}
 
 #define NAZARA_SHADERAST_STATEMENT(Node) void Visit(Node& node) override \
 				{ \
 					m_serializer.Serialize(node); \
+					m_serializer.SerializeNodeCommon(node); \
 				}
 #include <Nazara/Shader/Ast/AstNodeList.hpp>
 
@@ -45,8 +47,11 @@ namespace Nz::ShaderAst
 		Node(node.expr);
 
 		Container(node.identifiers);
-		for (std::string& identifier : node.identifiers)
-			Value(identifier);
+		for (auto& identifier : node.identifiers)
+		{
+			Value(identifier.identifier);
+			SourceLoc(identifier.sourceLocation);
+		}
 	}
 
 	void AstSerializerBase::Serialize(AccessIndexExpression& node)
@@ -204,11 +209,6 @@ namespace Nz::ShaderAst
 		Node(node.expression);
 	}
 
-	void AstSerializerBase::SerializeExpressionCommon(Expression& expr)
-	{
-		OptType(expr.cachedExpressionType);
-	}
-
 	void AstSerializerBase::Serialize(BranchStatement& node)
 	{
 		Container(node.condStatements);
@@ -235,6 +235,14 @@ namespace Nz::ShaderAst
 		Node(node.expression);
 	}
 
+	void AstSerializerBase::Serialize(DeclareConstStatement& node)
+	{
+		OptVal(node.constIndex);
+		Value(node.name);
+		ExprValue(node.type);
+		Node(node.expression);
+	}
+
 	void AstSerializerBase::Serialize(DeclareExternalStatement& node)
 	{
 		ExprValue(node.bindingSet);
@@ -247,17 +255,10 @@ namespace Nz::ShaderAst
 			ExprValue(extVar.type);
 			ExprValue(extVar.bindingIndex);
 			ExprValue(extVar.bindingSet);
+			SourceLoc(extVar.sourceLocation);
 		}
 	}
 
-	void AstSerializerBase::Serialize(DeclareConstStatement& node)
-	{
-		OptVal(node.constIndex);
-		Value(node.name);
-		ExprValue(node.type);
-		Node(node.expression);
-	}
-
 	void AstSerializerBase::Serialize(DeclareFunctionStatement& node)
 	{
 		Value(node.name);
@@ -274,6 +275,7 @@ namespace Nz::ShaderAst
 			Value(parameter.name);
 			ExprValue(parameter.type);
 			OptVal(parameter.varIndex);
+			SourceLoc(parameter.sourceLocation);
 		}
 
 		Container(node.statements);
@@ -305,6 +307,7 @@ namespace Nz::ShaderAst
 			ExprValue(member.builtin);
 			ExprValue(member.cond);
 			ExprValue(member.locationIndex);
+			SourceLoc(member.sourceLocation);
 		}
 	}
 	
@@ -378,6 +381,16 @@ namespace Nz::ShaderAst
 		Node(node.body);
 	}
 
+	void AstSerializerBase::SerializeExpressionCommon(Expression& expr)
+	{
+		OptType(expr.cachedExpressionType);
+	}
+
+	void AstSerializerBase::SerializeNodeCommon(ShaderAst::Node& node)
+	{
+		SourceLoc(node.sourceLocation);
+	}
+
 	void ShaderAstSerializer::Serialize(ModulePtr& module)
 	{
 		m_stream << s_shaderAstMagicNumber << s_shaderAstCurrentVersion;
@@ -387,23 +400,6 @@ namespace Nz::ShaderAst
 		m_stream.FlushBits();
 	}
 	
-	void ShaderAstSerializer::SerializeModule(ModulePtr& module)
-	{
-		m_stream << module->metadata->moduleName;
-		m_stream << module->metadata->moduleId;
-		m_stream << module->metadata->shaderLangVersion;
-
-		Container(module->importedModules);
-		for (auto& importedModule : module->importedModules)
-		{
-			Value(importedModule.identifier);
-			SerializeModule(importedModule.module);
-		}
-
-		ShaderSerializerVisitor visitor(*this);
-		module->rootNode->Visit(visitor);
-	}
-
 	bool ShaderAstSerializer::IsWriting() const
 	{
 		return true;
@@ -432,6 +428,44 @@ namespace Nz::ShaderAst
 			node->Visit(visitor);
 		}
 	}
+	
+	void ShaderAstSerializer::SerializeModule(ModulePtr& module)
+	{
+		m_stream << module->metadata->moduleName;
+		m_stream << module->metadata->moduleId;
+		m_stream << module->metadata->shaderLangVersion;
+
+		Container(module->importedModules);
+		for (auto& importedModule : module->importedModules)
+		{
+			Value(importedModule.identifier);
+			SerializeModule(importedModule.module);
+		}
+
+		ShaderSerializerVisitor visitor(*this);
+		module->rootNode->Visit(visitor);
+	}
+
+	void ShaderAstSerializer::SharedString(std::shared_ptr<const std::string>& val)
+	{
+		bool hasValue = (val != nullptr);
+		Value(hasValue);
+
+		if (hasValue)
+		{
+			auto it = m_stringIndices.find(*val);
+			bool newString = (it == m_stringIndices.end());
+			Value(newString);
+
+			if (newString)
+			{
+				Value(const_cast<std::string&>(*val)); //< won't be used for writing
+				m_stringIndices.emplace(*val, m_stringIndices.size());
+			}
+			else
+				Value(it->second); //< string index
+		}
+	}
 
 	void ShaderAstSerializer::Type(ExpressionType& type)
 	{
@@ -606,29 +640,6 @@ namespace Nz::ShaderAst
 		return module;
 	}
 
-	void ShaderAstUnserializer::SerializeModule(ModulePtr& module)
-	{
-		std::shared_ptr<Module::Metadata> metadata = std::make_shared<Module::Metadata>();
-		m_stream >> metadata->moduleName;
-		m_stream >> metadata->moduleId;
-		m_stream >> metadata->shaderLangVersion;
-
-		std::vector<Module::ImportedModule> importedModules;
-		Container(importedModules);
-		for (auto& importedModule : importedModules)
-		{
-			Value(const_cast<std::string&>(importedModule.identifier)); //< not used for writing
-			SerializeModule(importedModule.module);
-		}
-
-		MultiStatementPtr rootNode = std::make_unique<MultiStatement>();
-
-		ShaderSerializerVisitor visitor(*this);
-		rootNode->Visit(visitor);
-
-		module = std::make_shared<Module>(std::move(metadata), std::move(rootNode), std::move(importedModules));
-	}
-
 	bool ShaderAstUnserializer::IsWriting() const
 	{
 		return false;
@@ -686,6 +697,58 @@ namespace Nz::ShaderAst
 		}
 	}
 
+	void ShaderAstUnserializer::SerializeModule(ModulePtr& module)
+	{
+		std::shared_ptr<Module::Metadata> metadata = std::make_shared<Module::Metadata>();
+		m_stream >> metadata->moduleName;
+		m_stream >> metadata->moduleId;
+		m_stream >> metadata->shaderLangVersion;
+
+		std::vector<Module::ImportedModule> importedModules;
+		Container(importedModules);
+		for (auto& importedModule : importedModules)
+		{
+			Value(const_cast<std::string&>(importedModule.identifier)); //< not used for writing
+			SerializeModule(importedModule.module);
+		}
+
+		MultiStatementPtr rootNode = std::make_unique<MultiStatement>();
+
+		ShaderSerializerVisitor visitor(*this);
+		rootNode->Visit(visitor);
+
+		module = std::make_shared<Module>(std::move(metadata), std::move(rootNode), std::move(importedModules));
+	}
+
+	void ShaderAstUnserializer::SharedString(std::shared_ptr<const std::string>& val)
+	{
+		bool hasValue;
+		Value(hasValue);
+
+		if (hasValue)
+		{
+			bool newString;
+			Value(newString);
+
+			if (newString)
+			{
+				std::string newStr;
+				Value(newStr);
+
+				val = std::make_shared<const std::string>(std::move(newStr));
+				m_strings.emplace_back(val);
+			}
+			else
+			{
+				UInt32 strIndex;
+				Value(strIndex);
+
+				assert(strIndex < m_strings.size());
+				val = m_strings[strIndex];
+			}
+		}
+	}
+
 	void ShaderAstUnserializer::Type(ExpressionType& type)
 	{
 		UInt8 typeIndex;

src/Nazara/Shader/Ast/SanitizeVisitor.cpp

@@ -306,16 +306,16 @@ namespace Nz::ShaderAst
 				std::size_t moduleIndex = m_context->moduleIndices.Retrieve(identifierData->index);
 
 				const auto& env = *m_context->modules[moduleIndex].environment;
-				identifierData = FindIdentifier(env, node.identifiers.front());
+				identifierData = FindIdentifier(env, node.identifiers.front().identifier);
 				if (identifierData)
 					return HandleIdentifier(identifierData);
 			}
 		}
 
 		ExpressionPtr indexedExpr = CloneExpression(node.expr);
-		for (const std::string& identifier : node.identifiers)
+		for (const auto& identifierEntry : node.identifiers)
 		{
-			if (identifier.empty())
+			if (identifierEntry.identifier.empty())
 				throw AstError{ "empty identifier" };
 
 			const ExpressionType* exprType = GetExpressionType(*indexedExpr);
@@ -326,12 +326,12 @@ namespace Nz::ShaderAst
 			// TODO: Add proper support for methods
 			if (IsSamplerType(resolvedType))
 			{
-				if (identifier == "Sample")
+				if (identifierEntry.identifier == "Sample")
 				{
 					// TODO: Add a MethodExpression?
 					auto identifierExpr = std::make_unique<AccessIdentifierExpression>();
 					identifierExpr->expr = std::move(indexedExpr);
-					identifierExpr->identifiers.push_back(identifier);
+					identifierExpr->identifiers.emplace_back().identifier = identifierEntry.identifier;
 
 					MethodType methodType;
 					methodType.methodIndex = 0; //< FIXME
@@ -342,7 +342,7 @@ namespace Nz::ShaderAst
 					indexedExpr = std::move(identifierExpr);
 				}
 				else
-					throw AstError{ "type has no method " + identifier };
+					throw AstError{ "type has no method " + identifierEntry.identifier };
 			}
 			else if (IsStructType(resolvedType))
 			{
@@ -367,7 +367,7 @@ namespace Nz::ShaderAst
 							continue;
 					}
 
-					if (field.name == identifier)
+					if (field.name == identifierEntry.identifier)
 					{
 						fieldPtr = &field;
 						break;
@@ -377,7 +377,7 @@ namespace Nz::ShaderAst
 				}
 
 				if (!fieldPtr)
-					throw AstError{ "unknown field " + identifier };
+					throw AstError{ "unknown field " + identifierEntry.identifier };
 
 				if (m_context->options.useIdentifierAccessesForStructs)
 				{
@@ -394,8 +394,9 @@ namespace Nz::ShaderAst
 					else
 						accessIdentifierPtr = static_cast<AccessIdentifierExpression*>(indexedExpr.get());
 
-					accessIdentifierPtr->identifiers.push_back(fieldPtr->name);
 					accessIdentifierPtr->cachedExpressionType = ResolveTypeExpr(fieldPtr->type);
+
+					accessIdentifierPtr->identifiers.emplace_back().identifier = fieldPtr->name;
 				}
 				else
 				{
@@ -411,7 +412,7 @@ namespace Nz::ShaderAst
 			else if (IsPrimitiveType(resolvedType) || IsVectorType(resolvedType))
 			{
 				// Swizzle expression
-				std::size_t swizzleComponentCount = identifier.size();
+				std::size_t swizzleComponentCount = identifierEntry.identifier.size();
 				if (swizzleComponentCount > 4)
 					throw AstError{ "cannot swizzle more than four elements" };
 
@@ -419,7 +420,7 @@ namespace Nz::ShaderAst
 				{
 					for (std::size_t j = 0; j < swizzleComponentCount; ++j)
 					{
-						if (ToSwizzleIndex(identifier[j]) != 0)
+						if (ToSwizzleIndex(identifierEntry.identifier[j]) != 0)
 							throw AstError{ "invalid swizzle" };
 							//throw ShaderLang::CompilerInvalidSwizzleError{};
 					}
@@ -452,7 +453,7 @@ namespace Nz::ShaderAst
 
 					swizzle->componentCount = swizzleComponentCount;
 					for (std::size_t j = 0; j < swizzleComponentCount; ++j)
-						swizzle->components[j] = ToSwizzleIndex(identifier[j]);
+						swizzle->components[j] = ToSwizzleIndex(identifierEntry.identifier[j]);
 
 					Validate(*swizzle);
 

src/Nazara/Shader/GlslWriter.cpp

@@ -833,8 +833,8 @@ namespace Nz
 		assert(exprType);
 		assert(IsStructType(*exprType));
 
-		for (const std::string& identifier : node.identifiers)
-			Append(".", identifier);
+		for (const auto& identifierEntry : node.identifiers)
+			Append(".", identifierEntry.identifier);
 	}
 
 	void GlslWriter::Visit(ShaderAst::AccessIndexExpression& node)

src/Nazara/Shader/LangWriter.cpp

@@ -736,8 +736,8 @@ namespace Nz
 	{
 		Visit(node.expr, true);
 
-		for (const std::string& identifier : node.identifiers)
-			Append(".", identifier);
+		for (const auto& identifierEntry : node.identifiers)
+			Append(".", identifierEntry.identifier);
 	}
 
 	void LangWriter::Visit(ShaderAst::AccessIndexExpression& node)