tree.hpp

#ifndef _GYOJI_INTERNAL
#error "This header is intended to be used internally as a part of the Gyoji front-end.  Please include frontend.hpp instead."
#endif
#pragma once
 
 
namespace Gyoji::frontend::tree {
 
    class TerminalNonSyntax {
    public:
    typedef enum {
        EXTRA_COMMENT_SINGLE_LINE,
        EXTRA_COMMENT_MULTI_LINE,
        EXTRA_WHITESPACE,
        EXTRA_FILE_METADATA
    }  Type;
    
    TerminalNonSyntax(Type _type, const Gyoji::context::Token & _token);
    ~TerminalNonSyntax();
    
    const Type &get_type() const;
    const std::string & get_data() const;
    
    private:
    Type type;
    const Gyoji::context::Token & token;
    };
 
 
    class Terminal : public Gyoji::frontend::ast::SyntaxNode {
    public:
    typedef enum {
        IDENTIFIER_GLOBAL_SCOPE,
        IDENTIFIER_LOCAL_SCOPE,
 
        IDENTIFIER_UNCATEGORIZED
    } IdentifierType;
    
    Terminal(const Gyoji::context::Token & _token);
    ~Terminal();
    
    const Gyoji::context::TokenID & get_type() const;
    const std::string & get_value() const;
    
    const Gyoji::context::SourceReference & get_terminal_source_ref() const;
    
    std::string get_fully_qualified_name() const;
    
    std::string get_name() const;
 
    const IdentifierType & get_identifier_type() const;
    void set_identifier_type(IdentifierType _identifier_type);
    
    // The terminal "owns" uniquely all of the non-syntax data
    // in this vector.  It may be returned to access it,
    // but these are owned pointers, so they must only
    // be de-referenced and never assigned to
    std::vector<Gyoji::owned<TerminalNonSyntax>> non_syntax;
 
    void set_ns2_entity(Gyoji::frontend::namespaces::NS2Entity *_ns_entity);
    Gyoji::frontend::namespaces::NS2Entity *get_ns2_entity() const;
    
    
    private:
    const Gyoji::context::Token & token;
    std::string fully_qualified_name;
    IdentifierType identifier_type;
    // Tells us whether this is a namespace name, an entity, or what.
    Gyoji::frontend::namespaces::NS2Entity *ns2_entity;
    };
    
    
    class FileStatement : public Gyoji::frontend::ast::SyntaxNode {
    public:
    typedef std::variant<
            Gyoji::owned<FileStatementFunctionDefinition>,
            Gyoji::owned<FileStatementFunctionDeclaration>,
            Gyoji::owned<FileStatementGlobalDefinition>,
        Gyoji::owned<ClassDeclaration>,
            Gyoji::owned<ClassDefinition>,
            Gyoji::owned<EnumDefinition>,
            Gyoji::owned<TypeDefinition>,
            Gyoji::owned<FileStatementNamespace>,
            Gyoji::owned<FileStatementUsing>> FileStatementType;
    
    FileStatement(FileStatementType _statement, const Gyoji::frontend::ast::SyntaxNode & _sn);
    ~FileStatement();
    
    const FileStatementType & get_statement() const;
    
    private:
    FileStatementType statement;
    };
    
 
    class AccessQualifier : public Gyoji::frontend::ast::SyntaxNode {
    public:
    typedef enum {
        UNSPECIFIED,
        VOLATILE,
        CONST
    } AccessQualifierType;
    AccessQualifier(Gyoji::owned<Terminal> _qualifier);
    AccessQualifier(const Gyoji::context::SourceReference & _source_ref);
    ~AccessQualifier();
    const AccessQualifier::AccessQualifierType & get_type() const;
    private:
    AccessQualifier::AccessQualifierType type;
    Gyoji::owned<Terminal> qualifier;
    };
    
 
    class AccessModifier : public Gyoji::frontend::ast::SyntaxNode {
    public:
    typedef enum {
        PUBLIC,
        PROTECTED,
        PRIVATE
    } AccessModifierType;
    AccessModifier(Gyoji::owned<Terminal> _modifier);
    AccessModifier(const Gyoji::context::SourceReference & _source_ref);
    ~AccessModifier();
    const AccessModifierType & get_type() const;
    private:
    AccessModifierType type;
    Gyoji::owned<Terminal> modifier;
    };
    
 
    class UnsafeModifier : public Gyoji::frontend::ast::SyntaxNode {
    public:
    UnsafeModifier(Gyoji::owned<Terminal> _unsafe_token);
    UnsafeModifier(const Gyoji::context::SourceReference & _source_ref);
    ~UnsafeModifier();
    bool is_unsafe() const;
    private:
    Gyoji::owned<Terminal> unsafe_token;
    };
    
 
    class TypeName : public Gyoji::frontend::ast::SyntaxNode {
    public:
    TypeName(Gyoji::owned<Terminal> _type_name);
    
    TypeName(Gyoji::owned<Terminal> _typeof_token,
         Gyoji::owned<Terminal> _paren_l_token,
         Gyoji::owned<Expression> _expression,
         Gyoji::owned<Terminal> _paren_r_token
        );
    ~TypeName();
    bool is_expression() const;
    std::string get_name() const;
    const Gyoji::context::SourceReference & get_name_source_ref() const;
    const Expression & get_expression() const;
    private:
    bool m_is_expression;
    // For raw names
    Gyoji::owned<Terminal> type_name;
    // for typeof expressions
    Gyoji::owned<Terminal> typeof_token;
    Gyoji::owned<Terminal> paren_l_token;
    Gyoji::owned<Expression> expression;
    Gyoji::owned<Terminal> paren_r_token;
    };
    
 
    class TypeSpecifierCallArgs : public Gyoji::frontend::ast::SyntaxNode {
    public:
    TypeSpecifierCallArgs(const Gyoji::context::SourceReference & _source_ref);
    ~TypeSpecifierCallArgs();
    void add_argument(Gyoji::owned<TypeSpecifier> _argument);
    void add_argument(Gyoji::owned<Terminal> _comma_token, Gyoji::owned<TypeSpecifier> _argument);
    
    const std::vector<Gyoji::owned<TypeSpecifier>> & get_arguments() const;
    private:
    std::vector<Gyoji::owned<Terminal>> comma_list;
    std::vector<Gyoji::owned<TypeSpecifier>> arguments;
    };
    
 
    class TypeSpecifierSimple : public Gyoji::frontend::ast::SyntaxNode {
    public:
    TypeSpecifierSimple(
        Gyoji::owned<AccessQualifier> _access_qualifier,
        Gyoji::owned<TypeName> _type_name
        );
    ~TypeSpecifierSimple();
    const AccessQualifier & get_access_qualifier() const;
    const TypeName & get_type_name() const;
    private:
    Gyoji::owned<AccessQualifier> access_qualifier;
    Gyoji::owned<TypeName> type_name;
    };
    
 
    class TypeSpecifierTemplate : public Gyoji::frontend::ast::SyntaxNode {
    public:
    TypeSpecifierTemplate(
        Gyoji::owned<TypeSpecifier> _type_specifier,
        Gyoji::owned<Terminal> _paren_l_token,
        Gyoji::owned<TypeSpecifierCallArgs> _type_specifier_call_args,
        Gyoji::owned<Terminal> _paren_r_token
        );
    ~TypeSpecifierTemplate();
    const TypeSpecifier & get_type() const;
    const TypeSpecifierCallArgs & get_args() const;
    
    private:
    Gyoji::owned<TypeSpecifier> type_specifier;
    Gyoji::owned<Terminal> paren_l_token;
    Gyoji::owned<TypeSpecifierCallArgs> type_specifier_call_args;
    Gyoji::owned<Terminal> paren_r_token;
    };
    
 
    class TypeSpecifierFunctionPointer : public Gyoji::frontend::ast::SyntaxNode {
    public:
    TypeSpecifierFunctionPointer(
        Gyoji::owned<TypeSpecifier> _type_specifier,
        Gyoji::owned<Terminal> _paren_l1_token,
        Gyoji::owned<Terminal> _star_token,
        Gyoji::owned<Terminal> _identifier_token,
        Gyoji::owned<Terminal> _paren_r1_token,
        Gyoji::owned<Terminal> _paren_l2_token,
        Gyoji::owned<FunctionDefinitionArgList> _function_definition_arg_list,
        Gyoji::owned<Terminal> _paren_r2_token
        );
    ~TypeSpecifierFunctionPointer();
    const TypeSpecifier & get_return_type() const;
    const std::string & get_name() const;
    const Gyoji::context::SourceReference & get_name_source_ref() const;
    const FunctionDefinitionArgList & get_args() const;
    private:
    Gyoji::owned<TypeSpecifier> type_specifier;
    Gyoji::owned<Terminal> paren_l1_token;
    Gyoji::owned<Terminal> star_token;
    Gyoji::owned<Terminal> identifier_token;
    Gyoji::owned<Terminal> paren_r1_token;
    Gyoji::owned<Terminal> paren_l2_token;
    Gyoji::owned<FunctionDefinitionArgList> function_definition_arg_list;
    Gyoji::owned<Terminal> paren_r2_token;
    };
    
