You've already forked linux-packaging-mono
acceptance-tests
data
debian
docs
external
Newtonsoft.Json
api-doc-tools
api-snapshot
aspnetwebstack
bdwgc
binary-reference-assemblies
bockbuild
boringssl
cecil
cecil-legacy
corefx
corert
helix-binaries
ikdasm
ikvm
illinker-test-assets
linker
llvm-project
clang
clang-tools-extra
compiler-rt
libcxx
libcxxabi
libunwind
lld
lldb
cmake
docs
examples
include
lit
lldb.xcodeproj
lldb.xcworkspace
packages
resources
scripts
source
API
Breakpoint
Commands
Core
DataFormatters
Expression
Host
Initialization
Interpreter
Plugins
ABI
Architecture
Disassembler
DynamicLoader
ExpressionParser
Clang
Go
CMakeLists.txt
GoAST.h
GoLexer.cpp
GoLexer.h
GoParser.cpp
GoParser.h
GoUserExpression.cpp
GoUserExpression.h
gen_go_ast.py
CMakeLists.txt
Instruction
InstrumentationRuntime
JITLoader
Language
LanguageRuntime
MemoryHistory
ObjectContainer
ObjectFile
OperatingSystem
Platform
Process
ScriptInterpreter
StructuredData
SymbolFile
SymbolVendor
SystemRuntime
UnwindAssembly
CMakeLists.txt
Symbol
Target
Utility
CMakeLists.txt
lldb.cpp
third_party
tools
unittests
utils
www
.arcconfig
.clang-format
.gitignore
CMakeLists.txt
CODE_OWNERS.txt
INSTALL.txt
LICENSE.TXT
use_lldb_suite_root.py
llvm
openmp
polly
nuget-buildtasks
nunit-lite
roslyn-binaries
rx
xunit-binaries
how-to-bump-roslyn-binaries.md
ikvm-native
llvm
m4
man
mcs
mk
mono
msvc
netcore
po
runtime
samples
scripts
support
tools
COPYING.LIB
LICENSE
Makefile.am
Makefile.in
NEWS
README.md
acinclude.m4
aclocal.m4
autogen.sh
code_of_conduct.md
compile
config.guess
config.h.in
config.rpath
config.sub
configure.REMOVED.git-id
configure.ac.REMOVED.git-id
depcomp
install-sh
ltmain.sh.REMOVED.git-id
missing
mkinstalldirs
mono-uninstalled.pc.in
test-driver
winconfig.h
1978 lines
58 KiB
C
1978 lines
58 KiB
C
![]() |
//===-- 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
|