lldb/source/Plugins/ExpressionParser/Go/GoAST.h

//===-- GoAST.h -------------------------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

// DO NOT EDIT.
// Generated by gen_go_ast.py

#ifndef liblldb_GoAST_h
#define liblldb_GoAST_h

#include "lldb/lldb-forward.h"
#include "lldb/lldb-private.h"
#include "llvm/Support/Casting.h"
#include "Plugins/ExpressionParser/Go/GoLexer.h"

namespace lldb_private
{

class GoASTNode
{
  public:
    typedef GoLexer::TokenType TokenType;
    typedef GoLexer::Token Token;
    enum ChanDir
    {
        eChanBidir,
        eChanSend,
        eChanRecv,
    };
    enum NodeKind
    {
        eBadDecl,
        eFuncDecl,
        eGenDecl,
        eArrayType,
        eBadExpr,
        eBasicLit,
        eBinaryExpr,
        eIdent,
        eCallExpr,
        eChanType,
        eCompositeLit,
        eEllipsis,
        eFuncType,
        eFuncLit,
        eIndexExpr,
        eInterfaceType,
        eKeyValueExpr,
        eMapType,
        eParenExpr,
        eSelectorExpr,
        eSliceExpr,
        eStarExpr,
        eStructType,
        eTypeAssertExpr,
        eUnaryExpr,
        eImportSpec,
        eTypeSpec,
        eValueSpec,
        eAssignStmt,
        eBadStmt,
        eBlockStmt,
        eBranchStmt,
        eCaseClause,
        eCommClause,
        eDeclStmt,
        eDeferStmt,
        eEmptyStmt,
        eExprStmt,
        eForStmt,
        eGoStmt,
        eIfStmt,
        eIncDecStmt,
        eLabeledStmt,
        eRangeStmt,
        eReturnStmt,
        eSelectStmt,
        eSendStmt,
        eSwitchStmt,
        eTypeSwitchStmt,
        eField,
        eFieldList,
    };

    virtual ~GoASTNode() = default;

    NodeKind
    GetKind() const
    {
        return m_kind;
    }

    virtual const char *GetKindName() const = 0;

    template <typename V> void WalkChildren(V &v);

  protected:
    explicit GoASTNode(NodeKind kind) : m_kind(kind) { }

  private:
    const NodeKind m_kind;
    
    GoASTNode(const GoASTNode &) = delete;
    const GoASTNode &operator=(const GoASTNode &) = delete;
};


class GoASTDecl : public GoASTNode
{
  public:
    template <typename R, typename V> R Visit(V *v) const;

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() >= eBadDecl && n->GetKind() <= eGenDecl;
    }

  protected:
    explicit GoASTDecl(NodeKind kind) : GoASTNode(kind) { }
  private:

    GoASTDecl(const GoASTDecl &) = delete;
    const GoASTDecl &operator=(const GoASTDecl &) = delete;
};

class GoASTExpr : public GoASTNode
{
  public:
    template <typename R, typename V> R Visit(V *v) const;

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() >= eArrayType && n->GetKind() <= eUnaryExpr;
    }

  protected:
    explicit GoASTExpr(NodeKind kind) : GoASTNode(kind) { }
  private:

    GoASTExpr(const GoASTExpr &) = delete;
    const GoASTExpr &operator=(const GoASTExpr &) = delete;
};

class GoASTSpec : public GoASTNode
{
  public:
    template <typename R, typename V> R Visit(V *v) const;

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() >= eImportSpec && n->GetKind() <= eValueSpec;
    }

  protected:
    explicit GoASTSpec(NodeKind kind) : GoASTNode(kind) { }
  private:

    GoASTSpec(const GoASTSpec &) = delete;
    const GoASTSpec &operator=(const GoASTSpec &) = delete;
};

class GoASTStmt : public GoASTNode
{
  public:
    template <typename R, typename V> R Visit(V *v) const;

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() >= eAssignStmt && n->GetKind() <= eTypeSwitchStmt;
    }

  protected:
    explicit GoASTStmt(NodeKind kind) : GoASTNode(kind) { }
  private:

    GoASTStmt(const GoASTStmt &) = delete;
    const GoASTStmt &operator=(const GoASTStmt &) = delete;
};


class GoASTArrayType : public GoASTExpr
{
  public:
    GoASTArrayType(GoASTExpr *len, GoASTExpr *elt) : GoASTExpr(eArrayType), m_len_up(len), m_elt_up(elt) {}
    ~GoASTArrayType() override = default;

    const char *
    GetKindName() const override
    {
        return "ArrayType";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eArrayType;
    }
    
    const GoASTExpr *
    GetLen() const
    {
        return m_len_up.get();
    }
    void
    SetLen(GoASTExpr *len)
    {
        m_len_up.reset(len);
    }

    const GoASTExpr *
    GetElt() const
    {
        return m_elt_up.get();
    }
    void
    SetElt(GoASTExpr *elt)
    {
        m_elt_up.reset(elt);
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTExpr> m_len_up;
    std::unique_ptr<GoASTExpr> m_elt_up;

    GoASTArrayType(const GoASTArrayType &) = delete;
    const GoASTArrayType &operator=(const GoASTArrayType &) = delete;
};

class GoASTAssignStmt : public GoASTStmt
{
  public:
    explicit GoASTAssignStmt(bool define) : GoASTStmt(eAssignStmt), m_define(define) {}
    ~GoASTAssignStmt() override = default;

    const char *
    GetKindName() const override
    {
        return "AssignStmt";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eAssignStmt;
    }
    
    size_t
    NumLhs() const
    {
        return m_lhs.size();
    }
    const GoASTExpr *
    GetLhs(int i) const
    {
        return m_lhs[i].get();
    }
    void
    AddLhs(GoASTExpr *lhs)
    {
        m_lhs.push_back(std::unique_ptr<GoASTExpr>(lhs));
    }

    size_t
    NumRhs() const
    {
        return m_rhs.size();
    }
    const GoASTExpr *
    GetRhs(int i) const
    {
        return m_rhs[i].get();
    }
    void
    AddRhs(GoASTExpr *rhs)
    {
        m_rhs.push_back(std::unique_ptr<GoASTExpr>(rhs));
    }

    bool 
    GetDefine() const
    {
        return m_define;
    }
    void
    SetDefine(bool define)
    {
        m_define = define;
    }

  private:
    friend class GoASTNode;
    std::vector<std::unique_ptr<GoASTExpr> > m_lhs;
    std::vector<std::unique_ptr<GoASTExpr> > m_rhs;
    bool m_define;

    GoASTAssignStmt(const GoASTAssignStmt &) = delete;
    const GoASTAssignStmt &operator=(const GoASTAssignStmt &) = delete;
};

class GoASTBadDecl : public GoASTDecl
{
  public:
    GoASTBadDecl() : GoASTDecl(eBadDecl) {}
    ~GoASTBadDecl() override = default;

    const char *
    GetKindName() const override
    {
        return "BadDecl";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eBadDecl;
    }
    
    GoASTBadDecl(const GoASTBadDecl &) = delete;
    const GoASTBadDecl &operator=(const GoASTBadDecl &) = delete;
};

class GoASTBadExpr : public GoASTExpr
{
  public:
    GoASTBadExpr() : GoASTExpr(eBadExpr) {}
    ~GoASTBadExpr() override = default;

    const char *
    GetKindName() const override
    {
        return "BadExpr";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eBadExpr;
    }
    
    GoASTBadExpr(const GoASTBadExpr &) = delete;
    const GoASTBadExpr &operator=(const GoASTBadExpr &) = delete;
};

class GoASTBadStmt : public GoASTStmt
{
  public:
    GoASTBadStmt() : GoASTStmt(eBadStmt) {}
    ~GoASTBadStmt() override = default;

    const char *
    GetKindName() const override
    {
        return "BadStmt";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eBadStmt;
    }
    
    GoASTBadStmt(const GoASTBadStmt &) = delete;
    const GoASTBadStmt &operator=(const GoASTBadStmt &) = delete;
};

class GoASTBasicLit : public GoASTExpr
{
  public:
    explicit GoASTBasicLit(Token value) : GoASTExpr(eBasicLit), m_value(value) {}
    ~GoASTBasicLit() override = default;

    const char *
    GetKindName() const override
    {
        return "BasicLit";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eBasicLit;
    }
    
    Token 
    GetValue() const
    {
        return m_value;
    }
    void
    SetValue(Token value)
    {
        m_value = value;
    }

  private:
    friend class GoASTNode;
    Token m_value;

    GoASTBasicLit(const GoASTBasicLit &) = delete;
    const GoASTBasicLit &operator=(const GoASTBasicLit &) = delete;
};

class GoASTBinaryExpr : public GoASTExpr
{
  public:
    GoASTBinaryExpr(GoASTExpr *x, GoASTExpr *y, TokenType op) : GoASTExpr(eBinaryExpr), m_x_up(x), m_y_up(y), m_op(op) {}
    ~GoASTBinaryExpr() override = default;

    const char *
    GetKindName() const override
    {
        return "BinaryExpr";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eBinaryExpr;
    }
    