    class TypeSpecifierPointerTo : public Gyoji::frontend::ast::SyntaxNode {
    public:
    TypeSpecifierPointerTo(
        Gyoji::owned<TypeSpecifier> _type_specifier,
        Gyoji::owned<Terminal> _star_token,
        Gyoji::owned<AccessQualifier> _access_qualifier
        );
    ~TypeSpecifierPointerTo();
    
    const TypeSpecifier & get_type_specifier() const;
    const AccessQualifier & get_access_qualifier() const;
    private:
    Gyoji::owned<TypeSpecifier> type_specifier;
    Gyoji::owned<Terminal> star_token;
    Gyoji::owned<AccessQualifier> access_qualifier;
    };
 
    class TypeSpecifierArray : public Gyoji::frontend::ast::SyntaxNode {
    public:
    TypeSpecifierArray(
        Gyoji::owned<TypeSpecifier> _type_specifier,
        Gyoji::owned<Terminal> _bracket_l_token,
        Gyoji::owned<Terminal> _literal_int_token,
        Gyoji::owned<Terminal> _bracket_r_token
        );
    ~TypeSpecifierArray();
    
    const TypeSpecifier & get_type_specifier() const;
 
    const Terminal & get_literal_int_token() const;
    private:
    Gyoji::owned<TypeSpecifier> type_specifier;
    Gyoji::owned<Terminal> bracket_l_token;
    Gyoji::owned<Terminal> literal_int_token;
    Gyoji::owned<Terminal> bracket_r_token;
    };
 
    class TypeSpecifierReferenceTo : public Gyoji::frontend::ast::SyntaxNode {
    public:
    TypeSpecifierReferenceTo(
        Gyoji::owned<TypeSpecifier> _type_specifier,
        Gyoji::owned<Terminal> _andpersand_token,
        Gyoji::owned<AccessQualifier> _access_qualifier
        );
    ~TypeSpecifierReferenceTo();
    const TypeSpecifier & get_type_specifier() const;
    const AccessQualifier & get_access_qualifier() const;
    private:
    Gyoji::owned<TypeSpecifier> type_specifier;
    Gyoji::owned<Terminal> andpersand_token;
    Gyoji::owned<AccessQualifier> access_qualifier;
    };
    
 
    class TypeSpecifier : public Gyoji::frontend::ast::SyntaxNode {
    public:
    typedef std::variant<
        Gyoji::owned<TypeSpecifierSimple>,
        Gyoji::owned<TypeSpecifierTemplate>,
        Gyoji::owned<TypeSpecifierFunctionPointer>,
        Gyoji::owned<TypeSpecifierPointerTo>,
            Gyoji::owned<TypeSpecifierReferenceTo>,
        Gyoji::owned<TypeSpecifierArray>
    > TypeSpecifierType;
    TypeSpecifier(TypeSpecifier::TypeSpecifierType _type, const Gyoji::frontend::ast::SyntaxNode & _sn);
    ~TypeSpecifier();
    const TypeSpecifier::TypeSpecifierType & get_type() const;
    private:
    TypeSpecifier::TypeSpecifierType type;
    };
    
 
    class FunctionDefinitionArg : public Gyoji::frontend::ast::SyntaxNode {
    public:
    FunctionDefinitionArg(Gyoji::owned<TypeSpecifier> _type_specifier,
                  Gyoji::owned<Terminal> _identifier_token
        );
    ~FunctionDefinitionArg();
    const TypeSpecifier & get_type_specifier() const;
    const Terminal & get_identifier() const;
    private:
    Gyoji::owned<TypeSpecifier> type_specifier;
    Gyoji::owned<Terminal> identifier_token;
    };
    
 
    class FunctionDefinitionArgList : public Gyoji::frontend::ast::SyntaxNode {
    public:
    FunctionDefinitionArgList(const Gyoji::context::SourceReference & _source_ref);
    ~FunctionDefinitionArgList();
    const std::vector<Gyoji::owned<FunctionDefinitionArg>> & get_arguments() const;
    void add_argument(Gyoji::owned<FunctionDefinitionArg> _argument);
    void add_comma(Gyoji::owned<Terminal> _comma);
    private:
    std::vector<Gyoji::owned<Terminal>> commas;
    std::vector<Gyoji::owned<FunctionDefinitionArg>> arguments;
    };
    
 
    class FileStatementFunctionDeclaration : public Gyoji::frontend::ast::SyntaxNode {
    public:
    FileStatementFunctionDeclaration(
        Gyoji::owned<FileStatementFunctionDeclStart> _start,
        Gyoji::owned<Terminal> _paren_l,
        Gyoji::owned<FunctionDefinitionArgList> _arguments,
        Gyoji::owned<Terminal> _paren_r,
        Gyoji::owned<Terminal> _semicolon
        );
    ~FileStatementFunctionDeclaration();
    const AccessModifier & get_access_modifier() const;
    const UnsafeModifier & get_unsafe_modifier() const;
    const TypeSpecifier & get_return_type() const;
    const Terminal & get_name() const;
    const FunctionDefinitionArgList & get_arguments() const;
    
    private:
    Gyoji::owned<FileStatementFunctionDeclStart> start; 
    Gyoji::owned<Terminal> paren_l; // argument list delimiter PAREN_L
    Gyoji::owned<FunctionDefinitionArgList> arguments;
    Gyoji::owned<Terminal> paren_r; // argument list delimiter PAREN_R
    Gyoji::owned<Terminal> semicolon; // argument list delimiter SEMICOLON
    };
    
    class InitializerExpression : public Gyoji::frontend::ast::SyntaxNode {
    public:
    InitializerExpression(
        const Gyoji::context::SourceReference & _src_ref
        );
    InitializerExpression(
        Gyoji::owned<Terminal> _equals_token,
        Gyoji::owned<Expression> _expression
        );
    ~InitializerExpression();
    bool has_expression() const;
    const Expression & get_expression() const;
    private:
    Gyoji::owned<Terminal> equals_token;
    Gyoji::owned<Expression> expression;
    };
    
 
    class StatementVariableDeclaration : public Gyoji::frontend::ast::SyntaxNode {
    public:
    StatementVariableDeclaration(
        Gyoji::owned<TypeSpecifier> _type_specifier,
        Gyoji::owned<Terminal> _identifier_token,
        Gyoji::owned<InitializerExpression> _initializer,
        Gyoji::owned<Terminal> _semicolon_token
        );
    ~StatementVariableDeclaration();
    const TypeSpecifier & get_type_specifier() const;
    const Terminal & get_identifier() const;
    const InitializerExpression & get_initializer_expression() const;
    private:
    Gyoji::owned<TypeSpecifier> type_specifier;
    Gyoji::owned<Terminal> identifier_token;
    Gyoji::owned<ArrayLength> array_length;
    Gyoji::owned<InitializerExpression> initializer;
    Gyoji::owned<Terminal> semicolon_token;
    };
    
 
    class StatementBlock : public Gyoji::frontend::ast::SyntaxNode {
    public:
    StatementBlock(
        Gyoji::owned<UnsafeModifier> _unsafe_modifier,
        Gyoji::owned<ScopeBody> _scope_body
        );
    ~StatementBlock();
    const UnsafeModifier & get_unsafe_modifier() const;
    const ScopeBody & get_scope_body() const;
    private:
    Gyoji::owned<UnsafeModifier> unsafe_modifier;
    Gyoji::owned<ScopeBody> scope_body;
    };
    
 
    class StatementExpression : public Gyoji::frontend::ast::SyntaxNode {
    public:
    StatementExpression(
        Gyoji::owned<Expression> _expression,
        Gyoji::owned<Terminal> _semicolon_token
        );
    ~StatementExpression();
    const Expression & get_expression() const;
    private:
    Gyoji::owned<Expression> expression;
    Gyoji::owned<Terminal> semicolon_token;
    };
    
 
    class StatementIfElse : public Gyoji::frontend::ast::SyntaxNode {
    public:
    StatementIfElse(
        Gyoji::owned<Terminal> _if_token,
        Gyoji::owned<Terminal> _paren_l_token,
        Gyoji::owned<Expression> _expression,
        Gyoji::owned<Terminal> _paren_r_token,
        Gyoji::owned<ScopeBody> _if_scope_body
        );
    StatementIfElse(
        Gyoji::owned<Terminal> _if_token,
        Gyoji::owned<Terminal> _paren_l_token,
        Gyoji::owned<Expression> _expression,
        Gyoji::owned<Terminal> _paren_r_token,
        Gyoji::owned<ScopeBody> _if_scope_body,
        Gyoji::owned<Terminal> _else_token,
        Gyoji::owned<ScopeBody> _else_scope_body
        );
    StatementIfElse(
        Gyoji::owned<Terminal> _if_token,
        Gyoji::owned<Terminal> _paren_l_token,
        Gyoji::owned<Expression> _expression,
        Gyoji::owned<Terminal> _paren_r_token,
        Gyoji::owned<ScopeBody> _if_scope_body,
        Gyoji::owned<Terminal> _else_token,
        Gyoji::owned<StatementIfElse> _statement_if_else
        );
    ~StatementIfElse();
    const Expression & get_expression() const;
 
