tomteb
/
carbon-lang


			
				
					
						
						
							123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182
							// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
// Exceptions. See /LICENSE for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

#ifndef EXECUTABLE_SEMANTICS_AST_STATEMENT_H_
#define EXECUTABLE_SEMANTICS_AST_STATEMENT_H_

#include <list>

#include "executable_semantics/ast/expression.h"

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.
};

struct Statement;

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 Expression* 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;
};

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 Expression*, 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 Expression* 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* e) -> 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 Expression*, 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&;

  inline auto tag() const -> StatementKind {
    return std::visit([](const auto& t) { return t.Kind; }, value);
  }

  int line_num;

 private:
  std::variant<ExpressionStatement, Assign, VariableDefinition, If, Return,
               Sequence, Block, While, Break, Continue, Match, Continuation,
               Run, Await>
      value;
};

void PrintStatement(const Statement*, int);

}  // namespace Carbon

#endif  // EXECUTABLE_SEMANTICS_AST_STATEMENT_H_