    const GoASTExpr *
    GetX() const
    {
        return m_x_up.get();
    }
    void
    SetX(GoASTExpr *x)
    {
        m_x_up.reset(x);
    }

    const GoASTExpr *
    GetY() const
    {
        return m_y_up.get();
    }
    void
    SetY(GoASTExpr *y)
    {
        m_y_up.reset(y);
    }

    TokenType 
    GetOp() const
    {
        return m_op;
    }
    void
    SetOp(TokenType op)
    {
        m_op = op;
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTExpr> m_x_up;
    std::unique_ptr<GoASTExpr> m_y_up;
    TokenType m_op;

    GoASTBinaryExpr(const GoASTBinaryExpr &) = delete;
    const GoASTBinaryExpr &operator=(const GoASTBinaryExpr &) = delete;
};

class GoASTBlockStmt : public GoASTStmt
{
  public:
    GoASTBlockStmt() : GoASTStmt(eBlockStmt) {}
    ~GoASTBlockStmt() override = default;

    const char *
    GetKindName() const override
    {
        return "BlockStmt";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eBlockStmt;
    }
    
    size_t
    NumList() const
    {
        return m_list.size();
    }
    const GoASTStmt *
    GetList(int i) const
    {
        return m_list[i].get();
    }
    void
    AddList(GoASTStmt *list)
    {
        m_list.push_back(std::unique_ptr<GoASTStmt>(list));
    }

  private:
    friend class GoASTNode;
    std::vector<std::unique_ptr<GoASTStmt> > m_list;

    GoASTBlockStmt(const GoASTBlockStmt &) = delete;
    const GoASTBlockStmt &operator=(const GoASTBlockStmt &) = delete;
};

class GoASTIdent : public GoASTExpr
{
  public:
    explicit GoASTIdent(Token name) : GoASTExpr(eIdent), m_name(name) {}
    ~GoASTIdent() override = default;

    const char *
    GetKindName() const override
    {
        return "Ident";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eIdent;
    }
    
    Token 
    GetName() const
    {
        return m_name;
    }
    void
    SetName(Token name)
    {
        m_name = name;
    }

  private:
    friend class GoASTNode;
    Token m_name;

    GoASTIdent(const GoASTIdent &) = delete;
    const GoASTIdent &operator=(const GoASTIdent &) = delete;
};

class GoASTBranchStmt : public GoASTStmt
{
  public:
    GoASTBranchStmt(GoASTIdent *label, TokenType tok) : GoASTStmt(eBranchStmt), m_label_up(label), m_tok(tok) {}
    ~GoASTBranchStmt() override = default;

    const char *
    GetKindName() const override
    {
        return "BranchStmt";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eBranchStmt;
    }
    
    const GoASTIdent *
    GetLabel() const
    {
        return m_label_up.get();
    }
    void
    SetLabel(GoASTIdent *label)
    {
        m_label_up.reset(label);
    }

    TokenType 
    GetTok() const
    {
        return m_tok;
    }
    void
    SetTok(TokenType tok)
    {
        m_tok = tok;
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTIdent> m_label_up;
    TokenType m_tok;

    GoASTBranchStmt(const GoASTBranchStmt &) = delete;
    const GoASTBranchStmt &operator=(const GoASTBranchStmt &) = delete;
};

class GoASTCallExpr : public GoASTExpr
{
  public:
    explicit GoASTCallExpr(bool ellipsis) : GoASTExpr(eCallExpr), m_ellipsis(ellipsis) {}
    ~GoASTCallExpr() override = default;

    const char *
    GetKindName() const override
    {
        return "CallExpr";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eCallExpr;
    }
    
    const GoASTExpr *
    GetFun() const
    {
        return m_fun_up.get();
    }
    void
    SetFun(GoASTExpr *fun)
    {
        m_fun_up.reset(fun);
    }

    size_t
    NumArgs() const
    {
        return m_args.size();
    }
    const GoASTExpr *
    GetArgs(int i) const
    {
        return m_args[i].get();
    }
    void
    AddArgs(GoASTExpr *args)
    {
        m_args.push_back(std::unique_ptr<GoASTExpr>(args));
    }

    bool 
    GetEllipsis() const
    {
        return m_ellipsis;
    }
    void
    SetEllipsis(bool ellipsis)
    {
        m_ellipsis = ellipsis;
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTExpr> m_fun_up;
    std::vector<std::unique_ptr<GoASTExpr> > m_args;
    bool m_ellipsis;

    GoASTCallExpr(const GoASTCallExpr &) = delete;
    const GoASTCallExpr &operator=(const GoASTCallExpr &) = delete;
};

class GoASTCaseClause : public GoASTStmt
{
  public:
    GoASTCaseClause() : GoASTStmt(eCaseClause) {}
    ~GoASTCaseClause() override = default;

    const char *
    GetKindName() const override
    {
        return "CaseClause";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eCaseClause;
    }
    
    size_t
    NumList() const
    {
        return m_list.size();
    }
    const GoASTExpr *
    GetList(int i) const
    {
        return m_list[i].get();
    }
    void
    AddList(GoASTExpr *list)
    {
        m_list.push_back(std::unique_ptr<GoASTExpr>(list));
    }

    size_t
    NumBody() const
    {
        return m_body.size();
    }
    const GoASTStmt *
    GetBody(int i) const
    {
        return m_body[i].get();
    }
    void
    AddBody(GoASTStmt *body)
    {
        m_body.push_back(std::unique_ptr<GoASTStmt>(body));
    }

  private:
    friend class GoASTNode;
    std::vector<std::unique_ptr<GoASTExpr> > m_list;
    std::vector<std::unique_ptr<GoASTStmt> > m_body;

    GoASTCaseClause(const GoASTCaseClause &) = delete;
    const GoASTCaseClause &operator=(const GoASTCaseClause &) = delete;
};

class GoASTChanType : public GoASTExpr
{
  public:
    GoASTChanType(ChanDir dir, GoASTExpr *value) : GoASTExpr(eChanType), m_dir(dir), m_value_up(value) {}
    ~GoASTChanType() override = default;

    const char *
    GetKindName() const override
    {
        return "ChanType";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eChanType;
    }
    
    ChanDir 
    GetDir() const
    {
        return m_dir;
    }
    void
    SetDir(ChanDir dir)
    {
        m_dir = dir;
    }

    const GoASTExpr *
    GetValue() const
    {
        return m_value_up.get();
    }
    void
    SetValue(GoASTExpr *value)
    {
        m_value_up.reset(value);
    }

  private:
    friend class GoASTNode;
    ChanDir m_dir;
    std::unique_ptr<GoASTExpr> m_value_up;

    GoASTChanType(const GoASTChanType &) = delete;
    const GoASTChanType &operator=(const GoASTChanType &) = delete;
};

class GoASTCommClause : public GoASTStmt
{
  public:
    GoASTCommClause() : GoASTStmt(eCommClause) {}
    ~GoASTCommClause() override = default;

    const char *
    GetKindName() const override
    {
        return "CommClause";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eCommClause;
    }
    
    const GoASTStmt *
    GetComm() const
    {
        return m_comm_up.get();
    }
    void
    SetComm(GoASTStmt *comm)
    {
        m_comm_up.reset(comm);
    }

    size_t
    NumBody() const
    {
        return m_body.size();
    }
    const GoASTStmt *
    GetBody(int i) const
    {
        return m_body[i].get();
    }
    void
    AddBody(GoASTStmt *body)
    {
        m_body.push_back(std::unique_ptr<GoASTStmt>(body));
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTStmt> m_comm_up;
    std::vector<std::unique_ptr<GoASTStmt> > m_body;

    GoASTCommClause(const GoASTCommClause &) = delete;
    const GoASTCommClause &operator=(const GoASTCommClause &) = delete;
};

class GoASTCompositeLit : public GoASTExpr
{
  public:
    GoASTCompositeLit() : GoASTExpr(eCompositeLit) {}
    ~GoASTCompositeLit() override = default;

    const char *
    GetKindName() const override
    {
        return "CompositeLit";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eCompositeLit;
    }
    
    const GoASTExpr *
    GetType() const
    {
        return m_type_up.get();
    }
    void
    SetType(GoASTExpr *type)
    {
        m_type_up.reset(type);
    }

    size_t
    NumElts() const
    {
        return m_elts.size();
    }
    const GoASTExpr *
    GetElts(int i) const
    {
        return m_elts[i].get();
    }
    void
    AddElts(GoASTExpr *elts)
    {
        m_elts.push_back(std::unique_ptr<GoASTExpr>(elts));
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTExpr> m_type_up;
    std::vector<std::unique_ptr<GoASTExpr> > m_elts;

    GoASTCompositeLit(const GoASTCompositeLit &) = delete;
    const GoASTCompositeLit &operator=(const GoASTCompositeLit &) = delete;
};

class GoASTDeclStmt : public GoASTStmt
{
  public:
    explicit GoASTDeclStmt(GoASTDecl *decl) : GoASTStmt(eDeclStmt), m_decl_up(decl) {}
    ~GoASTDeclStmt() override = default;

    const char *
    GetKindName() const override
    {
        return "DeclStmt";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eDeclStmt;
    }
    