    const ScopeBody & get_if_scope_body() const;
 
    const StatementIfElse & get_else_if() const;
    const ScopeBody & get_else_scope_body() const;
    bool has_else() const;
    bool has_else_if() const;
    private:
    bool m_has_else;
    bool m_has_else_if;
    Gyoji::owned<Terminal> if_token;
    Gyoji::owned<Terminal> paren_l_token;
    Gyoji::owned<Expression> expression;
    Gyoji::owned<Terminal> paren_r_token;
    Gyoji::owned<ScopeBody> if_scope_body;
    Gyoji::owned<Terminal> else_token;
    Gyoji::owned<ScopeBody> else_scope_body;
    Gyoji::owned<StatementIfElse> else_if;
    };
    
 
    class StatementWhile : public Gyoji::frontend::ast::SyntaxNode {
    public:
    StatementWhile(
        Gyoji::owned<Terminal> _while_token,
        Gyoji::owned<Terminal> _paren_l_token,
        Gyoji::owned<Expression> _expression,
        Gyoji::owned<Terminal> _paren_r_token,
        Gyoji::owned<ScopeBody> _scope_body
        );
    ~StatementWhile();
    const Expression & get_expression() const;
    const ScopeBody & get_scope_body() const;
    private:
    Gyoji::owned<Terminal> while_token;
    Gyoji::owned<Terminal> paren_l_token;
    Gyoji::owned<Expression> expression;
    Gyoji::owned<Terminal> paren_r_token;
    Gyoji::owned<ScopeBody> scope_body;
    };
    
    class StatementFor : public Gyoji::frontend::ast::SyntaxNode {
    public:
    StatementFor(
        Gyoji::owned<Terminal> _for_token,
        Gyoji::owned<Terminal> _paren_l_token,
        Gyoji::owned<Expression> _expression_initial,
        Gyoji::owned<Terminal> _semicolon_initial,
        Gyoji::owned<Expression> _expression_termination,
        Gyoji::owned<Terminal> _semicolon_termination,
        Gyoji::owned<Expression> _expression_increment,
        Gyoji::owned<Terminal> _paren_r_token,
        Gyoji::owned<ScopeBody> _scope_body
        );
    StatementFor(
        Gyoji::owned<Terminal> _for_token,
        Gyoji::owned<Terminal> _paren_l_token,
        Gyoji::owned<TypeSpecifier> _type_specifier,
        Gyoji::owned<Terminal> _identifier_token,
        Gyoji::owned<Terminal> _assignment_token,
        Gyoji::owned<Expression> _expression_initial,
        Gyoji::owned<Terminal> _semicolon_initial,
        Gyoji::owned<Expression> _expression_termination,
        Gyoji::owned<Terminal> _semicolon_termination,
        Gyoji::owned<Expression> _expression_increment,
        Gyoji::owned<Terminal> _paren_r_token,
        Gyoji::owned<ScopeBody> _scope_body
        );
    ~StatementFor();
    bool is_declaration() const;
 
    const TypeSpecifier & get_type_specifier() const;
 
    const Terminal & get_identifier() const;
    
    const Expression & get_expression_initial() const;
    const Expression & get_expression_termination() const;
    const Expression & get_expression_increment() const;
    const ScopeBody & get_scope_body() const;
    private:
    bool is_declaration_initializer;
    Gyoji::owned<Terminal> for_token;
    Gyoji::owned<Terminal> paren_l_token;
    Gyoji::owned<TypeSpecifier> type_specifier;
    Gyoji::owned<Terminal> identifier_token;
    Gyoji::owned<Terminal> assignment_token;
    Gyoji::owned<Expression> expression_initial;
    Gyoji::owned<Terminal> semicolon_initial;
    Gyoji::owned<Expression> expression_termination;
    Gyoji::owned<Terminal> semicolon_termination;
    Gyoji::owned<Expression> expression_increment;
    Gyoji::owned<Terminal> paren_r_token;
    Gyoji::owned<ScopeBody> scope_body;
    };
    
    class StatementSwitchBlock : public Gyoji::frontend::ast::SyntaxNode {
    public:
    StatementSwitchBlock(
        Gyoji::owned<Terminal> _default_token,
        Gyoji::owned<Terminal> _colon_token,
        Gyoji::owned<ScopeBody> _scope_body
        );
    StatementSwitchBlock(
        Gyoji::owned<Terminal> _case_token,
        Gyoji::owned<Expression> _expression,
        Gyoji::owned<Terminal> _colon_token,
        Gyoji::owned<ScopeBody> _scope_body
        );
    ~StatementSwitchBlock();
    bool is_default() const;
    const Expression & get_expression();
    const ScopeBody & get_scope_body();
    private:
    bool m_is_default;
    // For the default case
    Gyoji::owned<Terminal> default_token;
    // For the expression case
    Gyoji::owned<Terminal> case_token;
    Gyoji::owned<Expression> expression;
    // Common:
    Gyoji::owned<Terminal> colon_token;
    Gyoji::owned<ScopeBody> scope_body;
    };
    
    class StatementSwitchContent : public Gyoji::frontend::ast::SyntaxNode {
    public:
    StatementSwitchContent(const Gyoji::context::SourceReference & _source_ref);
    ~StatementSwitchContent();
    const std::vector<Gyoji::owned<StatementSwitchBlock>> & get_blocks() const;
    void add_block(Gyoji::owned<StatementSwitchBlock> _block);
    private:
    std::vector<Gyoji::owned<StatementSwitchBlock>> blocks;
    };
    
    class StatementSwitch : public Gyoji::frontend::ast::SyntaxNode {
    public:
    StatementSwitch(
        Gyoji::owned<Terminal> _switch_token,
        Gyoji::owned<Terminal> _paren_l_token,
        Gyoji::owned<Expression> expression,
        Gyoji::owned<Terminal> _paren_r_token,
        Gyoji::owned<Terminal> _brace_l_token,
        Gyoji::owned<StatementSwitchContent> _switch_content,
        Gyoji::owned<Terminal> _brace_r_token
        );
    ~StatementSwitch();
    const Expression & get_expression() const;
    const StatementSwitchContent & get_switch_content() const;
    private:
    Gyoji::owned<Terminal> switch_token;
    Gyoji::owned<Terminal> paren_l_token;
    Gyoji::owned<Expression> expression;
    Gyoji::owned<Terminal> paren_r_token;
    Gyoji::owned<Terminal> brace_l_token;
    Gyoji::owned<StatementSwitchContent> switch_content;
    Gyoji::owned<Terminal> brace_r_token;
    };
    class StatementLabel : public Gyoji::frontend::ast::SyntaxNode {
    public:
    StatementLabel(
        Gyoji::owned<Terminal> _label_token,
        Gyoji::owned<Terminal> _identifier_token,
        Gyoji::owned<Terminal> _colon_token
        );
    ~StatementLabel();
    const std::string & get_name() const;
    const Gyoji::context::SourceReference & get_name_source_ref() const;
    private:
    Gyoji::owned<Terminal> label_token;
    Gyoji::owned<Terminal> identifier_token;
    Gyoji::owned<Terminal> colon_token;
    };
    class StatementGoto : public Gyoji::frontend::ast::SyntaxNode {
    public:
    StatementGoto(
        Gyoji::owned<Terminal> _goto_token,
        Gyoji::owned<Terminal> _identifier_token,
        Gyoji::owned<Terminal> _semicolon_token
        );
    ~StatementGoto();
    const std::string & get_label() const;
    const Gyoji::context::SourceReference & get_label_source_ref() const;
    private:
    Gyoji::owned<Terminal> goto_token;
    Gyoji::owned<Terminal> identifier_token;
    Gyoji::owned<Terminal> semicolon_token;
    };
    class StatementBreak : public Gyoji::frontend::ast::SyntaxNode {
    public:
    StatementBreak(
        Gyoji::owned<Terminal> _break_token,
        Gyoji::owned<Terminal> _semicolon_token
        );
    ~StatementBreak();
    private:
    Gyoji::owned<Terminal> break_token;
    Gyoji::owned<Terminal> semicolon_token;
    };
    class StatementContinue : public Gyoji::frontend::ast::SyntaxNode {
    public:
    StatementContinue(
        Gyoji::owned<Terminal> _continue_token,
        Gyoji::owned<Terminal> _semicolon_token
        );
    ~StatementContinue();
    private:
    Gyoji::owned<Terminal> continue_token;
    Gyoji::owned<Terminal> semicolon_token;
    };
    class StatementReturn : public Gyoji::frontend::ast::SyntaxNode {
    public:
    StatementReturn(
        Gyoji::owned<Terminal> _return_token,
        Gyoji::owned<Expression> _expression,
        Gyoji::owned<Terminal> _semicolon_token
        );
    StatementReturn(
        Gyoji::owned<Terminal> _return_token,
        Gyoji::owned<Terminal> _semicolon_token
        );
    ~StatementReturn();
    bool is_void() const;
    const Expression & get_expression() const;
    private:
    Gyoji::owned<Terminal> return_token;
    bool void_return;
    Gyoji::owned<Expression> expression;
    Gyoji::owned<Terminal> semicolon_token;
    };
    
