/home/renji/Data/projects/zenlang/sources/zbl/ParseContext.hpp

Go to the documentation of this file.

#pragma once
#include "Ast.hpp"
#include "Project.hpp"
#include "GetXRef.hpp"

#define INTERNAL_TOKEN_REF
#include "zbl/Token.hpp"

namespace zbl {

    class LexerContext {
    public:
        enum IdentifierState {
            iInit,           
            iImportDef,      
            iNamespaceDef,   
            iChildTypeRef,   
            iChildTypeScope, 
            iChildVarRef,    
            iChildVarScope,  
        };

    public:
        inline LexerContext() : _identifierState(iInit), _currentTypeSpec(0) {}

    public:
        inline void resetLexerState() {_identifierState = iInit;}

        inline void enterImportState() {_identifierState = iImportDef;}

        inline void enterNamespaceState() {_identifierState = iNamespaceDef;}

        inline void enterTypeRefState(const Ast::TypeSpec* typeSpec) {assert(typeSpec); _identifierState = iChildTypeRef; _currentTypeSpec = typeSpec;}

        inline void enterTypeScopeState() {_identifierState = iChildTypeScope;}

        inline void enterVarRefState() {_identifierState = iChildVarRef;}

        inline void enterVarScopeState() {_identifierState = iChildVarScope;}

    public:
        inline const IdentifierState& getIdentifierState() const {return _identifierState;}

    public:
        inline const Ast::TypeSpec& getCurrentTypeSpec() const {return ref(_currentTypeSpec);}

    private:
        IdentifierState _identifierState;

        const Ast::TypeSpec* _currentTypeSpec;
    };


    class Compiler;


    class ParseContext : public LexerContext {
    private:
        class IndexableTypeCaster {
        public:
            inline void cast(ParseContext& pctx, const Ast::TypeSpec& ptypeSpec) {
                const Ast::TypeSpec* typeSpec = ptr(ptypeSpec);
                const Ast::TypeDef* typeDef = dynamic_cast<const Ast::TypeDef*>(typeSpec);
                while(typeDef) {
                    typeSpec = ptr(ref(typeDef).getTargetType().getTypeSpec());
                    const Ast::TypeDef* t1 = dynamic_cast<const Ast::TypeDef*>(typeSpec);
                    if(!t1)
                        break;
                    typeDef = t1;
                }

                const Ast::ListTemplate* list = dynamic_cast<const Ast::ListTemplate*>(typeSpec);
                if(list) {
                    return visitList(pctx, ref(list));
                }

                const Ast::DictTemplate* dict = dynamic_cast<const Ast::DictTemplate*>(typeSpec);
                if(dict) {
                    return visitDict(pctx, ref(dict));
                }

                // special case for some typedecl
                const Ast::TypeDecl* typeDecl = dynamic_cast<const Ast::TypeDecl*>(typeSpec);
                if(typeDecl) {
                    if(ref(typeDecl).getName() == "tree") {
                        return visitTree(pctx, ref(typeDecl));
                    }
                    if(ref(typeDecl).getName() == "data") {
                        return visitTree(pctx, ref(typeDecl));
                    }
                    if(ref(typeDecl).getName() == "buffer") {
                        return visitBuffer(pctx, ref(typeDecl));
                    }
                    if(ref(typeDecl).getName() == "view") {
                        return visitView(pctx, ref(typeDecl));
                    }
                    if(ref(typeDecl).getName() == "widget") {
                        return visitWidget(pctx, ref(typeDecl));
                    }
                }

                throw z::exception(z::string::creator("%{err} Not an indexable/iterable type: %{type}").arg(z::any("err"), z::any(pctx.err())).arg(z::any("type"), z::any(ref(typeSpec).getFullName(z::string("::")))).value());
            }

        private:
            virtual void visitList(ParseContext& pctx, const Ast::ListTemplate& type) = 0;

            virtual void visitDict(ParseContext& pctx, const Ast::DictTemplate& type) = 0;

            virtual void visitTree(ParseContext& pctx, const Ast::TypeDecl& type) = 0;

            virtual void visitBuffer(ParseContext& pctx, const Ast::TypeDecl& type) = 0;

            virtual void visitView(ParseContext& pctx, const Ast::TypeDecl& type) = 0;

            virtual void visitWidget(ParseContext& pctx, const Ast::TypeDecl& type) = 0;
        };

    private:
        struct ImportFrame {
            Ast::UserDefinedTypeSpec::NativeType _ntype;

            z::string _fname;

            int _line;

            int _col;

            typedef z::stack<Ast::ChildTypeSpec*> TypeSpecStack;

            TypeSpecStack _typeSpecStack;
        };

        typedef z::stack<ImportFrame> ImportStack;

        ImportStack _importStack;

    public:
        inline void enterImport(const Ast::UserDefinedTypeSpec::NativeType& ntype, const z::string& fname) {
            _importStack.push(ImportFrame());
            ImportFrame& fi = _importStack.top();
            fi._ntype = ntype;
            fi._fname = fname;
            fi._line = 0;
            fi._col = 0;

            // if we are importing, set the current type to importNS.
            // Imported types don't need to go into Ast::Unit
            if(_importStack.size() > 1) {
                fi._typeSpecStack.push(ptr(_unit.getImportNS()));
            } else {
                fi._typeSpecStack.push(ptr(_unit.getRootNS()));
            }
        }

        inline void leaveImport() {
            _importStack.pop();
        }

        inline bool inImport() const {return (_importStack.size() > 1);}

        inline ImportFrame& getImportFrame() {
            assert(_importStack.size() > 0);
            return _importStack.top();
        }

        inline const ImportFrame& getImportFrame() const {
            assert(_importStack.size() > 0);
            return _importStack.top();
        }

        inline const Ast::UserDefinedTypeSpec::NativeType& getNativeType() const {
            const ImportFrame& fi = getImportFrame();
            return fi._ntype;
        }

    public:
        inline Ast::ChildTypeSpec& getCurrentType() const {
            const ImportFrame& fi = getImportFrame();
            return ref(fi._typeSpecStack.top());
        }

        inline Ast::ChildTypeSpec& enterCurrentType(Ast::ChildTypeSpec& type) {
            ImportFrame& fi = getImportFrame();
            fi._typeSpecStack.push(ptr(type));
            return type;
        }

        inline Ast::ChildTypeSpec& leaveCurrentType(Ast::ChildTypeSpec& type) {
            ImportFrame& fi = getImportFrame();
            fi._typeSpecStack.pop();
            return type;
        }

    public:
        inline const z::string& getFilename() const {
            const ImportFrame& fi = getImportFrame();
            return fi._fname;
        }

    public:
        inline void setTokenPos(const int& line, const int& col) {
            ImportFrame& fi = getImportFrame();
            fi._line = line;
            fi._col = col;
        }

    public:
        inline ParseContext(zbl::Compiler& compiler, Ast::Unit& unit)
            : _compiler(compiler), _unit(unit),
              _curr_vdef(0)
        {
            enterImport(Ast::TypeDefTypeSpec::ntNone, unit.getFilename());
        }

        inline ~ParseContext() {
            assert(_importStack.size() == 1);
            leaveImport();
        }

    public:
        inline const zbl::TokenData& getNullToken() const {return _nullToken;}

    private:
        inline z::string err(const int& line, const int& col) const {
            z::string str;
            z::stringstream z(str);
#ifdef _WIN32
            // MSVC style error message
            z << getFilename() << "(" << line << ", " << col << "): ";
#else
            // GCC style error message, or default.
            unused(col);
            z << getFilename() << ":" << line << ": ";
#endif
            return str;
        }

    public:
        inline z::string err() const {
            const ImportFrame& fi = getImportFrame();
            return err(fi._line, fi._col);
        }

        inline z::string err(const zbl::TokenData& token) const {
            return err(token.line, token.col);
        }

    private:
        void importHeaderFile(const Ast::ImportStatement& stmt, const Ast::ImportStatement::Type& type);

    public:
        inline void importHeader(Ast::ImportStatement& stmt, const Ast::ImportStatement::Type& type) {
            resetLexerState();
            for(Ast::Unit::ImportList::iterator it(_unit.getImportList()); !it.end(); ++it) {
                const Ast::ImportStatement& istmt = ref(*it);
                if((istmt.getName().join("::") == stmt.getName().join("::")) && (istmt.getType() == type)) {
                    return;
                }
            }

            stmt.setType(type);
            _unit.addImport(stmt);
            if(type != Ast::ImportStatement::itNative) {
                importHeaderFile(stmt, type);
            }
        }

    public:
        inline Ast::ImportStatement& createImportNamespace(const z::string& name) {
            enterImportState();
            Ast::ImportStatement& stmt = _unit.addNode(new Ast::ImportStatement());
            stmt.addPart(name);
            return stmt;
        }

    private:
        inline Ast::Namespace& addChildNamespace(Ast::ChildTypeSpec& type, const z::string& name) {
            if(!inImport()) {
                _unit.addUnitNS(name);
            }

            Ast::Namespace* ns = dynamic_cast<Ast::Namespace*>(ptr(type));
            Ast::Namespace* cns = ref(ns).hasNamespace(name);
            if(cns)
                return *cns;
            Ast::Namespace& nns = _unit.addNode(new Ast::Namespace(Ast::TypeSpec::AccessType::Public, ref(ns), name));

            return ref(ns).addNamespace(nns);
        }

    public:
        inline Ast::Namespace& enterUnitNamespace(const z::string& name) {
            Ast::Namespace& cns = addChildNamespace(getCurrentType(), name);
            enterCurrentType(cns);
            return cns;
        }

        inline Ast::Namespace& addUnitNamespace(Ast::Namespace& ns, const z::string& name) {
            Ast::Namespace& cns = addChildNamespace(ns, name);
            enterCurrentType(cns);
            return cns;
        }

        inline void leaveUnitNamespace(Ast::Namespace& ns) {
            unused(ns);
        }

    private:
        inline Ast::ChildTypeSpec* getParent(Ast::ChildTypeSpec* child) {
            Ast::TypeSpec& parent = ref(child).getParent();
            return dynamic_cast<Ast::ChildTypeSpec*>(ptr(parent));
        }

        inline Ast::ChildTypeSpec& getParent(Ast::ChildTypeSpec& child) {
            return ref(getParent(ptr(child)));
        }

    public:
        inline Ast::TypeSpec* hasRootType(const z::string& name) {
            // start from current type and search for this type
            // up the type nesting all the way up to the root NS.
            Ast::ChildTypeSpec* ctype = ptr(getCurrentType());
            while(ctype) {
                Ast::TypeSpec* root = hasChildType(ref(ctype), name);
                if(root)
                    return root;
                ctype = getParent(ctype);
            }

            // finally check all the imported types.
            ctype = _unit.getImportNS().hasChild<Ast::ChildTypeSpec>(name);
            return ctype;
        }

        inline Ast::TypeSpec* hasChildType(const Ast::TypeSpec& parent, const z::string& name) {
            return parent.hasChild<Ast::ChildTypeSpec>(name);
        }