    const GoASTDecl *
    GetDecl() const
    {
        return m_decl_up.get();
    }
    void
    SetDecl(GoASTDecl *decl)
    {
        m_decl_up.reset(decl);
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTDecl> m_decl_up;

    GoASTDeclStmt(const GoASTDeclStmt &) = delete;
    const GoASTDeclStmt &operator=(const GoASTDeclStmt &) = delete;
};

class GoASTDeferStmt : public GoASTStmt
{
  public:
    explicit GoASTDeferStmt(GoASTCallExpr *call) : GoASTStmt(eDeferStmt), m_call_up(call) {}
    ~GoASTDeferStmt() override = default;

    const char *
    GetKindName() const override
    {
        return "DeferStmt";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eDeferStmt;
    }
    
    const GoASTCallExpr *
    GetCall() const
    {
        return m_call_up.get();
    }
    void
    SetCall(GoASTCallExpr *call)
    {
        m_call_up.reset(call);
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTCallExpr> m_call_up;

    GoASTDeferStmt(const GoASTDeferStmt &) = delete;
    const GoASTDeferStmt &operator=(const GoASTDeferStmt &) = delete;
};

class GoASTEllipsis : public GoASTExpr
{
  public:
    explicit GoASTEllipsis(GoASTExpr *elt) : GoASTExpr(eEllipsis), m_elt_up(elt) {}
    ~GoASTEllipsis() override = default;

    const char *
    GetKindName() const override
    {
        return "Ellipsis";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eEllipsis;
    }
    
    const GoASTExpr *
    GetElt() const
    {
        return m_elt_up.get();
    }
    void
    SetElt(GoASTExpr *elt)
    {
        m_elt_up.reset(elt);
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTExpr> m_elt_up;

    GoASTEllipsis(const GoASTEllipsis &) = delete;
    const GoASTEllipsis &operator=(const GoASTEllipsis &) = delete;
};

class GoASTEmptyStmt : public GoASTStmt
{
  public:
    GoASTEmptyStmt() : GoASTStmt(eEmptyStmt) {}
    ~GoASTEmptyStmt() override = default;

    const char *
    GetKindName() const override
    {
        return "EmptyStmt";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eEmptyStmt;
    }
    
    GoASTEmptyStmt(const GoASTEmptyStmt &) = delete;
    const GoASTEmptyStmt &operator=(const GoASTEmptyStmt &) = delete;
};

class GoASTExprStmt : public GoASTStmt
{
  public:
    explicit GoASTExprStmt(GoASTExpr *x) : GoASTStmt(eExprStmt), m_x_up(x) {}
    ~GoASTExprStmt() override = default;

    const char *
    GetKindName() const override
    {
        return "ExprStmt";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eExprStmt;
    }
    
    const GoASTExpr *
    GetX() const
    {
        return m_x_up.get();
    }
    void
    SetX(GoASTExpr *x)
    {
        m_x_up.reset(x);
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTExpr> m_x_up;

    GoASTExprStmt(const GoASTExprStmt &) = delete;
    const GoASTExprStmt &operator=(const GoASTExprStmt &) = delete;
};

class GoASTField : public GoASTNode
{
  public:
    GoASTField() : GoASTNode(eField) {}
    ~GoASTField() override = default;

    const char *
    GetKindName() const override
    {
        return "Field";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eField;
    }
    
    size_t
    NumNames() const
    {
        return m_names.size();
    }
    const GoASTIdent *
    GetNames(int i) const
    {
        return m_names[i].get();
    }
    void
    AddNames(GoASTIdent *names)
    {
        m_names.push_back(std::unique_ptr<GoASTIdent>(names));
    }

    const GoASTExpr *
    GetType() const
    {
        return m_type_up.get();
    }
    void
    SetType(GoASTExpr *type)
    {
        m_type_up.reset(type);
    }

    const GoASTBasicLit *
    GetTag() const
    {
        return m_tag_up.get();
    }
    void
    SetTag(GoASTBasicLit *tag)
    {
        m_tag_up.reset(tag);
    }

  private:
    friend class GoASTNode;
    std::vector<std::unique_ptr<GoASTIdent> > m_names;
    std::unique_ptr<GoASTExpr> m_type_up;
    std::unique_ptr<GoASTBasicLit> m_tag_up;

    GoASTField(const GoASTField &) = delete;
    const GoASTField &operator=(const GoASTField &) = delete;
};

class GoASTFieldList : public GoASTNode
{
  public:
    GoASTFieldList() : GoASTNode(eFieldList) {}
    ~GoASTFieldList() override = default;

    const char *
    GetKindName() const override
    {
        return "FieldList";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eFieldList;
    }
    
    size_t
    NumList() const
    {
        return m_list.size();
    }
    const GoASTField *
    GetList(int i) const
    {
        return m_list[i].get();
    }
    void
    AddList(GoASTField *list)
    {
        m_list.push_back(std::unique_ptr<GoASTField>(list));
    }

  private:
    friend class GoASTNode;
    std::vector<std::unique_ptr<GoASTField> > m_list;

    GoASTFieldList(const GoASTFieldList &) = delete;
    const GoASTFieldList &operator=(const GoASTFieldList &) = delete;
};

class GoASTForStmt : public GoASTStmt
{
  public:
    GoASTForStmt(GoASTStmt *init, GoASTExpr *cond, GoASTStmt *post, GoASTBlockStmt *body) : GoASTStmt(eForStmt), m_init_up(init), m_cond_up(cond), m_post_up(post), m_body_up(body) {}
    ~GoASTForStmt() override = default;

    const char *
    GetKindName() const override
    {
        return "ForStmt";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eForStmt;
    }
    
    const GoASTStmt *
    GetInit() const
    {
        return m_init_up.get();
    }
    void
    SetInit(GoASTStmt *init)
    {
        m_init_up.reset(init);
    }

    const GoASTExpr *
    GetCond() const
    {
        return m_cond_up.get();
    }
    void
    SetCond(GoASTExpr *cond)
    {
        m_cond_up.reset(cond);
    }

    const GoASTStmt *
    GetPost() const
    {
        return m_post_up.get();
    }
    void
    SetPost(GoASTStmt *post)
    {
        m_post_up.reset(post);
    }

    const GoASTBlockStmt *
    GetBody() const
    {
        return m_body_up.get();
    }
    void
    SetBody(GoASTBlockStmt *body)
    {
        m_body_up.reset(body);
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTStmt> m_init_up;
    std::unique_ptr<GoASTExpr> m_cond_up;
    std::unique_ptr<GoASTStmt> m_post_up;
    std::unique_ptr<GoASTBlockStmt> m_body_up;

    GoASTForStmt(const GoASTForStmt &) = delete;
    const GoASTForStmt &operator=(const GoASTForStmt &) = delete;
};

class GoASTFuncType : public GoASTExpr
{
  public:
    GoASTFuncType(GoASTFieldList *params, GoASTFieldList *results) : GoASTExpr(eFuncType), m_params_up(params), m_results_up(results) {}
    ~GoASTFuncType() override = default;

    const char *
    GetKindName() const override
    {
        return "FuncType";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eFuncType;
    }
    
    const GoASTFieldList *
    GetParams() const
    {
        return m_params_up.get();
    }
    void
    SetParams(GoASTFieldList *params)
    {
        m_params_up.reset(params);
    }

    const GoASTFieldList *
    GetResults() const
    {
        return m_results_up.get();
    }
    void
    SetResults(GoASTFieldList *results)
    {
        m_results_up.reset(results);
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTFieldList> m_params_up;
    std::unique_ptr<GoASTFieldList> m_results_up;

    GoASTFuncType(const GoASTFuncType &) = delete;
    const GoASTFuncType &operator=(const GoASTFuncType &) = delete;
};

class GoASTFuncDecl : public GoASTDecl
{
  public:
    GoASTFuncDecl(GoASTFieldList *recv, GoASTIdent *name, GoASTFuncType *type, GoASTBlockStmt *body) : GoASTDecl(eFuncDecl), m_recv_up(recv), m_name_up(name), m_type_up(type), m_body_up(body) {}
    ~GoASTFuncDecl() override = default;

    const char *
    GetKindName() const override
    {
        return "FuncDecl";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eFuncDecl;
    }
    
    const GoASTFieldList *
    GetRecv() const
    {
        return m_recv_up.get();
    }
    void
    SetRecv(GoASTFieldList *recv)
    {
        m_recv_up.reset(recv);
    }

    const GoASTIdent *
    GetName() const
    {
        return m_name_up.get();
    }
    void
    SetName(GoASTIdent *name)
    {
        m_name_up.reset(name);
    }

    const GoASTFuncType *
    GetType() const
    {
        return m_type_up.get();
    }
    void
    SetType(GoASTFuncType *type)
    {
        m_type_up.reset(type);
    }