    class Statement : public Gyoji::frontend::ast::SyntaxNode {
    public:
    typedef std::variant<
        Gyoji::owned<StatementVariableDeclaration>,
        Gyoji::owned<StatementBlock>,
        Gyoji::owned<StatementExpression>,
        Gyoji::owned<StatementIfElse>,
        Gyoji::owned<StatementWhile>,
        Gyoji::owned<StatementFor>,
        Gyoji::owned<StatementSwitch>,
        Gyoji::owned<StatementLabel>,
        Gyoji::owned<StatementGoto>,
        Gyoji::owned<StatementBreak>,
        Gyoji::owned<StatementContinue>,
        Gyoji::owned<StatementReturn>
    > StatementType;
    
    Statement(StatementType _statement, const SyntaxNode & _sn);
    ~Statement();
    const StatementType & get_statement() const;
    private:
    StatementType statement;
    };
    
    class StatementList : public Gyoji::frontend::ast::SyntaxNode {
    public:
    StatementList(const Gyoji::context::SourceReference & _source_ref);
    ~StatementList();
    void add_statement(Gyoji::owned<Statement> _statement);
    const std::vector<Gyoji::owned<Statement>> &get_statements() const;
    private:
    std::vector<Gyoji::owned<Statement>> statements;
    };
    
    class ScopeBody : public Gyoji::frontend::ast::SyntaxNode {
    public:
    ScopeBody(
        Gyoji::owned<Terminal> brace_l_token,
        Gyoji::owned<StatementList> statement_list,
        Gyoji::owned<Terminal> brace_r_token
        );
    ~ScopeBody();
    const StatementList & get_statements() const;
    private:
    Gyoji::owned<Terminal> brace_l_token;
    Gyoji::owned<StatementList> statement_list;
    Gyoji::owned<Terminal> brace_r_token;
    };
 
    class FileStatementFunctionDeclStart : public Gyoji::frontend::ast::SyntaxNode {
    public:
    FileStatementFunctionDeclStart(
        Gyoji::owned<AccessModifier> _access_modifier,
        Gyoji::owned<UnsafeModifier> _unsafe_modifier,
        Gyoji::owned<TypeSpecifier> _type_specifier,
        Gyoji::owned<Terminal> _name
        );
    ~FileStatementFunctionDeclStart();
 
    const AccessModifier & get_access_modifier() const;
    const UnsafeModifier & get_unsafe_modifier() const;
    const TypeSpecifier & get_type_specifier() const;
    const Terminal & get_name() const;
    private:
    Gyoji::owned<AccessModifier> access_modifier;
    Gyoji::owned<UnsafeModifier> unsafe_modifier;
    Gyoji::owned<TypeSpecifier> type_specifier;
    Gyoji::owned<Terminal> name; // function name (IDENTIFIER)
    };
    
    class FileStatementFunctionDefinition : public Gyoji::frontend::ast::SyntaxNode {
    public:
    FileStatementFunctionDefinition(
        Gyoji::owned<FileStatementFunctionDeclStart> _start,
        Gyoji::owned<Terminal> _paren_l,
        Gyoji::owned<FunctionDefinitionArgList> _arguments,
        Gyoji::owned<Terminal> _paren_r,
        Gyoji::owned<ScopeBody> _scope_body
        );
    ~FileStatementFunctionDefinition();
    const AccessModifier & get_access_modifier() const;
    const UnsafeModifier & get_unsafe_modifier() const;
    const TypeSpecifier & get_return_type() const;
    const Terminal & get_name() const;
    const FunctionDefinitionArgList & get_arguments() const;
    const ScopeBody & get_scope_body() const;
    
    private:
    Gyoji::owned<FileStatementFunctionDeclStart> start;
    Gyoji::owned<Terminal> paren_l; // argument list delimiter PAREN_L
    Gyoji::owned<FunctionDefinitionArgList> arguments;
    Gyoji::owned<Terminal> paren_r; // argument list delimiter PAREN_R
    Gyoji::owned<ScopeBody> scope_body; // argument list delimiter SEMICOLON
    };
    
    class ArrayLength : public Gyoji::frontend::ast::SyntaxNode {
    public:
    ArrayLength(const Gyoji::context::SourceReference & _source_ref);
    ArrayLength(
        Gyoji::owned<Terminal> _bracket_l_token,
        Gyoji::owned<Terminal> _literal_int_token,
        Gyoji::owned<Terminal> _bracket_r_token
        );
    ~ArrayLength();
    bool is_array() const;
    size_t get_size() const;
    const Gyoji::context::SourceReference & get_size_source_ref() const;
    private:
    Gyoji::owned<Terminal> bracket_l_token;
    Gyoji::owned<Terminal> literal_int_token;
    Gyoji::owned<Terminal> bracket_r_token;
    };
    
    class ClassDeclStart : public Gyoji::frontend::ast::SyntaxNode {
    public:
    ClassDeclStart(
        Gyoji::owned<AccessModifier> _access_modifier,
        Gyoji::owned<Terminal> _class_token,
        Gyoji::owned<Terminal> _identifier_token,
        Gyoji::owned<ClassArgumentList> _class_argument_list,
        bool is_identifier
        );
    
    ~ClassDeclStart();
    const AccessModifier & get_access_modifier() const;
    const std::string & get_name() const;
    const Gyoji::context::SourceReference & get_name_source_ref() const;
    
    const ClassArgumentList & get_argument_list() const;
    private:
    Gyoji::owned<AccessModifier> access_modifier;
    Gyoji::owned<Terminal> class_token;
    Gyoji::owned<Terminal> identifier_token;
    Gyoji::owned<ClassArgumentList> class_argument_list;
    std::string name;
    };
    class ClassArgumentList : public Gyoji::frontend::ast::SyntaxNode {
    public:
    ClassArgumentList(const Gyoji::context::SourceReference & _source_ref);
    ClassArgumentList(Gyoji::owned<Terminal> _argument);
    ~ClassArgumentList();
    void add_argument(Gyoji::owned<Terminal> _comma, Gyoji::owned<Terminal> _argument);
    void add_parens(Gyoji::owned<Terminal> _paren_l, Gyoji::owned<Terminal> _paren_r);
    const std::vector<Gyoji::owned<Terminal>> & get_arguments() const;
    private:
    Gyoji::owned<Terminal> paren_l;
    std::vector<Gyoji::owned<Terminal>> comma_list;
    std::vector<Gyoji::owned<Terminal>> argument_list;
    Gyoji::owned<Terminal> paren_r;
    };
    
