ast.hpp

Go to the documentation of this file.

#include <cstdint>
#pragma clang diagnostic push
#pragma ide diagnostic ignored "modernize-use-nodiscard"
#pragma ide diagnostic ignored "google-explicit-constructor"
//
// Created by XIaokang00010 on 2023/1/24.
//
#ifndef HOSHI_LANG_AST_HPP
#define HOSHI_LANG_AST_HPP
 
#include "lexer.hpp"
#include <share/def.hpp>
 
namespace yoi {
    class AST {
        lexer::token token;
 
      public:
        AST();
 
        AST(lexer::token token); 
 
        std::tuple<yoi::indexT, yoi::indexT> getLocation();
 
        yoi::indexT getLine();
 
        yoi::indexT getColumn();
 
        yoi::lexer::token &getToken();
    };
 
    class hoshiModule;
 
    class innerMethodDef;
 
    class constructorDef;
 
    class innerMethodDecl;
 
    class constructorDecl;
 
    class subscript;
 
    class basicLiterals;
 
    class identifier;
 
    class identifierWithTypeSpec;
 
    class defTemplateArgSpec;
 
    class defTemplateArg;
 
    class templateArgSpec;
 
    class templateArg;
 
    class invocationArguments;
 
    class definitionArguments;
 
    class funcTypeSpec;
 
    class typeSpec;
 
    class subscript;
 
    class identifierWithTemplateArg;
 
    class identifierWithDefTemplateArg;
 
    class subscriptExpr;
 
    class memberExpr;
 
    class decltypeExpr;
 
    class primary;
 
    class uniqueExpr;
 
    class mulExpr;
 
    class addExpr;
 
    class shiftExpr;
 
    class relationalExpr;
 
    class equalityExpr;
 
    class andExpr;
 
    class exclusiveExpr;
 
    class inclusiveExpr;
 
    class logicalAndExpr;
 
    class logicalOrExpr;
 
    class rExpr;
 
    class codeBlock;
 
    class useStmt;
 
    class funcDefStmt;
 
    class interfaceDefInnerPair;
 
    class interfaceDefInner;
 
    class interfaceDefStmt;
 
    class structDefInnerPair;
 
    class structDefInner;
 
    class structDefStmt;
 
    class dataStructDefStmt;
    
    class implInnerPair;
 
    class implInner;
 
    class implStmt;
 
    class letAssignmentPair;
 
    class letStmt;
 
    class globalStmt;
 
    class ifStmt;
 
    class whileStmt;
 
    class forStmt;
 
    class forEachStmt;
 
    class returnStmt;
 
    class continueStmt;
 
    class breakStmt;
 
    class inCodeBlockStmt;
 
    class codeBlock;
 
    class leftExpr;
 
    class externModuleAccessExpression;
 
    class exportDecl;
 
    class importDecl;
 
    class importInner;
 
    class throwStmt;
 
    class catchParam;
 
    class tryCatchStmt;
 
    class dynCastExpression;
 
    class typeIdExpression;
 
    class newExpression;
 
    class abstractExpr;
 
    class lambdaExpr;
 
    class unnamedDefinitionArguments;
 
    class marcoPair;
 
    class marcoDescriptor;
 
    class typeAliasStmt;
 
    class finalizerDef;
 
    class finalizerDecl;
 
    class funcExpr;
 
    class letAssignmentPairLHS;
 
    class enumerationDefinition;
 
    class enumerationPair;
 
    class bracedInitalizerList;
 
    class yieldStmt;
 
    class decltypeExpr;
 
    class conceptDefinition;
 
    class conceptStmt;
 
    class satisfyStmt;
 
    class satisfyClause;
 
    class lambdaCapture;
 
    class bracedInitalizerList : public AST {
      public:
        yoi::vec<yoi::rExpr *> exprs;
    };
 
    class typeAliasStmt : public AST {
      public:
        yoi::identifierWithDefTemplateArg *lhs{};
        yoi::typeSpec *rhs{};
    };
 
    class marcoPair : public AST {
      public:
        lexer::token identifier;
        lexer::token constraint;
        lexer::token rhs;
    };
 
    class marcoDescriptor : public AST {
      public:
        yoi::vec<marcoPair *> pairs;
    };
 
