8  const std::shared_ptr<Expr> E;
 
    9  const std::shared_ptr<Dot> Do;
 
   10  const std::shared_ptr<AttrPath> Path;
 
   11  const std::shared_ptr<Expr> Default;
 
   15             std::shared_ptr<Dot> Do, std::shared_ptr<AttrPath> Path,
 
   16             std::shared_ptr<Expr> Default)
 
   17      : 
Expr(NK_ExprSelect, Range), E(std::move(E)), Do(std::move(Do)),
 
   18        Path(std::move(Path)), Default(std::move(Default)) {
 
   19    assert(this->E && 
"E must not be null");
 
 
   23    assert(E && 
"E must not be null");
 
 
   27  [[nodiscard]] 
Dot *
dot()
 const { 
return Do.get(); }
 
   34    return {E.get(), Path.get(), Default.get()};
 
 
 
   40  const std::shared_ptr<Expr> Fn;
 
   41  const std::vector<std::shared_ptr<Expr>> Args;
 
   45           std::vector<std::shared_ptr<Expr>> Args)
 
   46      : 
Expr(NK_ExprCall, Range), Fn(std::move(Fn)), Args(std::move(Args)) {
 
   47    assert(this->Fn && 
"Fn must not be null");
 
 
   51    assert(Fn && 
"Fn must not be null");
 
 
   55  [[nodiscard]] 
const std::vector<std::shared_ptr<Expr>> &
args()
 const {
 
 
   61    Children.reserve(Args.size() + 1);
 
   62    Children.emplace_back(Fn.get());
 
   63    for (
const auto &Member : Args) {
 
   64      Children.emplace_back(Member.get());
 
 
 
   71  const std::vector<std::shared_ptr<Expr>> Elements;
 
   75      : 
Expr(NK_ExprList, Range), Elements(std::move(Elements)) {}
 
 
   77  [[nodiscard]] 
const std::vector<std::shared_ptr<Expr>> &
elements()
 const {
 
 
   83    Children.reserve(Elements.size());
 
   84    for (
const auto &Element : Elements) {
 
   85      Children.emplace_back(Element.get());
 
 
 
   92  const std::shared_ptr<Expr> Cond;
 
   93  const std::shared_ptr<Expr> Then;
 
   94  const std::shared_ptr<Expr> Else;
 
   98         std::shared_ptr<Expr> Then, std::shared_ptr<Expr> Else)
 
   99      : 
Expr(NK_ExprIf, Range), Cond(std::move(Cond)), Then(std::move(Then)),
 
  100        Else(std::move(Else)) {}
 
 
  102  [[nodiscard]] 
Expr *
cond()
 const { 
return Cond.get(); }
 
  103  [[nodiscard]] 
Expr *
then()
 const { 
return Then.get(); }
 
  107    return {Cond.get(), Then.get(), Else.get()};
 
 
 
  112  const std::shared_ptr<Expr> Cond;
 
  113  const std::shared_ptr<Expr>
 
  118             std::shared_ptr<Expr> Value)
 
  119      : 
Expr(NK_ExprAssert, Range), Cond(std::move(Cond)),
 
  120        Value(std::move(Value)) {}
 
 
  122  [[nodiscard]] 
Expr *
cond()
 const { 
return Cond.get(); }
 
  123  [[nodiscard]] 
Expr *
value()
 const { 
return Value.get(); }
 
  126    return {Cond.get(), Value.get()};
 
 
 
  133  const std::shared_ptr<Misc> KwLet; 
 
  134  const std::shared_ptr<Misc> KwIn;
 
  135  const std::shared_ptr<Expr> E;
 
  137  const std::shared_ptr<ExprAttrs> Attrs;
 
  141          std::shared_ptr<Misc> KwIn, std::shared_ptr<Expr> E,
 
  142          std::shared_ptr<ExprAttrs> Attrs)
 
  143      : 
Expr(NK_ExprLet, Range), KwLet(std::move(KwLet)), KwIn(std::move(KwIn)),
 
  144        E(std::move(E)), Attrs(std::move(Attrs)) {
 
  145    assert(this->KwLet && 
"KwLet should not be empty!");
 
 
  149    return Attrs ? Attrs->binds() : 
nullptr;
 
 
  152  [[nodiscard]] 
const Expr *
expr()
 const { 
return E.get(); }
 
  153  [[nodiscard]] 
const Misc &
let()
 const { 
return *KwLet; }
 
  154  [[nodiscard]] 
const Misc *
in()
 const { 
return KwIn.get(); }
 
  157    return {KwLet.get(), Attrs.get(), KwIn.get(), E.get()};
 
 
 
  162  const std::shared_ptr<Misc> KwWith;
 
  163  const std::shared_ptr<Misc> TokSemi;
 
  164  const std::shared_ptr<Expr> With;
 
  165  const std::shared_ptr<Expr> E;
 
  169           std::shared_ptr<Misc> TokSemi, std::shared_ptr<Expr> With,
 
  170           std::shared_ptr<Expr> E)
 
  171      : 
Expr(NK_ExprWith, Range), KwWith(std::move(KwWith)),
 
  172        TokSemi(std::move(TokSemi)), With(std::move(With)), E(std::move(E)) {}
 
 
  175  [[nodiscard]] 
const Misc *
tokSemi()
 const { 
return TokSemi.get(); }
 
  176  [[nodiscard]] 
Expr *
with()
 const { 
return With.get(); }
 
  177  [[nodiscard]] 
Expr *
expr()
 const { 
return E.get(); }
 
  180    return {KwWith.get(), TokSemi.get(), With.get(), E.get()};
 
 
 
Holds a "." in the language.
ExprAssert(LexerCursorRange Range, std::shared_ptr< Expr > Cond, std::shared_ptr< Expr > Value)
ChildVector children() const override
ExprCall(LexerCursorRange Range, std::shared_ptr< Expr > Fn, std::vector< std::shared_ptr< Expr > > Args)
ChildVector children() const override
const std::vector< std::shared_ptr< Expr > > & args() const
ExprIf(LexerCursorRange Range, std::shared_ptr< Expr > Cond, std::shared_ptr< Expr > Then, std::shared_ptr< Expr > Else)
ChildVector children() const override
ExprLet(LexerCursorRange Range, std::shared_ptr< Misc > KwLet, std::shared_ptr< Misc > KwIn, std::shared_ptr< Expr > E, std::shared_ptr< ExprAttrs > Attrs)
const Binds * binds() const
const ExprAttrs * attrs() const
const Expr * expr() const
ChildVector children() const override
const std::vector< std::shared_ptr< Expr > > & elements() const
ChildVector children() const override
ExprList(LexerCursorRange Range, std::vector< std::shared_ptr< Expr > > Elements)
ChildVector children() const override
ExprSelect(LexerCursorRange Range, std::shared_ptr< Expr > E, std::shared_ptr< Dot > Do, std::shared_ptr< AttrPath > Path, std::shared_ptr< Expr > Default)
Expr * defaultExpr() const
const Misc & kwWith() const
const Misc * tokSemi() const
ExprWith(LexerCursorRange Range, std::shared_ptr< Misc > KwWith, std::shared_ptr< Misc > TokSemi, std::shared_ptr< Expr > With, std::shared_ptr< Expr > E)
ChildVector children() const override
Expr(NodeKind Kind, LexerCursorRange Range)
Misc node, used for parentheses, keywords, etc.
boost::container::small_vector< Node *, 8 > ChildVector