    class ClassMemberDeclarationVariable : public Gyoji::frontend::ast::SyntaxNode {
    public:
    ClassMemberDeclarationVariable(
        Gyoji::owned<AccessModifier> _access_modifier,
        Gyoji::owned<TypeSpecifier> _type_specifier,
        Gyoji::owned<Terminal> _identifier_token,
        Gyoji::owned<Terminal> _semicolon_token
        );
    ~ClassMemberDeclarationVariable();
    const AccessModifier & get_access_modifier() const;
    const TypeSpecifier & get_type_specifier() const;
    const std::string & get_name() const;
    const Gyoji::context::SourceReference & get_name_source_ref() const;
    private:
    Gyoji::owned<AccessModifier> access_modifier;
    Gyoji::owned<TypeSpecifier> type_specifier;
    Gyoji::owned<Terminal> identifier_token;
    Gyoji::owned<Terminal> semicolon_token;
    };    
    class ClassMemberDeclarationMethod : public Gyoji::frontend::ast::SyntaxNode {
    public:
    ClassMemberDeclarationMethod(
        Gyoji::owned<AccessModifier> _access_modifier,
        Gyoji::owned<TypeSpecifier> _type_specifier,
        Gyoji::owned<Terminal> _identifier_token,
        Gyoji::owned<Terminal> _paren_l_token,
        Gyoji::owned<FunctionDefinitionArgList> _function_definition_arg_list,
        Gyoji::owned<Terminal> _paren_r_token,
        Gyoji::owned<Terminal> _semicolon_token
        );
    ~ClassMemberDeclarationMethod();
    const AccessModifier & get_access_modifier() const;
    const TypeSpecifier & get_type_specifier() const;
    const Terminal & get_identifier() const;
    const FunctionDefinitionArgList & get_arguments() const;
    private:
    Gyoji::owned<AccessModifier> access_modifier;
    Gyoji::owned<TypeSpecifier> type_specifier;
    Gyoji::owned<Terminal> identifier_token;
    Gyoji::owned<Terminal> paren_l_token;
    Gyoji::owned<FunctionDefinitionArgList> function_definition_arg_list;
    Gyoji::owned<Terminal> paren_r_token;
    Gyoji::owned<Terminal> semicolon_token;
    };
    class ClassMemberDeclarationConstructor : public Gyoji::frontend::ast::SyntaxNode {
    public:
    ClassMemberDeclarationConstructor(
        Gyoji::owned<AccessModifier> _access_modifier,
        Gyoji::owned<TypeSpecifier> _type_specifier,
        Gyoji::owned<Terminal> _paren_l_token,
        Gyoji::owned<FunctionDefinitionArgList> _function_definition_arg_list,
        Gyoji::owned<Terminal> _paren_r_token,
        Gyoji::owned<Terminal> _semicolon_token
        );
    ~ClassMemberDeclarationConstructor();
    const AccessModifier & get_access_modifier() const;
    const TypeSpecifier & get_type_specifier() const;
    const FunctionDefinitionArgList & get_arguments() const;
    private:
    Gyoji::owned<AccessModifier> access_modifier;
    Gyoji::owned<TypeSpecifier> type_specifier;
    Gyoji::owned<Terminal> paren_l_token;
    Gyoji::owned<FunctionDefinitionArgList> function_definition_arg_list;
    Gyoji::owned<Terminal> paren_r_token;
    Gyoji::owned<Terminal> semicolon_token;
    };
    class ClassMemberDeclarationDestructor : public Gyoji::frontend::ast::SyntaxNode {
    public:
    ClassMemberDeclarationDestructor(
        Gyoji::owned<AccessModifier> _access_modifier,
        Gyoji::owned<Terminal> _tilde_token,
        Gyoji::owned<TypeSpecifier> _type_specifier,
        Gyoji::owned<Terminal> _paren_l_token,
        Gyoji::owned<FunctionDefinitionArgList> _function_definition_arg_list,
        Gyoji::owned<Terminal> _paren_r_token,
        Gyoji::owned<Terminal> _semicolon_token
        );
    ~ClassMemberDeclarationDestructor();
    const AccessModifier & get_access_modifier() const;
    const TypeSpecifier & get_type_specifier() const;
    const FunctionDefinitionArgList & get_arguments() const;
    private:
    Gyoji::owned<AccessModifier> access_modifier;
    Gyoji::owned<Terminal> tilde_token;
    Gyoji::owned<TypeSpecifier> type_specifier;
    Gyoji::owned<Terminal> paren_l_token;
    Gyoji::owned<FunctionDefinitionArgList> function_definition_arg_list;
    Gyoji::owned<Terminal> paren_r_token;
    Gyoji::owned<Terminal> semicolon_token;
    };
    
    class ClassMemberDeclaration : public Gyoji::frontend::ast::SyntaxNode {
    public:
    typedef std::variant<
        Gyoji::owned<ClassMemberDeclarationVariable>,
        Gyoji::owned<ClassMemberDeclarationMethod>,
        Gyoji::owned<ClassMemberDeclarationConstructor>,
        Gyoji::owned<ClassMemberDeclarationDestructor>,
        Gyoji::owned<ClassDeclaration>,
        Gyoji::owned<ClassDefinition>,
        Gyoji::owned<EnumDefinition>,
        Gyoji::owned<TypeDefinition>
    > MemberType;
    ClassMemberDeclaration(
        MemberType _member,
        const Gyoji::frontend::ast::SyntaxNode & _sn
        );
    ~ClassMemberDeclaration();
    const ClassMemberDeclaration::MemberType & get_member();
    private:
    MemberType member;
    };
    
    class ClassMemberDeclarationList : public Gyoji::frontend::ast::SyntaxNode {
    public:
    ClassMemberDeclarationList(const Gyoji::context::SourceReference & _source_ref);
    ~ClassMemberDeclarationList();
    const std::vector<Gyoji::owned<ClassMemberDeclaration>> & get_members() const;
    void add_member(Gyoji::owned<ClassMemberDeclaration> _member);
    private:
    std::vector<Gyoji::owned<ClassMemberDeclaration>> members;
    };
    
    class ClassDeclaration : public Gyoji::frontend::ast::SyntaxNode {
    public:
    ClassDeclaration(
        Gyoji::owned<ClassDeclStart> _class_decl_start,
        Gyoji::owned<Terminal> _semicolon_token
        );
    ~ClassDeclaration();
    const AccessModifier & get_access_modifier() const;
    
    const std::string & get_name() const;
    const Gyoji::context::SourceReference & get_name_source_ref() const;
    
    const ClassArgumentList & get_argument_list() const;
    private:
    Gyoji::owned<ClassDeclStart> class_decl_start;
    Gyoji::owned<Terminal> semicolon_token;
    };
    
    class ClassDefinition : public Gyoji::frontend::ast::SyntaxNode {
    public:
    ClassDefinition(
        Gyoji::owned<ClassDeclStart> _class_decl_start,
        Gyoji::owned<Terminal> _brace_l_token,
        Gyoji::owned<ClassMemberDeclarationList> _class_member_declaration_list,
        Gyoji::owned<Terminal> _brace_r_token,
        Gyoji::owned<Terminal> _semicolon_token
        );
    ~ClassDefinition();
    const AccessModifier & get_access_modifier() const;
    const std::string & get_name() const;
    const Gyoji::context::SourceReference & get_name_source_ref() const;
    const ClassArgumentList & get_argument_list() const;
    const std::vector<Gyoji::owned<ClassMemberDeclaration>> & get_members() const;
    private:
    Gyoji::owned<ClassDeclStart> class_decl_start;
    Gyoji::owned<Terminal> brace_l_token;
    Gyoji::owned<ClassMemberDeclarationList> class_member_declaration_list;
    Gyoji::owned<Terminal> brace_r_token;
    Gyoji::owned<Terminal> semicolon_token;
    };
    
    class TypeDefinition : public Gyoji::frontend::ast::SyntaxNode {
    public:
    TypeDefinition(
        Gyoji::owned<AccessModifier> _access_modifier,
        Gyoji::owned<Terminal> _typedef_token,
        Gyoji::owned<TypeSpecifier> _type_specifier,
        Gyoji::owned<Terminal> _identifier_token,
        Gyoji::owned<Terminal> _semicolon_token
        );
    ~TypeDefinition();
    const AccessModifier & get_access_modifier() const;
    const std::string & get_name() const;
    const Gyoji::context::SourceReference & get_name_source_ref() const;
    const TypeSpecifier & get_type_specifier() const;
    private:
    Gyoji::owned<AccessModifier> access_modifier;
    Gyoji::owned<Terminal> typedef_token;
    Gyoji::owned<TypeSpecifier> type_specifier;
    Gyoji::owned<Terminal> identifier_token;
    Gyoji::owned<Terminal> semicolon_token;
    };
    
    class EnumDefinitionValue : public Gyoji::frontend::ast::SyntaxNode {
    public:
    EnumDefinitionValue(
        Gyoji::owned<Terminal> _identifier_token,
        Gyoji::owned<Terminal> _equals_token,
        Gyoji::owned<Expression> _expression_primary,
        Gyoji::owned<Terminal> _semicolon_token
        );                          
    ~EnumDefinitionValue();
    const std::string & get_name() const;
    const Gyoji::context::SourceReference & get_name_source_ref() const;
    const Expression & get_expression() const;
    private:
    Gyoji::owned<Terminal> identifier_token;
    Gyoji::owned<Terminal> equals_token;
    Gyoji::owned<Expression> expression_primary;
    Gyoji::owned<Terminal> semicolon_token;      
    };
    