    class funcExpr : public AST {
      public:
        externModuleAccessExpression *name{};
        unnamedDefinitionArguments *args{};
    };
 
    class basicLiterals : public AST {
      public:
        lexer::token node;
 
        lexer::token &get();
    };
 
    class identifier : public AST {
      public:
        lexer::token node;
 
        lexer::token &get();
    };
 
    class identifierWithTypeSpec : public AST {
      public:
        identifier *id;
        typeSpec *spec;
 
        identifier &getId() const;
 
        typeSpec &getSpec() const;
    };
 
    class defTemplateArgSpec : public AST {
      public:
        identifier *id;
        satisfyClause *satisfyCondition;
 
        identifier &getId() const;
    };
 
    class defTemplateArg : public AST {
      public:
        vec<defTemplateArgSpec *> spec;
 
        vec<defTemplateArgSpec *> &get();
    };
 
    class templateArgSpec : public AST {
      public:
        typeSpec *spec;
 
        typeSpec &get() const;
    };
 
    class templateArg : public AST {
      public:
        vec<templateArgSpec *> spec;
 
        vec<templateArgSpec *> &get();
    };
 
    class invocationArguments : public AST {
      public:
        vec<rExpr *> arg;
 
        vec<rExpr *> &get();
    };
 
    class definitionArguments : public AST {
      public:
        vec<identifierWithTypeSpec *> spec;
 
        vec<identifierWithTypeSpec *> &get();
    };
 
    class funcTypeSpec : public AST {
      public:
        unnamedDefinitionArguments *args;
        typeSpec *resultType;
 
        unnamedDefinitionArguments &getArgs() const;
 
        typeSpec &getResultType() const;
    };
 
    class typeSpec : public AST {
      public:
        enum class typeSpecKind : int16_t {
            Member,
            Func,
            Null,
            Elipsis,
            DecltypeExpr
        } kind; // 0 is member 1 is func 2 is null, 3 is elipsis, 4 is decltypeExpr
        externModuleAccessExpression *member;
        funcTypeSpec *func;
        typeSpec *elipsis;
        decltypeExpr *decltypeExpression;
        bool isNull;
        yoi::vec<uint64_t> *arraySubscript;
 
        externModuleAccessExpression &getMemberExpr() const;
 
        funcTypeSpec &getTypeSpec() const;
    };
 
    class subscript : public AST {
      public:
        rExpr *expr;
        invocationArguments *args;
 
        bool isInvocation() const;
 
        bool isSubscript() const;
 
        rExpr &getExpr() const;
    };
 
    class identifierWithTemplateArg : public AST {
      public:
        identifier *id;
        templateArg *arg;
 
        identifier &getId() const;
 
        templateArg &getArg() const;
 
        bool hasTemplateArg() const;
    };
 
    class identifierWithDefTemplateArg : public AST {
      public:
        identifier *id;
        defTemplateArg *arg;
 
        identifier &getId() const;
 
        defTemplateArg &getArg() const;
 
        bool hasDefTemplateArg() const;
    };
 
    class subscriptExpr : public AST {
      public:
        identifierWithTemplateArg *id;
        vec<subscript *> subscriptVal;
 
        bool isIdentifier() const;
 
        vec<subscript *> &getSubscript();
    };
 
    class memberExpr : public AST {
      public:
        vec<subscriptExpr *> terms;
 
        vec<subscriptExpr *> &getTerms();
    };
 
    class newExpression : public AST {
      public:
        externModuleAccessExpression *type;
        subscript *length;
        invocationArguments *args;
    };
 
    class primary : public AST {
      public:
        // 0 is memberExpr 1 is basicLiterals 2 is rExpr, 3 is typeIdExpression, 4 is dynCastExpression, 5 is newExpression, 6 is lambdaExpr, 7 is
        // funcExpr
        enum class primaryKind : int8_t {
            memberExpr,
            basicLiterals,
            rExpr,
            typeIdExpression,
            dynCastExpression,
            newExpression,
            lambdaExpr,
            funcExpr,
            bracedInitalizerList
        } kind;
        memberExpr *member;
        basicLiterals *literals;
        rExpr *expr;
        typeIdExpression *typeId;
        dynCastExpression *dynCast;
        newExpression *newExpr;
        lambdaExpr *lambda;
        funcExpr *func;
        bracedInitalizerList *bracedInitalizer;
        decltypeExpr *decltypeExpr;
 