    public:
        inline Ast::TypeSpec& getChildType(const Ast::TypeSpec& parent, const zbl::TokenData& name) {
            if(!(name.typeSpec)) {
                throw z::exception(z::string::creator("%{err} Unknown child type: %{child} of %{parent}")
                                   .arg(z::any("err"), z::any(err()))
                                   .arg(z::any("child"), z::any(zbl::Token::getValue(name)))
                                   .arg(z::any("parent"), z::any(parent.getName()))
                                   .value());
            }
            return ref(name.typeSpec);
        }

    public:
        inline Ast::TypeSpec& enterTypeSpecRef(const zbl::TokenData& token) {
            return ref(token.typeSpec);
        }

        inline Ast::TypeSpec& leaveTypeSpecRef(Ast::TypeSpec& typeSpec) {
            return typeSpec;
        }

    public:
        inline Ast::QualifiedType& createQualifiedType(const bool& isConst, const Ast::TypeSpec& type, const bool& isRef) {
            return _unit.addNode(new Ast::QualifiedType(isConst, type, isRef));
        }

    private:
        typedef z::dict<z::string, Ast::QualifiedType*> QualifiedTypeMap;

        QualifiedTypeMap _qualifiedTypeMap;

    private:
        inline Ast::QualifiedType& getQualifiedType(const z::string& name) {
            // check if already in map
            QualifiedTypeMap::found f = _qualifiedTypeMap.find(name);
            if(f)
                return ref(*f);

            // search import namespace
            const Ast::ChildTypeSpec* ts = _unit.getImportNS().hasChild<Ast::ChildTypeSpec>(name);
            if(!ts) {
                // search root namespace. This will not find anything, for now,
                // since this function is meant for intrinsic types only.
                ts = _unit.getRootNS().hasChild<Ast::ChildTypeSpec>(name);
                if(!ts)
                    throw z::exception(z::string::creator("%{err} Unknown type: %{name}").arg(z::any("err"), z::any(err())).arg(z::any("name"), z::any(name)).value());
            }

            // create qtype
            Ast::QualifiedType& qtype = createQualifiedType(false, ref(ts), false);

            // add to map
            _qualifiedTypeMap.insert(name, ptr(qtype));

            // return qtype
            return qtype;
        }

    private:
        typedef z::list<const Ast::TypeSpec*> CoertionList;

        CoertionList _coertionList;

    public:
        inline void enterCoertionList(const Ast::TypeSpec& type) {
            _coertionList.append(ptr(type));
        }

        inline void addCoertionItem(const Ast::TypeSpec& type) {
            _coertionList.append(ptr(type));
        }

        inline void leaveCoertionList() {
            _coertionList.append(0);
        }

    private:
        inline int getTypeIndex(const Ast::QualifiedType& type) const {
            const z::string& name = type.getTypeSpec().getName();
            int idx = 0;
            for(CoertionList::iterator it(_coertionList); !it.end(); ++it, ++idx) {
                const Ast::TypeSpec* ts = *it;
                // IMP: this must be a separate check. Do not combine with the next if-stmt.
                if(!ts)
                    return -1;
                if(ref(ts).getName() == name)
                    return idx;
            }
            return -1;
        }

    private:
        typedef z::dict<const Ast::TypeSpec*, const Ast::TypeSpec*> CoertionSubMap;

        typedef z::dict<const Ast::TypeSpec*, CoertionSubMap> CoertionMap;

        CoertionMap _coertionMap;

    public:
        inline void addCoertionMap(const Ast::TypeSpec& lhs, const Ast::TypeSpec& rhs, const Ast::TypeSpec& dst) {
            if(!_coertionMap.has(ptr(lhs)))
                _coertionMap.insert(ptr(lhs), CoertionSubMap());

            CoertionSubMap& smap = _coertionMap.at(ptr(lhs));
            if(smap.has(ptr(rhs)))
                throw z::exception(z::string::creator("%{err} Coertion map already exists").arg(z::any("err"), z::any(err())).value());

            smap.insert(ptr(rhs), ptr(dst));
        }

    private:
        inline const Ast::TypeSpec* getTarget(const Ast::QualifiedType& lhs, const Ast::QualifiedType& rhs) {
            CoertionMap::found lf = _coertionMap.find(ptr(lhs.getTypeSpec()));
            if(!lf)
                return 0;

            CoertionSubMap::found sf = (*lf).find(ptr(rhs.getTypeSpec()));
            if(!sf)
                return 0;

            return *sf;
        }

    private:
        inline const Ast::VariableDef* hasUdtMember(const Ast::UserDefinedTypeSpec& udt, const z::string& name) const {
            return udt.hasMember(name);
        }

        inline const Ast::VariableDef* hasMember(const Ast::VariableDef& vd, const zbl::TokenData& name) const {
            const Ast::TypeSpec& vtype = vd.getType().getTypeSpec();
            const Ast::UserDefinedTypeSpec* udt = dynamic_cast<const Ast::UserDefinedTypeSpec*>(ptr(vtype));
            if(!udt)
                return 0;
            return hasUdtMember(ref(udt), zbl::Token::getValue(name));
        }

    private:
        inline Ast::Expr& getEnumRefExpr(const Ast::EnumDef& enumRef, const z::string& id) {
            const Ast::QualifiedType& qtype = createQualifiedType(false, enumRef, false);
            return _unit.addNode(new Ast::EnumRefExpr(qtype, enumRef, id));
        }

    private:
        inline bool isAny(const Ast::QualifiedType& rhs) {
            const Ast::QualifiedType& anyType = getQualifiedType(z::string("any"));
            return (ptr(anyType.getTypeSpec()) == ptr(rhs.getTypeSpec()));
        }

    private:
        inline const Ast::QualifiedType& coerce(const Ast::QualifiedType& lhs, const Ast::QualifiedType& rhs) {
            const z::string& lname = lhs.getTypeSpec().getName();
            const z::string& rname = rhs.getTypeSpec().getName();

            // check the linear lists
            int idxl = getTypeIndex(lhs);
            int idxr = getTypeIndex(rhs);
            if((lname == rname) || ( (idxl >= 0) && (idxr >= 0) )) {
                if((lhs.isConst() == rhs.isConst()) && (lhs.isRef() == rhs.isRef())) {
                    if(idxl < idxr)
                        return rhs;
                    return lhs;
                }
                if(idxl < idxr)
                    return createQualifiedType(false, rhs.getTypeSpec(), false);
                return createQualifiedType(false, lhs.getTypeSpec(), false);
            }

            const Ast::TypeSpec* lt = getTarget(lhs, rhs);
            if(lt)
                return createQualifiedType(false, ref(lt), false);

            const Ast::TypeSpec* rt = getTarget(rhs, lhs);
            if(rt)
                return createQualifiedType(false, ref(rt), false);

            throw z::exception(z::string::creator("%{err} Type mismatch: %{lname} and %{rname}").arg(z::any("err"), z::any(err())).arg(z::any("lname"), z::any(lname)).arg(z::any("rname"), z::any(rname)).value());
        }

    public:
        typedef z::dict<const Ast::TypeSpec*, const Ast::Expr*> TypeDefaultValueMap;

        TypeDefaultValueMap _typeDefaultValueMap;

        inline void addTypeDefaultValue(const Ast::TypeSpec& type, const Ast::Expr& expr) {
            _typeDefaultValueMap.insert(ptr(type), ptr(expr));
        }

        inline const Ast::Expr& getTypeDefaultValue(const Ast::TypeSpec& type) {
            TypeDefaultValueMap::found f = _typeDefaultValueMap.find(ptr(type));
            if(f) {
                return ref(*f);
            }

            const Ast::ListTemplate* list = dynamic_cast<const Ast::ListTemplate*>(ptr(type));
            if(list) {
                Ast::ListList& llist = createListList();
                const Ast::QualifiedType& vtype = list->getType();
                llist.setType(ptr(vtype));
                return createListExpr(llist);
            }

            const Ast::DictTemplate* dict = dynamic_cast<const Ast::DictTemplate*>(ptr(type));
            if(dict) {
                Ast::DictList& dlist = createDictList();
                const Ast::QualifiedType& ktype = dict->getKey();
                const Ast::QualifiedType& vtype = dict->getType();
                dlist.setKeyType(ptr(ktype));
                dlist.setValueType(ptr(vtype));
                return createDictExpr(dlist);
            }

            const Ast::EnumDef* enumDef = dynamic_cast<const Ast::EnumDef*>(ptr(type));
            if(enumDef) {
                if(ref(enumDef).getDefList().getList().size() == 0) {
                    throw z::exception(z::string::creator("%{err} Internal error: enum: %{name} must have at least one member").arg(z::any("err"), z::any(err())).arg(z::any("name"), z::any(type.getFullName(z::string("::")))).value());
                }

                const Ast::EnumMemberDef* mdef = ref(enumDef).getDefList().getList().at(0);
                return getEnumRefExpr(ref(enumDef), z::string(ref(mdef).getName()));
            }

            Ast::ExprList& exprList = createExprList();
            return createInstanceExpr(type, exprList);
        }

    public:
        inline Ast::StructMemberVariableDef& createStructVariableDefInit(const Ast::QualifiedType& type, const z::string& name, const Ast::Expr& expr) {
            return _unit.addNode(new Ast::StructMemberVariableDef(type, name, expr));
        }

        inline Ast::StructMemberVariableDef& createStructVariableDef(const Ast::QualifiedType& type, const z::string& name) {
            const Ast::Expr& expr = getTypeDefaultValue(type.getTypeSpec());
            return createStructVariableDefInit(type, name, expr);
        }

        inline Ast::ParamVariableDef& createParamVariableDefInit(const Ast::QualifiedType& type, const z::string& name, const Ast::Expr& expr) {
            return _unit.addNode(new Ast::ParamVariableDef(type, name, expr));
        }

        inline Ast::ParamVariableDef& createParamVariableDef(const Ast::QualifiedType& type, const z::string& name) {
            const Ast::Expr& expr = getTypeDefaultValue(type.getTypeSpec());
            return createParamVariableDefInit(type, name, expr);
        }

        inline Ast::InitVariableDef& createInitVariableDefInit(const Ast::VariableDef::DefType& defType, const Ast::QualifiedType& type, const z::string& name, const Ast::Expr& expr) {
            assert(defType == Ast::VariableDef::Local);
            Ast::InitVariableDef& vdef = _unit.addNode(new Ast::InitVariableDef(defType, type, name, expr));
            if(0 != _curr_vdef) {
                throw z::exception(z::string::creator("%{err} Internal error: _curr_vdef: %{name}").arg(z::any("err"), z::any(err())).arg(z::any("name"), z::any(ref(_curr_vdef).getName())).value());
            }
            _curr_vdef = ptr(vdef);
            return vdef;
        }

        inline Ast::InitVariableDef& createInitVariableDef(const Ast::VariableDef::DefType& defType, const z::string& name, const Ast::Expr& expr) {
            const Ast::QualifiedType& type = expr.getType();
            return createInitVariableDefInit(defType, type, name, expr);
        }