    class EnumDefinitionValueList : public Gyoji::frontend::ast::SyntaxNode {
    public:
    EnumDefinitionValueList(const Gyoji::context::SourceReference & _source_ref);
    ~EnumDefinitionValueList();
    void add_value(Gyoji::owned<EnumDefinitionValue>);
    const std::vector<Gyoji::owned<EnumDefinitionValue>> &get_values() const;
    private:
    std::vector<Gyoji::owned<EnumDefinitionValue>> values;
    };
    
    class EnumDefinition : public Gyoji::frontend::ast::SyntaxNode {
    public:
    EnumDefinition(
        Gyoji::owned<AccessModifier> _access_modifier,
        Gyoji::owned<Terminal> _enum_token,
        Gyoji::owned<Terminal> _type_name_token,
        Gyoji::owned<Terminal> _identifier_token,
        Gyoji::owned<Terminal> _brace_l_token,
        Gyoji::owned<EnumDefinitionValueList> _enum_value_list,
        Gyoji::owned<Terminal> _brace_r_token,
        Gyoji::owned<Terminal> _semicolon_token
        );
    ~EnumDefinition();
    const AccessModifier & get_access_modifier() const;
    const std::string & get_type_name() const;
    const Gyoji::context::SourceReference & get_type_name_source_ref() const;
    
    const std::string & get_name() const;
    const Gyoji::context::SourceReference & get_name_source_ref() const;
    
    const EnumDefinitionValueList & get_value_list() const;
    private:
    Gyoji::owned<AccessModifier> access_modifier;
    Gyoji::owned<Terminal> enum_token;
    Gyoji::owned<Terminal> type_name_token;
    Gyoji::owned<Terminal> identifier_token;
    Gyoji::owned<Terminal> brace_l_token;
    Gyoji::owned<EnumDefinitionValueList> enum_value_list;
    Gyoji::owned<Terminal> brace_r_token;
    Gyoji::owned<Terminal> semicolon_token;
    
    };
    
    class ExpressionPrimaryIdentifier : public Gyoji::frontend::ast::SyntaxNode {
    public:
    ExpressionPrimaryIdentifier(Gyoji::owned<Terminal> _identifier_token);
    ~ExpressionPrimaryIdentifier();
    const Terminal & get_identifier() const;
    private:
    Gyoji::owned<Terminal> identifier_token;
    };
    class ExpressionPrimaryNested : public Gyoji::frontend::ast::SyntaxNode {
    public:
    ExpressionPrimaryNested(
        Gyoji::owned<Terminal> _paren_l_token,
        Gyoji::owned<Expression> _expression,
        Gyoji::owned<Terminal> _paren_r_token
        );
    ~ExpressionPrimaryNested();
    const Expression & get_expression() const;
    private:
    Gyoji::owned<Terminal> paren_l_token;
    Gyoji::owned<Expression> expression;
    Gyoji::owned<Terminal> paren_r_token;
    };
    
    class ExpressionPrimaryLiteralInt : public Gyoji::frontend::ast::SyntaxNode {
    public:
    ExpressionPrimaryLiteralInt(
        Gyoji::owned<Terminal> literal_token
        );
    ~ExpressionPrimaryLiteralInt();
    const std::string & get_value() const;
    const Terminal & get_literal_int_token() const;
    const Gyoji::context::SourceReference & get_value_source_ref() const;
    private:
    Gyoji::owned<Terminal> literal_token;
    };
    class ExpressionPrimaryLiteralChar : public Gyoji::frontend::ast::SyntaxNode {
    public:
    ExpressionPrimaryLiteralChar(
        Gyoji::owned<Terminal> _literal_token
        );
    ~ExpressionPrimaryLiteralChar();
    std::string get_value() const;
    const Gyoji::context::SourceReference & get_value_source_ref() const;
    private:
    Gyoji::owned<Terminal> literal_token;
    };
    class ExpressionPrimaryLiteralString : public Gyoji::frontend::ast::SyntaxNode {
    public:
    ExpressionPrimaryLiteralString(
        Gyoji::owned<Terminal> _literal_token
        );
    ~ExpressionPrimaryLiteralString();
    std::string get_value() const;
    const Gyoji::context::SourceReference & get_value_source_ref() const;
    void add_string(Gyoji::owned<Terminal> _added);
    private:
    Gyoji::owned<Terminal> literal_token;
    std::vector<Gyoji::owned<Terminal>> additional_strings;
    };
    class ExpressionPrimaryLiteralFloat : public Gyoji::frontend::ast::SyntaxNode {
    public:
    ExpressionPrimaryLiteralFloat(
        Gyoji::owned<Terminal> _literal_token
        );
    ~ExpressionPrimaryLiteralFloat();
    
    const std::string & get_value() const;
    const std::string & get_type() const;
    const Gyoji::context::SourceReference & get_value_source_ref() const;
    private:
    Gyoji::owned<Terminal> literal_token;
    std::string float_part;
    std::string type_part;
    };
 
    class ExpressionPrimaryLiteralBool : public Gyoji::frontend::ast::SyntaxNode {
    public:
    ExpressionPrimaryLiteralBool(
        Gyoji::owned<Terminal> _literal_token
        );
    ~ExpressionPrimaryLiteralBool();
    
    bool get_value() const;
    private:
    Gyoji::owned<Terminal> literal_token;
    bool value;
    };
    class ExpressionPrimaryLiteralNull : public Gyoji::frontend::ast::SyntaxNode {
    public:
    ExpressionPrimaryLiteralNull(
        Gyoji::owned<Terminal> _literal_token
        );
    ~ExpressionPrimaryLiteralNull();
    private:
    Gyoji::owned<Terminal> literal_token;
    };
 
    class ExpressionPostfixArrayIndex : public Gyoji::frontend::ast::SyntaxNode {
    public:
    ExpressionPostfixArrayIndex(
        Gyoji::owned<Expression> _array_expression,
        Gyoji::owned<Terminal> _bracket_l_token,
        Gyoji::owned<Expression> _index_expression,
        Gyoji::owned<Terminal> _bracket_r_token
        );
    ~ExpressionPostfixArrayIndex();
    const Expression & get_array() const;
    const Expression & get_index() const;
    private:
    Gyoji::owned<Expression> array_expression;
    Gyoji::owned<Terminal> bracket_l_token;
    Gyoji::owned<Expression> index_expression;
    Gyoji::owned<Terminal> bracket_r_token;
    };
    
    class ArgumentExpressionList : public Gyoji::frontend::ast::SyntaxNode {
    public:
    ArgumentExpressionList(const Gyoji::context::SourceReference & _source_ref);
    ~ArgumentExpressionList();
    const std::vector<Gyoji::owned<Expression>> & get_arguments() const;
    void add_argument(Gyoji::owned<Expression> _argument);
    void add_argument(Gyoji::owned<Terminal> _comma_token, Gyoji::owned<Expression> _argument);
    private:
    std::vector<Gyoji::owned<Terminal>> comma_list;
    std::vector<Gyoji::owned<Expression>> arguments;
    };
    
    class ExpressionPostfixFunctionCall : public Gyoji::frontend::ast::SyntaxNode {
    public:
    ExpressionPostfixFunctionCall(
        Gyoji::owned<Expression> _function_expression,
        Gyoji::owned<Terminal> _paren_l_token,
        Gyoji::owned<ArgumentExpressionList> _arguments,
        Gyoji::owned<Terminal> _paren_r_token
        );
    ~ExpressionPostfixFunctionCall();
    const Expression & get_function() const;
    const ArgumentExpressionList & get_arguments() const;
    private:
    Gyoji::owned<Expression> function_expression;
    Gyoji::owned<Terminal> paren_l_token;
    Gyoji::owned<ArgumentExpressionList> arguments;
    Gyoji::owned<Terminal> paren_r_token;
    };
    
    class ExpressionPostfixDot : public Gyoji::frontend::ast::SyntaxNode {
    public:
    ExpressionPostfixDot(
        Gyoji::owned<Expression> _expression,
        Gyoji::owned<Terminal> _dot_token,
        Gyoji::owned<Terminal> _identifier_token
        );
    ~ExpressionPostfixDot();
    const Expression & get_expression() const;
    const Terminal & get_identifier() const;
    private:
    Gyoji::owned<Expression> expression;
    Gyoji::owned<Terminal> dot_token;
    Gyoji::owned<Terminal> identifier_token;
    };
    
    class ExpressionPostfixArrow : public Gyoji::frontend::ast::SyntaxNode {
    public:
    ExpressionPostfixArrow(
        Gyoji::owned<Expression> _expression,
        Gyoji::owned<Terminal> _arrow_token,
        Gyoji::owned<Terminal> _identifier_token
        );
    ~ExpressionPostfixArrow();
    const Expression & get_expression() const;
    const Terminal & get_identifier() const;
    private:
    Gyoji::owned<Expression> expression;
    Gyoji::owned<Terminal> arrow_token;
    Gyoji::owned<Terminal> identifier_token;
    };
    
