gcc/rust/backend/rust-compile-block.h

   1 // Copyright (C) 2020-2024 Free Software Foundation, Inc.
   2
   3 // This file is part of GCC.
   4
   5 // GCC is free software; you can redistribute it and/or modify it under
   6 // the terms of the GNU General Public License as published by the Free
   7 // Software Foundation; either version 3, or (at your option) any later
   8 // version.
   9
  10 // GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  11 // WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12 // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13 // for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with GCC; see the file COPYING3.  If not see
  17 // <http://www.gnu.org/licenses/>.
  18
  19 #ifndef RUST_COMPILE_BLOCK
  20 #define RUST_COMPILE_BLOCK
  21
  22 #include "rust-compile-base.h"
  23 #include "rust-hir-visitor.h"
  24
  25 namespace Rust {
  26 namespace Compile {
  27
  28 class CompileBlock : private HIRCompileBase
  29 {
  30 public:
  31   static tree compile (HIR::BlockExpr *expr, Context *ctx, Bvariable *result);
  32
  33 protected:
  34   void visit (HIR::BlockExpr &expr);
  35
  36 private:
  37   CompileBlock (Context *ctx, Bvariable *result);
  38
  39   tree translated;
  40   Bvariable *result;
  41 };
  42
  43 class CompileConditionalBlocks : public HIRCompileBase,
  44                                  public HIR::HIRExpressionVisitor
  45 {
  46 public:
  47   static tree compile (HIR::IfExpr *expr, Context *ctx, Bvariable *result)
  48   {
  49     CompileConditionalBlocks resolver (ctx, result);
  50     expr->accept_vis (resolver);
  51     return resolver.translated;
  52   }
  53
  54   void visit (HIR::IfExpr &expr) override;
  55   void visit (HIR::IfExprConseqElse &expr) override;
  56
  57   // Empty visit for unused Expression HIR nodes.
  58   void visit (HIR::PathInExpression &) override {}
  59   void visit (HIR::QualifiedPathInExpression &) override {}
  60   void visit (HIR::ClosureExpr &) override {}
  61   void visit (HIR::StructExprFieldIdentifier &) override {}
  62   void visit (HIR::StructExprFieldIdentifierValue &) override {}
  63   void visit (HIR::StructExprFieldIndexValue &) override {}
  64   void visit (HIR::StructExprStruct &) override {}
  65   void visit (HIR::StructExprStructFields &) override {}
  66   void visit (HIR::LiteralExpr &) override {}
  67   void visit (HIR::BorrowExpr &) override {}
  68   void visit (HIR::DereferenceExpr &) override {}
  69   void visit (HIR::ErrorPropagationExpr &) override {}
  70   void visit (HIR::NegationExpr &) override {}
  71   void visit (HIR::ArithmeticOrLogicalExpr &) override {}
  72   void visit (HIR::ComparisonExpr &) override {}
  73   void visit (HIR::LazyBooleanExpr &) override {}
  74   void visit (HIR::TypeCastExpr &) override {}
  75   void visit (HIR::AssignmentExpr &) override {}
  76   void visit (HIR::CompoundAssignmentExpr &) override {}
  77   void visit (HIR::GroupedExpr &) override {}
  78   void visit (HIR::ArrayExpr &) override {}
  79   void visit (HIR::ArrayIndexExpr &) override {}
  80   void visit (HIR::TupleExpr &) override {}
  81   void visit (HIR::TupleIndexExpr &) override {}
  82   void visit (HIR::CallExpr &) override {}
  83   void visit (HIR::MethodCallExpr &) override {}
  84   void visit (HIR::FieldAccessExpr &) override {}
  85   void visit (HIR::BlockExpr &) override {}
  86   void visit (HIR::ContinueExpr &) override {}
  87   void visit (HIR::BreakExpr &) override {}
  88   void visit (HIR::RangeFromToExpr &) override {}
  89   void visit (HIR::RangeFromExpr &) override {}
  90   void visit (HIR::RangeToExpr &) override {}
  91   void visit (HIR::RangeFullExpr &) override {}
  92   void visit (HIR::RangeFromToInclExpr &) override {}
  93   void visit (HIR::RangeToInclExpr &) override {}
  94   void visit (HIR::ReturnExpr &) override {}
  95   void visit (HIR::UnsafeBlockExpr &) override {}
  96   void visit (HIR::LoopExpr &) override {}
  97   void visit (HIR::WhileLoopExpr &) override {}
  98   void visit (HIR::WhileLetLoopExpr &) override {}
  99   void visit (HIR::IfLetExpr &) override {}
 100   void visit (HIR::IfLetExprConseqElse &) override {}
 101   void visit (HIR::MatchExpr &) override {}
 102   void visit (HIR::AwaitExpr &) override {}
 103   void visit (HIR::AsyncBlockExpr &) override {}
 104
 105 private:
 106   CompileConditionalBlocks (Context *ctx, Bvariable *result)
 107     : HIRCompileBase (ctx), translated (nullptr), result (result)
 108   {}
 109
 110   tree translated;
 111   Bvariable *result;
 112 };
 113
 114 class CompileExprWithBlock : public HIRCompileBase,
 115                              public HIR::HIRExpressionVisitor
 116 {
 117 public:
 118   static tree compile (HIR::ExprWithBlock *expr, Context *ctx,
 119                        Bvariable *result)
 120   {
 121     CompileExprWithBlock resolver (ctx, result);
 122     expr->accept_vis (resolver);
 123     return resolver.translated;
 124   }
 125
 126   void visit (HIR::IfExpr &expr) override
 127   {
 128     translated = CompileConditionalBlocks::compile (&expr, ctx, result);
 129   }
 130
 131   void visit (HIR::IfExprConseqElse &expr) override
 132   {
 133     translated = CompileConditionalBlocks::compile (&expr, ctx, result);
 134   }
 135
 136   void visit (HIR::BlockExpr &expr) override
 137   {
 138     translated = CompileBlock::compile (&expr, ctx, result);
 139   }
 140
 141   // Empty visit for unused Expression HIR nodes.
 142   void visit (HIR::PathInExpression &) override {}
 143   void visit (HIR::QualifiedPathInExpression &) override {}
 144   void visit (HIR::ClosureExpr &) override {}
 145   void visit (HIR::StructExprFieldIdentifier &) override {}
 146   void visit (HIR::StructExprFieldIdentifierValue &) override {}
 147   void visit (HIR::StructExprFieldIndexValue &) override {}
 148   void visit (HIR::StructExprStruct &) override {}
 149   void visit (HIR::StructExprStructFields &) override {}
 150   void visit (HIR::LiteralExpr &) override {}
 151   void visit (HIR::BorrowExpr &) override {}
 152   void visit (HIR::DereferenceExpr &) override {}
 153   void visit (HIR::ErrorPropagationExpr &) override {}
 154   void visit (HIR::NegationExpr &) override {}
 155   void visit (HIR::ArithmeticOrLogicalExpr &) override {}
 156   void visit (HIR::ComparisonExpr &) override {}
 157   void visit (HIR::LazyBooleanExpr &) override {}
 158   void visit (HIR::TypeCastExpr &) override {}
 159   void visit (HIR::AssignmentExpr &) override {}
 160   void visit (HIR::CompoundAssignmentExpr &) override {}
 161   void visit (HIR::GroupedExpr &) override {}
 162   void visit (HIR::ArrayExpr &) override {}
 163   void visit (HIR::ArrayIndexExpr &) override {}
 164   void visit (HIR::TupleExpr &) override {}
 165   void visit (HIR::TupleIndexExpr &) override {}
 166   void visit (HIR::CallExpr &) override {}
 167   void visit (HIR::MethodCallExpr &) override {}
 168   void visit (HIR::FieldAccessExpr &) override {}
 169   void visit (HIR::ContinueExpr &) override {}
 170   void visit (HIR::BreakExpr &) override {}
 171   void visit (HIR::RangeFromToExpr &) override {}
 172   void visit (HIR::RangeFromExpr &) override {}
 173   void visit (HIR::RangeToExpr &) override {}
 174   void visit (HIR::RangeFullExpr &) override {}
 175   void visit (HIR::RangeFromToInclExpr &) override {}
 176   void visit (HIR::RangeToInclExpr &) override {}
 177   void visit (HIR::ReturnExpr &) override {}
 178   void visit (HIR::UnsafeBlockExpr &) override {}
 179   void visit (HIR::LoopExpr &) override {}
 180   void visit (HIR::WhileLoopExpr &) override {}
 181   void visit (HIR::WhileLetLoopExpr &) override {}
 182   void visit (HIR::IfLetExpr &) override {}
 183   void visit (HIR::IfLetExprConseqElse &) override {}
 184   void visit (HIR::MatchExpr &) override {}
 185   void visit (HIR::AwaitExpr &) override {}
 186   void visit (HIR::AsyncBlockExpr &) override {}
 187
 188 private:
 189   CompileExprWithBlock (Context *ctx, Bvariable *result)
 190     : HIRCompileBase (ctx), translated (nullptr), result (result)
 191   {}
 192
 193   tree translated;
 194   Bvariable *result;
 195 };
 196
 197 } // namespace Compile
 198 } // namespace Rust
 199
 200 #endif // RUST_COMPILE_BLOCK