        class InitVariableDefCreator : public IndexableTypeCaster {
        public:
            inline InitVariableDefCreator(const Ast::VariableDef::DefType& defType, const z::string& name, const Ast::Expr& expr)
                : _defType(defType), _name(name), _expr(expr), _rv(0) {}
        public:
            inline Ast::InitVariableDef& create(ParseContext& pctx, const Ast::TypeSpec& typeSpec) {
                cast(pctx, typeSpec);
                return ref(_rv);
            }

        private:
            virtual void visitList(ParseContext& pctx, const Ast::ListTemplate& type) {
                unused(pctx);
                const Ast::QualifiedType& qtype = type.getType();
                _rv = ptr(pctx.createInitVariableDefInit(_defType, qtype, _name, _expr));
            }

            virtual void visitDict(ParseContext& pctx, const Ast::DictTemplate& type) {
                const Ast::QualifiedType& qtype = type.getType();
                _rv = ptr(pctx.createInitVariableDefInit(_defType, qtype, _name, _expr));
            }

            virtual void visitTree(ParseContext& pctx, const Ast::TypeDecl& type) {
                unused(pctx);
                unused(type);
                assert(false);
            }

            virtual void visitBuffer(ParseContext& pctx, const Ast::TypeDecl& type) {
                unused(type);
                const Ast::QualifiedType& qtype = pctx.getQualifiedType(z::string("char"));
                _rv = ptr(pctx.createInitVariableDefInit(_defType, qtype, _name, _expr));
            }

            virtual void visitView(ParseContext& pctx, const Ast::TypeDecl& type) {
                unused(type);
                const Ast::QualifiedType& qtype = pctx.getQualifiedType(z::string("widget"));
                _rv = ptr(pctx.createInitVariableDefInit(_defType, qtype, _name, _expr));
            }

            virtual void visitWidget(ParseContext& pctx, const Ast::TypeDecl& type) {
                unused(type);
                const Ast::QualifiedType& qtype = pctx.getQualifiedType(z::string("property"));
                _rv = ptr(pctx.createInitVariableDefInit(_defType, qtype, _name, _expr));
            }

        private:
            const Ast::VariableDef::DefType& _defType;

            const z::string& _name;

            const Ast::Expr& _expr;

            Ast::InitVariableDef* _rv;
        };

        inline Ast::InitVariableDef& createForeachInitVariableDef(const Ast::VariableDef::DefType& defType, const z::string& name, const Ast::Expr& expr) {
            InitVariableDefCreator creator(defType, name, expr);
            return creator.create(ref(this), expr.getType().getTypeSpec());
        }

        inline Ast::QualifiedType& createOutParam(const Ast::VariableDefMap& defList) {
            Ast::OutParam& op = _unit.addNode(new Ast::OutParam(Ast::TypeSpec::AccessType::Private, z::string("Return"), getNativeType(), defList, true));
            return createQualifiedType(false, op, false);
        }

    private:
        inline Ast::SharedVariableDef& createSharedVariableDef(const Ast::QualifiedType& qtype, const z::string& name, const Ast::Expr& expr) {
            return _unit.addNode(new Ast::SharedVariableDef(Ast::VariableDef::Shared, qtype, name, expr));
        }

    public:
        inline Ast::SharedVariableDef& createSharedTypeExprDef(const Ast::QualifiedType& qtype, const zbl::TokenData& name, const Ast::Expr& expr) {
            return createSharedVariableDef(qtype, zbl::Token::getValue(name), expr);
        }

        inline Ast::SharedVariableDef& createSharedExprDef(const zbl::TokenData& name, const Ast::Expr& expr) {
            const Ast::QualifiedType& qtype = expr.getType();
            return createSharedVariableDef(qtype, zbl::Token::getValue(name), expr);
        }

        inline Ast::SharedVariableDef& createSharedMemberDef(const Ast::VariableRef& vref) {
            const Ast::QualifiedType& qtype = vref.getLast().getType();
            const z::string& name = vref.getLast().getName();
            const Ast::Expr& expr = createVariableRefExpr(vref);
            return createSharedVariableDef(qtype, name, expr);
        }

    public:
        inline Ast::SharedDef& createSharedDef(const Ast::VariableDefMap& defList) {
            Ast::SharedDef& list = _unit.addNode(new Ast::SharedDef(Ast::TypeSpec::AccessType::Private, z::string("Shared"), getNativeType(), defList));
            return addChildLevel(list);
        }

        inline Ast::FunctionDef& getFunctionDef() const {
            Ast::ChildTypeSpec& type = getCurrentType();
            Ast::FunctionDef* fdef = dynamic_cast<Ast::FunctionDef*>(ptr(type));
            if(!fdef) {
                throw z::exception(z::string::creator("%{err} Internal error: %{name} is not a FunctionDef").arg(z::any("err"), z::any(err())).arg(z::any("name"), z::any(type.getFullName(z::string("::")))).value());
            }
            return ref(fdef);
        }

    public:
        inline const Ast::VariableDef* getIdentifier(const z::string& name, Ast::Storage::T& storage) const {
            storage = Ast::Storage::Block;

            // Because of the way the parser works, in some situations the most
            // recent variable_def is not yet added to the scope. Hence this check.
            if(_curr_vdef) {
                if(ref(_curr_vdef).getName() == name) {
                    return _curr_vdef;
                }
            }

            // search backward through the scope stack (from last to first)
            // for a variable with this name.
            ScopeStack::iterator it(_scopeStack);
            it.toBack();
            while(!it.begin()) {
                Ast::Scope& scope = ref(--it);
                const Ast::VariableDef* vd = scope.getDefList().hasDef(name);
                if(vd) {
                    return vd;
                }
            }
            return 0;
        }

    private:
        inline Ast::VariableDef& addVariableDef(const Ast::VariableDef::DefType& defType, const Ast::QualifiedType& type, const z::string& name) {
            assert(_scopeStack.size() > 0);
            Ast::Storage::T storage = Ast::Storage::Init;
            const Ast::VariableDef* vd = getIdentifier(name, storage);
            if(vd) {
                throw z::exception(z::string::creator("%{err} Variable: %{name} shadows earlier variable with same name").arg(z::any("err"), z::any(err())).arg(z::any("name"), z::any(name)).value());
            }
            Ast::VariableDef& vdef = _unit.addNode(new Ast::VariableDef(defType, type, name));
            ref(_scopeStack.top()).addDef(vdef);
            return vdef;
        }

        inline Ast::VariableDef& addVariableDef(Ast::VariableDef& vdef) {
            assert(_scopeStack.size() > 0);
            Ast::Storage::T storage = Ast::Storage::Init;
            const Ast::VariableDef* vd = getIdentifier(vdef.getName(), storage);
            if(vd) {
                throw z::exception(z::string::creator("%{err} Variable: %{name} shadows earlier variable with same name").arg(z::any("err"), z::any(err())).arg(z::any("name"), z::any(vdef.getName())).value());
            }
            ref(_scopeStack.top()).addDef(vdef);
            return vdef;
        }

    private:
        template <typename T>
        inline T& addChildLevel(T& t) {
            getCurrentType().addChild(t);
            return t;
        }

        template <typename T>
        inline T& enterTypeSpec(T& t) {
            enterCurrentType(t);
            return t;
        }

        template <typename T>
        inline T& leaveTypeSpec(T& t) {
            assert(ptr(getCurrentType()) == ptr(t));
            leaveCurrentType(getParent(getCurrentType()));
            return t;
        }

    public:
        inline Ast::VariableDefMap& createVariableDefMap() {
            return _unit.addNode(new Ast::VariableDefMap());
        }

        inline Ast::StructDefList& createStructDefList() {
            return _unit.addNode(new Ast::StructDefList());
        }

    public:
        inline Ast::StructDef& enterStructDef(const Ast::TypeSpec::AccessType::T& accessType, const z::string& name) {
            Ast::StructDef& rv = _unit.addNode(new Ast::StructDef(accessType, name, getNativeType()));
            return addChildLevel(rv);
        }

        inline Ast::StructDef& leaveStructDef(Ast::StructDef& structDef) {
            return structDef;
        }

        inline Ast::StructDef& leaveStructDefList(Ast::StructDef& structDef, const Ast::VariableDefMap& defList, const Ast::StructDefList& subTypeList) {
            structDef.setDefList(defList);
            structDef.setSubTypeList(subTypeList);
            return leaveStructDef(structDef);
        }

    public:
        inline Ast::EnumDef& createEnumDef(const Ast::TypeSpec::AccessType::T& accessType, const z::string& name, Ast::EnumMemberDefList& defList) {
            Ast::EnumDef& rv = _unit.addNode(new Ast::EnumDef(accessType, name, getNativeType(), defList));
            return addChildLevel(rv);
        }

        inline Ast::EnumMemberDefList& createEnumMemberDefList() {
            Ast::EnumMemberDefList& rv = _unit.addNode(new Ast::EnumMemberDefList());
            return rv;
        }

        inline Ast::EnumMemberDef& createEnumMemberDefInit(const zbl::TokenData& name, const bool& hasInit, const Ast::Expr& initExpr) {
            Ast::EnumMemberDef& rv = _unit.addNode(new Ast::EnumMemberDef(Ast::TypeSpec::AccessType::Private, zbl::Token::getValue(name), hasInit, initExpr));
            return rv;
        }

        inline Ast::EnumMemberDef& createEnumMemberDef(const zbl::TokenData& name) {
            Ast::NumericConstantExpr& expr = createNumericConstantExpr(z::string("int"), z::string("0"));
            return createEnumMemberDefInit(name, false, expr);
        }

    public:
        struct TypeDefSig {
            Ast::TypeSpec::AccessType::T accessType;

            zbl::TokenData name;
        };

    public:
        inline TypeDefSig createTypeDefSig(const Ast::TypeSpec::AccessType::T& accessType, const zbl::TokenData& name) {
            TypeDefSig sig;
            sig.accessType = accessType;
            sig.name = name;
            return sig;
        }

        inline Ast::TypeDecl& createTypeDecl(const TypeDefSig& sig) {
            Ast::TypeDecl& rv = _unit.addNode(new Ast::TypeDecl(sig.accessType, zbl::Token::getValue(sig.name), getNativeType()));
            return addChildLevel(rv);
        }

        inline Ast::TypeDef& createTypeDef(const TypeDefSig& sig, const Ast::QualifiedType& type) {
            Ast::TypeDef& rv = _unit.addNode(new Ast::TypeDef(sig.accessType, zbl::Token::getValue(sig.name), getNativeType(), type));
            return addChildLevel(rv);
        }

    public:
        inline Ast::GrammarToken& createGrammarToken(const TokenData& name, const TokenData& txt, const bool& isRex, const bool& isNot) {
            z::string namev = zbl::Token::getValue(name);
            if(namev.length() > 0) {
                const Ast::QualifiedType& type = getQualifiedType(z::string("string"));
                addVariableDef(Ast::VariableDef::Param, type, namev);
            }

            Ast::GrammarToken& rv = _unit.addNode(new Ast::GrammarToken(namev, zbl::Token::getValue(txt), isRex, isNot));
            return rv;
        }

        inline Ast::GrammarTokenList& createGrammarTokenList() {
            Ast::GrammarTokenList& rv = _unit.addNode(new Ast::GrammarTokenList());
            return rv;
        }

