mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-10-05 22:02:55 +01:00
Switch Statement to use inheritance+cast (#718)
This commit is contained in:
Jon Meow
GitHub
@@ -6,196 +6,24 @@
|
||||
|
||||
#include "common/check.h"
|
||||
#include "executable_semantics/common/arena.h"
|
||||
#include "llvm/Support/Casting.h"
|
||||
|
||||
namespace Carbon {
|
||||
|
||||
auto Statement::GetExpressionStatement() const -> const ExpressionStatement& {
|
||||
return std::get<ExpressionStatement>(value);
|
||||
}
|
||||
|
||||
auto Statement::GetAssign() const -> const Assign& {
|
||||
return std::get<Assign>(value);
|
||||
}
|
||||
|
||||
auto Statement::GetVariableDefinition() const -> const VariableDefinition& {
|
||||
return std::get<VariableDefinition>(value);
|
||||
}
|
||||
|
||||
auto Statement::GetIf() const -> const If& { return std::get<If>(value); }
|
||||
|
||||
auto Statement::GetReturn() const -> const Return& {
|
||||
return std::get<Return>(value);
|
||||
}
|
||||
|
||||
auto Statement::GetSequence() const -> const Sequence& {
|
||||
return std::get<Sequence>(value);
|
||||
}
|
||||
|
||||
auto Statement::GetBlock() const -> const Block& {
|
||||
return std::get<Block>(value);
|
||||
}
|
||||
|
||||
auto Statement::GetWhile() const -> const While& {
|
||||
return std::get<While>(value);
|
||||
}
|
||||
|
||||
auto Statement::GetBreak() const -> const Break& {
|
||||
return std::get<Break>(value);
|
||||
}
|
||||
|
||||
auto Statement::GetContinue() const -> const Continue& {
|
||||
return std::get<Continue>(value);
|
||||
}
|
||||
|
||||
auto Statement::GetMatch() const -> const Match& {
|
||||
return std::get<Match>(value);
|
||||
}
|
||||
|
||||
auto Statement::GetContinuation() const -> const Continuation& {
|
||||
return std::get<Continuation>(value);
|
||||
}
|
||||
|
||||
auto Statement::GetRun() const -> const Run& { return std::get<Run>(value); }
|
||||
|
||||
auto Statement::GetAwait() const -> const Await& {
|
||||
return std::get<Await>(value);
|
||||
}
|
||||
|
||||
auto Statement::MakeExpressionStatement(int line_num, const Expression* exp)
|
||||
-> const Statement* {
|
||||
auto* s = global_arena->New<Statement>();
|
||||
s->line_num = line_num;
|
||||
s->value = ExpressionStatement({.exp = exp});
|
||||
return s;
|
||||
}
|
||||
|
||||
auto Statement::MakeAssign(int line_num, const Expression* lhs,
|
||||
const Expression* rhs) -> const Statement* {
|
||||
auto* s = global_arena->New<Statement>();
|
||||
s->line_num = line_num;
|
||||
s->value = Assign({.lhs = lhs, .rhs = rhs});
|
||||
return s;
|
||||
}
|
||||
|
||||
auto Statement::MakeVariableDefinition(int line_num, const Pattern* pat,
|
||||
const Expression* init)
|
||||
-> const Statement* {
|
||||
auto* s = global_arena->New<Statement>();
|
||||
s->line_num = line_num;
|
||||
s->value = VariableDefinition({.pat = pat, .init = init});
|
||||
return s;
|
||||
}
|
||||
|
||||
auto Statement::MakeIf(int line_num, const Expression* cond,
|
||||
const Statement* then_stmt, const Statement* else_stmt)
|
||||
-> const Statement* {
|
||||
auto* s = global_arena->New<Statement>();
|
||||
s->line_num = line_num;
|
||||
s->value = If({.cond = cond, .then_stmt = then_stmt, .else_stmt = else_stmt});
|
||||
return s;
|
||||
}
|
||||
|
||||
auto Statement::MakeWhile(int line_num, const Expression* cond,
|
||||
const Statement* body) -> const Statement* {
|
||||
auto* s = global_arena->New<Statement>();
|
||||
s->line_num = line_num;
|
||||
s->value = While({.cond = cond, .body = body});
|
||||
return s;
|
||||
}
|
||||
|
||||
auto Statement::MakeBreak(int line_num) -> const Statement* {
|
||||
auto* s = global_arena->New<Statement>();
|
||||
s->line_num = line_num;
|
||||
s->value = Break();
|
||||
return s;
|
||||
}
|
||||
|
||||
auto Statement::MakeContinue(int line_num) -> const Statement* {
|
||||
auto* s = global_arena->New<Statement>();
|
||||
s->line_num = line_num;
|
||||
s->value = Continue();
|
||||
return s;
|
||||
}
|
||||
|
||||
auto Statement::MakeReturn(int line_num, const Expression* exp,
|
||||
bool is_omitted_exp) -> const Statement* {
|
||||
auto* s = global_arena->New<Statement>();
|
||||
s->line_num = line_num;
|
||||
if (exp == nullptr) {
|
||||
CHECK(is_omitted_exp);
|
||||
exp = global_arena->New<TupleLiteral>(line_num);
|
||||
}
|
||||
s->value = Return({.exp = exp, .is_omitted_exp = is_omitted_exp});
|
||||
return s;
|
||||
}
|
||||
|
||||
auto Statement::MakeSequence(int line_num, const Statement* s1,
|
||||
const Statement* s2) -> const Statement* {
|
||||
auto* s = global_arena->New<Statement>();
|
||||
s->line_num = line_num;
|
||||
s->value = Sequence({.stmt = s1, .next = s2});
|
||||
return s;
|
||||
}
|
||||
|
||||
auto Statement::MakeBlock(int line_num, const Statement* stmt)
|
||||
-> const Statement* {
|
||||
auto* s = global_arena->New<Statement>();
|
||||
s->line_num = line_num;
|
||||
s->value = Block({.stmt = stmt});
|
||||
return s;
|
||||
}
|
||||
|
||||
auto Statement::MakeMatch(
|
||||
int line_num, const Expression* exp,
|
||||
std::list<std::pair<const Pattern*, const Statement*>>* clauses)
|
||||
-> const Statement* {
|
||||
auto* s = global_arena->New<Statement>();
|
||||
s->line_num = line_num;
|
||||
s->value = Match({.exp = exp, .clauses = clauses});
|
||||
return s;
|
||||
}
|
||||
|
||||
// Returns an AST node for a continuation statement give its line number and
|
||||
// parts.
|
||||
auto Statement::MakeContinuation(int line_num,
|
||||
std::string continuation_variable,
|
||||
const Statement* body) -> const Statement* {
|
||||
auto* s = global_arena->New<Statement>();
|
||||
s->line_num = line_num;
|
||||
s->value =
|
||||
Continuation({.continuation_variable = std::move(continuation_variable),
|
||||
.body = body});
|
||||
return s;
|
||||
}
|
||||
|
||||
// Returns an AST node for a run statement give its line number and argument.
|
||||
auto Statement::MakeRun(int line_num, const Expression* argument)
|
||||
-> const Statement* {
|
||||
auto* s = global_arena->New<Statement>();
|
||||
s->line_num = line_num;
|
||||
s->value = Run({.argument = argument});
|
||||
return s;
|
||||
}
|
||||
|
||||
// Returns an AST node for an await statement give its line number.
|
||||
auto Statement::MakeAwait(int line_num) -> const Statement* {
|
||||
auto* s = global_arena->New<Statement>();
|
||||
s->line_num = line_num;
|
||||
s->value = Await();
|
||||
return s;
|
||||
}
|
||||
using llvm::cast;
|
||||
|
||||
void Statement::PrintDepth(int depth, llvm::raw_ostream& out) const {
|
||||
if (depth == 0) {
|
||||
out << " ... ";
|
||||
return;
|
||||
}
|
||||
switch (tag()) {
|
||||
case StatementKind::Match:
|
||||
out << "match (" << *GetMatch().exp << ") {";
|
||||
switch (Tag()) {
|
||||
case Kind::Match: {
|
||||
const auto& match = cast<Match>(*this);
|
||||
out << "match (" << *match.Exp() << ") {";
|
||||
if (depth < 0 || depth > 1) {
|
||||
out << "\n";
|
||||
for (auto& clause : *GetMatch().clauses) {
|
||||
for (auto& clause : *match.Clauses()) {
|
||||
out << "case " << *clause.first << " =>\n";
|
||||
clause.second->PrintDepth(depth - 1, out);
|
||||
out << "\n";
|
||||
@@ -205,59 +33,72 @@ void Statement::PrintDepth(int depth, llvm::raw_ostream& out) const {
|
||||
}
|
||||
out << "}";
|
||||
break;
|
||||
case StatementKind::While:
|
||||
out << "while (" << *GetWhile().cond << ")\n";
|
||||
GetWhile().body->PrintDepth(depth - 1, out);
|
||||
}
|
||||
case Kind::While: {
|
||||
const auto& while_stmt = cast<While>(*this);
|
||||
out << "while (" << *while_stmt.Cond() << ")\n";
|
||||
while_stmt.Body()->PrintDepth(depth - 1, out);
|
||||
break;
|
||||
case StatementKind::Break:
|
||||
}
|
||||
case Kind::Break:
|
||||
out << "break;";
|
||||
break;
|
||||
case StatementKind::Continue:
|
||||
case Kind::Continue:
|
||||
out << "continue;";
|
||||
break;
|
||||
case StatementKind::VariableDefinition:
|
||||
out << "var " << *GetVariableDefinition().pat << " = "
|
||||
<< *GetVariableDefinition().init << ";";
|
||||
case Kind::VariableDefinition: {
|
||||
const auto& var = cast<VariableDefinition>(*this);
|
||||
out << "var " << *var.Pat() << " = " << *var.Init() << ";";
|
||||
break;
|
||||
case StatementKind::ExpressionStatement:
|
||||
out << *GetExpressionStatement().exp << ";";
|
||||
}
|
||||
case Kind::ExpressionStatement:
|
||||
out << *cast<ExpressionStatement>(*this).Exp() << ";";
|
||||
break;
|
||||
case StatementKind::Assign:
|
||||
out << *GetAssign().lhs << " = " << *GetAssign().rhs << ";";
|
||||
case Kind::Assign: {
|
||||
const auto& assign = cast<Assign>(*this);
|
||||
out << *assign.Lhs() << " = " << *assign.Rhs() << ";";
|
||||
break;
|
||||
case StatementKind::If:
|
||||
out << "if (" << *GetIf().cond << ")\n";
|
||||
GetIf().then_stmt->PrintDepth(depth - 1, out);
|
||||
if (GetIf().else_stmt) {
|
||||
}
|
||||
case Kind::If: {
|
||||
const auto& if_stmt = cast<If>(*this);
|
||||
out << "if (" << *if_stmt.Cond() << ")\n";
|
||||
if_stmt.ThenStmt()->PrintDepth(depth - 1, out);
|
||||
if (if_stmt.ElseStmt()) {
|
||||
out << "\nelse\n";
|
||||
GetIf().else_stmt->PrintDepth(depth - 1, out);
|
||||
if_stmt.ElseStmt()->PrintDepth(depth - 1, out);
|
||||
}
|
||||
break;
|
||||
case StatementKind::Return:
|
||||
if (GetReturn().is_omitted_exp) {
|
||||
}
|
||||
case Kind::Return: {
|
||||
const auto& ret = cast<Return>(*this);
|
||||
if (ret.IsOmittedExp()) {
|
||||
out << "return;";
|
||||
} else {
|
||||
out << "return " << *GetReturn().exp << ";";
|
||||
out << "return " << *ret.Exp() << ";";
|
||||
}
|
||||
break;
|
||||
case StatementKind::Sequence:
|
||||
GetSequence().stmt->PrintDepth(depth, out);
|
||||
}
|
||||
case Kind::Sequence: {
|
||||
const auto& seq = cast<Sequence>(*this);
|
||||
seq.Stmt()->PrintDepth(depth, out);
|
||||
if (depth < 0 || depth > 1) {
|
||||
out << "\n";
|
||||
} else {
|
||||
out << " ";
|
||||
}
|
||||
if (GetSequence().next) {
|
||||
GetSequence().next->PrintDepth(depth - 1, out);
|
||||
if (seq.Next()) {
|
||||
seq.Next()->PrintDepth(depth - 1, out);
|
||||
}
|
||||
break;
|
||||
case StatementKind::Block:
|
||||
}
|
||||
case Kind::Block: {
|
||||
const auto& block = cast<Block>(*this);
|
||||
out << "{";
|
||||
if (depth < 0 || depth > 1) {
|
||||
out << "\n";
|
||||
}
|
||||
if (GetBlock().stmt) {
|
||||
GetBlock().stmt->PrintDepth(depth, out);
|
||||
if (block.Stmt()) {
|
||||
block.Stmt()->PrintDepth(depth, out);
|
||||
if (depth < 0 || depth > 1) {
|
||||
out << "\n";
|
||||
}
|
||||
@@ -267,23 +108,33 @@ void Statement::PrintDepth(int depth, llvm::raw_ostream& out) const {
|
||||
out << "\n";
|
||||
}
|
||||
break;
|
||||
case StatementKind::Continuation:
|
||||
out << "continuation " << GetContinuation().continuation_variable << " ";
|
||||
}
|
||||
case Kind::Continuation: {
|
||||
const auto& cont = cast<Continuation>(*this);
|
||||
out << "continuation " << cont.ContinuationVariable() << " ";
|
||||
if (depth < 0 || depth > 1) {
|
||||
out << "\n";
|
||||
}
|
||||
GetContinuation().body->PrintDepth(depth - 1, out);
|
||||
cont.Body()->PrintDepth(depth - 1, out);
|
||||
if (depth < 0 || depth > 1) {
|
||||
out << "\n";
|
||||
}
|
||||
break;
|
||||
case StatementKind::Run:
|
||||
out << "run " << *GetRun().argument << ";";
|
||||
}
|
||||
case Kind::Run:
|
||||
out << "run " << *cast<Run>(*this).Argument() << ";";
|
||||
break;
|
||||
case StatementKind::Await:
|
||||
case Kind::Await:
|
||||
out << "await;";
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
Return::Return(int line_num, const Expression* exp, bool is_omitted_exp)
|
||||
: Statement(Kind::Return, line_num),
|
||||
exp(exp != nullptr ? exp : global_arena->New<TupleLiteral>(line_num)),
|
||||
is_omitted_exp(is_omitted_exp) {
|
||||
CHECK(exp != nullptr || is_omitted_exp);
|
||||
}
|
||||
|
||||
} // namespace Carbon
|
||||
|
||||
@@ -14,174 +14,277 @@
|
||||
|
||||
namespace Carbon {
|
||||
|
||||
enum class StatementKind {
|
||||
ExpressionStatement,
|
||||
Assign,
|
||||
VariableDefinition,
|
||||
If,
|
||||
Return,
|
||||
Sequence,
|
||||
Block,
|
||||
While,
|
||||
Break,
|
||||
Continue,
|
||||
Match,
|
||||
Continuation, // Create a first-class continuation.
|
||||
Run, // Run a continuation to the next await or until it finishes..
|
||||
Await, // Pause execution of the continuation.
|
||||
};
|
||||
class Statement {
|
||||
public:
|
||||
enum class Kind {
|
||||
ExpressionStatement,
|
||||
Assign,
|
||||
VariableDefinition,
|
||||
If,
|
||||
Return,
|
||||
Sequence,
|
||||
Block,
|
||||
While,
|
||||
Break,
|
||||
Continue,
|
||||
Match,
|
||||
Continuation, // Create a first-class continuation.
|
||||
Run, // Run a continuation to the next await or until it finishes.
|
||||
Await, // Pause execution of the continuation.
|
||||
};
|
||||
|
||||
struct Statement;
|
||||
// Returns the enumerator corresponding to the most-derived type of this
|
||||
// object.
|
||||
auto Tag() const -> Kind { return tag; }
|
||||
|
||||
struct ExpressionStatement {
|
||||
static constexpr StatementKind Kind = StatementKind::ExpressionStatement;
|
||||
const Expression* exp;
|
||||
};
|
||||
|
||||
struct Assign {
|
||||
static constexpr StatementKind Kind = StatementKind::Assign;
|
||||
const Expression* lhs;
|
||||
const Expression* rhs;
|
||||
};
|
||||
|
||||
struct VariableDefinition {
|
||||
static constexpr StatementKind Kind = StatementKind::VariableDefinition;
|
||||
const Pattern* pat;
|
||||
const Expression* init;
|
||||
};
|
||||
|
||||
struct If {
|
||||
static constexpr StatementKind Kind = StatementKind::If;
|
||||
const Expression* cond;
|
||||
const Statement* then_stmt;
|
||||
const Statement* else_stmt;
|
||||
};
|
||||
|
||||
struct Return {
|
||||
static constexpr StatementKind Kind = StatementKind::Return;
|
||||
const Expression* exp;
|
||||
bool is_omitted_exp;
|
||||
};
|
||||
|
||||
struct Sequence {
|
||||
static constexpr StatementKind Kind = StatementKind::Sequence;
|
||||
const Statement* stmt;
|
||||
const Statement* next;
|
||||
};
|
||||
|
||||
struct Block {
|
||||
static constexpr StatementKind Kind = StatementKind::Block;
|
||||
const Statement* stmt;
|
||||
};
|
||||
|
||||
struct While {
|
||||
static constexpr StatementKind Kind = StatementKind::While;
|
||||
const Expression* cond;
|
||||
const Statement* body;
|
||||
};
|
||||
|
||||
struct Break {
|
||||
static constexpr StatementKind Kind = StatementKind::Break;
|
||||
};
|
||||
|
||||
struct Continue {
|
||||
static constexpr StatementKind Kind = StatementKind::Continue;
|
||||
};
|
||||
|
||||
struct Match {
|
||||
static constexpr StatementKind Kind = StatementKind::Match;
|
||||
const Expression* exp;
|
||||
std::list<std::pair<const Pattern*, const Statement*>>* clauses;
|
||||
};
|
||||
|
||||
struct Continuation {
|
||||
static constexpr StatementKind Kind = StatementKind::Continuation;
|
||||
std::string continuation_variable;
|
||||
const Statement* body;
|
||||
};
|
||||
|
||||
struct Run {
|
||||
static constexpr StatementKind Kind = StatementKind::Run;
|
||||
const Expression* argument;
|
||||
};
|
||||
|
||||
struct Await {
|
||||
static constexpr StatementKind Kind = StatementKind::Await;
|
||||
};
|
||||
|
||||
struct Statement {
|
||||
// Constructors
|
||||
static auto MakeExpressionStatement(int line_num, const Expression* exp)
|
||||
-> const Statement*;
|
||||
static auto MakeAssign(int line_num, const Expression* lhs,
|
||||
const Expression* rhs) -> const Statement*;
|
||||
static auto MakeVariableDefinition(int line_num, const Pattern* pat,
|
||||
const Expression* init)
|
||||
-> const Statement*;
|
||||
static auto MakeIf(int line_num, const Expression* cond,
|
||||
const Statement* then_stmt, const Statement* else_stmt)
|
||||
-> const Statement*;
|
||||
static auto MakeReturn(int line_num, const Expression* exp,
|
||||
bool is_omitted_exp) -> const Statement*;
|
||||
static auto MakeSequence(int line_num, const Statement* s1,
|
||||
const Statement* s2) -> const Statement*;
|
||||
static auto MakeBlock(int line_num, const Statement* s) -> const Statement*;
|
||||
static auto MakeWhile(int line_num, const Expression* cond,
|
||||
const Statement* body) -> const Statement*;
|
||||
static auto MakeBreak(int line_num) -> const Statement*;
|
||||
static auto MakeContinue(int line_num) -> const Statement*;
|
||||
static auto MakeMatch(
|
||||
int line_num, const Expression* exp,
|
||||
std::list<std::pair<const Pattern*, const Statement*>>* clauses)
|
||||
-> const Statement*;
|
||||
// Returns an AST node for a continuation statement give its line number and
|
||||
// contituent parts.
|
||||
//
|
||||
// __continuation <continuation_variable> {
|
||||
// <body>
|
||||
// }
|
||||
static auto MakeContinuation(int line_num, std::string continuation_variable,
|
||||
const Statement* body) -> const Statement*;
|
||||
// Returns an AST node for a run statement give its line number and argument.
|
||||
//
|
||||
// __run <argument>;
|
||||
static auto MakeRun(int line_num, const Expression* argument)
|
||||
-> const Statement*;
|
||||
// Returns an AST node for an await statement give its line number.
|
||||
//
|
||||
// __await;
|
||||
static auto MakeAwait(int line_num) -> const Statement*;
|
||||
|
||||
auto GetExpressionStatement() const -> const ExpressionStatement&;
|
||||
auto GetAssign() const -> const Assign&;
|
||||
auto GetVariableDefinition() const -> const VariableDefinition&;
|
||||
auto GetIf() const -> const If&;
|
||||
auto GetReturn() const -> const Return&;
|
||||
auto GetSequence() const -> const Sequence&;
|
||||
auto GetBlock() const -> const Block&;
|
||||
auto GetWhile() const -> const While&;
|
||||
auto GetBreak() const -> const Break&;
|
||||
auto GetContinue() const -> const Continue&;
|
||||
auto GetMatch() const -> const Match&;
|
||||
auto GetContinuation() const -> const Continuation&;
|
||||
auto GetRun() const -> const Run&;
|
||||
auto GetAwait() const -> const Await&;
|
||||
auto LineNumber() const -> int { return line_num; }
|
||||
|
||||
void Print(llvm::raw_ostream& out) const { PrintDepth(-1, out); }
|
||||
void PrintDepth(int depth, llvm::raw_ostream& out) const;
|
||||
LLVM_DUMP_METHOD void Dump() const { Print(llvm::errs()); }
|
||||
|
||||
inline auto tag() const -> StatementKind {
|
||||
return std::visit([](const auto& t) { return t.Kind; }, value);
|
||||
}
|
||||
|
||||
int line_num;
|
||||
protected:
|
||||
// Constructs an Statement representing syntax at the given line number.
|
||||
// `tag` must be the enumerator corresponding to the most-derived type being
|
||||
// constructed.
|
||||
Statement(Kind tag, int line_num) : tag(tag), line_num(line_num) {}
|
||||
|
||||
private:
|
||||
std::variant<ExpressionStatement, Assign, VariableDefinition, If, Return,
|
||||
Sequence, Block, While, Break, Continue, Match, Continuation,
|
||||
Run, Await>
|
||||
value;
|
||||
const Kind tag;
|
||||
int line_num;
|
||||
};
|
||||
|
||||
class ExpressionStatement : public Statement {
|
||||
public:
|
||||
ExpressionStatement(int line_num, const Expression* exp)
|
||||
: Statement(Kind::ExpressionStatement, line_num), exp(exp) {}
|
||||
|
||||
static auto classof(const Statement* stmt) -> bool {
|
||||
return stmt->Tag() == Kind::ExpressionStatement;
|
||||
}
|
||||
|
||||
auto Exp() const -> const Expression* { return exp; }
|
||||
|
||||
private:
|
||||
const Expression* exp;
|
||||
};
|
||||
|
||||
class Assign : public Statement {
|
||||
public:
|
||||
Assign(int line_num, const Expression* lhs, const Expression* rhs)
|
||||
: Statement(Kind::Assign, line_num), lhs(lhs), rhs(rhs) {}
|
||||
|
||||
static auto classof(const Statement* stmt) -> bool {
|
||||
return stmt->Tag() == Kind::Assign;
|
||||
}
|
||||
|
||||
auto Lhs() const -> const Expression* { return lhs; }
|
||||
auto Rhs() const -> const Expression* { return rhs; }
|
||||
|
||||
private:
|
||||
const Expression* lhs;
|
||||
const Expression* rhs;
|
||||
};
|
||||
|
||||
class VariableDefinition : public Statement {
|
||||
public:
|
||||
VariableDefinition(int line_num, const Pattern* pat, const Expression* init)
|
||||
: Statement(Kind::VariableDefinition, line_num), pat(pat), init(init) {}
|
||||
|
||||
static auto classof(const Statement* stmt) -> bool {
|
||||
return stmt->Tag() == Kind::VariableDefinition;
|
||||
}
|
||||
|
||||
auto Pat() const -> const Pattern* { return pat; }
|
||||
auto Init() const -> const Expression* { return init; }
|
||||
|
||||
private:
|
||||
const Pattern* pat;
|
||||
const Expression* init;
|
||||
};
|
||||
|
||||
class If : public Statement {
|
||||
public:
|
||||
If(int line_num, const Expression* cond, const Statement* then_stmt,
|
||||
const Statement* else_stmt)
|
||||
: Statement(Kind::If, line_num),
|
||||
cond(cond),
|
||||
then_stmt(then_stmt),
|
||||
else_stmt(else_stmt) {}
|
||||
|
||||
static auto classof(const Statement* stmt) -> bool {
|
||||
return stmt->Tag() == Kind::If;
|
||||
}
|
||||
|
||||
auto Cond() const -> const Expression* { return cond; }
|
||||
auto ThenStmt() const -> const Statement* { return then_stmt; }
|
||||
auto ElseStmt() const -> const Statement* { return else_stmt; }
|
||||
|
||||
private:
|
||||
const Expression* cond;
|
||||
const Statement* then_stmt;
|
||||
const Statement* else_stmt;
|
||||
};
|
||||
|
||||
class Return : public Statement {
|
||||
public:
|
||||
Return(int line_num, const Expression* exp, bool is_omitted_exp);
|
||||
|
||||
static auto classof(const Statement* stmt) -> bool {
|
||||
return stmt->Tag() == Kind::Return;
|
||||
}
|
||||
|
||||
auto Exp() const -> const Expression* { return exp; }
|
||||
auto IsOmittedExp() const -> bool { return is_omitted_exp; }
|
||||
|
||||
private:
|
||||
const Expression* exp;
|
||||
bool is_omitted_exp;
|
||||
};
|
||||
|
||||
class Sequence : public Statement {
|
||||
public:
|
||||
Sequence(int line_num, const Statement* stmt, const Statement* next)
|
||||
: Statement(Kind::Sequence, line_num), stmt(stmt), next(next) {}
|
||||
|
||||
static auto classof(const Statement* stmt) -> bool {
|
||||
return stmt->Tag() == Kind::Sequence;
|
||||
}
|
||||
|
||||
auto Stmt() const -> const Statement* { return stmt; }
|
||||
auto Next() const -> const Statement* { return next; }
|
||||
|
||||
private:
|
||||
const Statement* stmt;
|
||||
const Statement* next;
|
||||
};
|
||||
|
||||
class Block : public Statement {
|
||||
public:
|
||||
Block(int line_num, const Statement* stmt)
|
||||
: Statement(Kind::Block, line_num), stmt(stmt) {}
|
||||
|
||||
static auto classof(const Statement* stmt) -> bool {
|
||||
return stmt->Tag() == Kind::Block;
|
||||
}
|
||||
|
||||
auto Stmt() const -> const Statement* { return stmt; }
|
||||
|
||||
private:
|
||||
const Statement* stmt;
|
||||
};
|
||||
|
||||
class While : public Statement {
|
||||
public:
|
||||
While(int line_num, const Expression* cond, const Statement* body)
|
||||
: Statement(Kind::While, line_num), cond(cond), body(body) {}
|
||||
|
||||
static auto classof(const Statement* stmt) -> bool {
|
||||
return stmt->Tag() == Kind::While;
|
||||
}
|
||||
|
||||
auto Cond() const -> const Expression* { return cond; }
|
||||
auto Body() const -> const Statement* { return body; }
|
||||
|
||||
private:
|
||||
const Expression* cond;
|
||||
const Statement* body;
|
||||
};
|
||||
|
||||
class Break : public Statement {
|
||||
public:
|
||||
explicit Break(int line_num) : Statement(Kind::Break, line_num) {}
|
||||
|
||||
static auto classof(const Statement* stmt) -> bool {
|
||||
return stmt->Tag() == Kind::Break;
|
||||
}
|
||||
};
|
||||
|
||||
class Continue : public Statement {
|
||||
public:
|
||||
explicit Continue(int line_num) : Statement(Kind::Continue, line_num) {}
|
||||
|
||||
static auto classof(const Statement* stmt) -> bool {
|
||||
return stmt->Tag() == Kind::Continue;
|
||||
}
|
||||
};
|
||||
|
||||
class Match : public Statement {
|
||||
public:
|
||||
Match(int line_num, const Expression* exp,
|
||||
std::list<std::pair<const Pattern*, const Statement*>>* clauses)
|
||||
: Statement(Kind::Match, line_num), exp(exp), clauses(clauses) {}
|
||||
|
||||
static auto classof(const Statement* stmt) -> bool {
|
||||
return stmt->Tag() == Kind::Match;
|
||||
}
|
||||
|
||||
auto Exp() const -> const Expression* { return exp; }
|
||||
auto Clauses() const
|
||||
-> const std::list<std::pair<const Pattern*, const Statement*>>* {
|
||||
return clauses;
|
||||
}
|
||||
|
||||
private:
|
||||
const Expression* exp;
|
||||
std::list<std::pair<const Pattern*, const Statement*>>* clauses;
|
||||
};
|
||||
|
||||
// A continuation statement.
|
||||
//
|
||||
// __continuation <continuation_variable> {
|
||||
// <body>
|
||||
// }
|
||||
class Continuation : public Statement {
|
||||
public:
|
||||
Continuation(int line_num, std::string continuation_variable,
|
||||
const Statement* body)
|
||||
: Statement(Kind::Continuation, line_num),
|
||||
continuation_variable(std::move(continuation_variable)),
|
||||
body(body) {}
|
||||
|
||||
static auto classof(const Statement* stmt) -> bool {
|
||||
return stmt->Tag() == Kind::Continuation;
|
||||
}
|
||||
|
||||
auto ContinuationVariable() const -> const std::string& {
|
||||
return continuation_variable;
|
||||
}
|
||||
auto Body() const -> const Statement* { return body; }
|
||||
|
||||
private:
|
||||
std::string continuation_variable;
|
||||
const Statement* body;
|
||||
};
|
||||
|
||||
// A run statement.
|
||||
//
|
||||
// __run <argument>;
|
||||
class Run : public Statement {
|
||||
public:
|
||||
Run(int line_num, const Expression* argument)
|
||||
: Statement(Kind::Run, line_num), argument(argument) {}
|
||||
|
||||
static auto classof(const Statement* stmt) -> bool {
|
||||
return stmt->Tag() == Kind::Run;
|
||||
}
|
||||
|
||||
auto Argument() const -> const Expression* { return argument; }
|
||||
|
||||
private:
|
||||
const Expression* argument;
|
||||
};
|
||||
|
||||
// An await statement.
|
||||
//
|
||||
// __await;
|
||||
class Await : public Statement {
|
||||
public:
|
||||
explicit Await(int line_num) : Statement(Kind::Await, line_num) {}
|
||||
|
||||
static auto classof(const Statement* stmt) -> bool {
|
||||
return stmt->Tag() == Kind::Await;
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace Carbon
|
||||
|
||||
Reference in New Issue
Block a user