    const GoASTBlockStmt *
    GetBody() const
    {
        return m_body_up.get();
    }
    void
    SetBody(GoASTBlockStmt *body)
    {
        m_body_up.reset(body);
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTFieldList> m_recv_up;
    std::unique_ptr<GoASTIdent> m_name_up;
    std::unique_ptr<GoASTFuncType> m_type_up;
    std::unique_ptr<GoASTBlockStmt> m_body_up;

    GoASTFuncDecl(const GoASTFuncDecl &) = delete;
    const GoASTFuncDecl &operator=(const GoASTFuncDecl &) = delete;
};

class GoASTFuncLit : public GoASTExpr
{
  public:
    GoASTFuncLit(GoASTFuncType *type, GoASTBlockStmt *body) : GoASTExpr(eFuncLit), m_type_up(type), m_body_up(body) {}
    ~GoASTFuncLit() override = default;

    const char *
    GetKindName() const override
    {
        return "FuncLit";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eFuncLit;
    }
    
    const GoASTFuncType *
    GetType() const
    {
        return m_type_up.get();
    }
    void
    SetType(GoASTFuncType *type)
    {
        m_type_up.reset(type);
    }

    const GoASTBlockStmt *
    GetBody() const
    {
        return m_body_up.get();
    }
    void
    SetBody(GoASTBlockStmt *body)
    {
        m_body_up.reset(body);
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTFuncType> m_type_up;
    std::unique_ptr<GoASTBlockStmt> m_body_up;

    GoASTFuncLit(const GoASTFuncLit &) = delete;
    const GoASTFuncLit &operator=(const GoASTFuncLit &) = delete;
};

class GoASTGenDecl : public GoASTDecl
{
  public:
    explicit GoASTGenDecl(TokenType tok) : GoASTDecl(eGenDecl), m_tok(tok) {}
    ~GoASTGenDecl() override = default;

    const char *
    GetKindName() const override
    {
        return "GenDecl";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eGenDecl;
    }
    
    TokenType 
    GetTok() const
    {
        return m_tok;
    }
    void
    SetTok(TokenType tok)
    {
        m_tok = tok;
    }

    size_t
    NumSpecs() const
    {
        return m_specs.size();
    }
    const GoASTSpec *
    GetSpecs(int i) const
    {
        return m_specs[i].get();
    }
    void
    AddSpecs(GoASTSpec *specs)
    {
        m_specs.push_back(std::unique_ptr<GoASTSpec>(specs));
    }

  private:
    friend class GoASTNode;
    TokenType m_tok;
    std::vector<std::unique_ptr<GoASTSpec> > m_specs;

    GoASTGenDecl(const GoASTGenDecl &) = delete;
    const GoASTGenDecl &operator=(const GoASTGenDecl &) = delete;
};

class GoASTGoStmt : public GoASTStmt
{
  public:
    explicit GoASTGoStmt(GoASTCallExpr *call) : GoASTStmt(eGoStmt), m_call_up(call) {}
    ~GoASTGoStmt() override = default;

    const char *
    GetKindName() const override
    {
        return "GoStmt";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eGoStmt;
    }
    
    const GoASTCallExpr *
    GetCall() const
    {
        return m_call_up.get();
    }
    void
    SetCall(GoASTCallExpr *call)
    {
        m_call_up.reset(call);
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTCallExpr> m_call_up;

    GoASTGoStmt(const GoASTGoStmt &) = delete;
    const GoASTGoStmt &operator=(const GoASTGoStmt &) = delete;
};

class GoASTIfStmt : public GoASTStmt
{
  public:
    GoASTIfStmt(GoASTStmt *init, GoASTExpr *cond, GoASTBlockStmt *body, GoASTStmt *els) : GoASTStmt(eIfStmt), m_init_up(init), m_cond_up(cond), m_body_up(body), m_els_up(els) {}
    ~GoASTIfStmt() override = default;

    const char *
    GetKindName() const override
    {
        return "IfStmt";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eIfStmt;
    }
    
    const GoASTStmt *
    GetInit() const
    {
        return m_init_up.get();
    }
    void
    SetInit(GoASTStmt *init)
    {
        m_init_up.reset(init);
    }

    const GoASTExpr *
    GetCond() const
    {
        return m_cond_up.get();
    }
    void
    SetCond(GoASTExpr *cond)
    {
        m_cond_up.reset(cond);
    }

    const GoASTBlockStmt *
    GetBody() const
    {
        return m_body_up.get();
    }
    void
    SetBody(GoASTBlockStmt *body)
    {
        m_body_up.reset(body);
    }

    const GoASTStmt *
    GetEls() const
    {
        return m_els_up.get();
    }
    void
    SetEls(GoASTStmt *els)
    {
        m_els_up.reset(els);
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTStmt> m_init_up;
    std::unique_ptr<GoASTExpr> m_cond_up;
    std::unique_ptr<GoASTBlockStmt> m_body_up;
    std::unique_ptr<GoASTStmt> m_els_up;

    GoASTIfStmt(const GoASTIfStmt &) = delete;
    const GoASTIfStmt &operator=(const GoASTIfStmt &) = delete;
};

class GoASTImportSpec : public GoASTSpec
{
  public:
    GoASTImportSpec(GoASTIdent *name, GoASTBasicLit *path) : GoASTSpec(eImportSpec), m_name_up(name), m_path_up(path) {}
    ~GoASTImportSpec() override = default;

    const char *
    GetKindName() const override
    {
        return "ImportSpec";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eImportSpec;
    }
    
    const GoASTIdent *
    GetName() const
    {
        return m_name_up.get();
    }
    void
    SetName(GoASTIdent *name)
    {
        m_name_up.reset(name);
    }

    const GoASTBasicLit *
    GetPath() const
    {
        return m_path_up.get();
    }
    void
    SetPath(GoASTBasicLit *path)
    {
        m_path_up.reset(path);
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTIdent> m_name_up;
    std::unique_ptr<GoASTBasicLit> m_path_up;

    GoASTImportSpec(const GoASTImportSpec &) = delete;
    const GoASTImportSpec &operator=(const GoASTImportSpec &) = delete;
};

class GoASTIncDecStmt : public GoASTStmt
{
  public:
    GoASTIncDecStmt(GoASTExpr *x, TokenType tok) : GoASTStmt(eIncDecStmt), m_x_up(x), m_tok(tok) {}
    ~GoASTIncDecStmt() override = default;

    const char *
    GetKindName() const override
    {
        return "IncDecStmt";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eIncDecStmt;
    }
    
    const GoASTExpr *
    GetX() const
    {
        return m_x_up.get();
    }
    void
    SetX(GoASTExpr *x)
    {
        m_x_up.reset(x);
    }

    TokenType 
    GetTok() const
    {
        return m_tok;
    }
    void
    SetTok(TokenType tok)
    {
        m_tok = tok;
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTExpr> m_x_up;
    TokenType m_tok;

    GoASTIncDecStmt(const GoASTIncDecStmt &) = delete;
    const GoASTIncDecStmt &operator=(const GoASTIncDecStmt &) = delete;
};

class GoASTIndexExpr : public GoASTExpr
{
  public:
    GoASTIndexExpr(GoASTExpr *x, GoASTExpr *index) : GoASTExpr(eIndexExpr), m_x_up(x), m_index_up(index) {}
    ~GoASTIndexExpr() override = default;

    const char *
    GetKindName() const override
    {
        return "IndexExpr";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eIndexExpr;
    }
    
    const GoASTExpr *
    GetX() const
    {
        return m_x_up.get();
    }
    void
    SetX(GoASTExpr *x)
    {
        m_x_up.reset(x);
    }

    const GoASTExpr *
    GetIndex() const
    {
        return m_index_up.get();
    }
    void
    SetIndex(GoASTExpr *index)
    {
        m_index_up.reset(index);
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTExpr> m_x_up;
    std::unique_ptr<GoASTExpr> m_index_up;

    GoASTIndexExpr(const GoASTIndexExpr &) = delete;
    const GoASTIndexExpr &operator=(const GoASTIndexExpr &) = delete;
};

class GoASTInterfaceType : public GoASTExpr
{
  public:
    explicit GoASTInterfaceType(GoASTFieldList *methods) : GoASTExpr(eInterfaceType), m_methods_up(methods) {}
    ~GoASTInterfaceType() override = default;

    const char *
    GetKindName() const override
    {
        return "InterfaceType";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eInterfaceType;
    }
    
    const GoASTFieldList *
    GetMethods() const
    {
        return m_methods_up.get();
    }
    void
    SetMethods(GoASTFieldList *methods)
    {
        m_methods_up.reset(methods);
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTFieldList> m_methods_up;

    GoASTInterfaceType(const GoASTInterfaceType &) = delete;
    const GoASTInterfaceType &operator=(const GoASTInterfaceType &) = delete;
};

class GoASTKeyValueExpr : public GoASTExpr
{
  public:
    GoASTKeyValueExpr(GoASTExpr *key, GoASTExpr *value) : GoASTExpr(eKeyValueExpr), m_key_up(key), m_value_up(value) {}
    ~GoASTKeyValueExpr() override = default;

    const char *
    GetKindName() const override
    {
        return "KeyValueExpr";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eKeyValueExpr;
    }
    
    const GoASTExpr *
    GetKey() const
    {
        return m_key_up.get();
    }
    void
    SetKey(GoASTExpr *key)
    {
        m_key_up.reset(key);
    }