        inline Ast::GrammarMemberId& createGrammarMemberId(const TokenData& name) {
            Ast::GrammarMemberId& rv = _unit.addNode(new Ast::GrammarMemberId(zbl::Token::getValue(name)));
            return rv;
        }

        inline const Ast::VariableDef& createGrammarMemberNameDef(const TokenData& name) {
            const Ast::QualifiedType& type = getQualifiedType(z::string("string"));
            return addVariableDef(Ast::VariableDef::Param, type, zbl::Token::getValue(name));
        }

        inline Ast::GrammarMemberNameId& createGrammarMemberNameId(const TokenData& name, const TokenData& txt) {
            const Ast::VariableDef& vdef = createGrammarMemberNameDef(name);
            Ast::GrammarMemberNameId& rv = _unit.addNode(new Ast::GrammarMemberNameId(vdef, zbl::Token::getValue(txt)));
            return rv;
        }

        inline Ast::GrammarMemberList& createGrammarMemberList() {
            Ast::GrammarMemberList& rv = _unit.addNode(new Ast::GrammarMemberList());
            return rv;
        }

    public:
        inline Ast::FunctionDef& enterGrammarRuleOut(Ast::QualifiedType& out, const TokenData& name, Ast::Scope& in) {
            int idx = _unit.getImplList().size();

            z::string fname = z::string::creator(z::string("_gru_%{n}_%{i}"))
                .arg(z::any("n"), z::any(zbl::Token::getValue(name)))
                .arg(z::any("i"), z::any(idx))
                .value();

            Ast::TypeSpec::AccessType::T accessType = Ast::TypeSpec::AccessType::Private;
            Ast::FunctionDef::Modifier::T modifier = Ast::FunctionDef::Modifier::None;
            Ast::FunctionDef& fdef = enterFunctionName(accessType, out, fname, in, modifier);
            fdef.setGrammarName(zbl::Token::getValue(name));
            return fdef;
        }

        inline Ast::FunctionDef& enterGrammarRule(const TokenData& name, Ast::Scope& in) {
            Ast::QualifiedType& out = getQualifiedType(z::string("int"));
            return enterGrammarRuleOut(out, name, in);
        }

        inline Ast::GrammarRuleStatement& leaveGrammarRuleBlock(Ast::FunctionDef& fdef, const Ast::GrammarMemberList& list, const Ast::StatementList& stmtList) {
            Ast::FunctionBlock& fblock = createFunctionBlock(stmtList);
            Ast::FunctionImplItem& implItem = leaveFunctionDef(fdef, fblock);
            unused(implItem);

            Ast::GrammarRuleStatement& rv = _unit.addNode(new Ast::GrammarRuleStatement(fdef.getGrammarName(), fdef, fblock, list));
            return rv;
        }

        inline Ast::GrammarRuleStatement& leaveGrammarRule(Ast::FunctionDef& fdef, const Ast::GrammarMemberList& list) {
            // manually construct a "return true;" statement and add it to the empty statement list.
            Ast::BooleanConstantExpr& texpr = createBooleanConstantExpr(z::string("true"));
            Ast::RoutineReturnStatement& rtn = createRoutineReturnStatement(texpr);
            Ast::StatementList& stmtList = createEmptyStatementList();
            stmtList.addStatement(rtn);

            return leaveGrammarRuleBlock(fdef, list, stmtList);
        }

    private:
        inline Ast::GrammarLexer& enterLexerState(const z::string& name) {
            Ast::GrammarLexer& rv = _unit.addNode(new Ast::GrammarLexer(name));
            _grammarLexerStack.push(ptr(rv));
            return rv;
        }

    public:
        inline Ast::GrammarLexer& enterLexerState(const TokenData& name) {
            return enterLexerState(zbl::Token::getValue(name));
        }

        inline Ast::GrammarLexer& enterLexerState() {
            return enterLexerState(z::string("stdlx"));
        }

        inline Ast::GrammarLexer& leaveLexerState(Ast::GrammarLexer& lexer, Ast::LexerStatementList& list) {
            assert(_grammarLexerStack.top() == ptr(lexer));
            _grammarLexerStack.pop();

            lexer.setList(list);
            return lexer;
        }

    public:
        inline Ast::FunctionDef& enterLexer(const TokenData& name, Ast::Scope& in) {
            assert(_grammarLexerStack.size() > 0);
            Ast::GrammarLexer& lexer = ref(_grammarLexerStack.top());

            int idx = _unit.getImplList().size();

            z::string fname = z::string::creator(
                z::string("_glx_%{l}_%{n}_%{i}"))
                .arg(z::any("l"), z::any(lexer.getName()))
                .arg(z::any("n"), z::any(zbl::Token::getValue(name)))
                .arg(z::any("i"), z::any(idx)
                ).value();

            Ast::QualifiedType& out = getQualifiedType(z::string("string"));
            Ast::TypeSpec::AccessType::T accessType = Ast::TypeSpec::AccessType::Private;
            Ast::FunctionDef::Modifier::T modifier = Ast::FunctionDef::Modifier::None;
            Ast::FunctionDef& fdef = enterFunctionName(accessType, out, fname, in, modifier);
            fdef.setGrammarName(zbl::Token::getValue(name));
            return fdef;
        }

        inline Ast::LexerStatement& leaveLexer(Ast::FunctionDef& fdef, const Ast::GrammarTokenList& list, const Ast::StatementList& stmtList) {
            // get top-most lexer
            assert(_grammarLexerStack.size() > 0);
            Ast::GrammarLexer& lexer = ref(_grammarLexerStack.top());

            // leave function
            Ast::FunctionBlock& fblock = createFunctionBlock(stmtList);
            leaveFunctionDef(fdef, fblock);

            // create lexer
            Ast::LexerStatement& rv = _unit.addNode(new Ast::LexerStatement(fdef.getGrammarName(), fdef, fblock, lexer, list));
            return rv;
        }

        inline Ast::LexerStatement& leaveLexer(Ast::FunctionDef& fdef, const Ast::GrammarTokenList& list) {
            // add dummy in-param
            Ast::Scope& in = fdef.getInType();
            Ast::QualifiedType& type = getQualifiedType(z::string("string"));
            Ast::ParamVariableDef& vdef = createParamVariableDef(type, z::string("_t"));
            in.addDef(vdef);

            // manually construct a "return _t;" statement...
            const Ast::VariableRef& vref = createVariableRef(Ast::Storage::Block, vdef);
            Ast::Expr& vrefExpr = createVariableRefExpr(vref);
            Ast::RoutineReturnStatement& rtn = createRoutineReturnStatement(vrefExpr);

            // and add it to the empty statement list.
            Ast::StatementList& stmtList = createEmptyStatementList();
            stmtList.addStatement(rtn);

            return leaveLexer(fdef, list, stmtList);
        }

    public:
        inline Ast::LexerStatementList& createLexerStatementList() {
            Ast::LexerStatementList& rv = _unit.addNode(new Ast::LexerStatementList());
            return rv;
        }

        inline Ast::GrammarLexerList& createGrammarLexerList() {
            Ast::GrammarLexerList& rv = _unit.addNode(new Ast::GrammarLexerList());
            return rv;
        }

        inline Ast::GrammarStatementList& createGrammarStatementList() {
            Ast::GrammarStatementList& rv = _unit.addNode(new Ast::GrammarStatementList());
            return rv;
        }

        inline Ast::GrammarOptionValueList& createGrammarOptionValueList(const TokenData& value) {
            Ast::GrammarOptionValueList& rv = _unit.addNode(new Ast::GrammarOptionValueList());
            rv.addValue(zbl::Token::getValue(value));
            return rv;
        }

        inline Ast::GrammarOptionValueList& addGrammarOptionValue(Ast::GrammarOptionValueList& list, const TokenData& value) {
            list.addValue(zbl::Token::getValue(value));
            return list;
        }

        inline Ast::GrammarOption& createGrammarOption(const TokenData& name, const Ast::GrammarOptionValueList& list) {
            Ast::GrammarOption& rv = _unit.addNode(new Ast::GrammarOption(zbl::Token::getValue(name), list));
            return rv;
        }

        inline Ast::GrammarOptionList& createGrammarOptionList() {
            Ast::GrammarOptionList& rv = _unit.addNode(new Ast::GrammarOptionList());
            return rv;
        }

    private:
        inline void addOutParamChild(Ast::MethodTypeSpec& rv, const Ast::QualifiedType& out) const {
            const Ast::TypeSpec& ts = out.getTypeSpec();
            const Ast::OutParam* cop = dynamic_cast<const Ast::OutParam*>(ptr(ts));
            if(0 != cop) {
                Ast::OutParam* op = const_cast<Ast::OutParam*>(cop); //TODO: eliminate const_cast
                rv.addChild(ref(op));
                rv.setIsTuple(ref(op).getIsTuple());
            }
        }

    public:
        inline Ast::FunctionDef& enterFunctionName(const Ast::TypeSpec::AccessType::T& accessType, const Ast::QualifiedType& out, const z::string& name, Ast::Scope& in, const Ast::FunctionDef::Modifier::T& modifier) {
            Ast::FunctionDef& fdef = _unit.addNode(new Ast::FunctionDef(accessType, out, name, in, getNativeType(), modifier));
            addOutParamChild(fdef, out);

            addChildLevel(fdef);
            return enterTypeSpec(fdef);
        }

        inline Ast::FunctionDef& enterFunction(const Ast::TypeSpec::AccessType::T& accessType, Ast::QualifiedType& out, const zbl::TokenData& name, Ast::Scope& in, const Ast::FunctionDef::Modifier::T& modifier) {
            return enterFunctionName(accessType, out, zbl::Token::getValue(name), in, modifier);
        }

    public:
        inline Ast::FunctionDef& leaveFunction(Ast::FunctionDef& fdef) {
            leaveInParamScope();
            return leaveTypeSpec(fdef);
        }

    private:
        template <typename BlockT, typename ImplT>
        inline ImplT& createImplItemT(Ast::FunctionDef& fdef, const BlockT& block) {
            int idx = _unit.getImplList().size();
            ImplT& item = _unit.addNode(new ImplT(idx, fdef, block));
            _unit.addItem(item);
            fdef.setImpl(item);
            return item;
        }

        template <typename BlockT, typename ImplT>
        inline ImplT& leaveFunctionT(Ast::FunctionDef& fdef, const BlockT& block) {
            ImplT& item = createImplItemT<BlockT, ImplT>(fdef, block);
            leaveFunction(fdef);
            return item;
        }

