AST.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "ASTEnums.hpp"
#include "Identifier.hpp"
#include "Token.hpp"
#include "TypeDenoter.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/Flags.hpp"
#include "CeresEngine/Foundation/Function.hpp"
#include "CeresEngine/Foundation/String.hpp"
#include "CeresEngine/Foundation/Container/InitializerList.hpp"
#include "CeresEngine/Foundation/Container/Map.hpp"
#include "CeresEngine/Foundation/Container/Set.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include "CeresEngine/Material/ShaderCompiler/SourceCode.hpp"
#include "CeresEngine/Material/ShaderCompiler/Targets.hpp"
#include "CeresEngine/Material/ShaderCompiler/Variant.hpp"
 
#include "CeresEngine/Material/ShaderCompiler/AST/Visitor/Visitor.hpp"
 
#include <functional>
 
namespace CeresEngine::ShaderCompiler {
 
    class Visitor;
 
    // Enumeration for expression finding predicates.
    enum SearchFlags : UInt32 {
        SearchLValue = (1 << 0),
        SearchRValue = (1 << 1),
        SearchAll = (~0u),
    };
 
    // Iteration callback for VarDecl AST nodes.
    using VarDeclarationIteratorFunctor = UniqueFunction<void(VarDeclarationPtr& varDeclaration) const>;
 
    // Iteration callback for Expression AST nodes.
    using ExpressionIteratorFunctor = UniqueFunction<void(ExpressionPtr& expression, VarDeclaration* param) const>;
 
    // Iteration callback for argument/parameter-type associations.
    using ArgumentParameterTypeFunctor = UniqueFunction<void(ExpressionPtr& argument, const TypeDenoter& paramTypeDen) const>;
 
    // Predicate callback to find an expression inside an expression tree.
    using FindPredicateConstFunctor = UniqueFunction<bool(const Expression& expression) const>;
 