    const GoASTExpr *
    GetValue() const
    {
        return m_value_up.get();
    }
    void
    SetValue(GoASTExpr *value)
    {
        m_value_up.reset(value);
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTExpr> m_key_up;
    std::unique_ptr<GoASTExpr> m_value_up;

    GoASTKeyValueExpr(const GoASTKeyValueExpr &) = delete;
    const GoASTKeyValueExpr &operator=(const GoASTKeyValueExpr &) = delete;
};

class GoASTLabeledStmt : public GoASTStmt
{
  public:
    GoASTLabeledStmt(GoASTIdent *label, GoASTStmt *stmt) : GoASTStmt(eLabeledStmt), m_label_up(label), m_stmt_up(stmt) {}
    ~GoASTLabeledStmt() override = default;

    const char *
    GetKindName() const override
    {
        return "LabeledStmt";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eLabeledStmt;
    }
    
    const GoASTIdent *
    GetLabel() const
    {
        return m_label_up.get();
    }
    void
    SetLabel(GoASTIdent *label)
    {
        m_label_up.reset(label);
    }

    const GoASTStmt *
    GetStmt() const
    {
        return m_stmt_up.get();
    }
    void
    SetStmt(GoASTStmt *stmt)
    {
        m_stmt_up.reset(stmt);
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTIdent> m_label_up;
    std::unique_ptr<GoASTStmt> m_stmt_up;

    GoASTLabeledStmt(const GoASTLabeledStmt &) = delete;
    const GoASTLabeledStmt &operator=(const GoASTLabeledStmt &) = delete;
};

class GoASTMapType : public GoASTExpr
{
  public:
    GoASTMapType(GoASTExpr *key, GoASTExpr *value) : GoASTExpr(eMapType), m_key_up(key), m_value_up(value) {}
    ~GoASTMapType() override = default;

    const char *
    GetKindName() const override
    {
        return "MapType";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eMapType;
    }
    
    const GoASTExpr *
    GetKey() const
    {
        return m_key_up.get();
    }
    void
    SetKey(GoASTExpr *key)
    {
        m_key_up.reset(key);
    }

    const GoASTExpr *
    GetValue() const
    {
        return m_value_up.get();
    }
    void
    SetValue(GoASTExpr *value)
    {
        m_value_up.reset(value);
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTExpr> m_key_up;
    std::unique_ptr<GoASTExpr> m_value_up;

    GoASTMapType(const GoASTMapType &) = delete;
    const GoASTMapType &operator=(const GoASTMapType &) = delete;
};

class GoASTParenExpr : public GoASTExpr
{
  public:
    explicit GoASTParenExpr(GoASTExpr *x) : GoASTExpr(eParenExpr), m_x_up(x) {}
    ~GoASTParenExpr() override = default;

    const char *
    GetKindName() const override
    {
        return "ParenExpr";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eParenExpr;
    }
    
    const GoASTExpr *
    GetX() const
    {
        return m_x_up.get();
    }
    void
    SetX(GoASTExpr *x)
    {
        m_x_up.reset(x);
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTExpr> m_x_up;

    GoASTParenExpr(const GoASTParenExpr &) = delete;
    const GoASTParenExpr &operator=(const GoASTParenExpr &) = delete;
};

class GoASTRangeStmt : public GoASTStmt
{
  public:
    GoASTRangeStmt(GoASTExpr *key, GoASTExpr *value, bool define, GoASTExpr *x, GoASTBlockStmt *body) : GoASTStmt(eRangeStmt), m_key_up(key), m_value_up(value), m_define(define), m_x_up(x), m_body_up(body) {}
    ~GoASTRangeStmt() override = default;

    const char *
    GetKindName() const override
    {
        return "RangeStmt";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eRangeStmt;
    }
    
    const GoASTExpr *
    GetKey() const
    {
        return m_key_up.get();
    }
    void
    SetKey(GoASTExpr *key)
    {
        m_key_up.reset(key);
    }

    const GoASTExpr *
    GetValue() const
    {
        return m_value_up.get();
    }
    void
    SetValue(GoASTExpr *value)
    {
        m_value_up.reset(value);
    }

    bool 
    GetDefine() const
    {
        return m_define;
    }
    void
    SetDefine(bool define)
    {
        m_define = define;
    }

    const GoASTExpr *
    GetX() const
    {
        return m_x_up.get();
    }
    void
    SetX(GoASTExpr *x)
    {
        m_x_up.reset(x);
    }

    const GoASTBlockStmt *
    GetBody() const
    {
        return m_body_up.get();
    }
    void
    SetBody(GoASTBlockStmt *body)
    {
        m_body_up.reset(body);
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTExpr> m_key_up;
    std::unique_ptr<GoASTExpr> m_value_up;
    bool m_define;
    std::unique_ptr<GoASTExpr> m_x_up;
    std::unique_ptr<GoASTBlockStmt> m_body_up;

    GoASTRangeStmt(const GoASTRangeStmt &) = delete;
    const GoASTRangeStmt &operator=(const GoASTRangeStmt &) = delete;
};

class GoASTReturnStmt : public GoASTStmt
{
  public:
    GoASTReturnStmt() : GoASTStmt(eReturnStmt) {}
    ~GoASTReturnStmt() override = default;

    const char *
    GetKindName() const override
    {
        return "ReturnStmt";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eReturnStmt;
    }
    
    size_t
    NumResults() const
    {
        return m_results.size();
    }
    const GoASTExpr *
    GetResults(int i) const
    {
        return m_results[i].get();
    }
    void
    AddResults(GoASTExpr *results)
    {
        m_results.push_back(std::unique_ptr<GoASTExpr>(results));
    }

  private:
    friend class GoASTNode;
    std::vector<std::unique_ptr<GoASTExpr> > m_results;

    GoASTReturnStmt(const GoASTReturnStmt &) = delete;
    const GoASTReturnStmt &operator=(const GoASTReturnStmt &) = delete;
};

class GoASTSelectStmt : public GoASTStmt
{
  public:
    explicit GoASTSelectStmt(GoASTBlockStmt *body) : GoASTStmt(eSelectStmt), m_body_up(body) {}
    ~GoASTSelectStmt() override = default;

    const char *
    GetKindName() const override
    {
        return "SelectStmt";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eSelectStmt;
    }
    
    const GoASTBlockStmt *
    GetBody() const
    {
        return m_body_up.get();
    }
    void
    SetBody(GoASTBlockStmt *body)
    {
        m_body_up.reset(body);
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTBlockStmt> m_body_up;

    GoASTSelectStmt(const GoASTSelectStmt &) = delete;
    const GoASTSelectStmt &operator=(const GoASTSelectStmt &) = delete;
};

class GoASTSelectorExpr : public GoASTExpr
{
  public:
    GoASTSelectorExpr(GoASTExpr *x, GoASTIdent *sel) : GoASTExpr(eSelectorExpr), m_x_up(x), m_sel_up(sel) {}
    ~GoASTSelectorExpr() override = default;

    const char *
    GetKindName() const override
    {
        return "SelectorExpr";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eSelectorExpr;
    }
    
    const GoASTExpr *
    GetX() const
    {
        return m_x_up.get();
    }
    void
    SetX(GoASTExpr *x)
    {
        m_x_up.reset(x);
    }

    const GoASTIdent *
    GetSel() const
    {
        return m_sel_up.get();
    }
    void
    SetSel(GoASTIdent *sel)
    {
        m_sel_up.reset(sel);
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTExpr> m_x_up;
    std::unique_ptr<GoASTIdent> m_sel_up;

    GoASTSelectorExpr(const GoASTSelectorExpr &) = delete;
    const GoASTSelectorExpr &operator=(const GoASTSelectorExpr &) = delete;
};

class GoASTSendStmt : public GoASTStmt
{
  public:
    GoASTSendStmt(GoASTExpr *chan, GoASTExpr *value) : GoASTStmt(eSendStmt), m_chan_up(chan), m_value_up(value) {}
    ~GoASTSendStmt() override = default;

    const char *
    GetKindName() const override
    {
        return "SendStmt";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eSendStmt;
    }
    
    const GoASTExpr *
    GetChan() const
    {
        return m_chan_up.get();
    }
    void
    SetChan(GoASTExpr *chan)
    {
        m_chan_up.reset(chan);
    }

    const GoASTExpr *
    GetValue() const
    {
        return m_value_up.get();
    }
    void
    SetValue(GoASTExpr *value)
    {
        m_value_up.reset(value);
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTExpr> m_chan_up;
    std::unique_ptr<GoASTExpr> m_value_up;

    GoASTSendStmt(const GoASTSendStmt &) = delete;
    const GoASTSendStmt &operator=(const GoASTSendStmt &) = delete;
};

class GoASTSliceExpr : public GoASTExpr
{
  public:
    GoASTSliceExpr(GoASTExpr *x, GoASTExpr *low, GoASTExpr *high, GoASTExpr *max, bool slice3) : GoASTExpr(eSliceExpr), m_x_up(x), m_low_up(low), m_high_up(high), m_max_up(max), m_slice3(slice3) {}
    ~GoASTSliceExpr() override = default;

    const char *
    GetKindName() const override
    {
        return "SliceExpr";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eSliceExpr;
    }
    
    const GoASTExpr *
    GetX() const
    {
        return m_x_up.get();
    }
    void
    SetX(GoASTExpr *x)
    {
        m_x_up.reset(x);
    }

