1  // Copyright (C) 2020-2023 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_AST_LOWER_EXPR
      20  #define RUST_AST_LOWER_EXPR
      21  
      22  #include "rust-ast-lower-base.h"
      23  
      24  namespace Rust {
      25  namespace HIR {
      26  
      27  class ASTLowerPathInExpression : public ASTLoweringBase
      28  {
      29    using Rust::HIR::ASTLoweringBase::visit;
      30  
      31  public:
      32    static HIR::PathInExpression *translate (AST::PathInExpression *expr)
      33    {
      34      ASTLowerPathInExpression compiler;
      35      expr->accept_vis (compiler);
      36      rust_assert (compiler.translated);
      37      return compiler.translated;
      38    }
      39  
      40    void visit (AST::PathInExpression &expr) override;
      41  
      42  private:
      43    ASTLowerPathInExpression () : translated (nullptr) {}
      44  
      45    HIR::PathInExpression *translated;
      46  };
      47  
      48  class ASTLowerQualPathInExpression : public ASTLoweringBase
      49  {
      50    using Rust::HIR::ASTLoweringBase::visit;
      51  
      52  public:
      53    static HIR::QualifiedPathInExpression *
      54    translate (AST::QualifiedPathInExpression *expr)
      55    {
      56      ASTLowerQualPathInExpression compiler;
      57      expr->accept_vis (compiler);
      58      rust_assert (compiler.translated);
      59      return compiler.translated;
      60    }
      61  
      62    void visit (AST::QualifiedPathInExpression &expr) override;
      63  
      64  private:
      65    ASTLowerQualPathInExpression () : translated (nullptr) {}
      66  
      67    HIR::QualifiedPathInExpression *translated;
      68  };
      69  
      70  class ASTLoweringExpr : public ASTLoweringBase
      71  {
      72    using Rust::HIR::ASTLoweringBase::visit;
      73  
      74  public:
      75    static HIR::Expr *translate (AST::Expr *expr, bool *terminated = nullptr);
      76  
      77    void visit (AST::TupleIndexExpr &expr) override;
      78    void visit (AST::TupleExpr &expr) override;
      79    void visit (AST::IfExpr &expr) override;
      80    void visit (AST::IfExprConseqElse &expr) override;
      81    void visit (AST::IfExprConseqIf &expr) override;
      82    void visit (AST::BlockExpr &expr) override;
      83    void visit (AST::UnsafeBlockExpr &expr) override;
      84    void visit (AST::PathInExpression &expr) override;
      85    void visit (AST::QualifiedPathInExpression &expr) override;
      86    void visit (AST::ReturnExpr &expr) override;
      87    void visit (AST::CallExpr &expr) override;
      88    void visit (AST::MethodCallExpr &expr) override;
      89    void visit (AST::AssignmentExpr &expr) override;
      90    void visit (AST::IdentifierExpr &expr) override;
      91    void visit (AST::ArrayExpr &expr) override;
      92    void visit (AST::ArrayIndexExpr &expr) override;
      93    void visit (AST::ArrayElemsValues &elems) override;
      94    void visit (AST::ArrayElemsCopied &elems) override;
      95    void visit (AST::LiteralExpr &expr) override;
      96    void visit (AST::ArithmeticOrLogicalExpr &expr) override;
      97    void visit (AST::ComparisonExpr &expr) override;
      98    void visit (AST::LazyBooleanExpr &expr) override;
      99    void visit (AST::NegationExpr &expr) override;
     100    void visit (AST::TypeCastExpr &expr) override;
     101    void visit (AST::CompoundAssignmentExpr &expr) override;
     102    void visit (AST::StructExprStruct &struct_expr) override;
     103    void visit (AST::StructExprStructFields &struct_expr) override;
     104    void visit (AST::GroupedExpr &expr) override;
     105    void visit (AST::FieldAccessExpr &expr) override;
     106    void visit (AST::LoopExpr &expr) override;
     107    void visit (AST::WhileLoopExpr &expr) override;
     108    void visit (AST::ForLoopExpr &expr) override;
     109    void visit (AST::BreakExpr &expr) override;
     110    void visit (AST::ContinueExpr &expr) override;
     111    void visit (AST::BorrowExpr &expr) override;
     112    void visit (AST::DereferenceExpr &expr) override;
     113    void visit (AST::MatchExpr &expr) override;
     114    void visit (AST::RangeFromToExpr &expr) override;
     115    void visit (AST::RangeFromExpr &expr) override;
     116    void visit (AST::RangeToExpr &expr) override;
     117    void visit (AST::RangeFullExpr &expr) override;
     118    void visit (AST::RangeFromToInclExpr &expr) override;
     119    void visit (AST::ClosureExprInner &expr) override;
     120    void visit (AST::ClosureExprInnerTyped &expr) override;
     121  
     122  private:
     123    ASTLoweringExpr ();
     124  
     125    HIR::Expr *translated;
     126    HIR::ArrayElems *translated_array_elems;
     127    bool terminated;
     128  };
     129  
     130  } // namespace HIR
     131  } // namespace Rust
     132  
     133  #endif // RUST_AST_LOWER_EXPR