        memberExpr &getMemberExpr() const;
 
        basicLiterals &getLiterals() const;
 
        rExpr &getExpr() const;
    };
 
    class abstractExpr : public AST {
      public:
        primary *lhs;
        lexer::token op;
        externModuleAccessExpression *rhs;
 
        primary &getLhs() const;
 
        lexer::token &getOp();
 
        externModuleAccessExpression &getRhs() const;
    };
 
    class uniqueExpr : public AST {
      public:
        lexer::token op;
        abstractExpr *lhs{};
 
        lexer::token &getOp();
 
        abstractExpr &getLhs() const;
 
        operator bool() const;
    };
 
    class leftExpr : public AST {
      public:
        lexer::token op;
        uniqueExpr *lhs;
        rExpr *rhs;
 
        lexer::token &getOp();
 
        uniqueExpr &getLhs() const;
 
        rExpr &getRhs() const;
 
        bool hasRhs() const;
    };
 
    class mulExpr : public AST {
      public:
        vec<leftExpr *> terms;
        vec<lexer::token> ops;
 
        vec<leftExpr *> &getTerms();
 
        vec<lexer::token> &getOp();
 
        operator bool() const;
    };
 
    class addExpr : public AST {
      public:
        vec<mulExpr *> terms;
        vec<lexer::token> ops;
 
        vec<mulExpr *> &getTerms();
 
        vec<lexer::token> &getOp();
 
        operator bool() const;
    };
 
    class shiftExpr : public AST {
      public:
        vec<addExpr *> terms;
        vec<lexer::token> ops;
 
        vec<addExpr *> &getTerms();
 
        vec<lexer::token> &getOp();
 
        operator bool() const;
    };
 
    class relationalExpr : public AST {
      public:
        vec<shiftExpr *> terms;
        vec<lexer::token> ops;
 
        vec<shiftExpr *> &getTerms();
 
        vec<lexer::token> &getOp();
 
        operator bool() const;
    };
 
    class equalityExpr : public AST {
      public:
        vec<relationalExpr *> terms;
        vec<lexer::token> ops;
 
        vec<relationalExpr *> &getTerms();
 
        vec<lexer::token> &getOp();
 
        operator bool() const;
    };
 
    class andExpr : public AST {
      public:
        vec<equalityExpr *> terms;
        vec<lexer::token> ops;
 
        vec<equalityExpr *> &getTerms();
 
        vec<lexer::token> &getOp();
 
        operator bool() const;
    };
 
    class exclusiveExpr : public AST {
      public:
        vec<andExpr *> terms;
        vec<lexer::token> ops;
 
        vec<andExpr *> &getTerms();
 
        vec<lexer::token> &getOp();
 
        operator bool() const;
    };
 
    class inclusiveExpr : public AST {
      public:
        vec<exclusiveExpr *> terms;
        vec<lexer::token> ops;
 
        vec<exclusiveExpr *> &getTerms();
 
        vec<lexer::token> &getOp();
 
        operator bool() const;
    };
 
    class logicalAndExpr : public AST {
      public:
        vec<inclusiveExpr *> terms;
        vec<lexer::token> ops;
 
        vec<inclusiveExpr *> &getTerms();
 
        vec<lexer::token> &getOp();
 
        operator bool() const;
    };
 
    class logicalOrExpr : public AST {
      public:
        vec<logicalAndExpr *> terms;
        vec<lexer::token> ops;
 
        vec<logicalAndExpr *> &getTerms();
 
        vec<lexer::token> &getOp();
 
        operator bool() const;
    };
 
    class rExpr : public AST {
      public:
        logicalOrExpr *expr;
 
        logicalOrExpr &getExpr() const;
    };
 
    class useStmt : public AST {
      public:
        identifier *name;
        lexer::token path;
 
        identifier &getName();
 
        lexer::token &getPath();
    };
 
    class decltypeExpr : public AST {
      public:
        rExpr *expr{};
    };
 
    class funcDefStmt : public AST {
      public:
        yoi::vec<lexer::token> attrs;
        identifierWithDefTemplateArg *id;
        definitionArguments *args;
        typeSpec *resultType;
        codeBlock *block;
 