    public:
        inline Ast::FunctionImplItem& leaveFunctionDef(Ast::FunctionDef& fdef, const Ast::FunctionBlock& block) {
            if(fdef.getName() == "main") {
                // manually create the AST nodes to generate a continuation that invokes the main function.
                enterContinuation();
                Ast::FunctionCall& fcall = createFunctionCall(fdef);
                Ast::ExprList& exprList = createExprList();

                const Ast::QualifiedType& stype = getQualifiedType(z::string("string"));
                Ast::ListTemplate& ltype = createListTemplate(stype);
                const Ast::QualifiedType& type = createQualifiedType(false, ltype, false);
                Ast::VariableDef& vdef = addVariableDef(Ast::VariableDef::Local, type, "_argl");

                Ast::VariableRef& vref = createVariableRef(Ast::Storage::Block, vdef);
                Ast::VariableRefExpr& vrefExpr = createVariableRefExpr(vref);
                exprList.addExpr(vrefExpr);

                Ast::Invoker& invoker = createInvoker(fcall, exprList);
                Ast::InitClosure& closure = createCallClosure(invoker);
                Ast::ClosureList& closureList = createClosureList(closure);
                Ast::ContinuationImplItem& continuation = createContinuationImplItem(closureList);
                leaveContinuation(continuation);

                // set _mainSeq in unit.
                _unit.setMainContinuation(continuation);
            }

            Ast::FunctionImplItem& impl = leaveFunctionT<Ast::FunctionBlock, Ast::FunctionImplItem>(fdef, block);
            return impl;
        }

        inline Ast::RoutineImplItem& leaveRoutineDef(Ast::FunctionDef& fdef, const Ast::RoutineBlock& block) {
            return leaveFunctionT<Ast::RoutineBlock, Ast::RoutineImplItem>(fdef, block);
        }

        inline Ast::GrammarImplItem& leaveGrammarDef(Ast::FunctionDef& fdef, const Ast::GrammarBlock& block) {
            return leaveFunctionT<Ast::GrammarBlock, Ast::GrammarImplItem>(fdef, block);
        }

        inline Ast::WindowImplItem& leaveWindowDef(Ast::FunctionDef& fdef, const Ast::WindowBlock& block) {
            return leaveFunctionT<Ast::WindowBlock, Ast::WindowImplItem>(fdef, block);
        }

    public:
        inline Ast::FunctionDef& enterFunctionImpl(Ast::TypeSpec& type) {
            Ast::FunctionDef* fdef = dynamic_cast<Ast::FunctionDef*>(ptr(type));
            if(0 == fdef) {
                throw z::exception(z::string::creator("%{err} Not a function: %{name}").arg(z::any("err"), z::any(err())).arg(z::any("name"), z::any(type.getFullName(z::string("::")))).value());
            }

            Ast::Scope& scope = ref(fdef).getInType();
            _scopeStack.push(ptr(scope));
            enterTypeSpec(ref(fdef));

            return ref(fdef);
        }

        inline Ast::FunctionImplItem& leaveFunctionImpl(Ast::FunctionDef& fdef, Ast::FunctionBlock& block) {
            int idx = _unit.getImplList().size();
            Ast::FunctionImplItem& item = _unit.addNode(new Ast::FunctionImplItem(idx, fdef, block));
            _unit.addItem(item);

            leaveTypeSpec(fdef);
            _scopeStack.pop();

            return item;

        }

        inline Ast::FunctionImplExpr& createFunctionImplExpr(Ast::FunctionImplItem& item) {
            const Ast::QualifiedType& qtype = createQualifiedType(false, item.getFunctionDef(), false);
            Ast::FunctionImplExpr& impl = _unit.addNode(new Ast::FunctionImplExpr(qtype, item));
            return impl;
        }

        inline Ast::FunctionDefImplExpr& createFunctionDefImplExpr(Ast::ImplItem& item) {
            const Ast::QualifiedType& qtype = createQualifiedType(false, item.getFunctionDef(), false);
            Ast::FunctionDefImplExpr& impl = _unit.addNode(new Ast::FunctionDefImplExpr(qtype, item));
            return impl;
        }

    public:
        inline Ast::RoutineBlock& createRoutineBlock(Ast::StatementList& list) {
            const Ast::StatementBlock& sblock = createStatementBlock(list);
            Ast::VariableRefList refList;
            Ast::RoutineBlock& block = _unit.addNode(new Ast::RoutineBlock(refList, sblock));
            return block;
        }

        inline Ast::FunctionBlock& createFunctionBlock(const Ast::StatementList& list) {
            const Ast::FunctionDef& fdef = getFunctionDef();
            zbl::RefCollector col(ref(this), Ast::Storage::ExternalRef);
            col.getStatementListRefList(fdef, list);
            const Ast::VariableRefList& refList = col.getRefList();

            const Ast::StatementBlock& sblock = createStatementBlock(list);
            Ast::FunctionBlock& block = _unit.addNode(new Ast::FunctionBlock(refList, sblock));
            return block;
        }

        inline Ast::GrammarBlock& createGrammarBlock(const Ast::GrammarOptionList& optList, const Ast::GrammarStatementList& list, const Ast::GrammarLexerList& lexList) {
            zbl::RefCollector col(ref(this), Ast::Storage::ExternalRef);
            const Ast::VariableRefList& refList = col.getRefList();

            Ast::GrammarBlock& rv = _unit.addNode(new Ast::GrammarBlock(refList, optList, list, lexList));
            return rv;
        }

        inline Ast::WindowBlock& createWindowBlock(Ast::FunctionBlock& functionBlock) {
            zbl::RefCollector col(ref(this), Ast::Storage::ExternalRef);
            const Ast::VariableRefList& refList = col.getRefList();

            Ast::WindowBlock& rv = _unit.addNode(new Ast::WindowBlock(refList, functionBlock));
            return rv;
        }

    private:
        inline const Ast::AnyExpr& createVarExpr(const Ast::Expr& expr) {
            const Ast::QualifiedType& type = getQualifiedType(z::string("any"));
            return _unit.addNode(new Ast::AnyExpr(type, expr));
        }

        inline const Ast::CastExpr& createCastExpr(const Ast::Expr& expr) {
            const Ast::QualifiedType& type = expr.getType();
            return _unit.addNode(new Ast::CastExpr(type, expr));
        }

    public:
        inline Ast::OwnerTemplate& createOwnerTemplate(const Ast::QualifiedType& type) {
            return _unit.addNode(new Ast::OwnerTemplate(Ast::TypeSpec::AccessType::Private, z::string("owner"), type));
        }

        inline Ast::ListTemplate& createListTemplate(const Ast::QualifiedType& type) {
            return _unit.addNode(new Ast::ListTemplate(Ast::TypeSpec::AccessType::Private, z::string("list"), type));
        }

        inline Ast::DictTemplate& createDictTemplate(const Ast::QualifiedType& key, const Ast::QualifiedType& type) {
            return _unit.addNode(new Ast::DictTemplate(Ast::TypeSpec::AccessType::Private, z::string("dict"), key, type));
        }

    public:
        inline Ast::ListItem& createListItem(const Ast::Expr& expr) {
            return _unit.addNode(new Ast::ListItem(expr));
        }

        inline void addListItem(Ast::ListList& list, const Ast::ListItem& item) {
            const Ast::QualifiedType* ltype = list.hasType();
            const Ast::QualifiedType* rtype = ptr(item.getExpr().getType());
            if(ltype != 0) {
                const Ast::QualifiedType& type = coerce(ref(ltype), ref(rtype));
                rtype = ptr(type);
            }
            assert(rtype != 0);
            list.setType(rtype);
            return list.addItem(item);
        }

        inline Ast::ListList& createListList() {
            return _unit.addNode(new Ast::ListList());
        }

    public:
        inline Ast::DictItem& createDictItem(const Ast::Expr& key, const Ast::Expr& expr) {
            return _unit.addNode(new Ast::DictItem(key, expr));
        }

        inline void addDictItem(Ast::DictList& list, const Ast::DictItem& item) {
            const Ast::QualifiedType* lkey = list.hasKey();
            const Ast::QualifiedType* rkey = ptr(item.getKey().getType());
            if(lkey != 0) {
                const Ast::QualifiedType& key = coerce(ref(lkey), ref(rkey));
                rkey = ptr(key);
            }
            assert(rkey != 0);
            list.setKeyType(rkey);

            const Ast::QualifiedType* ltype = list.hasType();
            const Ast::QualifiedType* rtype = ptr(item.getExpr().getType());
            if(ltype != 0) {
                const Ast::QualifiedType& type = coerce(ref(ltype), ref(rtype));
                rtype = ptr(type);
            }
            assert(rtype != 0);
            list.setValueType(rtype);

            return list.addItem(item);
        }

        inline Ast::DictList& createDictList() {
            return _unit.addNode(new Ast::DictList());
        }

    public:
        inline Ast::DictItem& createTreeItem(const Ast::Expr& key, const Ast::Expr& expr) {
            return _unit.addNode(new Ast::DictItem(createVarExpr(key), createVarExpr(expr)));
        }

        inline void addTreeItem(Ast::DictList& list, const Ast::DictItem& item) {
            return list.addItem(item);
        }

        inline Ast::DictList& createTreeList() {
            const Ast::QualifiedType* ltype = ptr(getQualifiedType(z::string("any")));
            Ast::DictList& list = _unit.addNode(new Ast::DictList());
            list.setKeyType(ltype);
            list.setValueType(ltype);
            return list;
        }

    private:
        inline const Ast::VariableDef& addClosureVariableDef(const Ast::QualifiedType& type, const zbl::TokenData& name) {
            const Ast::VariableDef& vdef = addVariableDef(Ast::VariableDef::Closure, type, zbl::Token::getValue(name));
            return vdef;
        }

    public:
        inline Ast::RunClosure& createRunClosure() {
            Ast::VariableRefList refList;
            const Ast::QualifiedType& qtype = getQualifiedType(z::string("void"));
            return _unit.addNode(new Ast::RunClosure(refList, qtype));
        }

        inline Ast::ExitClosure& createExitClosure() {
            Ast::VariableRefList refList;
            const Ast::QualifiedType& qtype = getQualifiedType(z::string("void"));
            return _unit.addNode(new Ast::ExitClosure(refList, qtype));
        }

        inline Ast::CallClosure& createNamedCallClosure(const zbl::TokenData& name, const Ast::Invoker& fcall) {
            const Ast::VariableDef& vdef = addClosureVariableDef(fcall.getInvokerType().getFunctionDef().getOutType(), name);

            if(fcall.getInvokerType().getFunctionDef().getModifier() == Ast::FunctionDef::Modifier::Routine) {
                Ast::VariableRefList refList;
                return _unit.addNode(new Ast::CallClosure(refList, vdef, fcall));
            }

            zbl::RefCollector col(ref(this), Ast::Storage::ExternalRef);
            col.getInvokerRefList(fcall);
            const Ast::VariableRefList& refList = col.getRefList();

            return _unit.addNode(new Ast::CallClosure(refList, vdef, fcall));
        }

        inline Ast::CallClosure& createCallClosure(const Ast::Invoker& fcall) {
            zbl::Token name(fcall.getInvokerType().getFunctionDef().getName());
            return createNamedCallClosure(name, fcall);
        }

        inline Ast::FunctionCallClosure& createFunctionCallClosure(const zbl::TokenData& name, const Ast::Invoker& fcall) {
            zbl::RefCollector col(ref(this), Ast::Storage::ExternalRef);
            col.getInvokerRefList(fcall);
            const Ast::VariableRefList& refList = col.getRefList();

            const Ast::VariableDef& vdef = addClosureVariableDef(fcall.getInvokerType().getFunctionDef().getOutType(), name);
            return _unit.addNode(new Ast::FunctionCallClosure(refList, vdef, fcall));
        }