    class ExpressionPostfixIncDec : public Gyoji::frontend::ast::SyntaxNode {
    public:
    typedef enum {
        INCREMENT,
        DECREMENT
    } OperationType;
    ExpressionPostfixIncDec(
        Gyoji::owned<Expression> _expression,
        Gyoji::owned<Terminal> _operator_token,
        ExpressionPostfixIncDec::OperationType _type                              
        );
    ~ExpressionPostfixIncDec();
    const ExpressionPostfixIncDec::OperationType & get_type() const;
    const Expression & get_expression() const;
    private:
    ExpressionPostfixIncDec::OperationType type;
    Gyoji::owned<Terminal> operator_token;
    Gyoji::owned<Expression> expression;
    };
    
    class ExpressionUnaryPrefix : public Gyoji::frontend::ast::SyntaxNode {
    public:
    typedef enum {
        INCREMENT,
        DECREMENT,
        ADDRESSOF,
        DEREFERENCE,
        PLUS,
        MINUS,
        BITWISE_NOT,
        LOGICAL_NOT
    } OperationType;
    ExpressionUnaryPrefix(
        Gyoji::owned<Terminal> _operator_token,
        Gyoji::owned<Expression> _expression,
        ExpressionUnaryPrefix::OperationType _type
        );
    ~ExpressionUnaryPrefix();
    const ExpressionUnaryPrefix::OperationType & get_type() const;
    const Gyoji::context::SourceReference & get_operator_source_ref() const;
    const Expression & get_expression() const;
    private:
    ExpressionUnaryPrefix::OperationType type;
    Gyoji::owned<Terminal> operator_token;
    Gyoji::owned<Expression> expression;
    };
    
    class ExpressionUnarySizeofType : public Gyoji::frontend::ast::SyntaxNode {
    public:
    ExpressionUnarySizeofType(
        Gyoji::owned<Terminal> _sizeof_token,
        Gyoji::owned<Terminal> _paren_l_token,
        Gyoji::owned<TypeSpecifier> _type_specifier,
        Gyoji::owned<Terminal> _paren_r_token
        );
    ~ExpressionUnarySizeofType();
    const TypeSpecifier & get_type_specifier() const;
    private:
    Gyoji::owned<Terminal> sizeof_token;
    Gyoji::owned<Terminal> paren_l_token;
    Gyoji::owned<TypeSpecifier> type_specifier;
    Gyoji::owned<Terminal> paren_r_token;
    };
    
    class ExpressionCast : public Gyoji::frontend::ast::SyntaxNode {
    public:
    ExpressionCast(
        Gyoji::owned<Terminal> _cast_token,
        Gyoji::owned<Terminal> _paren_l_token,
        Gyoji::owned<TypeSpecifier> _type_specifier,
        Gyoji::owned<Terminal> _comma_token,
        Gyoji::owned<Expression> _expression,
        Gyoji::owned<Terminal> _paren_r_token
        );
    ~ExpressionCast();
    const TypeSpecifier & get_type() const;
    const Expression & get_expression() const;
    private:
    Gyoji::owned<Terminal> cast_token;
    Gyoji::owned<Terminal> paren_l_token;
    Gyoji::owned<TypeSpecifier> type_specifier;
    Gyoji::owned<Terminal> comma_token;
    Gyoji::owned<Expression> expression;
    Gyoji::owned<Terminal> paren_r_token;
    };
    
    class ExpressionBinary : public Gyoji::frontend::ast::SyntaxNode {
    public:
    typedef enum {
        // Arithmetic
        ADD,
        SUBTRACT,
        MULTIPLY,
        DIVIDE,
        MODULO,
        // Logical
        LOGICAL_AND,
        LOGICAL_OR,
        
        // Bitwise
        BITWISE_AND,
        BITWISE_OR,
        BITWISE_XOR,
        SHIFT_LEFT,
        SHIFT_RIGHT,
        
        // Relational
        COMPARE_LESS,
        COMPARE_GREATER,
        COMPARE_LESS_EQUAL,
        COMPARE_GREATER_EQUAL,
        COMPARE_EQUAL,
        COMPARE_NOT_EQUAL,
        
        // Assignment
        ASSIGNMENT,
        MUL_ASSIGNMENT,
        DIV_ASSIGNMENT,
        MOD_ASSIGNMENT,
        ADD_ASSIGNMENT,
        SUB_ASSIGNMENT,
        LEFT_ASSIGNMENT,
        RIGHT_ASSIGNMENT,
        AND_ASSIGNMENT,
        XOR_ASSIGNMENT,
        OR_ASSIGNMENT
    } OperationType;
    ExpressionBinary(
        Gyoji::owned<Expression> _expression_a,
        Gyoji::owned<Terminal> _operator_token,
        Gyoji::owned<Expression> _expression_b,
        ExpressionBinary::OperationType _type
        );
    ExpressionBinary(
        Gyoji::owned<Expression> _expression_a,
        Gyoji::owned<Terminal> _operator_token,
        Gyoji::owned<Terminal> _operator_token2,
        Gyoji::owned<Expression> _expression_b,
        ExpressionBinary::OperationType _type
        );
    ~ExpressionBinary();
    const Expression & get_a() const;
    const ExpressionBinary::OperationType & get_operator() const;
    const Gyoji::context::SourceReference & get_operator_source_ref() const;
    const Expression & get_b() const;
    
    private:
    OperationType type;
    Gyoji::owned<Expression> expression_a;
    Gyoji::owned<Terminal> operator_token;
    Gyoji::owned<Terminal> operator_token2;
    Gyoji::owned<Expression> expression_b;
    };
    
    class ExpressionTrinary : public Gyoji::frontend::ast::SyntaxNode {
    public:
    ExpressionTrinary(
        Gyoji::owned<Expression> _condition,
        Gyoji::owned<Terminal> _questionmark_token,
        Gyoji::owned<Expression> _if_expression,
        Gyoji::owned<Terminal> _colon_token,
        Gyoji::owned<Expression> _else_expression
        );
    ~ExpressionTrinary();
    const Expression & get_condition() const;
    const Expression & get_if() const;
    const Expression & get_else() const;
    private:
    Gyoji::owned<Expression> condition;
    Gyoji::owned<Terminal> questionmark_token;
    Gyoji::owned<Expression> if_expression;
    Gyoji::owned<Terminal> colon_token;
    Gyoji::owned<Expression> else_expression;      
    };
    
    class Expression : public Gyoji::frontend::ast::SyntaxNode {
    public:
    typedef std::variant<
                 Gyoji::owned<ExpressionPrimaryIdentifier>,
                 Gyoji::owned<ExpressionPrimaryNested>,
                 Gyoji::owned<ExpressionPrimaryLiteralChar>,
                 Gyoji::owned<ExpressionPrimaryLiteralString>,
                 Gyoji::owned<ExpressionPrimaryLiteralInt>,
                 Gyoji::owned<ExpressionPrimaryLiteralFloat>,
                 Gyoji::owned<ExpressionPrimaryLiteralBool>,
                 Gyoji::owned<ExpressionPrimaryLiteralNull>,
                 Gyoji::owned<ExpressionPostfixArrayIndex>,
                 Gyoji::owned<ExpressionPostfixFunctionCall>,
                 Gyoji::owned<ExpressionPostfixDot>,
                 Gyoji::owned<ExpressionPostfixArrow>,
                 Gyoji::owned<ExpressionPostfixIncDec>,
                 Gyoji::owned<ExpressionUnaryPrefix>,
                 Gyoji::owned<ExpressionUnarySizeofType>,
                 Gyoji::owned<ExpressionBinary>,
                 Gyoji::owned<ExpressionTrinary>,
                 Gyoji::owned<ExpressionCast>
                 > ExpressionType;
    Expression(Expression::ExpressionType _expression_type, const SyntaxNode & _sn);
    ~Expression();
    const Expression::ExpressionType & get_expression() const;
    private:
    Expression::ExpressionType expression_type;
    };
    
    class GlobalInitializerExpressionPrimary : public Gyoji::frontend::ast::SyntaxNode {
    public:
    GlobalInitializerExpressionPrimary(
        Gyoji::owned<Terminal> _equals_token,
        Gyoji::owned<Expression> _expression
        );
    ~GlobalInitializerExpressionPrimary();
    const Expression & get_expression() const;
    private:
    Gyoji::owned<Terminal> equals_token;
    Gyoji::owned<Expression> expression;
    
    };
    class GlobalInitializerAddressofExpressionPrimary : public Gyoji::frontend::ast::SyntaxNode {
    public:
    GlobalInitializerAddressofExpressionPrimary(
        Gyoji::owned<Terminal> _equals_token,
        Gyoji::owned<Terminal> _addressof_token,
        Gyoji::owned<Expression> _expression
        );
    ~GlobalInitializerAddressofExpressionPrimary();
    const Expression & get_expression() const;
    private:
    Gyoji::owned<Terminal> equals_token;
    Gyoji::owned<Terminal> addressof_token;
    Gyoji::owned<Expression> expression;
    };
    