        identifierWithDefTemplateArg &getId();
 
        definitionArguments &getArgs();
 
        typeSpec &getResultType();
 
        codeBlock &getBlock();
    };
 
    class interfaceDefInnerPair : public AST {
      public:
        // member var
        identifierWithTypeSpec *var;
 
        identifierWithTypeSpec &getVar();
 
        // method
        innerMethodDecl *method;
 
        innerMethodDecl &getMethod();
 
        bool isMethod();
    };
 
    class interfaceDefInner : public AST {
      public:
        vec<interfaceDefInnerPair *> inner;
 
        vec<interfaceDefInnerPair *> &getInner();
    };
 
    class interfaceDefStmt : public AST {
      public:
        identifierWithDefTemplateArg *id;
        interfaceDefInner *inner;
 
        identifierWithDefTemplateArg &getId();
 
        interfaceDefInner &getInner();
    };
 
    class structDefInnerPair : public AST {
      public:
        // 0 is member 1 is constructor 2 is method, 3 is finalizer
        int8_t kind;
        enum class Modifier {None, DataField, Weak} modifier;
        // member var
        identifierWithTypeSpec *var;
        // constructor
        constructorDecl *con;
        // method
        innerMethodDecl *method;
        // finalizer
        finalizerDecl *finalizer;
 
        identifierWithTypeSpec &getVar();
 
        constructorDecl &getConstructor();
 
        innerMethodDecl &getMethod();
 
        finalizerDecl &getFinalizer();
    };
 
    class lambdaCapture : public AST {
      public:
        structDefInnerPair::Modifier attr;
        yoi::identifier *identifier;
    };
 
    class lambdaExpr : public AST {
      public:
        vec<yoi::lambdaCapture *> captures;
        definitionArguments *args;
        typeSpec *resultType;
        codeBlock *block;
    };
 
    class structDefInner : public AST {
      public:
        vec<structDefInnerPair *> inner;
 
        vec<structDefInnerPair *> &getInner();
    };
 
    class structDefStmt : public AST {
      public:
        identifierWithDefTemplateArg *id;
        structDefInner *inner;
 
        identifierWithDefTemplateArg &getId();
 
        structDefInner &getInner();
    };
 
    class dataStructDefStmt : public AST {
      public:
        identifier *id;
        structDefInner *inner;
 
        identifier &getId();
 
        structDefInner &getInner();
    };
 
    class implInnerPair : public AST {
      public:
        // constructor
        constructorDef *con;
        // method
        innerMethodDef *met;
        // finalizer
        finalizerDef *finalizer;
 
        constructorDef &getConstructor();
 
        innerMethodDef &getMethod();
 
        finalizerDef &getFinalizer();
 
        bool isConstructor() const;
 
        bool isFinalizer() const;
 
        bool isMethod() const;
    };
 
    class implInner : public AST {
      public:
        vec<implInnerPair *> inner;
 
        vec<implInnerPair *> &getInner();
    };
 
    class implStmt : public AST {
      public:
        externModuleAccessExpression *interfaceName;
        externModuleAccessExpression *structName;
        implInner *inner;
 
        externModuleAccessExpression &getInterfaceId();
 
        externModuleAccessExpression &getStructId();
 
        implInner &getInner();
 
        bool isImplForStmt();
    };
 
    class letAssignmentPairLHS : public AST {
      public:
        enum class vKind : int16_t { identifier, list } kind;
        identifier *id;
        vec<lexer::token> list; // like [..., a, b, c] [a, b, c, ...], [a, b, c]
    };
 
    class letAssignmentPair : public AST {
      public:
        letAssignmentPairLHS *lhs;
        typeSpec *type;
        rExpr *rhs;
 
        letAssignmentPairLHS &getLhs();
 
        rExpr &getRhs();
    };
 
    class letStmt : public AST {
      public:
        vec<letAssignmentPair *> terms;
 
        vec<letAssignmentPair *> &getTerms();
    };
 
    class globalStmt : public AST {
      public:
        enum class vKind : int16_t {
            useStmt,
            funcDefStmt,
            interfaceDefStmt,
            structDefStmt,
            dataStructDefStmt,
            implStmt,
            letStmt,
            importDecl,
            exportDecl,
            typeAliasStmt,
            enumerationDef,
            conceptDef,
        } kind;
 