        inline Ast::FunctionCallClosure& createFunctionCallClosure(const Ast::Invoker& fcall) {
            z::string iname = fcall.getInvokerType().getFunctionDef().getName();
            iname = "c" + iname;
            zbl::Token name(iname);

            zbl::RefCollector col(ref(this), Ast::Storage::ExternalRef);
            col.getInvokerRefList(fcall);
            const Ast::VariableRefList& refList = col.getRefList();

            const Ast::VariableDef& vdef = addClosureVariableDef(fcall.getInvokerType().getFunctionDef().getOutType(), name);
            return _unit.addNode(new Ast::FunctionCallClosure(refList, vdef, fcall));
        }

        inline Ast::LoopClosure& createLoopClosure(const Ast::Expr& expr) {
            zbl::RefCollector col(ref(this), Ast::Storage::ExternalRef);
            col.getExprRefList(expr);
            const Ast::VariableRefList& refList = col.getRefList();

            return _unit.addNode(new Ast::LoopClosure(refList, expr));
        }

        inline Ast::SharedClosure& createSharedClosure(const zbl::TokenData& name, const Ast::SharedDef& sharedList) {
            zbl::RefCollector col(ref(this), Ast::Storage::ExternalRef);
            col.getSharedDefRefList(sharedList);
            const Ast::VariableRefList& refList = col.getRefList();

            const Ast::QualifiedType& qtype = createQualifiedType(false, sharedList, false);
            const Ast::VariableDef& vdef = addClosureVariableDef(qtype, name);
            return _unit.addNode(new Ast::SharedClosure(refList, vdef, sharedList));
        }

        inline Ast::ReturnClosure& createReturnClosure(const Ast::Closure::Type& type, const Ast::ExprList& list) {
            zbl::RefCollector col(ref(this), Ast::Storage::ExternalRef);
            col.getExprListRefList(list);
            const Ast::VariableRefList& refList = col.getRefList();
            Ast::ReturnClosure& closure = _unit.addNode(new Ast::ReturnClosure(refList, list));

            closure.setType(type);
            return closure;
        }

        inline Ast::ReturnClosure& createDefaultReturnClosure(const Ast::Closure::Type& type, Ast::FunctionDef& fdef) {
            Ast::ExprList& list = createExprList();

            const Ast::TypeSpec& ts = fdef.getOutType().getTypeSpec();

            // if outtype of fdef is not an outparam, return default value for qtype
            const Ast::OutParam* op = dynamic_cast<const Ast::OutParam*>(ptr(ts));
            if(0 != op) {
                for(Ast::VariableDefMap::List::iterator it(ref(op).getDefList().getList()); !it.end(); ++it) {
                    const Ast::VariableDef& vdef = ref(*it);
                    const Ast::Expr& expr = getTypeDefaultValue(vdef.getType().getTypeSpec());
                    list.addExpr(expr);
                }
            } else {
                const Ast::Expr& expr = getTypeDefaultValue(ts);
                list.addExpr(expr);
            }

            return createReturnClosure(type, list);
        }

    public:
        inline Ast::ClosureList& createClosureList(Ast::Closure& closure) {
            Ast::ClosureList& rv = _unit.addNode(new Ast::ClosureList());
            rv.addClosure(closure);
            return rv;
        }

        inline Ast::ClosureList& addClosureToList(Ast::ClosureList& list, const Ast::Closure::Type& type, Ast::Closure& closure) {
            list.addClosure(closure);
            closure.setType(type);
            return list;
        }

        inline Ast::ContinuationImplItem& createContinuationImplItem(Ast::ClosureList& closureList, const Ast::ReturnClosure& retnClosure) {
            Ast::FunctionDef& fdef = getFunctionDef();
            int id = _unit.getImplList().size();
            Ast::ContinuationImplItem& item = _unit.addNode(new Ast::ContinuationImplItem(id, fdef, closureList, retnClosure));
            _unit.addItem(item);

            zbl::RefCollector col(ref(this), Ast::Storage::ExternalRef);
            col.getImplItemRefList(item);
            const Ast::VariableRefList& refList = col.getRefList();
            item.setXRefList(refList);

            return item;
        }

        inline Ast::ContinuationImplItem& createContinuationImplItem(Ast::ClosureList& closureList) {
            Ast::FunctionDef& fdef = getFunctionDef();
            Ast::ReturnClosure& retnClosure = createDefaultReturnClosure(Ast::Closure::Link, fdef);
            return createContinuationImplItem(closureList, retnClosure);
        }

    public:
        inline Ast::ExprList& createExprList() {return _unit.addNode(new Ast::ExprList());}

    private:
        inline const Ast::Expr& convertToQueryConstant(const Ast::Expr& expr) {
            if(isQueryType(expr.getType()))
                return expr;

            // Note there is no binary expression per se here. We are only coercing expr's
            // type with val, to get the query expression type from a native constant value.
            const Ast::QualifiedType& ctype = getQualifiedType(z::string("qval"));
            const Ast::QualifiedType& qtype = coerce(ctype, expr.getType());
            return _unit.addNode(new Ast::QueryConstantExpr(qtype, expr));
        }

    public:
        inline Ast::QueryExpr& createQueryExpr(const Ast::Expr& expr) {
            const Ast::QualifiedType& type = getQualifiedType(z::string("query"));
            return _unit.addNode(new Ast::QueryExpr(type, expr));
        }

        inline Ast::QueryPartExpr& createQueryPartExpr(const Ast::Expr& keyExpr, const Ast::Expr& valExpr) {
            const Ast::QualifiedType& type = getQualifiedType(z::string("qpair"));
            const Ast::Expr& kexpr = convertToQueryConstant(keyExpr);
            const Ast::Expr& vexpr = convertToQueryConstant(valExpr);
            return _unit.addNode(new Ast::QueryPartExpr(type, kexpr, vexpr));
        }

        inline Ast::QueryValExpr& createQueryValExpr() {
            const Ast::QualifiedType& type = getQualifiedType(z::string("qval"));
            return _unit.addNode(new Ast::QueryValExpr(type));
        }

    private:
        inline bool isQueryType(const Ast::QualifiedType& type) {
            const Ast::TypeSpec* ts = ptr(type.getTypeSpec());
            const Ast::UserDefinedTypeSpec* uts = dynamic_cast<const Ast::UserDefinedTypeSpec*>(ts);
            if(!uts)
                return false;
            return (ref(uts).getNativeType() == Ast::UserDefinedTypeSpec::ntQuery);
        }

    public:
        inline Ast::TernaryOpExpr& createTernaryOpExpr(const Ast::Expr& lhs, const z::string& op1, const Ast::Expr& rhs1, const z::string& op2, const Ast::Expr& rhs2) {
            const Ast::QualifiedType& type = coerce(rhs1.getType(), rhs2.getType());
            return _unit.addNode(new Ast::TernaryOpExpr(type, lhs, op1, rhs1, op2, rhs2));
        }

        inline Ast::BinaryExpr& createBinaryOpExpr(const Ast::Expr& lhs, const z::string& op, const Ast::Expr& rhs) {
            const Ast::QualifiedType& type = coerce(lhs.getType(), rhs.getType());
            if(isQueryType(type)) {
                const Ast::QualifiedType& qtype = getQualifiedType(z::string("qbinary"));
                const Ast::Expr& lexpr = convertToQueryConstant(lhs);
                const Ast::Expr& rexpr = convertToQueryConstant(rhs);
                return _unit.addNode(new Ast::QueryBinaryExpr(qtype, lexpr, op, rexpr));
            }

            const Ast::QualifiedType& qtype = createQualifiedType(false, type.getTypeSpec(), false);
            return _unit.addNode(new Ast::BinaryOpExpr(qtype, lhs, op, rhs));
        }

        inline Ast::OrderedExpr& createOrderedExpr(const Ast::Expr& rhs) {
            const Ast::QualifiedType& type = rhs.getType();
            return _unit.addNode(new Ast::OrderedExpr(type, rhs));
        }

        class IndexExprCreator : public IndexableTypeCaster {
        public:
            inline IndexExprCreator(const Ast::Expr& expr, const Ast::Expr& idx) : _rv(0), _expr(expr), _idx(idx) {}

        public:
            inline Ast::IndexExpr& create(ParseContext& pctx, const Ast::TypeSpec& typeSpec) {
                cast(pctx, typeSpec);
                return pctx._unit.addNode(_rv);
            }

        private:
            virtual void visitList(ParseContext& pctx, const Ast::ListTemplate& type) {
                unused(pctx);
                const Ast::QualifiedType& qtype = type.getType();
                _rv = new Ast::IndexExpr(qtype, _expr, _idx);
            }

            virtual void visitDict(ParseContext& pctx, const Ast::DictTemplate& type) {
                const Ast::QualifiedType& qtype = type.getType();
                // possible hack. The index of a tree must be an any expr.
                if((qtype.getTypeSpec().getName() == "any") && (_idx.getType().getTypeSpec().getName() != "any")) {
                    const Ast::AnyExpr& vexpr = pctx.createVarExpr(_idx);
                    _rv = new Ast::IndexExpr(qtype, _expr, vexpr);
                    return;
                }
                _rv = new Ast::IndexExpr(qtype, _expr, _idx);
            }

            virtual void visitTree(ParseContext& pctx, const Ast::TypeDecl& type) {
                unused(type);

                // The index of a tree must be an any expr.
                const Ast::QualifiedType& qtype = pctx.getQualifiedType(z::string("any"));
                if(_idx.getType().getTypeSpec().getName() != "any") {
                    const Ast::AnyExpr& vexpr = pctx.createVarExpr(_idx);
                    _rv = new Ast::IndexExpr(qtype, _expr, vexpr);
                    return;
                }
                _rv = new Ast::IndexExpr(qtype, _expr, _idx);
            }

            virtual void visitBuffer(ParseContext& pctx, const Ast::TypeDecl& type) {
                unused(type);

                // The index of a buffer must be a char expr.
                const Ast::QualifiedType& qtype = pctx.getQualifiedType(z::string("char"));
                _rv = new Ast::IndexExpr(qtype, _expr, _idx);
            }

            virtual void visitView(ParseContext& pctx, const Ast::TypeDecl& type) {
                unused(type);
                const Ast::QualifiedType& qtype = pctx.getQualifiedType(z::string("widget"));
                _rv = new Ast::IndexExpr(qtype, _expr, _idx);
            }

            virtual void visitWidget(ParseContext& pctx, const Ast::TypeDecl& type) {
                unused(type);
                const Ast::QualifiedType& qtype = pctx.getQualifiedType(z::string("property"));
                _rv = new Ast::IndexExpr(qtype, _expr, _idx);
            }

        private:
            Ast::IndexExpr* _rv;

            const Ast::Expr& _expr;

            const Ast::Expr& _idx;
        };

        inline Ast::IndexExpr& createIndexExpr(const Ast::Expr& expr, const Ast::Expr& idx) {
            IndexExprCreator creator(expr, idx);
            return creator.create(ref(this), expr.getType().getTypeSpec());
        }

