src/third_party/llvm-project/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 "Plugins/ExpressionParser/Go/GoLexer.h"
#include "lldb/lldb-forward.h"
#include "lldb/lldb-private.h"
#include "llvm/Support/Casting.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