        marcoDescriptor *marco;
 
        union vValue {
            useStmt *useStmtVal;
            interfaceDefStmt *interfaceDefStmtVal;
            structDefStmt *structDefStmtVal;
            dataStructDefStmt *dataStructDefStmtVal;
            implStmt *implStmtVal;
            letStmt *letStmtVal;
            funcDefStmt *funcDefStmtVal;
            importDecl *importDeclVal;
            exportDecl *exportDeclVal;
            typeAliasStmt *typeAliasStmtVal;
            enumerationDefinition *enumerationDefVal;
            conceptDefinition *conceptDefVal;
            void *ptr;
 
            template <typename T> vValue(T *t) : ptr(static_cast<void *>(t)) {}
        } value;
 
        vKind &getKind();
 
        vValue &getValue();
    };
 
    class ifStmt : public AST {
      public:
        struct ifBlock {
            rExpr *cond;
            codeBlock *block;
 
            rExpr &getCond();
 
            codeBlock &getBlock();
        };
 
        ifBlock ifB;
        vec<ifBlock> elifB;
        codeBlock *elseB;
 
        ifBlock &getIfBlock();
 
        vec<ifBlock> &getElifBlock();
 
        codeBlock &getElseBlock();
 
        bool hasElseBlock() const;
    };
 
    class whileStmt : public AST {
      public:
        rExpr *cond;
        codeBlock *block;
 
        rExpr &getCond();
 
        codeBlock &getBlock();
    };
 
    class forStmt : public AST {
      public:
        inCodeBlockStmt *initStmt;
        rExpr *cond;
        inCodeBlockStmt *afterStmt;
        codeBlock *block;
 
        inCodeBlockStmt &getInitStmt();
 
        rExpr &getCond();
 
        inCodeBlockStmt &getAfterStmt();
 
        codeBlock &getBlock();
    };
 
    class forEachStmt : public AST {
      public:
        identifier *var;
        rExpr *container;
        codeBlock *block;
 
        identifier &getVar();
 
        rExpr &getContainer();
 
        codeBlock &getBlock();
    };
 
    class returnStmt : public AST {
      public:
        rExpr *value;
 
        rExpr &getValue();
 
        bool hasValue() const;
    };
 
    class continueStmt : public AST {};
 
    class breakStmt : public AST {};
 
    class inCodeBlockStmt : public AST {
      public:
        enum class vKind : int16_t {
            ifStmt,
            whileStmt,
            forStmt,
            forEachStmt,
            returnStmt,
            continueStmt,
            breakStmt,
            letStmt,
            codeBlock,
            tryCatchStmt,
            throwStmt,
            yieldStmt,
            rExpr,
        } kind;
 
        marcoDescriptor *marco;
 
        union vValue {
            ifStmt *ifStmtVal;
            whileStmt *whileStmtVal;
            forEachStmt *forEachStmtVal;
            returnStmt *returnStmtVal;
            continueStmt *continueStmtVal;
            breakStmt *breakStmtVal;
            letStmt *letStmtVal;
            codeBlock *codeBlockVal;
            yieldStmt *yieldStmtVal;
            rExpr *rExprVal;
            forStmt *forStmtVal;
            void *ptr;
 
            template <typename T> vValue(T *t) : ptr((void *)t) {}
        } value;
 
        vKind &getKind();
 
        vValue &getValue();
    };
 
    class innerMethodDecl : public AST {
      public:
        yoi::vec<lexer::token> attrs;
        identifierWithDefTemplateArg *name;
        definitionArguments *args;
        typeSpec *resultType;
 
        identifierWithDefTemplateArg &getName();
 
        definitionArguments &getArgs();
 
        typeSpec &getResultType();
    };
 
    class innerMethodDef : public AST {
      public:
        yoi::vec<lexer::token> attrs;
        identifierWithTemplateArg *name;
        definitionArguments *args;
        typeSpec *resultType;
        codeBlock *block;
 
        identifierWithTemplateArg &getName();
 
        definitionArguments &getArgs();
 
        typeSpec &getResultType();
 
        codeBlock &getBlock();
    };
 
    class constructorDecl : public AST {
      public:
        defTemplateArg *tempArgs;
        definitionArguments *args;
 
        definitionArguments &getArgs();
    };
 