    // Function callback to merge two expressions into one.
    using MergeExpressionFunctor = UniqueFunction<ExpressionPtr(const ExpressionPtr& expression0, const ExpressionPtr& expression1) const>;
 
#define AST_INTERFACE(CLASS_NAME)                                                       \
    static const Types classType = Types::CLASS_NAME;                                   \
    explicit CLASS_NAME(const SourcePosition& astPos) { area = SourceArea(astPos, 1); } \
    explicit CLASS_NAME(const SourceArea& astArea) { area = astArea; }                  \
    Types getType() const override { return Types::CLASS_NAME; }                        \
    void visit(Visitor* visitor, void* args = nullptr) override { visitor->visit##CLASS_NAME(this, args); }
 
#define DECLARATION_AST_ALIAS(ALIAS, BASE) \
    using ALIAS = BASE;                    \
    using ALIAS##Ptr = BASE##Ptr
 
#define FLAG_ENUM enum : UInt32
 
#define FLAG(IDENT, INDEX) IDENT = (1u << (INDEX))
 
    // Base class for all AST node classes.
    struct AST {
        // Types of AST classes.
        enum class Types {
            // Common AST classes
 
            Program,
            // AST root node
            CodeBlock,
            Attribute,
            SwitchCase,
            SamplerValue,
            Register,
            // Register qualifier (e.g. "register(b0)")
            PackOffset,
            // Pack-offset qualifier (e.g. "packoffset(c0.x)")
            ArrayDimension,
            // Array dimension (e.g. "[10]")
            TypeSpecifier,
            // Type specifier with type denoter/modifiers/classes and optional structure (StructDecl)
 
            // Declaration objects that can be referenced by an 'ObjectExpression'
 
            VarDeclaration,
            // Variable declaration
            BufferDeclaration,
            // Buffer declaration (Texture- and Storage Buffers)
            SamplerDeclaration,
            // Sampler state declaration
            StructDeclaration,
            // Structure declaration
            AliasDeclaration,
            // Type alias declaration
            FunctionDeclaration,
            // Function declaration
            UniformBufferDeclaration,
            // Uniform/constant buffer declaration
 
            // Declaration statements
 
            VarDeclarationStatement,
            // Variable declaration statement with several variables (VarDecl)
            BufferDeclarationStatement,
            // Buffer declaration statement with several buffers (BufferDecl)
            SamplerDeclarationStatement,
            // Sampler declaration statement with several samplers (SamplerDecl)
            AliasDeclarationStatement,
            // Type alias declaration statement with several types (AliasDecl)
            BasicDeclarationStatement,
            // Statement with a single declaration object (StructDecl, FunctionDecl, or UniformBufferDecl)
 
            // Common statements
 
            NullStatement,
            CodeBlockStatement,
            ForLoopStatement,
            WhileLoopStatement,
            DoWhileLoopStatement,
            IfStatement,
            ElseStatement,
            SwitchStatement,
            ExpressionStatement,
            ReturnStatement,
            CtrlTransferStatement,
            // Control transfer statement (Break, Continue, Discard)
            LayoutStatement,
            // GLSL only
 
            // Expressions
 
            NullExpression,
            SequenceExpression,
            LiteralExpression,
            TypeSpecifierExpression,
            TernaryExpression,
            BinaryExpression,
            UnaryExpression,
            PostUnaryExpression,
            CallExpression,
            BracketExpression,
            ObjectExpression,
            AssignExpression,
            ArrayExpression,
            CastExpression,
            InitializerExpression,
        };
 
        FLAG_ENUM{
            FLAG(isReachable, 30),
            // This AST node is reachable from the main entry point.
            FLAG(isDeadCode, 29),
            // This AST node is dead code (after return path).
            FLAG(isBuiltin, 28),
            // This AST node is a built-in node (not part of the actual program source).
        };
 
        SourceArea area; // Source code area.
        RawFlags flags; // Flags bitmask (default 0).
 
        virtual ~AST();
 
        // Returns the AST node type.
        [[nodiscard]] virtual Types getType() const = 0;
 
        // Calls the respective visit-function of the specified visitor.
        virtual void visit(Visitor* visitor, void* args = nullptr) = 0;
 
        // Returns the AST node as the specified sub class if this AST node has the correct type. Otherwise, null is returned.
        template<typename T> [[nodiscard]] static T* getAs(AST* ast) {
            return (ast != nullptr && ast->getType() == T::classType ? static_cast<T*>(ast) : nullptr);
        }
 
        // Returns the AST node as the specified sub class if this AST node has the correct type. Otherwise, null is returned.
        template<typename T> [[nodiscard]] static const T* getAs(const AST* ast) {
            return (ast != nullptr && ast->getType() == T::classType ? static_cast<const T*>(ast) : nullptr);
        }
 
        // Returns this AST node as the specified sub class if this AST node has the correct type. Otherwise, null is returned.
        template<typename T> [[nodiscard]] T* as() { return (getType() == T::classType ? static_cast<T*>(this) : nullptr); }
 
        // Returns this AST node as the specified sub class if this AST node has the correct type. Otherwise, null is returned.
        template<typename T> [[nodiscard]] const T* as() const { return (getType() == T::classType ? static_cast<const T*>(this) : nullptr); }
    };
 
    // Returns true if the specified AST type denotes a "Decl" AST.
    [[nodiscard]] bool isDeclarationAST(const AST::Types t);
 
    // Returns true if the specified AST type denotes an "Expression" AST.
    [[nodiscard]] bool isExpressionAST(const AST::Types t);
 
    // Returns true if the specified AST type denotes a "Statement" AST.
    [[nodiscard]] bool isStatementAST(const AST::Types t);
 
    // Returns true if the specified AST type denotes a "...declStatement" AST.
    [[nodiscard]] bool isDeclarationStatementAST(const AST::Types t);
 
    // MARK: - Common AST classes -
 
    // Statement AST base class.
    struct Statement : public AST {
        String comment; // Optional commentary for this statement. May be a multi-line string.
        Vector<AttributePtr> attributes; // Attribute list. May be empty.
 
        // Collects all variable-, buffer-, and sampler AST nodes with their identifiers in the specified map.
        virtual void collectDeclarationIdents(Map<const AST*, String>& declarationASTIdents) const;
    };
 
    // AST base class with type denoter.
    struct TypedAST : public AST {
    public:
        // Returns a type denoter for this AST node or throws an std::runtime_error if a type denoter can not be derived.
        const TypeDenoterPtr& getTypeDenoter(const TypeDenoter* expectedTypeDenoter = nullptr);
 
        // Resets the buffered type denoter.
        void resetTypeDenoter();
 
    protected:
        [[nodiscard]] virtual TypeDenoterPtr deriveTypeDenoter(const TypeDenoter* expectedTypeDenoter) = 0;
 
    private:
        // Buffered type denoter which is stored in the "GetTypeDenoter" function and can be reset with the "resetTypeDenoter" function.
        TypeDenoterPtr mBufferedTypeDenoter;
    };
 
    // Expression AST base class.
    struct Expression : public TypedAST {
        FLAG_ENUM{
            FLAG(wasConverted, 0),
            // This expression has already been converted.
        };
 
        // Returns the variable or null if this is not just a single variable expression.
        [[nodiscard]] VarDeclaration* fetchVarDeclaration() const;
 
        [[nodiscard]] virtual const ObjectExpression* fetchLValueExpression() const;
        [[nodiscard]] ObjectExpression* fetchLValueExpression();
 
        // Returns the semantic of this expression, or Semantic::Undefined if this expression has no semantic.
        [[nodiscard]] virtual IndexedSemantic fetchSemantic() const;
 
        // Returns true if this expression can be trivially copied (e.g. simple expressions without potential side effects). By default false.
        [[nodiscard]] virtual bool isTrivialCopyable(UInt32 maxTreeDepth = 3) const;
 
        // Returns the first expression for which the specified predicate returns true.
        [[nodiscard]] virtual const Expression* find(const FindPredicateConstFunctor& predicate, UInt32 flags = SearchAll) const;
 
        // Returns the first expression of the specified type in this expression tree.
        [[nodiscard]] const Expression* findFirstOf(const Types expressionType, UInt32 flags = SearchAll) const;
 
        // Returns the first expression of a different type than the specified type in this expression tree.
        [[nodiscard]] const Expression* findFirstNotOf(const Types expressionType, UInt32 flags = SearchAll) const;
 
        // Returns the first expression for which the specified predicate returns true.
        [[nodiscard]] Expression* find(const FindPredicateConstFunctor& predicate, UInt32 flags = SearchAll);
 
        // Returns the first expression of the specified type in this expression tree.
        [[nodiscard]] Expression* findFirstOf(const Types expressionType, UInt32 flags = SearchAll);
 
        // Returns the first expression of a different type than the specified type in this expression tree.
        [[nodiscard]] Expression* findFirstNotOf(const Types expressionType, UInt32 flags = SearchAll);
    };
 
    // Declaration AST base class.
    struct Declaration : public TypedAST {
        FLAG_ENUM{
            FLAG(isWrittenTo, 0),
            // This declaration object is eventually written to.
            FLAG(isReadFrom, 1),
            // This declaration object is eventually read from.
        };
 
        // Identifier of the declaration object (may be empty, e.g. for anonymous structures).
        Identifier ident;
 
        // Returns a descriptive string of the type signature.
        [[nodiscard]] virtual String toString() const;
 
        // Returns the type specifier of this declaration object, or null if there is no type specifier. By default null.
        [[nodiscard]] virtual TypeSpecifier* fetchTypeSpecifier() const;
 
        // Returns true if this is an anonymous structure.
        [[nodiscard]] bool isAnonymous() const;
    };
 
    // Program AST root.
    struct Program : public AST {
        AST_INTERFACE(Program);
 
        // Layout meta data for tessellation-control shaders
        struct LayoutTessControlShader {
            UInt32 outputControlPoints = 0;
            float maxTessFactor = 0.0f;
            FunctionDeclaration* patchConstFunctionRef = nullptr;
        };
 
        // Layout meta data for tessellation-evaluation shaders
        struct LayoutTessEvaluationShader {
            AttributeValue domainType = AttributeValue::Undefined;
            AttributeValue partitioning = AttributeValue::Undefined;
            AttributeValue outputTopology = AttributeValue::Undefined;
        };
 
        // Layout meta data for fragment shaders
        struct LayoutGeometryShader {
            PrimitiveType inputPrimitive = PrimitiveType::Undefined;
            BufferType outputPrimitive = BufferType::Undefined; // Must be PointStream, LineStream, or TriangleStream
            UInt32 maxVertices = 0;
        };
 
        // Layout meta data for fragment shaders
        struct LayoutFragmentShader {
            // True, if fragment coordinate (SV_Position) is used inside a fragment shader.
            bool fragCoordUsed = false;
 
            // True, if pixel center is assumed to be integral, otherwise pixel center is assumed to have an (0.5, 0.5) offset.
            bool pixelCenterInteger = false;
 
            // True, if the [earlydepthstencil] attribute is specified for the fragment shader entry point.
            bool earlyDepthStencil = false;
        };
 
        // Layout meta data for compute shaders
        struct LayoutComputeShader {
            UInt32 numThreads[3] = {0};
        };
 
        Vector<StatementPtr> globalStatements;
 
        Vector<ASTPtr> disabledAST;
 
        SourceCodePtr sourceCode;
 
        FunctionDeclaration* entryPointRef = nullptr;
 
        Map<Intrinsic, IntrinsicUsage> usedIntrinsics;
 
        Set<MatrixSubscriptUsage> usedMatrixSubscripts;
 
        LayoutTessControlShader layoutTessControl;
 
        LayoutTessEvaluationShader layoutTessEvaluation;
 
        LayoutGeometryShader layoutGeometry;
 
        LayoutFragmentShader layoutFragment;
 
        LayoutComputeShader layoutCompute;
 
        // Registers a usage of an intrinsic with the specified argument data types (only base types).
        void registerIntrinsicUsage(const Intrinsic intrinsic, const Vector<DataType>& argumentDataTypes);
 
        // Registers a usage of an intrinsic with the specified arguments (only base types).
        void registerIntrinsicUsage(const Intrinsic intrinsic, const Vector<ExpressionPtr>& arguments);
 
        // Returns a usage-container of the specified intrinsic or null if the specified intrinsic was not registered to be used.
        [[nodiscard]] const IntrinsicUsage* fetchIntrinsicUsage(const Intrinsic intrinsic) const;
    };
 
    // Code block.
    struct CodeBlock : public AST {
        AST_INTERFACE(CodeBlock);
 
        Vector<StatementPtr> statements;
    };
 
    // Sampler state value assignment.
    // see https://msdn.microsoft.com/de-de/library/windows/desktop/bb509644(v=vs.85).aspx
    struct SamplerValue : public AST {
        AST_INTERFACE(SamplerValue);
 
        String name; // Sampler state name.
        ExpressionPtr value; // Sampler state value expression.
    };
 
    // Attribute (e.g. "[unroll]" or "[numthreads(x,y,z)]").
    struct Attribute : public AST {
        AST_INTERFACE(Attribute);
 
        AttributeType attributeType = AttributeType::Undefined; // Type of this attribute. Must not be undefined.
        Vector<ExpressionPtr> arguments; // Optional attribute arguments.
 
        [[nodiscard]] String toString() const;
 
        [[nodiscard]] static AttributePtr findAttribute(const Vector<AttributePtr>& attributes, AttributeType type);
    };
 
    // Case block for a switch statement.
    struct SwitchCase : public AST {
        AST_INTERFACE(SwitchCase);
 
        ExpressionPtr expression; // Case expression; null for the default case.
        Vector<StatementPtr> statements; // Statement list (switch-case does not require a braced code block).
 
        // Returns true, if this is a default case (if 'expression' is null).
        [[nodiscard]] bool isDefaultCase() const;
    };
 
    // Register (e.g. ": register(t0)").
    struct Register : public AST {
        AST_INTERFACE(Register);
 
        ShaderTarget shaderTarget = ShaderTarget::Undefined; // Shader target (or profile). Undefined means all targets are affected.
        RegisterType registerType = RegisterType::Undefined; // Type of the register. Must not be undefined.
        Int32 set = 0; // Zero-based register set index. By default 0.
        Int32 slot = 0; // Zero-based register slot index. By default 0.
 
        [[nodiscard]] String toString() const;
 
        // Returns the first slot register for the specified shader target or null, if there is no register.
        [[nodiscard]] static Register* getForTarget(const Vector<RegisterPtr>& registers, const ShaderTarget shaderTarget);
    };
 
    // Pack offset.
    struct PackOffset : public AST {
        AST_INTERFACE(PackOffset);
 
        //TODO: change this to an enumeration (like 'RegisterType').
        String registerName;
        String vectorComponent; // Vector component. May be empty.
 
        [[nodiscard]] String toString() const;
    };
 
    // Array dimension with bufferd expression evaluation.
    struct ArrayDimension : public TypedAST {
        AST_INTERFACE(ArrayDimension);
 
        ExpressionPtr expression; // Array dimension expression. Must be a constant integer expression.
        Int32 size = 0; // Evaluated array dimension size. Zero for dynamic array dimension.
 
        [[nodiscard]] String toString() const;
 
        [[nodiscard]] TypeDenoterPtr deriveTypeDenoter(const TypeDenoter* expectedTypeDenoter) override;
 
        // Returns true if this array dimension has a dynamic size (i.e. size == 0).
        [[nodiscard]] bool hasDynamicSize() const;
 
        // Validates the boundary of the specified index, if this array dimension has a fixed size. Throws a runtime error on failure.
        void validateIndexBoundary(int idx) const;
 
#if 0 //UNUSED
    // Returns the array dimension sizes as integral vector.
        [[nodiscard]] static Vector<int> getArrayDimensionSizes(const Vector<ArrayDimensionPtr>& arrayDimensions);
#endif
    };
 
    // Type specifier with optional structure declaration.
    struct TypeSpecifier : public TypedAST {
        AST_INTERFACE(TypeSpecifier);
 
        bool isInput = false; // Input modifier 'in'.
        bool isOutput = false; // Input modifier 'out'.
        bool isUniform = false; // Input modifier 'uniform'.
 
        Set<StorageClass> storageClasses; // Storage classes, e.g. extern, precise, etc.
        Set<InterpModifier> interpModifiers; // Interpolation modifiers, e.g. nointerpolation, linear, centroid etc.
        Set<TypeModifier> typeModifiers; // Type modifiers, e.g. const, row_major, column_major (also 'snorm' and 'unorm' for floats).
        PrimitiveType primitiveType = PrimitiveType::Undefined; // Primitive type for geometry entry pointer parameters.
        StructDeclarationPtr structDeclaration; // Optional structure declaration.
 
        TypeDenoterPtr typeDenoter; // Own type denoter.
 
        // Returns the name of this type and all modifiers.
        [[nodiscard]] String toString() const;
 
        [[nodiscard]] TypeDenoterPtr deriveTypeDenoter(const TypeDenoter* expectedTypeDenoter) override;
 
        // Returns the StructDecl reference of this type denoter or null if there is no such reference.
        [[nodiscard]] StructDeclaration* getStructDeclarationRef();
 
        // Returns true if the 'const' type modifier is set.
        [[nodiscard]] bool isConst() const;
 
        // Returns true if the 'const' type modifier or the 'uniform' input modifier is set.
        [[nodiscard]] bool isConstOrUniform() const;
 
        // Inserts the specified type modifier. Overlapping matrix packings will be removed.
        void setTypeModifier(const TypeModifier modifier);
 
        // Returns true if any of the specified type modifiers is contained.
        [[nodiscard]] bool hasAnyTypeModifierOf(const InitializerList<TypeModifier>& modifiers) const;
 
        // Returns true if any of the specified storage classes is contained.
        [[nodiscard]] bool hasAnyStorageClassOf(const InitializerList<StorageClass>& modifiers) const;
 
        // Swaps the 'row_major' with 'column_major' storage layout, and inserts the specified default layout if none of these are set.
        void swapMatrixStorageLayout(const TypeModifier defaultStorgeLayout);
    };
 
    // MARK: - Declaration objects -
 
    // Variable declaration.
    struct VarDeclaration : public Declaration {
        AST_INTERFACE(VarDeclaration);
 
        FLAG_ENUM{
            FLAG(isShaderInput, 2),
            // This variable is used as shader input.
            FLAG(isShaderOutput, 3),
            // This variable is used as shader output.
            FLAG(isSystemValue, 4),
            // This variable is a system value (e.g. SV_Position/ gl_Position).
            FLAG(isDynamicArray, 5),
            // This variable is a dynamic array (for input/output semantics).
            FLAG(isEntryPointOutput, 6),
            // This variable is used as entry point output (return value, output parameter, stream output).
            FLAG(isEntryPointLocal, 7),
            // This variable is a local variable of the entry point.
 
            IsShaderInputSv = (isShaderInput | isSystemValue),
            // This variable is used as shader input, and it is a system value.
            IsShaderOutputSv = (isShaderOutput | isSystemValue),
            // This variable is used as shader output, and it is a system value.
        };
 
        ObjectExpressionPtr namespaceExpression; // Optional namespace expression. May be null.
        Vector<ArrayDimensionPtr> arrayDimensions; // Array dimension list. May be empty.
        Vector<RegisterPtr> slotRegisters; // Slot register list. May be empty.
        IndexedSemantic semantic; // Variable semantic. May be invalid.
        PackOffsetPtr packOffset; // Optional pack offset. May be null.
        Vector<VarDeclarationStatementPtr> annotations; // Annotations can be ignored by analyzers and generators.
        ExpressionPtr initializer; // Optional initializer expression. May be null.
 
        TypeDenoterPtr customTypeDenoter; // Optional type denoter which can be different from the type of its declaration statement.
        Variant initializerValue; // Optional variant of the initializer value (if the initializer is a constant expression).
 
        VarDeclarationStatement* declarationStatementRef = nullptr; // Reference to its declaration statement (parent node). May be null.
        UniformBufferDeclaration* bufferDeclarationRef = nullptr; // Reference to its uniform buffer declaration (optional parent-parent-node). May be null.
        StructDeclaration* structDeclarationRef = nullptr; // Reference to its owner structure declaration (optional parent-parent-node). May be null.
        VarDeclaration* staticMemberVarRef = nullptr; // Bi-directional reference to its static variable declaration or definition. May be null.
 
        // Returns the variable declaration as string.
        [[nodiscard]] String toString() const override;
 
        // Returns a type denoter for this variable declaration or throws an std::runtime_error if the type can not be derived.
        [[nodiscard]] TypeDenoterPtr deriveTypeDenoter(const TypeDenoter* expectedTypeDenoter) override;
 
        // Returns the type specifier of the declaration statemnt reference (if set).
        [[nodiscard]] TypeSpecifier* fetchTypeSpecifier() const override;
 
        // Returns the reference to the static member variable declaration, or null if there is no such declaration (see staticMemberVarRef).
        [[nodiscard]] VarDeclaration* fetchStaticVarDeclarationRef() const;
 
        // Returns the reference to the static member variable definition, or null if there is no such definition (see staticMemberVarRef).
        [[nodiscard]] VarDeclaration* fetchStaticVarDefRef() const;
 
        // Returns true if this variable is declared as static.
        [[nodiscard]] bool isStatic() const;
 
        // Returns true if this variable is a function parameter.
        [[nodiscard]] bool isParameter() const;
 
        // Returns true if this is a non-parameter local variable with a constant initializer.
        [[nodiscard]] bool hasStaticConstInitializer() const;
 
        // Sets a custom type denoter, or the default type denoter if the parameter is null.
        void setCustomTypeDenoter(const TypeDenoterPtr& typeDenoter);
 
        // Adds the specified flag to this variable and all members and sub members of the structure, if the variable has a structure type.
        void addFlagsRecursive(UInt32 varFlags);
 
        // Accumulates the vector size for this variables (with a 16 byte boundary), and returns true on success.
        bool accumulateAlignedVectorSize(UInt32& size, UInt32& padding, UInt32* offset = nullptr);
    };
 
    // Buffer declaration.
    struct BufferDeclaration : public Declaration {
        AST_INTERFACE(BufferDeclaration);
 
        FLAG_ENUM{
            FLAG(isUsedForCompare, 2),
            // This buffer is used in a texture compare operation.
            FLAG(isUsedForImageRead, 3),
            // This is a buffer used in an image load or image atomic operation.
        };
 
        Vector<ArrayDimensionPtr> arrayDimensions; // Array dimension list. May be empty.
        Vector<RegisterPtr> slotRegisters; // Slot register list. May be empty.
        Vector<VarDeclarationStatementPtr> annotations; // Annotations can be ignored by analyzers and generators.
 
        BufferDeclarationStatement* declarationStatementRef = nullptr; // Reference to its declaration statement (parent node).
 
        [[nodiscard]] TypeDenoterPtr deriveTypeDenoter(const TypeDenoter* expectedTypeDenoter) override;
 
        // Returns the buffer type of the parent's node type denoter.
        [[nodiscard]] BufferType getBufferType() const;
    };
 
    // Sampler state declaration.
    struct SamplerDeclaration : public Declaration {
        AST_INTERFACE(SamplerDeclaration);
 
        Vector<ArrayDimensionPtr> arrayDimensions; // Array dimension list. May be empty.
        Vector<RegisterPtr> slotRegisters; // Slot register list. May be empty.
        String textureIdent; // Optional variable identifier of the texture object (for DX9 effect files).
        Vector<SamplerValuePtr> samplerValues; // State values for a sampler decl-ident.
 
        SamplerDeclarationStatement* declarationStatementRef = nullptr; // Reference to its declaration statmenet (parent node).
 
        [[nodiscard]] TypeDenoterPtr deriveTypeDenoter(const TypeDenoter* expectedTypeDenoter) override;
 
        // Returns the sampler type of the parent's node type denoter.
        [[nodiscard]] SamplerType getSamplerType() const;
    };
 
    // StructDecl object.
    struct StructDeclaration : public Declaration {
        AST_INTERFACE(StructDeclaration);
 
        FLAG_ENUM{
            FLAG(isShaderInput, 2),
            // This structure is used as shader input.
            FLAG(isShaderOutput, 3),
            // This structure is used as shader output.
            FLAG(isNestedStruct, 4),
            // This is a nested structure within another structure.
 
            //TODO: rename this flag, since it's meaning is confusing
            FLAG(isNonEntryPointParam, 5),
            // This structure is eventually used as variable or parameter type of function other than the entry point.
        };
 
        bool isClass = false; // This struct was declared as 'class'.
        String baseStructName; // May be empty (if no inheritance is used).
        Vector<StatementPtr> localStatements; // Local declaration statements.
 
        //TODO: maybe replace "VarDeclStatementPtr" by "VarDeclPtr" here.
        Vector<VarDeclarationStatementPtr> varMembers; // List of all member variable declaration statements.
        Vector<FunctionDeclarationPtr> funcMembers; // List of all member function declarations.
 
        BasicDeclarationStatement* declarationStatementRef = nullptr; // Reference to its declaration statement (parent node).
        StructDeclaration* baseStructRef = nullptr; // Optional reference to base struct.
        StructDeclaration* compatibleStructRef = nullptr; // Optional reference to a type compatible struct (only for anonymous structs).
        Map<String, VarDeclaration*> systemValuesRef; // List of members with system value semantic (SV_...).
        Set<StructDeclaration*> parentStructDeclarationRefs; // References to all structures that have a member variable with this structure type.
        Set<VarDeclaration*> shaderOutputVarDeclarationRefs; // References to all variables from this structure that are used as entry point outputs.
 
        // Returns a descriptive string of the structure signature (e.g. "struct s" or "struct <anonymous>").
        [[nodiscard]] String toString() const override;
 
        // Returns true if the specified structure declaration has the same member types as this structure (see 'TypeDenoter' for valid compare flags).
        [[nodiscard]] bool equalsMemberTypes(const StructDeclaration& rhs, const RawFlags& compareFlags = 0) const;
 
        // Returns true if this structure type is castable to the specified base type denoter.
        [[nodiscard]] bool isCastableTo(const BaseTypeDenoter& rhs) const;
 
        // Returns the VarDecl AST node inside this struct decl for the specified identifier, or null if there is no such VarDecl.
        [[nodiscard]] VarDeclaration* fetchVarDeclaration(const String& ident, const StructDeclaration** owner = nullptr) const;
 
        // Returns the VarDecl AST node of the 'base' member variable, or null if there is no such VarDecl.
        [[nodiscard]] VarDeclaration* fetchBaseMember() const;
 
        // Returns the StructDecl AST node with the specified identifier, that is a base of this structure (or the structure itself), or null if there is no such StructDecl.
        [[nodiscard]] StructDeclaration* fetchBaseStructDeclaration(const String& ident);
 
        // Returns the FunctionDecl AST node for the specified argument type denoter list (used to derive the overloaded function).
        [[nodiscard]] FunctionDeclaration* fetchFunctionDeclaration(const String& ident, const Vector<TypeDenoterPtr>& argTypeDenoters,
            const StructDeclaration** owner = nullptr, bool throwErrorIfNoMatch = false) const;
 
        // Returns an identifier that is similar to the specified identifier (for suggestions of typos)
        [[nodiscard]] String fetchSimilar(const String& ident);
 
        // Returns a type denoter for this structure.
        [[nodiscard]] TypeDenoterPtr deriveTypeDenoter(const TypeDenoter* expectedTypeDenoter) override;
 
        // Returns true if this structure has at least one member that is not a system value.
        [[nodiscard]] bool hasNonSystemValueMembers() const;
 
        // Returns the total number of member variables (including all base structures).
        [[nodiscard]] std::size_t numMemberVariables(bool onlyNonStaticMembers = false) const;
 
        // Returns the total number of member functions (including all base structures).
        [[nodiscard]] std::size_t numMemberFunctions(bool onlyNonStaticMembers = false) const;
 
        // Returns a list with the type denoters of all members (including all base structures, if enabled).
        void collectMemberTypeDenoters(Vector<TypeDenoterPtr>& memberTypeDens, bool includeBaseStructs = true) const;
 
        // Iterates over each VarDecl AST node (included nested structures, and members in base structures).
        void forEachVarDeclaration(const VarDeclarationIteratorFunctor& iterator, bool includeBaseStructs = true);
 
        // Adds the specified variable as an instance of this structure, that is used as shader output (see HasMultipleShaderOutputInstances).
        void addShaderOutputInstance(VarDeclaration* varDeclaration);
 
        // Returns true if this structure is used more than once as entry point output (either through variable arrays or multiple variable declarations).
        [[nodiscard]] bool hasMultipleShaderOutputInstances() const;
 
        // Returns true if this structure is a base of the specified sub structure.
        [[nodiscard]] bool isBaseOf(const StructDeclaration* subStructDeclaration, bool includeSelf = false) const;
 
        // Adds the specified flags to this structure, all base structures, all nested structures, and all structures of its member variables.
        void addFlagsRecursive(UInt32 structFlags);
 
        // Adds the specified flags to this structure, and all parent structures (i.e. all structures that have a member variable with this structure type).
        void addFlagsRecursiveParents(UInt32 structFlags);
 
        // Returns the zero-based index of the specified member variable, or ~0 on failure.
        [[nodiscard]] std::size_t memberVarToIndex(const VarDeclaration* varDeclaration, bool includeBaseStructs = true) const;
 
        // Returns the member variable of the specified zero-based index, null on failure.
        [[nodiscard]] VarDeclaration* indexToMemberVar(std::size_t idx, bool includeBaseStructs = true) const;
 
        // Accumulates the vector size for all members in this structure (with a 16 byte boundary for each member), and returns true on success.
        bool accumulateAlignedVectorSize(UInt32& size, UInt32& padding, UInt32* offset = nullptr);
    };
 
    // Type alias declaration.
    struct AliasDeclaration : public Declaration {
        AST_INTERFACE(AliasDeclaration);
 
        TypeDenoterPtr typeDenoter; // Type denoter of the aliased type.
        AliasDeclarationStatement* declarationStatementRef = nullptr; // Reference to its declaration statement (parent node).
 
        [[nodiscard]] TypeDenoterPtr deriveTypeDenoter(const TypeDenoter* expectedTypeDenoter) override;
    };
 
    // Function declaration.
    struct FunctionDeclaration : public Declaration {
        AST_INTERFACE(FunctionDeclaration);
 
        struct ParameterSemantics {
            using IteratorFunc = FunctionView<void(VarDeclaration* varDeclaration) const>;
 
            Vector<VarDeclaration*> varDeclarationRefs; // References to all variable declarations of the user defined semantics
            Vector<VarDeclaration*> varDeclarationRefsSV; // References to all variable declarations of the system value semantics
 
            void add(VarDeclaration* varDeclaration);
            [[nodiscard]] bool contains(const VarDeclaration* varDeclaration) const;
            void forEach(const IteratorFunc& iterator);
 
            // Returns true if both lists are empty.
            [[nodiscard]] bool empty() const;
 
            // Updates the distribution of system-value and non-system-value semantics.
            void updateDistribution();
        };
 
        struct ParameterStructure {
            Expression* expression; // Either this is used ...
            VarDeclaration* varDeclaration; // ... or this
            StructDeclaration* structDeclaration;
        };
 
        FLAG_ENUM{
            FLAG(isEntryPoint, 0),
            // This function is the main entry point.
            FLAG(isSecondaryEntryPoint, 1),
            // This function is a secondary entry point (e.g. patch constant function).
            FLAG(hasNonReturnControlPath, 2),
            // At least one control path does not return a value.
        };
 
        TypeSpecifierPtr returnType; // Function return type (TypeSpecifier).
        Vector<VarDeclarationStatementPtr> parameters; // Function parameter list.
        IndexedSemantic semantic = Semantic::Undefined; // Function return semantic; may be undefined.
        Vector<VarDeclarationStatementPtr> annotations; // Annotations can be ignored by analyzers and generators.
        CodeBlockPtr codeBlock; // May be null (if this AST node is a forward declaration).
 
        ParameterSemantics inputSemantics; // Entry point input semantics.
        ParameterSemantics outputSemantics; // Entry point output semantics.
 
        BasicDeclarationStatement* declarationStatementRef = nullptr; // Reference to its declaration statement (parent node). Must not be null.
        FunctionDeclaration* funcImplRef = nullptr; // Reference to the function implementation (only for forward declarations).
        Vector<FunctionDeclaration*> funcForwardDeclarationRefs; // Reference to all forward declarations (only for implementations).
        StructDeclaration* structDeclarationRef = nullptr; // Structure declaration reference if this is a member function; may be null
 
        Vector<ParameterStructure> paramStructs; // Parameter with structure type (only for entry point).
 
        [[nodiscard]] TypeDenoterPtr deriveTypeDenoter(const TypeDenoter* expectedTypeDenoter) override;
 
        // Returns true if this function declaration is just a forward declaration (without function body).
        [[nodiscard]] bool isForwardDeclaration() const;
 
        // Returns true if this function has a void return type.
        [[nodiscard]] bool hasVoidReturnType() const;
 
        // Returns true if this is a member function (member of a structure).
        [[nodiscard]] bool isMemberFunction() const;
 
        // Returns true if this is a static function (see TypeSpecifier::HasAnyStorageClassOf).
        [[nodiscard]] bool isStatic() const;
 
        // Returns a descriptive string of the function signature (e.g. "void f(int x)").
        [[nodiscard]] String toString() const override;
 
        // Returns a descriptive string of the function signature (e.g. "void f(int x)").
        [[nodiscard]] String toString(bool useParamNames) const;
 
        // Returns a descriptive strinf of the type of this function object (e.g. "void(int)").
        [[nodiscard]] String toTypeDenoterString() const;
 
        // Returns true if the specified function declaration has the same signature as this function (see 'TypeDenoter' for valid compare flags).
        [[nodiscard]] bool equalsSignature(const FunctionDeclaration& rhs, const RawFlags& compareFlags = 0) const;
 
        // Returns the minimal number of arguments for a call to this function.
        [[nodiscard]] std::size_t numMinArgs() const;
 
        // Returns the maximal number of arguments for a call to this function (this is merely: parameters.size()).
        [[nodiscard]] std::size_t numMaxArgs() const;
 
        // Sets the specified function AST node as the implementation of this forward declaration.
        void setFuncImplRef(FunctionDeclaration* funcDeclaration);
 
        // Returns true if the specified type denoter matches the parameter.
        [[nodiscard]] bool matchParameterWithTypeDenoter(std::size_t paramIndex, const TypeDenoter& argType, bool implicitConversion) const;
 
        // Fetches the function declaration from the list that matches the specified argument types.
        [[nodiscard]] static FunctionDeclaration* fetchFunctionDeclarationFromList(const Vector<FunctionDeclaration*>& funcDeclarationList, const String& ident,
            const Vector<TypeDenoterPtr>& argTypeDenoters, bool throwErrorIfNoMatch = true);
    };
 
    // Uniform buffer (cbuffer, tbuffer) declaration.
    struct UniformBufferDeclaration : public Declaration {
        AST_INTERFACE(UniformBufferDeclaration);
 
        UniformBufferType bufferType = UniformBufferType::Undefined; // Type of this uniform buffer. Must not be undefined.
        Vector<RegisterPtr> slotRegisters; // Slot register list. May be empty.
        Vector<StatementPtr> localStatements; // Local declaration statements.
        Vector<VarDeclarationStatementPtr> varMembers; // List of all member variable declaration statements.
        TypeModifier commonStorageLayout = TypeModifier::ColumnMajor; // Type modifier of the common matrix/vector storage.
        BasicDeclarationStatement* declarationStatementRef = nullptr; // Reference to its declaration statement (parent node). Must not be null.
 
        [[nodiscard]] TypeDenoterPtr deriveTypeDenoter(const TypeDenoter* expectedTypeDenoter) override;
 
        [[nodiscard]] String toString() const override;
 
        // Derives the common storage layout type modifier of all variable members (see 'commonStorageLayout' member).
        TypeModifier deriveCommonStorageLayout(const TypeModifier defaultStorgeLayout = TypeModifier::Undefined);
 
        // Accumulates the vector size of the entire uniform buffer (with 16 byte alignemnd for each vector), and return true on success.
        bool accumulateAlignedVectorSize(UInt32& size, UInt32& padding, UInt32* offset = nullptr);
    };
 
    // MARK: - Declaration statements -
 
    // Buffer (and texture) declaration.
    struct BufferDeclarationStatement : public Statement {
        AST_INTERFACE(BufferDeclarationStatement);
 
        BufferTypeDenoterPtr typeDenoter; // Own type denoter.
        Vector<BufferDeclarationPtr> bufferDeclarations; // Buffer declaration list.
 
        // Implements Statement::CollectDeclIdents
        void collectDeclarationIdents(Map<const AST*, String>& declarationASTIdents) const override;
    };
 
    // Sampler declaration.
    struct SamplerDeclarationStatement : public Statement {
        AST_INTERFACE(SamplerDeclarationStatement);
 
        SamplerTypeDenoterPtr typeDenoter; // Own type denoter.
        Vector<SamplerDeclarationPtr> samplerDeclarations; // Sampler declaration list.
 
        // Implements Statement::CollectDeclIdents
        void collectDeclarationIdents(Map<const AST*, String>& declarationASTIdents) const override;
    };
 
    // Basic declaration statement.
    struct BasicDeclarationStatement : public Statement {
        AST_INTERFACE(BasicDeclarationStatement);
 
        DeclarationPtr declarationObject; // Declaration object.
    };
 
    // Variable declaration statement.
    struct VarDeclarationStatement : public Statement {
        AST_INTERFACE(VarDeclarationStatement);
 
        FLAG_ENUM{
            FLAG(isShaderInput, 0),
            // This variable is used as shader input.
            FLAG(isShaderOutput, 1),
            // This variable is used as shader output.
            FLAG(isParameter, 2),
            // This variable is a function parameter (flag should be set during parsing).
            FLAG(isSelfParameter, 3),
            // This variable is the 'self' parameter of a member function.
            FLAG(isBaseMember, 4),
            // This variable is the 'base' member of a structure with inheritance.
            FLAG(isImplicitConst, 5),
            // This variable is implicitly declared as constant.
        };
 
        TypeSpecifierPtr typeSpecifier; // Type basis for all variables (can be extended by array indices in each individual variable).
        Vector<VarDeclarationPtr> varDeclarations; // Variable declaration list.
 
        // Implements Statement::CollectDeclIdents
        void collectDeclarationIdents(Map<const AST*, String>& declarationASTIdents) const override;
 
        // Returns the var-decl statement as string.
        [[nodiscard]] String toString(bool useVarNames = true) const;
 
        // Returns the VarDecl AST node inside this var-decl statement for the specified identifier, or null if there is no such VarDecl.
        [[nodiscard]] VarDeclaration* fetchVarDeclaration(const String& ident) const;
 
        // Returns the one and only VarDecl AST node (used for parameters of FunctionDecl AST nodes).
        [[nodiscard]] VarDeclaration* fetchUniqueVarDeclaration() const;
 
        // Returns true if this is an input parameter.
        [[nodiscard]] bool isInput() const;
 
        // Returns true if this is an output parameter.
        [[nodiscard]] bool isOutput() const;
 
        // Returns true if this is a uniform.
        [[nodiscard]] bool isUniform() const;
 
        // Returns true if the 'const' type modifier or the 'uniform' input modifier is set.
        [[nodiscard]] bool isConstOrUniform() const;
 
        // Inserts the specified type modifier. Overlapping matrix packings will be removed.
        void setTypeModifier(const TypeModifier modifier);
 
        // Returns true if any of the specified type modifiers is contained.
        [[nodiscard]] bool hasAnyTypeModifierOf(const InitializerList<TypeModifier>& modifiers) const;
 
        // Iterates over each VarDecl AST node.
        void forEachVarDeclaration(const VarDeclarationIteratorFunctor& iterator);
 
        // Makes this var-decl statement implicitly constant, iff not explicitly declared as constant (see 'isUniform' and 'isImplicitlyConst').
        void makeImplicitConst();
 
        // Returns the reference to the owner structure from the first variable entry, or null if there is no such owner structure.
        [[nodiscard]] StructDeclaration* fetchStructDeclarationRef() const;
 
        // Accumulates the vector size for all variables in this statement (with a 16 byte boundary for each member), and returns true on success.
        bool accumulateAlignedVectorSize(UInt32& size, UInt32& padding, UInt32* offset = nullptr);
    };
 
    // Type alias declaration statement.
    struct AliasDeclarationStatement : public Statement {
        AST_INTERFACE(AliasDeclarationStatement);
 
        StructDeclarationPtr structDeclaration; // Optional structure declaration. May be null.
        Vector<AliasDeclarationPtr> aliasDeclarations; // Alias declaration list.
    };
 
    // MARK: - Statements -
 
    // Null statement.
    struct NullStatement : public Statement {
        AST_INTERFACE(NullStatement);
    };
 
    // Code block statement.
    struct CodeBlockStatement : public Statement {
        AST_INTERFACE(CodeBlockStatement);
 
        CodeBlockPtr codeBlock; // Code block.
    };
 
    // 'for'-loop statemnet.
    struct ForLoopStatement : public Statement {
        AST_INTERFACE(ForLoopStatement);
 
        StatementPtr initStatement; // Initializer statement. Must not be null, but can be an instance of 'NullStatement'.
        ExpressionPtr condition; // Condition expressionesion. May be null.
        ExpressionPtr iteration; // Loop iteration expression. May be null.
        StatementPtr bodyStatement; // Loop body statement.
    };
 
    // 'while'-loop statement.
    struct WhileLoopStatement : public Statement {
        AST_INTERFACE(WhileLoopStatement);
 
        ExpressionPtr condition; // Condition expression.
        StatementPtr bodyStatement; // Loop body statement.
    };
 
    // 'do/while'-loop statement.
    struct DoWhileLoopStatement : public Statement {
        AST_INTERFACE(DoWhileLoopStatement);
 
        StatementPtr bodyStatement; // Loop body statement.
        ExpressionPtr condition; // Condition expression.
    };
 
    // 'if' statement.
    struct IfStatement : public Statement {
        AST_INTERFACE(IfStatement);
 
        ExpressionPtr condition; // Condition expression.
        StatementPtr bodyStatement; // 'then'-branch body statement.
        ElseStatementPtr elseStatement; // 'else'-branch statement. May be null.
    };
 
    // 'else' statement.
    struct ElseStatement : public Statement {
        AST_INTERFACE(ElseStatement);
 
        StatementPtr bodyStatement; // 'else'-branch body statement.
    };
 
    // 'switch' statement.
    struct SwitchStatement : public Statement {
        AST_INTERFACE(SwitchStatement);
 
        ExpressionPtr selector; // Switch selector expression.
        Vector<SwitchCasePtr> cases; // Switch case list.
    };
 
    // Arbitrary expression statement.
    struct ExpressionStatement : public Statement {
        AST_INTERFACE(ExpressionStatement);
 
        ExpressionPtr expression; // Common expression.
    };
 
    // Returns statement.
    struct ReturnStatement : public Statement {
        AST_INTERFACE(ReturnStatement);
 
        FLAG_ENUM{
            FLAG(isEndOfFunction, 0),
            // This return statement is at the end of its function body.
        };
 
        ExpressionPtr expression; // Return statement expression. May be null.
    };
 
    // Control transfer statement.
    struct CtrlTransferStatement : public Statement {
        AST_INTERFACE(CtrlTransferStatement);
 
        CtrlTransfer transfer = CtrlTransfer::Undefined; // Control transfer type (break, continue, discard). Must not be undefined.
    };
 
    struct LayoutStatement : public Statement {
        AST_INTERFACE(LayoutStatement);
 
        bool isInput = false; // Input modifier 'in'.
        bool isOutput = false; // Input modifier 'out'.
    };
 
    // MARK: - Expressions -
 
    // Null expression (used for dynamic array dimensions).
    struct NullExpression : public Expression {
        AST_INTERFACE(NullExpression);
 
        [[nodiscard]] TypeDenoterPtr deriveTypeDenoter(const TypeDenoter* expectedTypeDenoter) override;
    };
 
    // List expression ( expression (',' expression)+ ).
    struct SequenceExpression : public Expression {
        AST_INTERFACE(SequenceExpression);
 
        Vector<ExpressionPtr> expressions; // Sub expression list. Must have at least two elements.
 
        [[nodiscard]] TypeDenoterPtr deriveTypeDenoter(const TypeDenoter* expectedTypeDenoter) override;
 
        [[nodiscard]] const Expression* find(const FindPredicateConstFunctor& predicate, UInt32 flags = SearchAll) const override;
 
        // Appens the specified expression to the sub expressions ('SequenceExpression' will be flattened).
        void append(const ExpressionPtr& expression);
    };
 
    // Literal expression.
    struct LiteralExpression : public Expression {
        AST_INTERFACE(LiteralExpression);
 
        String value; // Literal expression value.
        DataType dataType = DataType::Undefined; // Valid data types: String, Bool, Int, UInt, Half, Float, Double. Undefined for 'NULL'.
 
        [[nodiscard]] TypeDenoterPtr deriveTypeDenoter(const TypeDenoter* expectedTypeDenoter) override;
 
        // Converts the data type of this literal expression, resets the buffered type denoter (see ResetTypeDenoter), and modifies the value string.
        void convertDataType(const DataType type);
 
        // Returns the value of this literal if it is a string literal (excluding the quotation marks). Otherwise an empty string is returned.
        [[nodiscard]] String getStringValue() const;
 
        // Returns the value either with or without suffixes (e.g. "1.0f" or "1.0").
        [[nodiscard]] String getLiteralValue(bool enableSuffix = true) const;
 
        // Returns true if this is a NULL literal.
        [[nodiscard]] bool isNull() const;
 
        // Returns true if this literal needs a space after the literal, when a vector subscript is used as postfix.
        [[nodiscard]] bool isSpaceRequiredForSubscript() const;
    };
 
    // Type name expression (used for simpler cast-expression parsing).
    struct TypeSpecifierExpression : public Expression {
        AST_INTERFACE(TypeSpecifierExpression);
 
        TypeSpecifierPtr typeSpecifier; // Type specifier.
 
        [[nodiscard]] TypeDenoterPtr deriveTypeDenoter(const TypeDenoter* expectedTypeDenoter) override;
    };
 
    // Ternary expression.
    struct TernaryExpression : public Expression {
        AST_INTERFACE(TernaryExpression);
 
        ExpressionPtr condExpression; // Ternary condition expression.
        ExpressionPtr thenExpression; // 'then'-branch expression.
        ExpressionPtr elseExpression; // 'else'-branch expression.
 
        [[nodiscard]] TypeDenoterPtr deriveTypeDenoter(const TypeDenoter* expectedTypeDenoter) override;
        [[nodiscard]] const Expression* find(const FindPredicateConstFunctor& predicate, UInt32 flags = SearchAll) const override;
 
        // Returns true if the conditional expression is a vector type.
        [[nodiscard]] bool isVectorCondition() const;
    };
 
    // Binary expression.
    struct BinaryExpression : public Expression {
        AST_INTERFACE(BinaryExpression);
 
        ExpressionPtr lhsExpression; // Left-hand-side expression.
        BinaryOp op = BinaryOp::Undefined; // Binary operator. Must not be undefined.
        ExpressionPtr rhsExpression; // Right-hand-side expression.
 
        [[nodiscard]] TypeDenoterPtr deriveTypeDenoter(const TypeDenoter* expectedTypeDenoter) override;
        [[nodiscard]] const Expression* find(const FindPredicateConstFunctor& predicate, UInt32 flags = SearchAll) const override;
    };
 
    // (Pre-) Unary expression.
    struct UnaryExpression : public Expression {
        AST_INTERFACE(UnaryExpression);
 
        UnaryOp op = UnaryOp::Undefined; // Unary operator. Must not be undefined.
        ExpressionPtr expression; // Right-hand-side expression.
 
        [[nodiscard]] TypeDenoterPtr deriveTypeDenoter(const TypeDenoter* expectedTypeDenoter) override;
        [[nodiscard]] const Expression* find(const FindPredicateConstFunctor& predicate, UInt32 flags = SearchAll) const override;
        [[nodiscard]] const ObjectExpression* fetchLValueExpression() const override;
    };
 
    // Post unary expression (e.g. x++, x--)
    struct PostUnaryExpression : public Expression {
        AST_INTERFACE(PostUnaryExpression);
 
        ExpressionPtr expression; // Left-hand-side expression.
        UnaryOp op = UnaryOp::Undefined; // Unary operator. Must not be undefined.
 
        [[nodiscard]] TypeDenoterPtr deriveTypeDenoter(const TypeDenoter* expectedTypeDenoter) override;
        [[nodiscard]] const Expression* find(const FindPredicateConstFunctor& predicate, UInt32 flags = SearchAll) const override;
    };
 
    // Function call expression (e.g. "foo()" or "foo().bar()" or "foo()[0].bar()").
    struct CallExpression : public Expression {
        AST_INTERFACE(CallExpression);
 
        FLAG_ENUM{
            // If this function call is an intrinsic, it's wrapper function can be inlined (i.e. no wrapper function must be generated)
            // e.g. "clip(a), clip(b);" can not be inlined, due to the list expression.
            FLAG(canInlineIntrinsicWrapper, 0),
 
            // This is a call expression to a wrapper function (use expression identifier, not from a function reference).
            FLAG(isWrapperCall, 1),
        };
 
        ExpressionPtr prefixExpression; // Optional prefix expression. May be null.
        bool isStatic = false; // Specifies whether this function is a static member.
        String ident; // Function name identifier. Empty for type constructors.
        TypeDenoterPtr typeDenoter; // Null, if the function call is NOT a type constructor (e.g. "float2(0, 0)").
        Vector<ExpressionPtr> arguments; // Argument expression list.
 
        FunctionDeclaration* funcDeclarationRef = nullptr; // Reference to the function declaration. May be null.
        Intrinsic intrinsic = Intrinsic::Undefined; // Intrinsic ID (if this is an intrinsic).
        Vector<VarDeclaration*> defaultParamRefs; // Reference to parameters that have a default argument.
 
        [[nodiscard]] TypeDenoterPtr deriveTypeDenoter(const TypeDenoter* expectedTypeDenoter) override;
 
        [[nodiscard]] const Expression* find(const FindPredicateConstFunctor& predicate, UInt32 flags = SearchAll) const override;
 
        [[nodiscard]] IndexedSemantic fetchSemantic() const override;
 
#if 0 //UNUSED
    // Returns a list of all argument expressions (including the default arguments).
        [[nodiscard]] Vector<Expression*> getArguments() const;
#endif
 
        // Returns the reference to the function declaration of this call expression, or null if not set.
        [[nodiscard]] FunctionDeclaration* getFunctionDeclaration() const;
 
        // Returns the reference to the function implementation of this call expression, or null if not set.
        [[nodiscard]] FunctionDeclaration* getFunctionImpl() const;
 
        // Iterates over each argument expression that is assigned to an output parameter.
        void forEachOutputArgument(const ExpressionIteratorFunctor& iterator);
 
        // Iterates over each argument expression together with its associated parameter.
        void forEachArgumentWithParameterType(const ArgumentParameterTypeFunctor& iterator);
 
        // Inserts the specified argument expression at the front of the argument list.
        void pushArgumentFront(const ExpressionPtr& expression);
 
        // Moves the prefix expression into the argument list as first argument.
        [[nodiscard]] bool pushPrefixToArguments();
 
        // Moves the first argument out of the argument list as prefix expression.
        [[nodiscard]] bool popPrefixFromArguments();
 
        // Merges the argument with index 'firstArgIndex' and the next argument with the merge function callback.
        [[nodiscard]] bool mergeArguments(std::size_t firstArgIndex, const MergeExpressionFunctor& mergeFunctor);
 
        // Returns the expression which denotes the member function class instance (either the prefix expression or the first argument); see PushPrefixToArguments.
        [[nodiscard]] Expression* getMemberFuncObjectExpression() const;
    };
 
    // Bracket expression.
    struct BracketExpression : public Expression {
        AST_INTERFACE(BracketExpression);
 
        ExpressionPtr expression; // Inner expression.
 
        [[nodiscard]] TypeDenoterPtr deriveTypeDenoter(const TypeDenoter* expectedTypeDenoter) override;
        [[nodiscard]] const Expression* find(const FindPredicateConstFunctor& predicate, UInt32 flags = SearchAll) const override;
        [[nodiscard]] const ObjectExpression* fetchLValueExpression() const override;
        [[nodiscard]] IndexedSemantic fetchSemantic() const override;
    };
 
    // Assignment expression.
    struct AssignExpression : public Expression {
        AST_INTERFACE(AssignExpression);
 
        ExpressionPtr lvalueExpression; // L-value expression.
        AssignOp op = AssignOp::Undefined; // Assignment operator. Must not be undefined.
        ExpressionPtr rvalueExpression; // R-value expression.
 
        [[nodiscard]] TypeDenoterPtr deriveTypeDenoter(const TypeDenoter* expectedTypeDenoter) override;
        [[nodiscard]] const Expression* find(const FindPredicateConstFunctor& predicate, UInt32 flags = SearchAll) const override;
        [[nodiscard]] const ObjectExpression* fetchLValueExpression() const override;
    };
 
    // Object access expression.
    struct ObjectExpression : public Expression {
        AST_INTERFACE(ObjectExpression);
 
        FLAG_ENUM{
            FLAG(isImmutable, 1),
            // This object identifier must be written out as it is.
            FLAG(isBaseStructNamespace, 2),
            // This expression is a base structure namespace expression.
        };
 
        ExpressionPtr prefixExpression; // Optional prefix expression. May be null.
        bool isStatic = false; // Specifies whether this object is a static member.
        String ident; // Object identifier.
        Declaration* symbolRef = nullptr; // Optional symbol reference to the object declaration. May be null (e.g. for vector subscripts).
 
        [[nodiscard]] TypeDenoterPtr deriveTypeDenoter(const TypeDenoter* expectedTypeDenoter) override;
        [[nodiscard]] const Expression* find(const FindPredicateConstFunctor& predicate, UInt32 flags = SearchAll) const override;
        [[nodiscard]] const ObjectExpression* fetchLValueExpression() const override;
        [[nodiscard]] IndexedSemantic fetchSemantic() const override;
        [[nodiscard]] bool isTrivialCopyable(UInt32 maxTreeDepth = 3) const override;
 
        // Returns a type denoter for the vector subscript of this object expression or throws an runtime error on failure.
        [[nodiscard]] BaseTypeDenoterPtr getTypeDenoterFromSubscript() const;
 
        // Returns this object expression as a static namespace, i.e. only for prefix expression that are also from type ObjectExpression.
        [[nodiscard]] String toStringAsNamespace() const;
 
        // Replaces the old symbol and identifier by the new symbol.
        void replaceSymbol(Declaration* symbol);
 
        // Returns the specified type of AST node from the symbol (if the symbol refers to one).
        template<typename T> [[nodiscard]] T* fetchSymbol() const {
            if(symbolRef) {
                if(auto ast = symbolRef->as<T>()) {
                    return ast;
                }
            }
            return nullptr;
        }
 
        // Returns the variable AST node (if the symbol refers to one).
        [[nodiscard]] VarDeclaration* fetchVarDeclaration() const;
    };
 
    // Array-access expression (e.g. "foo()[arrayAccess]").
    struct ArrayExpression : public Expression {
        AST_INTERFACE(ArrayExpression);
 
        ExpressionPtr prefixExpression; // Prefix expression.
        Vector<ExpressionPtr> arrayIndices; // Array index expression list (right hand side).
 
        [[nodiscard]] TypeDenoterPtr deriveTypeDenoter(const TypeDenoter* expectedTypeDenoter) override;
 
        [[nodiscard]] const Expression* find(const FindPredicateConstFunctor& predicate, UInt32 flags = SearchAll) const override;
 
        [[nodiscard]] const ObjectExpression* fetchLValueExpression() const override;
 
        // Returns the number of array indices (shortcut for "arrayIndices.size()").
        [[nodiscard]] std::size_t numIndices() const;
    };
 
    // Cast expression.
    struct CastExpression : public Expression {
        AST_INTERFACE(CastExpression);
 
        TypeSpecifierPtr typeSpecifier; // Destination type specifier.
        ExpressionPtr expression; // Source value expression.
 
        [[nodiscard]] TypeDenoterPtr deriveTypeDenoter(const TypeDenoter* expectedTypeDenoter) override;
 
        [[nodiscard]] const Expression* find(const FindPredicateConstFunctor& predicate, UInt32 flags = SearchAll) const override;
    };
 
    // Initializer list expression.
    struct InitializerExpression : public Expression {
        AST_INTERFACE(InitializerExpression);
 
        Vector<ExpressionPtr> expressions; // Sub expression list.
 
        [[nodiscard]] TypeDenoterPtr deriveTypeDenoter(const TypeDenoter* expectedTypeDenoter) override;
 
        [[nodiscard]] const Expression* find(const FindPredicateConstFunctor& predicate, UInt32 flags = SearchAll) const override;
 
        // Returns the number of elements with all sub initializers being unrollwed (e.g. { 1, { 2, 3 } } has 3 'unrolled' elements just like { 1, 2, 3 }).
        [[nodiscard]] std::size_t numElementsUnrolled() const;
 
        // Collects all elements from the sub expressions without initializer lists (e.g. { 1, { 2, 3 } } --> { 1, 2, 3 }).
        void collectElements(Vector<ExpressionPtr>& elements) const;
 
        // Resolves all initializer lists in the sub expression.
        void unrollElements();
 
        // Fetches the sub expression with the specified array indices and throws an ASTRuntimeError on failure.
        [[nodiscard]] ExpressionPtr fetchSubExpression(const Vector<int>& arrayIndices) const;
 
        // Returns the next array indices for a sub expression.
        [[nodiscard]] bool nextArrayIndices(Vector<int>& arrayIndices) const;
    };
 
#undef AST_INTERFACE
#undef DECLARATION_AST_ALIAS
#undef FLAG_ENUM
#undef FLAG
} // namespace CeresEngine::ShaderCompiler