| //===-- 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 |