    class finalizerDecl : public AST {
      public:
    };
 
    class constructorDef : public AST {
      public:
        templateArg *tempArgs;
        definitionArguments *args;
        codeBlock *block;
 
        definitionArguments &getArgs();
 
        codeBlock &getBlock();
    };
 
    class finalizerDef : public AST {
      public:
        codeBlock *block;
 
        codeBlock &getBlock();
    };
 
    class codeBlock : public AST {
      public:
        vec<inCodeBlockStmt *> stmts;
        // Set by the parser from the closing brace; AST's base token is the opening brace.
        yoi::indexT endLine = 0;
        yoi::indexT endColumn = 0;
 
        vec<inCodeBlockStmt *> &getStmts();
    };
 
    class hoshiModule : public AST {
      public:
        vec<globalStmt *> stmts;
 
        vec<globalStmt *> &getStmts();
    };
 
    class externModuleAccessExpression : public AST {
      public:
        vec<identifierWithTemplateArg *> terms;
 
        vec<identifierWithTemplateArg *> &getTerms();
 
        bool isIdentifier() const;
    };
 
    class exportDecl : public AST {
      public:
        yoi::vec<lexer::token> attrs;
        typeSpec *from;
        identifier *as;
    };
 
    class importDecl : public AST {
      public:
        innerMethodDecl *inner;
        lexer::token from_path;
    };
 
    class throwStmt : public AST {
      public:
        rExpr *expr;
    };
 
    class catchParam : public AST {
      public:
        typeSpec *type;
        identifier *name;
        codeBlock *block;
    };
 
    class tryCatchStmt : public AST {
      public:
        codeBlock *tryBlock;
        vec<catchParam *> catchParams;
        codeBlock *finallyBlock;
    };
 
    class typeIdExpression : public AST {
      public:
        typeSpec *type;
        rExpr *expr;
    };
 
    class dynCastExpression : public AST {
      public:
        typeSpec *type;
        rExpr *expr;
    };
 
    class unnamedDefinitionArguments : public AST {
      public:
        vec<typeSpec *> types;
    };
 
    class enumerationDefinition : public AST {
      public:
        identifier *name;
        vec<enumerationPair *> values;
    };
 
    class enumerationPair : public AST {
      public:
        identifier *name;
        lexer::token value; // optional
    };
 
    class yieldStmt : public AST {
      public:
        rExpr *expr;
    };
 
    class conceptDefinition : public AST {
      public:
        lexer::token name;
        yoi::vec<lexer::token> typeParams;
        yoi::vec<identifierWithTypeSpec *> algebraParams;
 
        yoi::vec<conceptStmt *> conceptBlock;
    };
 
    class conceptStmt : public AST {
      public:
        enum class Kind {
            SatisfyStmt,
            Expression
        } kind;
        
        union ConceptStmtValue {
            void *storage;
            satisfyStmt *satisfyStmt;
            rExpr *expression;
 
            template<typename T> ConceptStmtValue(T a) : storage((void*)a) {}
        } value;
    };
 
    class satisfyStmt : public AST {
      public:
        externModuleAccessExpression *emae;
    };
 
    class satisfyClause : public AST {
      public:
        yoi::vec<externModuleAccessExpression *> emaes;
    };
 
    void finalizeAST(satisfyClause *ptr);
 
    void finalizeAST(satisfyStmt *ptr);
 
    void finalizeAST(conceptStmt *ptr);
 
    void finalizeAST(conceptDefinition *ptr);
 
    void finalizeAST(exportDecl *ptr);
 
    void finalizeAST(importInner *ptr);
 
    void finalizeAST(importDecl *ptr);
 
    void finalizeAST(externModuleAccessExpression *ptr);
 
    void finalizeAST(hoshiModule *ptr);
 
    void finalizeAST(leftExpr *ptr);
 
    void finalizeAST(basicLiterals *ptr);
 
    void finalizeAST(identifier *ptr);
 
    void finalizeAST(typeSpec *ptr);
 
    void finalizeAST(identifierWithTypeSpec *ptr);
 
    void finalizeAST(defTemplateArgSpec *ptr);
 
    void finalizeAST(defTemplateArg *ptr);
 
    void finalizeAST(templateArgSpec *ptr);
 