        inline Ast::IndexExpr& createIndexKeyExpr(const Ast::Expr& expr, const TokenData& idx) {
            const Ast::Expr& idxe = createStringConstantExpr(idx);
            return createIndexExpr(expr, idxe);
        }

        inline Ast::PrefixOpExpr& createPrefixOpExpr(const z::string& op, const Ast::Expr& rhs) {
            const Ast::QualifiedType& type = rhs.getType();
            return _unit.addNode(new Ast::PrefixOpExpr(type, op, rhs));
        }

        inline Ast::PostfixOpExpr& createPostfixOpExpr(const Ast::Expr& lhs, const z::string& op) {
            const Ast::QualifiedType& type = lhs.getType();
            return _unit.addNode(new Ast::PostfixOpExpr(type, lhs, op));
        }

        inline Ast::StringFormatExpr& createStringFormatExpr(const Ast::Expr& format, const Ast::DictList& list) {
            const Ast::QualifiedType& type = getQualifiedType(z::string("string"));
            return _unit.addNode(new Ast::StringFormatExpr(type, format, list));
        }

        inline Ast::ListExpr& createListExpr(const Ast::ListList& list) {
            const Ast::QualifiedType* ltype = list.hasType();
            if(ltype == 0)
                ltype = ptr(getQualifiedType(z::string("void")));

            const Ast::ListTemplate& type = createListTemplate(ref(ltype));
            const Ast::QualifiedType& etype = createQualifiedType(false, type, false);
            return _unit.addNode(new Ast::ListExpr(etype, list));
        }

        inline Ast::DictExpr& createDictExpr(const Ast::DictList& list) {
            const Ast::QualifiedType* lkey = list.hasKey();
            if(lkey == 0)
                lkey = ptr(getQualifiedType(z::string("any")));

            const Ast::QualifiedType* ltype = list.hasType();
            if(ltype == 0)
                ltype = ptr(getQualifiedType(z::string("any")));

            const Ast::DictTemplate& type = createDictTemplate(ref(lkey), ref(ltype));
            const Ast::QualifiedType& etype = createQualifiedType(false, type, false);
            return _unit.addNode(new Ast::DictExpr(etype, list));
        }

        inline Ast::TreeExpr& createTreeExpr(const Ast::DictList& list) {
            const Ast::QualifiedType& etype = getQualifiedType(z::string("tree"));
            return _unit.addNode(new Ast::TreeExpr(etype, list));
        }

    public:
        inline Ast::VariableRef& createVariableRef(const Ast::Storage::T& storage, const Ast::VariableDef& vdef) {
            Ast::VariableRef& vref = _unit.addNode(new Ast::VariableRef(storage));
            vref.addDef(vdef);
            return vref;
        }

        inline Ast::VariableRef& createVariableRef(const zbl::TokenData& name) {
            Ast::Storage::T storage = name.storage;
            const Ast::VariableDef* vd = name.vdef;
            if(!vd) {
                throw z::exception(z::string::creator("%{err} Variable: %{name} not found")
                                   .arg(z::any("err"), z::any(err()))
                                   .arg(z::any("name"), z::any(zbl::Token::getValue(name)))
                                   .value());
            }
            return createVariableRef(storage, ref(vd));
        }

        inline Ast::VariableRef& addVariableDefToList(Ast::VariableRef& vref, const zbl::TokenData& name) {
            const Ast::VariableDef& vdefl = vref.getLast();
            const Ast::VariableDef* cvd = hasMember(vdefl, name);
            if(!cvd) {
                throw z::exception(z::string::creator("%{err} Member variable: %{name} of %{parent} not found")
                                   .arg(z::any("err"), z::any(err(name)))
                                   .arg(z::any("name"), z::any(zbl::Token::getValue(name)))
                                   .arg(z::any("parent"), z::any(vref.getLast().getName()))
                                   .value());
            }
            vref.addDef(ref(cvd));
            return vref;
        }

        inline Ast::VariableRefExpr& createVariableRefExpr(const Ast::VariableRef& vref) {
            // get type of last entry in vardef list. So if vdl is 'x.y.i', get the qtype of 'i'.
            const Ast::QualifiedType& type = vref.getLast().getType();

            // create new qtype which is a ref of the original (const-ness remains the same)
            const Ast::QualifiedType& qtype = createQualifiedType(type.isConst(), type.getTypeSpec(), true);

            // create node
            return _unit.addNode(new Ast::VariableRefExpr(qtype, vref));
        }

        inline Ast::Expr& createEnumRefExpr(const Ast::TypeSpec& typeSpec, const zbl::TokenData& id) {
            const Ast::EnumDef* enumDef = dynamic_cast<const Ast::EnumDef*>(ptr(typeSpec));
            if(enumDef) {
                return getEnumRefExpr(ref(enumDef), zbl::Token::getValue(id));
            }

            throw z::exception(z::string::creator("%{err} Not an enum type: %{name}").arg(z::any("err"), z::any(err())).arg(z::any("name"), z::any(typeSpec.getFullName(z::string("::")))).value());
        }

    private:
        typedef z::stack<const Ast::StructDef*> StructInitStack;

        StructInitStack _structInitStack;

    public:
        inline void enterStructInit(const Ast::TypeSpec& typeSpec) {
            const Ast::StructDef* structDef = dynamic_cast<const Ast::StructDef*>(ptr(typeSpec));
            if(structDef) {
                _structInitStack.push(structDef);
                return;
            }

            throw z::exception(z::string::creator("%{err} Type is not a struct: %{name}").arg(z::any("err"), z::any(err())).arg(z::any("name"), z::any(typeSpec.getFullName(z::string("::")))).value());
        }

        inline Ast::StructInitItem& createStructInitItem(const zbl::TokenData& name, const Ast::Expr& expr) {
            const Ast::StructDef& structDef = ref(_structInitStack.top());
            const Ast::VariableDef* cvd = hasUdtMember(structDef, zbl::Token::getValue(name));
            if(!cvd) {
                throw z::exception(z::string::creator("%{err} Struct member variable: %{name} of %{parent} not found")
                                   .arg(z::any("err"), z::any(err(name)))
                                   .arg(z::any("name"), z::any(zbl::Token::getValue(name)))
                                   .arg(z::any("parent"), z::any(structDef.getName()))
                                   .value());
            }

            return _unit.addNode(new Ast::StructInitItem(ref(cvd), expr));
        }

        inline Ast::StructInitList& addStructInitItemToList(Ast::StructInitList& list, const Ast::StructInitItem& item) {
            list.addItem(item);
            return list;
        }

        inline Ast::StructInitList& createStructInitList() {
            return _unit.addNode(new Ast::StructInitList());
        }

        inline Ast::StructInitExpr& createStructInitExpr(const Ast::StructInitList& initList) {
            if(_structInitStack.size() <= 0) {
                throw z::exception(z::string::creator("%{err} Internal error: Struct stack underflow").arg(z::any("err"), z::any(err())).value());
            }

            const Ast::StructDef* structDef = _structInitStack.pop();
            const Ast::QualifiedType& type = createQualifiedType(false, ref(structDef), false);
            return _unit.addNode(new Ast::StructInitExpr(type, initList));
        }

        inline Ast::StructInitExpr& createStructInitEmptyExpr() {
            const Ast::StructInitList& initList = createStructInitList();
            return createStructInitExpr(initList);
        }

    public:
        inline Ast::InstanceExpr& createInstanceExpr(const Ast::TypeSpec& typeSpec, const Ast::ExprList& exprList) {
            const Ast::StructDef* strct = dynamic_cast<const Ast::StructDef*>(ptr(typeSpec));
            if(strct) {
                const Ast::QualifiedType& type = createQualifiedType(false, ref(strct), false);
                return _unit.addNode(new Ast::StructExpr(type, exprList));
            }

            const Ast::TypeDefTypeSpec* typeDef = dynamic_cast<const Ast::TypeDefTypeSpec*>(ptr(typeSpec));
            if(typeDef) {
                const Ast::QualifiedType& type = createQualifiedType(false, ref(typeDef), false);
                return _unit.addNode(new Ast::TypeDefExpr(type, exprList));
            }

            const Ast::FunctionDef* function = dynamic_cast<const Ast::FunctionDef*>(ptr(typeSpec));
            if(function) {
                const Ast::QualifiedType& type = createQualifiedType(false, ref(function), false);
                return _unit.addNode(new Ast::FunctionExpr(type, ref(function), exprList));
            }

            const Ast::ListTemplate* list = dynamic_cast<const Ast::ListTemplate*>(ptr(typeSpec));
            if(list) {
                const Ast::QualifiedType& type = createQualifiedType(false, ref(list), false);
                return _unit.addNode(new Ast::ListTemplateExpr(type, exprList));
            }

            const Ast::DictTemplate* dict = dynamic_cast<const Ast::DictTemplate*>(ptr(typeSpec));
            if(dict) {
                const Ast::QualifiedType& type = createQualifiedType(false, ref(dict), false);
                return _unit.addNode(new Ast::DictTemplateExpr(type, exprList));
            }

            throw z::exception(z::string::creator("%{err} Cannot create instance for type: %{name}").arg(z::any("err"), z::any(err())).arg(z::any("name"), z::any(typeSpec.getFullName(z::string("::")))).value());
        }

    public:
        inline const Ast::QualifiedType& getInternalCallType(const TokenData& name, const Ast::ExprList& exprList) {
            if(zbl::Token::getValue(name) == "create") {
                assert(exprList.getList().size() == 1);
                const Ast::Expr& expr = ref(exprList.getList().at(0));
                const Ast::TypeSpec& qtype = expr.getType().getTypeSpec();
                const Ast::TypeDef* typeDef = dynamic_cast<const Ast::TypeDef*>(ptr(qtype));
                if(!typeDef) {
                    throw z::exception(z::string::creator("%{err} First parameter of create must be typedef type").arg(z::any("err"), z::any(err(name))).value());
                }

                const Ast::TypeSpec& targetTypeSpec = ref(typeDef).getTargetType().getTypeSpec();
                const Ast::OwnerTemplate* ownerTypeSpec = dynamic_cast<const Ast::OwnerTemplate*>(ptr(targetTypeSpec));
                if(!ownerTypeSpec) {
                    throw z::exception(z::string::creator("%{err} First parameter of create must be typedef of owner type").arg(z::any("err"), z::any(err(name))).value());
                }

                const Ast::TypeSpec& instanceTypeSpec = ref(ownerTypeSpec).getType().getTypeSpec();
                const Ast::QualifiedType& type = createQualifiedType(false, instanceTypeSpec, true);
                return type;
            }

            const Ast::QualifiedType& type = getQualifiedType(z::string("void"));
            return type;
        }

        inline Ast::InternalCallExpr& createInternalCallExpr(const TokenData& name, const Ast::ExprList& exprList) {
            const Ast::QualifiedType& type = getInternalCallType(name, exprList);
            return _unit.addNode(new Ast::InternalCallExpr(type, zbl::Token::getValue(name), exprList));
        }