    const GoASTExpr *
    GetLow() const
    {
        return m_low_up.get();
    }
    void
    SetLow(GoASTExpr *low)
    {
        m_low_up.reset(low);
    }

    const GoASTExpr *
    GetHigh() const
    {
        return m_high_up.get();
    }
    void
    SetHigh(GoASTExpr *high)
    {
        m_high_up.reset(high);
    }

    const GoASTExpr *
    GetMax() const
    {
        return m_max_up.get();
    }
    void
    SetMax(GoASTExpr *max)
    {
        m_max_up.reset(max);
    }

    bool 
    GetSlice3() const
    {
        return m_slice3;
    }
    void
    SetSlice3(bool slice3)
    {
        m_slice3 = slice3;
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTExpr> m_x_up;
    std::unique_ptr<GoASTExpr> m_low_up;
    std::unique_ptr<GoASTExpr> m_high_up;
    std::unique_ptr<GoASTExpr> m_max_up;
    bool m_slice3;

    GoASTSliceExpr(const GoASTSliceExpr &) = delete;
    const GoASTSliceExpr &operator=(const GoASTSliceExpr &) = delete;
};

class GoASTStarExpr : public GoASTExpr
{
  public:
    explicit GoASTStarExpr(GoASTExpr *x) : GoASTExpr(eStarExpr), m_x_up(x) {}
    ~GoASTStarExpr() override = default;

    const char *
    GetKindName() const override
    {
        return "StarExpr";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eStarExpr;
    }
    
    const GoASTExpr *
    GetX() const
    {
        return m_x_up.get();
    }
    void
    SetX(GoASTExpr *x)
    {
        m_x_up.reset(x);
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTExpr> m_x_up;

    GoASTStarExpr(const GoASTStarExpr &) = delete;
    const GoASTStarExpr &operator=(const GoASTStarExpr &) = delete;
};

class GoASTStructType : public GoASTExpr
{
  public:
    explicit GoASTStructType(GoASTFieldList *fields) : GoASTExpr(eStructType), m_fields_up(fields) {}
    ~GoASTStructType() override = default;

    const char *
    GetKindName() const override
    {
        return "StructType";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eStructType;
    }
    
    const GoASTFieldList *
    GetFields() const
    {
        return m_fields_up.get();
    }
    void
    SetFields(GoASTFieldList *fields)
    {
        m_fields_up.reset(fields);
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTFieldList> m_fields_up;

    GoASTStructType(const GoASTStructType &) = delete;
    const GoASTStructType &operator=(const GoASTStructType &) = delete;
};

class GoASTSwitchStmt : public GoASTStmt
{
  public:
    GoASTSwitchStmt(GoASTStmt *init, GoASTExpr *tag, GoASTBlockStmt *body) : GoASTStmt(eSwitchStmt), m_init_up(init), m_tag_up(tag), m_body_up(body) {}
    ~GoASTSwitchStmt() override = default;

    const char *
    GetKindName() const override
    {
        return "SwitchStmt";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eSwitchStmt;
    }
    
    const GoASTStmt *
    GetInit() const
    {
        return m_init_up.get();
    }
    void
    SetInit(GoASTStmt *init)
    {
        m_init_up.reset(init);
    }

    const GoASTExpr *
    GetTag() const
    {
        return m_tag_up.get();
    }
    void
    SetTag(GoASTExpr *tag)
    {
        m_tag_up.reset(tag);
    }

    const GoASTBlockStmt *
    GetBody() const
    {
        return m_body_up.get();
    }
    void
    SetBody(GoASTBlockStmt *body)
    {
        m_body_up.reset(body);
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTStmt> m_init_up;
    std::unique_ptr<GoASTExpr> m_tag_up;
    std::unique_ptr<GoASTBlockStmt> m_body_up;

    GoASTSwitchStmt(const GoASTSwitchStmt &) = delete;
    const GoASTSwitchStmt &operator=(const GoASTSwitchStmt &) = delete;
};

class GoASTTypeAssertExpr : public GoASTExpr
{
  public:
    GoASTTypeAssertExpr(GoASTExpr *x, GoASTExpr *type) : GoASTExpr(eTypeAssertExpr), m_x_up(x), m_type_up(type) {}
    ~GoASTTypeAssertExpr() override = default;

    const char *
    GetKindName() const override
    {
        return "TypeAssertExpr";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eTypeAssertExpr;
    }
    
    const GoASTExpr *
    GetX() const
    {
        return m_x_up.get();
    }
    void
    SetX(GoASTExpr *x)
    {
        m_x_up.reset(x);
    }

    const GoASTExpr *
    GetType() const
    {
        return m_type_up.get();
    }
    void
    SetType(GoASTExpr *type)
    {
        m_type_up.reset(type);
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTExpr> m_x_up;
    std::unique_ptr<GoASTExpr> m_type_up;

    GoASTTypeAssertExpr(const GoASTTypeAssertExpr &) = delete;
    const GoASTTypeAssertExpr &operator=(const GoASTTypeAssertExpr &) = delete;
};

class GoASTTypeSpec : public GoASTSpec
{
  public:
    GoASTTypeSpec(GoASTIdent *name, GoASTExpr *type) : GoASTSpec(eTypeSpec), m_name_up(name), m_type_up(type) {}
    ~GoASTTypeSpec() override = default;

    const char *
    GetKindName() const override
    {
        return "TypeSpec";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eTypeSpec;
    }
    
    const GoASTIdent *
    GetName() const
    {
        return m_name_up.get();
    }
    void
    SetName(GoASTIdent *name)
    {
        m_name_up.reset(name);
    }

    const GoASTExpr *
    GetType() const
    {
        return m_type_up.get();
    }
    void
    SetType(GoASTExpr *type)
    {
        m_type_up.reset(type);
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTIdent> m_name_up;
    std::unique_ptr<GoASTExpr> m_type_up;

    GoASTTypeSpec(const GoASTTypeSpec &) = delete;
    const GoASTTypeSpec &operator=(const GoASTTypeSpec &) = delete;
};

class GoASTTypeSwitchStmt : public GoASTStmt
{
  public:
    GoASTTypeSwitchStmt(GoASTStmt *init, GoASTStmt *assign, GoASTBlockStmt *body) : GoASTStmt(eTypeSwitchStmt), m_init_up(init), m_assign_up(assign), m_body_up(body) {}
    ~GoASTTypeSwitchStmt() override = default;

    const char *
    GetKindName() const override
    {
        return "TypeSwitchStmt";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eTypeSwitchStmt;
    }
    
    const GoASTStmt *
    GetInit() const
    {
        return m_init_up.get();
    }
    void
    SetInit(GoASTStmt *init)
    {
        m_init_up.reset(init);
    }

    const GoASTStmt *
    GetAssign() const
    {
        return m_assign_up.get();
    }
    void
    SetAssign(GoASTStmt *assign)
    {
        m_assign_up.reset(assign);
    }

    const GoASTBlockStmt *
    GetBody() const
    {
        return m_body_up.get();
    }
    void
    SetBody(GoASTBlockStmt *body)
    {
        m_body_up.reset(body);
    }

  private:
    friend class GoASTNode;
    std::unique_ptr<GoASTStmt> m_init_up;
    std::unique_ptr<GoASTStmt> m_assign_up;
    std::unique_ptr<GoASTBlockStmt> m_body_up;

    GoASTTypeSwitchStmt(const GoASTTypeSwitchStmt &) = delete;
    const GoASTTypeSwitchStmt &operator=(const GoASTTypeSwitchStmt &) = delete;
};

class GoASTUnaryExpr : public GoASTExpr
{
  public:
    GoASTUnaryExpr(TokenType op, GoASTExpr *x) : GoASTExpr(eUnaryExpr), m_op(op), m_x_up(x) {}
    ~GoASTUnaryExpr() override = default;

    const char *
    GetKindName() const override
    {
        return "UnaryExpr";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eUnaryExpr;
    }
    
    TokenType 
    GetOp() const
    {
        return m_op;
    }
    void
    SetOp(TokenType op)
    {
        m_op = op;
    }

    const GoASTExpr *
    GetX() const
    {
        return m_x_up.get();
    }
    void
    SetX(GoASTExpr *x)
    {
        m_x_up.reset(x);
    }

  private:
    friend class GoASTNode;
    TokenType m_op;
    std::unique_ptr<GoASTExpr> m_x_up;

    GoASTUnaryExpr(const GoASTUnaryExpr &) = delete;
    const GoASTUnaryExpr &operator=(const GoASTUnaryExpr &) = delete;
};

class GoASTValueSpec : public GoASTSpec
{
  public:
    GoASTValueSpec() : GoASTSpec(eValueSpec) {}
    ~GoASTValueSpec() override = default;

    const char *
    GetKindName() const override
    {
        return "ValueSpec";
    }

    static bool
    classof(const GoASTNode *n)
    {
        return n->GetKind() == eValueSpec;
    }
    
    size_t
    NumNames() const
    {
        return m_names.size();
    }
    const GoASTIdent *
    GetNames(int i) const
    {
        return m_names[i].get();
    }
    void
    AddNames(GoASTIdent *names)
    {
        m_names.push_back(std::unique_ptr<GoASTIdent>(names));
    }