    void finalizeAST(templateArg *ptr);
 
    void finalizeAST(invocationArguments *ptr);
 
    void finalizeAST(definitionArguments *ptr);
 
    void finalizeAST(funcTypeSpec *ptr);
 
    void finalizeAST(subscript *ptr);
 
    void finalizeAST(identifierWithDefTemplateArg *ptr);
 
    void finalizeAST(identifierWithTemplateArg *ptr);
 
    void finalizeAST(subscriptExpr *ptr);
 
    void finalizeAST(memberExpr *ptr);
 
    void finalizeAST(primary *ptr);
 
    void finalizeAST(decltypeExpr *ptr);
 
    void finalizeAST(uniqueExpr *ptr);
 
    void finalizeAST(mulExpr *ptr);
 
    void finalizeAST(addExpr *ptr);
 
    void finalizeAST(shiftExpr *ptr);
 
    void finalizeAST(relationalExpr *ptr);
 
    void finalizeAST(equalityExpr *ptr);
 
    void finalizeAST(andExpr *ptr);
 
    void finalizeAST(exclusiveExpr *ptr);
 
    void finalizeAST(inclusiveExpr *ptr);
 
    void finalizeAST(logicalAndExpr *ptr);
 
    void finalizeAST(logicalOrExpr *ptr);
 
    void finalizeAST(rExpr *ptr);
 
    void finalizeAST(codeBlock *ptr);
 
    void finalizeAST(useStmt *ptr);
 
    void finalizeAST(funcDefStmt *ptr);
 
    void finalizeAST(interfaceDefInner *ptr);
 
    void finalizeAST(interfaceDefInnerPair *ptr);
 
    void finalizeAST(interfaceDefStmt *ptr);
 
    void finalizeAST(structDefInnerPair *ptr);
 
    void finalizeAST(structDefInner *ptr);
 
    void finalizeAST(structDefStmt *ptr);
 
    void finalizeAST(implInnerPair *ptr);
 
    void finalizeAST(implInner *ptr);
 
    void finalizeAST(implStmt *ptr);
 
    void finalizeAST(letAssignmentPair *ptr);
 
    void finalizeAST(letStmt *ptr);
 
    void finalizeAST(globalStmt *ptr);
 
    void finalizeAST(ifStmt *ptr);
 
    void finalizeAST(whileStmt *ptr);
 
    void finalizeAST(forStmt *ptr);
 
    void finalizeAST(forEachStmt *ptr);
 
    void finalizeAST(returnStmt *ptr);
 
    void finalizeAST(continueStmt *ptr);
 
    void finalizeAST(breakStmt *ptr);
 
    void finalizeAST(inCodeBlockStmt *ptr);
 
    void finalizeAST(innerMethodDecl *ptr);
 
    void finalizeAST(innerMethodDef *ptr);
 
    void finalizeAST(constructorDecl *ptr);
 
    void finalizeAST(constructorDef *ptr);
 
    void finalizeAST(tryCatchStmt *ptr);
 
    void finalizeAST(catchParam *ptr);
 
    void finalizeAST(throwStmt *ptr);
 
    void finalizeAST(dynCastExpression *ptr);
 
    void finalizeAST(typeIdExpression *ptr);
 
    void finalizeAST(newExpression *ptr);
 
    void finalizeAST(abstractExpr *ptr);
 
    void finalizeAST(lambdaExpr *ptr);
 
    void finalizeAST(unnamedDefinitionArguments *ptr);
 
    void finalizeAST(marcoPair *ptr);
 
    void finalizeAST(marcoDescriptor *ptr);
 
    void finalizeAST(typeAliasStmt *ptr);
 
    void finalizeAST(finalizerDef *ptr);
 
    void finalizeAST(finalizerDecl *ptr);
 
    void finalizeAST(funcExpr *ptr);
 
    void finalizeAST(letAssignmentPairLHS *ptr);
 
    void finalizeAST(enumerationDefinition *ptr);
 
    void finalizeAST(enumerationPair *ptr);
 
    void finalizeAST(bracedInitalizerList *ptr);
 
    void finalizeAST(yieldStmt *ptr);
 
    void finalizeAST(lambdaCapture *ptr);
} // namespace yoi
#endif // HOSHI_LANG_AST_HPP
#pragma clang diagnostic pop