        inline Ast::InvokerCallExpr& createInvokerCallExpr(const Ast::Invoker& invoker) {
            const Ast::QualifiedType& type = invoker.getInvokerType().getFunctionDef().getOutType();
            return _unit.addNode(new Ast::InvokerCallExpr(type, invoker));
        }

        inline Ast::FunctionCallExpr& createFunctionCallExpr(Ast::ContinuationImplItem& continuation) {
            const Ast::QualifiedType& type = continuation.getInitClosure().getOutType();
            return _unit.addNode(new Ast::FunctionCallExpr(type, continuation));
        }

    public:
        inline Ast::Invoker& createInvoker(const Ast::InvokerType& invokerType, const Ast::ExprList& exprList) {
            return _unit.addNode(new Ast::Invoker(invokerType, exprList));
        }

    public:
        inline Ast::FunctionCall& createFunctionCall(const Ast::TypeSpec& typeSpec) {
            const Ast::FunctionDef* function = dynamic_cast<const Ast::FunctionDef*>(ptr(typeSpec));
            if(function) {
                return _unit.addNode(new Ast::FunctionCall(ref(function)));
            }

            throw z::exception(z::string::creator("%{err} Not a function type: %{name}").arg(z::any("err"), z::any(err())).arg(z::any("name"), z::any(typeSpec.getFullName(z::string("::")))).value());
        }

        inline Ast::FunctionDefCall& createFunctionDefCall(const Ast::ImplItem& item) {
            return _unit.addNode(new Ast::FunctionDefCall(item.getFunctionDef(), item));
        }

        inline Ast::FunctionImplCall& createFunctionImplCall(const Ast::ImplItem& item) {
            return _unit.addNode(new Ast::FunctionImplCall(item.getFunctionDef(), item));
        }

        inline Ast::FunctorCall& createFunctorExprCall(const Ast::Expr& expr) {
            const Ast::TypeSpec& typeSpec = expr.getType().getTypeSpec();
            const Ast::FunctionDef* function = dynamic_cast<const Ast::FunctionDef*>(ptr(typeSpec));
            if(function) {
                return _unit.addNode(new Ast::FunctorCall(ref(function), expr));
            }

            throw z::exception(z::string::creator("%{err} Not a function type: %{name}").arg(z::any("err"), z::any(err())).arg(z::any("name"), z::any(typeSpec.getFullName(z::string("::")))).value());
        }

        inline Ast::FunctorCall& createFunctorObjectCall(const Ast::VariableRef& vref) {
            Ast::Expr& expr = createVariableRefExpr(vref);
            return createFunctorExprCall(expr);
        }

    public:
        inline Ast::NumericConstantExpr& createNumericConstantExpr(const z::string& typestr, const z::string& val) {
            const Ast::QualifiedType& type = getQualifiedType(typestr);
            return _unit.addNode(new Ast::NumericConstantExpr(type, val));
        }

        inline Ast::BooleanConstantExpr& createBooleanConstantExpr(const z::string& val) {
            const Ast::QualifiedType& type = getQualifiedType(z::string("bool"));
            return _unit.addNode(new Ast::BooleanConstantExpr(type, val));
        }

        inline Ast::CharConstantExpr& createCharConstantExpr(const z::string& val) {
            const Ast::QualifiedType& type = getQualifiedType(z::string("char"));
            return _unit.addNode(new Ast::CharConstantExpr(type, val));
        }

        inline Ast::StringConstantExpr& createStringConstantExpr(const zbl::TokenData& token) {
            z::string val = zbl::Token::getValue(token);
            const Ast::QualifiedType& type = getQualifiedType(z::string("string"));
            return _unit.addNode(new Ast::StringConstantExpr(type, val));
        }

    public:
        inline Ast::ExprStatement& createExprStatement(const Ast::Expr& expr) {
            return _unit.addNode(new Ast::ExprStatement(expr));
        }

        inline Ast::StatementBlock& createStatementBlock(const Ast::StatementList& list) {
            return _unit.addNode(new Ast::StatementBlock(list));
        }

        inline Ast::DefineVarStatement& createDefineVarStatement(Ast::InitVariableDef& vdef) {
            return _unit.addNode(new Ast::DefineVarStatement(vdef));
        }

        inline Ast::IfThenStatement& createIfThenStatement(const Ast::Expr& cond, const Ast::StatementList& tlist) {
            return _unit.addNode(new Ast::IfThenStatement(cond, tlist));
        }

        inline Ast::IfElseStatement& createIfElseStatement(const Ast::Expr& cond, const Ast::StatementList& tlist, const Ast::StatementList& flist) {
            return _unit.addNode(new Ast::IfElseStatement(cond, tlist, flist));
        }

        inline Ast::IfElseStatement& createIfElseIfStatement(const Ast::Expr& cond, const Ast::StatementList& tlist, Ast::Statement& fstmt) {
            Ast::StatementList& flist = enterStatementList(fstmt);
            Ast::IfElseStatement& rv = createIfElseStatement(cond, tlist, flist);
            leaveStatementList(flist);
            return rv;
        }

        inline Ast::SelectStatement& createSelectStatement(const Ast::SwitchLabelList& list) {
            return _unit.addNode(new Ast::SelectStatement(list));
        }

        inline Ast::SwitchStatement& createSwitchStatement(const Ast::Expr& expr, const Ast::SwitchLabelList& list) {
            return _unit.addNode(new Ast::SwitchStatement(expr, list));
        }

        inline Ast::SwitchLabelList& createSwitchLabelList() {
            return _unit.addNode(new Ast::SwitchLabelList());
        }

        inline Ast::CaseLabel& createCaseLabel(const Ast::Expr& expr, const Ast::StatementList& list) {
            return _unit.addNode(new Ast::CaseLabel(expr, list));
        }

        inline Ast::DefaultLabel& createDefaultLabel(const Ast::StatementList& list) {
            return _unit.addNode(new Ast::DefaultLabel(list));
        }

        inline Ast::ForStatement& createForStatement(const Ast::InitVariableDef& init, const Ast::Expr& cond, const Ast::Expr& incx, const Ast::StatementList& list) {
            return _unit.addNode(new Ast::ForStatement(init, cond, incx, list));
        }

        inline Ast::ForeachStatement& createForeachStatement(const Ast::InitVariableDef& init, const Ast::StatementList& list) {
            return _unit.addNode(new Ast::ForeachStatement(init, list));
        }

        inline Ast::WhileStatement& createWhileStatement(const Ast::Expr& cond, const Ast::StatementList& list) {
            return _unit.addNode(new Ast::WhileStatement(cond, list));
        }

        inline Ast::DoWhileStatement& createDoWhileStatement(const Ast::Expr& cond, const Ast::StatementList& list) {
            return _unit.addNode(new Ast::DoWhileStatement(cond, list));
        }

        inline Ast::LogStatement& createLogStatement(const z::string& name, const Ast::ExprList& list) {
            return _unit.addNode(new Ast::LogStatement(name, list));
        }

        inline Ast::BreakStatement& createBreakStatement() {
            return _unit.addNode(new Ast::BreakStatement());
        }

        inline Ast::ContinueStatement& createContinueStatement() {
            return _unit.addNode(new Ast::ContinueStatement());
        }

        inline Ast::EmptyStatement& createEmptyStatement() {
            return _unit.addNode(new Ast::EmptyStatement());
        }

        inline Ast::RoutineReturnStatement& createRoutineReturnStatement(const Ast::Expr& expr) {
            return _unit.addNode(new Ast::RoutineReturnStatement(expr));
        }

        inline Ast::FunctionReturnStatement& createFunctionReturnStatement(const Ast::ExprList& list) {
            Ast::FunctionDef& fdef = getFunctionDef();
            return _unit.addNode(new Ast::FunctionReturnStatement(fdef, list));
        }

        inline Ast::TypeSpecStatement& createTypeSpecStatement(const Ast::TypeSpec& typeSpec) {
            return _unit.addNode(new Ast::TypeSpecStatement(typeSpec));
        }

        inline Ast::TypeSpecStatement& createFunctionImplStatement(const Ast::ImplItem& item) {
            return createTypeSpecStatement(item.getFunctionDef());
        }

    private:
        inline Ast::Scope& enterScope(const Ast::Scope::Type& type) {
            Ast::Scope& scope = _unit.addNode(new Ast::Scope(type));
            _scopeStack.push(ptr(scope));
            return scope;
        }

        inline void leaveScope(const Ast::Scope::Type& type) {
            assert(_scopeStack.size() > 0);
            Ast::Scope& scope = ref(_scopeStack.top());
            if(scope.getType() != type) {
                throw z::exception(z::string::creator("%{err} Internal error: Scope type mismatch: %{name} != %{scope}").arg(z::any("err"), z::any(err())).arg(z::any("name"), z::any((int)type)).arg(z::any("scope"), z::any((int)scope.getType())).value());
            }
            _scopeStack.pop();
        }

    public:
        inline Ast::Scope& enterInParamScope() {
            return enterScope(Ast::Scope::InParam);
        }

        inline void leaveInParamScope() {
            return leaveScope(Ast::Scope::InParam);
        }

    public:
        inline Ast::Scope& enterBlockScope() {
            return enterScope(Ast::Scope::Block);
        }

        inline void leaveBlockScope() {
            return leaveScope(Ast::Scope::Block);
        }

    public:
        inline Ast::Scope& enterContinuation() {
            return enterScope(Ast::Scope::Continuation);
        }

        inline Ast::ContinuationImplItem& leaveContinuation(Ast::ContinuationImplItem& continuation) {
            leaveScope(Ast::Scope::Continuation);
            return continuation;
        }

    private:
        inline void resetCurrentVDef() {
            if(_curr_vdef) {
                ref(_scopeStack.top()).addDef(ref(_curr_vdef));
                _curr_vdef = 0;
            }
        }

    public:
        inline Ast::StatementList& enterStatementList(Ast::Statement& stmt) {
            enterScope(Ast::Scope::Block);
            Ast::StatementList& list = _unit.addNode(new Ast::StatementList());
            resetCurrentVDef();
            list.addStatement(stmt);
            return list;
        }

        inline Ast::StatementList& leaveStatementList(Ast::StatementList& list) {
            leaveScope(Ast::Scope::Block);
            return list;
        }

    public:
        inline Ast::StatementList& createEmptyStatementList() {
            return _unit.addNode(new Ast::StatementList());
        }

        inline Ast::StatementList& addStatement(Ast::StatementList& list, Ast::Statement& stmt) {
            resetCurrentVDef();
            list.addStatement(stmt);
            return list;
        }

    public:
        inline void setProjectDef(const Ast::StructInitExpr& expr) {_unit.setProjectDef(expr);}

    private:
        zbl::Compiler& _compiler;

        Ast::Unit& _unit;

    private:
        typedef z::stack<Ast::Scope*> ScopeStack;

        ScopeStack _scopeStack;

    private:
        typedef z::stack<Ast::GrammarLexer*> GrammarLexerStack;

        GrammarLexerStack _grammarLexerStack;

    private:
        Ast::InitVariableDef* _curr_vdef;

    private:
        Token _nullToken;
    };
}