    const GoASTExpr *
    GetType() const
    {
        return m_type_up.get();
    }
    void
    SetType(GoASTExpr *type)
    {
        m_type_up.reset(type);
    }

    size_t
    NumValues() const
    {
        return m_values.size();
    }
    const GoASTExpr *
    GetValues(int i) const
    {
        return m_values[i].get();
    }
    void
    AddValues(GoASTExpr *values)
    {
        m_values.push_back(std::unique_ptr<GoASTExpr>(values));
    }

  private:
    friend class GoASTNode;
    std::vector<std::unique_ptr<GoASTIdent> > m_names;
    std::unique_ptr<GoASTExpr> m_type_up;
    std::vector<std::unique_ptr<GoASTExpr> > m_values;

    GoASTValueSpec(const GoASTValueSpec &) = delete;
    const GoASTValueSpec &operator=(const GoASTValueSpec &) = delete;
};


template <typename R, typename V>
R GoASTDecl::Visit(V* v) const
{
    switch(GetKind())
    {
    case eBadDecl:
        return v->VisitBadDecl(llvm::cast<const GoASTBadDecl>(this));
    case eFuncDecl:
        return v->VisitFuncDecl(llvm::cast<const GoASTFuncDecl>(this));
    case eGenDecl:
        return v->VisitGenDecl(llvm::cast<const GoASTGenDecl>(this));
    default:
        assert(false && "Invalid kind");
    }
}

template <typename R, typename V>
R GoASTExpr::Visit(V* v) const
{
    switch(GetKind())
    {
    case eArrayType:
        return v->VisitArrayType(llvm::cast<const GoASTArrayType>(this));
    case eBadExpr:
        return v->VisitBadExpr(llvm::cast<const GoASTBadExpr>(this));
    case eBasicLit:
        return v->VisitBasicLit(llvm::cast<const GoASTBasicLit>(this));
    case eBinaryExpr:
        return v->VisitBinaryExpr(llvm::cast<const GoASTBinaryExpr>(this));
    case eIdent:
        return v->VisitIdent(llvm::cast<const GoASTIdent>(this));
    case eCallExpr:
        return v->VisitCallExpr(llvm::cast<const GoASTCallExpr>(this));
    case eChanType:
        return v->VisitChanType(llvm::cast<const GoASTChanType>(this));
    case eCompositeLit:
        return v->VisitCompositeLit(llvm::cast<const GoASTCompositeLit>(this));
    case eEllipsis:
        return v->VisitEllipsis(llvm::cast<const GoASTEllipsis>(this));
    case eFuncType:
        return v->VisitFuncType(llvm::cast<const GoASTFuncType>(this));
    case eFuncLit:
        return v->VisitFuncLit(llvm::cast<const GoASTFuncLit>(this));
    case eIndexExpr:
        return v->VisitIndexExpr(llvm::cast<const GoASTIndexExpr>(this));
    case eInterfaceType:
        return v->VisitInterfaceType(llvm::cast<const GoASTInterfaceType>(this));
    case eKeyValueExpr:
        return v->VisitKeyValueExpr(llvm::cast<const GoASTKeyValueExpr>(this));
    case eMapType:
        return v->VisitMapType(llvm::cast<const GoASTMapType>(this));
    case eParenExpr:
        return v->VisitParenExpr(llvm::cast<const GoASTParenExpr>(this));
    case eSelectorExpr:
        return v->VisitSelectorExpr(llvm::cast<const GoASTSelectorExpr>(this));
    case eSliceExpr:
        return v->VisitSliceExpr(llvm::cast<const GoASTSliceExpr>(this));
    case eStarExpr:
        return v->VisitStarExpr(llvm::cast<const GoASTStarExpr>(this));
    case eStructType:
        return v->VisitStructType(llvm::cast<const GoASTStructType>(this));
    case eTypeAssertExpr:
        return v->VisitTypeAssertExpr(llvm::cast<const GoASTTypeAssertExpr>(this));
    case eUnaryExpr:
        return v->VisitUnaryExpr(llvm::cast<const GoASTUnaryExpr>(this));
    default:
        assert(false && "Invalid kind");
        return R();
    }
}

template <typename R, typename V>
R GoASTSpec::Visit(V* v) const
{
    switch(GetKind())
    {
    case eImportSpec:
        return v->VisitImportSpec(llvm::cast<const GoASTImportSpec>(this));
    case eTypeSpec:
        return v->VisitTypeSpec(llvm::cast<const GoASTTypeSpec>(this));
    case eValueSpec:
        return v->VisitValueSpec(llvm::cast<const GoASTValueSpec>(this));
    default:
        assert(false && "Invalid kind");
    }
}

template <typename R, typename V>
R GoASTStmt::Visit(V* v) const
{
    switch(GetKind())
    {
    case eAssignStmt:
        return v->VisitAssignStmt(llvm::cast<const GoASTAssignStmt>(this));
    case eBadStmt:
        return v->VisitBadStmt(llvm::cast<const GoASTBadStmt>(this));
    case eBlockStmt:
        return v->VisitBlockStmt(llvm::cast<const GoASTBlockStmt>(this));
    case eBranchStmt:
        return v->VisitBranchStmt(llvm::cast<const GoASTBranchStmt>(this));
    case eCaseClause:
        return v->VisitCaseClause(llvm::cast<const GoASTCaseClause>(this));
    case eCommClause:
        return v->VisitCommClause(llvm::cast<const GoASTCommClause>(this));
    case eDeclStmt:
        return v->VisitDeclStmt(llvm::cast<const GoASTDeclStmt>(this));
    case eDeferStmt:
        return v->VisitDeferStmt(llvm::cast<const GoASTDeferStmt>(this));
    case eEmptyStmt:
        return v->VisitEmptyStmt(llvm::cast<const GoASTEmptyStmt>(this));
    case eExprStmt:
        return v->VisitExprStmt(llvm::cast<const GoASTExprStmt>(this));
    case eForStmt:
        return v->VisitForStmt(llvm::cast<const GoASTForStmt>(this));
    case eGoStmt:
        return v->VisitGoStmt(llvm::cast<const GoASTGoStmt>(this));
    case eIfStmt:
        return v->VisitIfStmt(llvm::cast<const GoASTIfStmt>(this));
    case eIncDecStmt:
        return v->VisitIncDecStmt(llvm::cast<const GoASTIncDecStmt>(this));
    case eLabeledStmt:
        return v->VisitLabeledStmt(llvm::cast<const GoASTLabeledStmt>(this));
    case eRangeStmt:
        return v->VisitRangeStmt(llvm::cast<const GoASTRangeStmt>(this));
    case eReturnStmt:
        return v->VisitReturnStmt(llvm::cast<const GoASTReturnStmt>(this));
    case eSelectStmt:
        return v->VisitSelectStmt(llvm::cast<const GoASTSelectStmt>(this));
    case eSendStmt:
        return v->VisitSendStmt(llvm::cast<const GoASTSendStmt>(this));
    case eSwitchStmt:
        return v->VisitSwitchStmt(llvm::cast<const GoASTSwitchStmt>(this));
    case eTypeSwitchStmt:
        return v->VisitTypeSwitchStmt(llvm::cast<const GoASTTypeSwitchStmt>(this));
    default:
        assert(false && "Invalid kind");
    }
}

template <typename V>
void GoASTNode::WalkChildren(V &v)
{
    switch (m_kind)
    {


    case eArrayType:
        {
            GoASTArrayType *n = llvm::cast<GoASTArrayType>(this);
            (void)n;
            v(n->m_len_up.get());
            v(n->m_elt_up.get());
            return;
        }
    case eAssignStmt:
        {
            GoASTAssignStmt *n = llvm::cast<GoASTAssignStmt>(this);
            (void)n;
            for (auto& e : n->m_lhs) { v(e.get()); }
            for (auto& e : n->m_rhs) { v(e.get()); }
            return;
        }
    case eBasicLit:
        {
            GoASTBasicLit *n = llvm::cast<GoASTBasicLit>(this);
            (void)n;
            return;
        }
    case eBinaryExpr:
        {
            GoASTBinaryExpr *n = llvm::cast<GoASTBinaryExpr>(this);
            (void)n;
            v(n->m_x_up.get());
            v(n->m_y_up.get());
            return;
        }
    case eBlockStmt:
        {
            GoASTBlockStmt *n = llvm::cast<GoASTBlockStmt>(this);
            (void)n;
            for (auto& e : n->m_list) { v(e.get()); }
            return;
        }
    case eIdent:
        {
            GoASTIdent *n = llvm::cast<GoASTIdent>(this);
            (void)n;
            return;
        }
    case eBranchStmt:
        {
            GoASTBranchStmt *n = llvm::cast<GoASTBranchStmt>(this);
            (void)n;
            v(n->m_label_up.get());
            return;
        }
    case eCallExpr:
        {
            GoASTCallExpr *n = llvm::cast<GoASTCallExpr>(this);
            (void)n;
            v(n->m_fun_up.get());
            for (auto& e : n->m_args) { v(e.get()); }
            return;
        }
    case eCaseClause:
        {
            GoASTCaseClause *n = llvm::cast<GoASTCaseClause>(this);
            (void)n;
            for (auto& e : n->m_list) { v(e.get()); }
            for (auto& e : n->m_body) { v(e.get()); }
            return;
        }
    case eChanType:
        {
            GoASTChanType *n = llvm::cast<GoASTChanType>(this);
            (void)n;
            v(n->m_value_up.get());
            return;
        }
    case eCommClause:
        {
            GoASTCommClause *n = llvm::cast<GoASTCommClause>(this);
            (void)n;
            v(n->m_comm_up.get());
            for (auto& e : n->m_body) { v(e.get()); }
            return;
        }
    case eCompositeLit:
        {
            GoASTCompositeLit *n = llvm::cast<GoASTCompositeLit>(this);
            (void)n;
            v(n->m_type_up.get());
            for (auto& e : n->m_elts) { v(e.get()); }
            return;
        }
    case eDeclStmt:
        {
            GoASTDeclStmt *n = llvm::cast<GoASTDeclStmt>(this);
            (void)n;
            v(n->m_decl_up.get());
            return;
        }
    case eDeferStmt:
        {
            GoASTDeferStmt *n = llvm::cast<GoASTDeferStmt>(this);
            (void)n;
            v(n->m_call_up.get());
            return;
        }
    case eEllipsis:
        {
            GoASTEllipsis *n = llvm::cast<GoASTEllipsis>(this);
            (void)n;
            v(n->m_elt_up.get());
            return;
        }
    case eExprStmt:
        {
            GoASTExprStmt *n = llvm::cast<GoASTExprStmt>(this);
            (void)n;
            v(n->m_x_up.get());
            return;
        }
    case eField:
        {
            GoASTField *n = llvm::cast<GoASTField>(this);
            (void)n;
            for (auto& e : n->m_names) { v(e.get()); }
            v(n->m_type_up.get());
            v(n->m_tag_up.get());
            return;
        }
    case eFieldList:
        {
            GoASTFieldList *n = llvm::cast<GoASTFieldList>(this);
            (void)n;
            for (auto& e : n->m_list) { v(e.get()); }
            return;
        }
    case eForStmt:
        {
            GoASTForStmt *n = llvm::cast<GoASTForStmt>(this);
            (void)n;
            v(n->m_init_up.get());
            v(n->m_cond_up.get());
            v(n->m_post_up.get());
            v(n->m_body_up.get());
            return;
        }
    case eFuncType:
        {
            GoASTFuncType *n = llvm::cast<GoASTFuncType>(this);
            (void)n;
            v(n->m_params_up.get());
            v(n->m_results_up.get());
            return;
        }
    case eFuncDecl:
        {
            GoASTFuncDecl *n = llvm::cast<GoASTFuncDecl>(this);
            (void)n;
            v(n->m_recv_up.get());
            v(n->m_name_up.get());
            v(n->m_type_up.get());
            v(n->m_body_up.get());
            return;
        }
    case eFuncLit:
        {
            GoASTFuncLit *n = llvm::cast<GoASTFuncLit>(this);
            (void)n;
            v(n->m_type_up.get());
            v(n->m_body_up.get());
            return;
        }
    case eGenDecl:
        {
            GoASTGenDecl *n = llvm::cast<GoASTGenDecl>(this);
            (void)n;
            for (auto& e : n->m_specs) { v(e.get()); }
            return;
        }
    case eGoStmt:
        {
            GoASTGoStmt *n = llvm::cast<GoASTGoStmt>(this);
            (void)n;
            v(n->m_call_up.get());
            return;
        }
    case eIfStmt:
        {
            GoASTIfStmt *n = llvm::cast<GoASTIfStmt>(this);
            (void)n;
            v(n->m_init_up.get());
            v(n->m_cond_up.get());
            v(n->m_body_up.get());
            v(n->m_els_up.get());
            return;
        }
    case eImportSpec:
        {
            GoASTImportSpec *n = llvm::cast<GoASTImportSpec>(this);
            (void)n;
            v(n->m_name_up.get());
            v(n->m_path_up.get());
            return;
        }
    case eIncDecStmt:
        {
            GoASTIncDecStmt *n = llvm::cast<GoASTIncDecStmt>(this);
            (void)n;
            v(n->m_x_up.get());
            return;
        }
    case eIndexExpr:
        {
            GoASTIndexExpr *n = llvm::cast<GoASTIndexExpr>(this);
            (void)n;
            v(n->m_x_up.get());
            v(n->m_index_up.get());
            return;
        }
    case eInterfaceType:
        {
            GoASTInterfaceType *n = llvm::cast<GoASTInterfaceType>(this);
            (void)n;
            v(n->m_methods_up.get());
            return;
        }
    case eKeyValueExpr:
        {
            GoASTKeyValueExpr *n = llvm::cast<GoASTKeyValueExpr>(this);
            (void)n;
            v(n->m_key_up.get());
            v(n->m_value_up.get());
            return;
        }
    case eLabeledStmt:
        {
            GoASTLabeledStmt *n = llvm::cast<GoASTLabeledStmt>(this);
            (void)n;
            v(n->m_label_up.get());
            v(n->m_stmt_up.get());
            return;
        }
    case eMapType:
        {
            GoASTMapType *n = llvm::cast<GoASTMapType>(this);
            (void)n;
            v(n->m_key_up.get());
            v(n->m_value_up.get());
            return;
        }
    case eParenExpr:
        {
            GoASTParenExpr *n = llvm::cast<GoASTParenExpr>(this);
            (void)n;
            v(n->m_x_up.get());
            return;
        }
    case eRangeStmt:
        {
            GoASTRangeStmt *n = llvm::cast<GoASTRangeStmt>(this);
            (void)n;
            v(n->m_key_up.get());
            v(n->m_value_up.get());
            v(n->m_x_up.get());
            v(n->m_body_up.get());
            return;
        }
    case eReturnStmt:
        {
            GoASTReturnStmt *n = llvm::cast<GoASTReturnStmt>(this);
            (void)n;
            for (auto& e : n->m_results) { v(e.get()); }
            return;
        }
    case eSelectStmt:
        {
            GoASTSelectStmt *n = llvm::cast<GoASTSelectStmt>(this);
            (void)n;
            v(n->m_body_up.get());
            return;
        }
    case eSelectorExpr:
        {
            GoASTSelectorExpr *n = llvm::cast<GoASTSelectorExpr>(this);
            (void)n;
            v(n->m_x_up.get());
            v(n->m_sel_up.get());
            return;
        }
    case eSendStmt:
        {
            GoASTSendStmt *n = llvm::cast<GoASTSendStmt>(this);
            (void)n;
            v(n->m_chan_up.get());
            v(n->m_value_up.get());
            return;
        }
    case eSliceExpr:
        {
            GoASTSliceExpr *n = llvm::cast<GoASTSliceExpr>(this);
            (void)n;
            v(n->m_x_up.get());
            v(n->m_low_up.get());
            v(n->m_high_up.get());
            v(n->m_max_up.get());
            return;
        }
    case eStarExpr:
        {
            GoASTStarExpr *n = llvm::cast<GoASTStarExpr>(this);
            (void)n;
            v(n->m_x_up.get());
            return;
        }
    case eStructType:
        {
            GoASTStructType *n = llvm::cast<GoASTStructType>(this);
            (void)n;
            v(n->m_fields_up.get());
            return;
        }
    case eSwitchStmt:
        {
            GoASTSwitchStmt *n = llvm::cast<GoASTSwitchStmt>(this);
            (void)n;
            v(n->m_init_up.get());
            v(n->m_tag_up.get());
            v(n->m_body_up.get());
            return;
        }
    case eTypeAssertExpr:
        {
            GoASTTypeAssertExpr *n = llvm::cast<GoASTTypeAssertExpr>(this);
            (void)n;
            v(n->m_x_up.get());
            v(n->m_type_up.get());
            return;
        }
    case eTypeSpec:
        {
            GoASTTypeSpec *n = llvm::cast<GoASTTypeSpec>(this);
            (void)n;
            v(n->m_name_up.get());
            v(n->m_type_up.get());
            return;
        }
    case eTypeSwitchStmt:
        {
            GoASTTypeSwitchStmt *n = llvm::cast<GoASTTypeSwitchStmt>(this);
            (void)n;
            v(n->m_init_up.get());
            v(n->m_assign_up.get());
            v(n->m_body_up.get());
            return;
        }
    case eUnaryExpr:
        {
            GoASTUnaryExpr *n = llvm::cast<GoASTUnaryExpr>(this);
            (void)n;
            v(n->m_x_up.get());
            return;
        }
    case eValueSpec:
        {
            GoASTValueSpec *n = llvm::cast<GoASTValueSpec>(this);
            (void)n;
            for (auto& e : n->m_names) { v(e.get()); }
            v(n->m_type_up.get());
            for (auto& e : n->m_values) { v(e.get()); }
            return;
        }

        case eEmptyStmt:
        case eBadDecl:
        case eBadExpr:
        case eBadStmt:
          break;
    }
}

}  // namespace lldb_private

#endif