    class StructInitializer : public Gyoji::frontend::ast::SyntaxNode {
    public:
    StructInitializer(
        Gyoji::owned<Terminal> _dot_token,
        Gyoji::owned<Terminal> _identifier_token,
        Gyoji::owned<GlobalInitializer> _global_initializer,
        Gyoji::owned<Terminal> _semicolon_token
        );
    ~StructInitializer();
    const GlobalInitializer & get_initializer() const;
    private:
    Gyoji::owned<Terminal> dot_token;
    Gyoji::owned<Terminal> identifier_token;
    Gyoji::owned<GlobalInitializer> global_initializer;
    Gyoji::owned<Terminal> semicolon_token;
    };
    
    class StructInitializerList : public Gyoji::frontend::ast::SyntaxNode {
    public:
    StructInitializerList(const Gyoji::context::SourceReference & _source_ref);
    ~StructInitializerList();
    void add_initializer(Gyoji::owned<StructInitializer> initializer);
    const std::vector<Gyoji::owned<StructInitializer>> & get_initializers() const;
    private:
    std::vector<Gyoji::owned<StructInitializer>> initializers;
    };
    
    class GlobalInitializerStructInitializerList : public Gyoji::frontend::ast::SyntaxNode {
    public:
    GlobalInitializerStructInitializerList(
        Gyoji::owned<Terminal> _equals_token,
        Gyoji::owned<Terminal> _brace_l_token,
        Gyoji::owned<StructInitializerList> _struct_initializer,
        Gyoji::owned<Terminal> _brace_r_token
        );
    
    ~GlobalInitializerStructInitializerList();
    const StructInitializerList & get_struct_initializer() const;
    private:
    Gyoji::owned<Terminal> equals_token;
    Gyoji::owned<Terminal> brace_l_token;
    Gyoji::owned<StructInitializerList> struct_initializer;
    Gyoji::owned<Terminal> brace_r_token;
    };
    
    class GlobalInitializer : public Gyoji::frontend::ast::SyntaxNode {
    public:
    typedef std::variant<
        Gyoji::owned<GlobalInitializerExpressionPrimary>,
        Gyoji::owned<GlobalInitializerAddressofExpressionPrimary>,
        Gyoji::owned<GlobalInitializerStructInitializerList>,
        nullptr_t> GlobalInitializerType;
    GlobalInitializer(const Gyoji::context::SourceReference & _source_ref);
    GlobalInitializer(GlobalInitializerType initializer, const Gyoji::frontend::ast::SyntaxNode & _sn);
    ~GlobalInitializer();
    const GlobalInitializerType & get_initializer() const;
    private:
    GlobalInitializerType initializer;
    };
    
    class FileStatementGlobalDefinition : public Gyoji::frontend::ast::SyntaxNode {
    public:
    FileStatementGlobalDefinition(
        Gyoji::owned<AccessModifier> _access_modifier,
        Gyoji::owned<UnsafeModifier> _unsafe_modifier,
        Gyoji::owned<TypeSpecifier> _type_specifier,
        Gyoji::owned<Terminal> _name,
        Gyoji::owned<GlobalInitializer> _global_initializer,
        Gyoji::owned<Terminal> _semicolon
        );
    ~FileStatementGlobalDefinition();
    const AccessModifier & get_access_modifier() const;
    const UnsafeModifier & get_unsafe_modifier() const;
    const TypeSpecifier & get_type_specifier() const;
    const std::string & get_name() const;
    const Gyoji::context::SourceReference & get_name_source_ref() const;
    const GlobalInitializer & get_global_initializer() const;
    private:
    Gyoji::owned<AccessModifier> access_modifier;
    Gyoji::owned<UnsafeModifier> unsafe_modifier;
    Gyoji::owned<TypeSpecifier> type_specifier;
    Gyoji::owned<Terminal> name; // function name (IDENTIFIER)
    Gyoji::owned<GlobalInitializer> global_initializer;
    Gyoji::owned<Terminal> semicolon;
    };
    
    class NamespaceDeclaration : public Gyoji::frontend::ast::SyntaxNode {
    public:
    NamespaceDeclaration(
        Gyoji::owned<AccessModifier> _access_modifier,
        Gyoji::owned<Terminal> _namespace_token,
        Gyoji::owned<Terminal> _identifier_token
        );
    ~NamespaceDeclaration();
    const AccessModifier & get_access_modifier() const;
    const Terminal & get_name() const;
    private:
    Gyoji::owned<AccessModifier> access_modifier;
    Gyoji::owned<Terminal> namespace_token;
    Gyoji::owned<Terminal> identifier_token;
    };
    
    class FileStatementNamespace : public Gyoji::frontend::ast::SyntaxNode {
    public:
    FileStatementNamespace(
        Gyoji::owned<NamespaceDeclaration> _namespace_declaration,
        Gyoji::owned<Terminal> _brace_l_token,
        Gyoji::owned<FileStatementList> _file_statement_list,
        Gyoji::owned<Terminal> _brace_r_token,
        Gyoji::owned<Terminal> _semicolon_token
        );
    ~FileStatementNamespace();
    const NamespaceDeclaration & get_declaration() const;
    const FileStatementList & get_statement_list() const;
    private:
    Gyoji::owned<NamespaceDeclaration> namespace_declaration;
    Gyoji::owned<Terminal> brace_l_token;
    Gyoji::owned<FileStatementList> file_statement_list;
    Gyoji::owned<Terminal> brace_r_token;
    Gyoji::owned<Terminal> semicolon_token;
    };
    
    class UsingAs : public Gyoji::frontend::ast::SyntaxNode {
    public:
    UsingAs(
        Gyoji::owned<Terminal> _as_token,
        Gyoji::owned<Terminal> _identifier_token
        );
    UsingAs(const Gyoji::context::SourceReference & _source_ref);
    ~UsingAs();
    bool is_as() const;
    const std::string & get_using_name() const;
    const Gyoji::context::SourceReference & get_using_name_source_ref() const;
    private:
    bool aas;
    std::string using_name;
    Gyoji::owned<Terminal> as_token;
    Gyoji::owned<Terminal> identifier_token;
    };
    
    class FileStatementUsing : public Gyoji::frontend::ast::SyntaxNode {
    public:
    FileStatementUsing(
        Gyoji::owned<AccessModifier> _access_modifier,
        Gyoji::owned<Terminal> _using,
        Gyoji::owned<Terminal> _namespace,
        Gyoji::owned<Terminal> _namespace_name,
        Gyoji::owned<UsingAs> _using_as,
        Gyoji::owned<Terminal> _semicolon);
    ~FileStatementUsing();
    private:
    const AccessModifier & get_access_modifier() const;
    std::string get_namespace() const;
    const Gyoji::context::SourceReference & get_namespace_source_ref() const;
    const UsingAs &get_using_as() const;
    
    Gyoji::owned<AccessModifier> access_modifier;
    Gyoji::owned<Terminal> using_token;
    Gyoji::owned<Terminal> namespace_token;
    Gyoji::owned<Terminal> namespace_name_token;
    Gyoji::owned<UsingAs> using_as;
    Gyoji::owned<Terminal> semicolon_token;
    };
    
    class FileStatementList : public Gyoji::frontend::ast::SyntaxNode {
    public:
    FileStatementList(const Gyoji::context::SourceReference & _source_ref);
    FileStatementList(Gyoji::owned<Terminal> _yyeof);
    ~FileStatementList();
    const std::vector<Gyoji::owned<FileStatement>> & get_statements() const;
    void add_statement(Gyoji::owned<FileStatement> statement);
    private:
    Gyoji::owned<Terminal> yyeof;
    std::vector<Gyoji::owned<FileStatement>> statements;
    };
    
 
    class TranslationUnit : public Gyoji::frontend::ast::SyntaxNode {
    public:
    TranslationUnit(
        Gyoji::owned<FileStatementList> file_statement_list,
        Gyoji::owned<Terminal> yyeof_token
        );
    ~TranslationUnit();
    const std::vector<Gyoji::owned<FileStatement>> & get_statements() const;
    private:
    Gyoji::owned<FileStatementList> file_statement_list;
    Gyoji::owned<Terminal> yyeof_token;
    
    };
    
};