Line data    Source code

       1              : // Copyright (C) 2020-2026 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_BIR_BUILDER_EXPR_H
      20              : #define RUST_BIR_BUILDER_EXPR_H
      21              : 
      22              : #include "rust-hir-expr.h"
      23              : #include "rust-hir-visitor.h"
      24              : #include "rust-bir-builder-internal.h"
      25              : 
      26              : namespace Rust {
      27              : namespace BIR {
      28              : 
      29              : /**
      30              :  * Compiles expressions into a BIR place.
      31              :  * See AbstractExprBuilder for API usage docs (mainly `return_place` and
      32              :  * `return_expr`).
      33              :  */
      34              : class ExprStmtBuilder final : public AbstractExprBuilder,
      35              :                               public HIR::HIRStmtVisitor
      36              : {
      37              : public:
      38           40 :   explicit ExprStmtBuilder (BuilderContext &ctx) : AbstractExprBuilder (ctx) {}
      39              : 
      40              :   /** Entry point. */
      41           40 :   PlaceId build (HIR::Expr &expr, PlaceId destination = INVALID_PLACE)
      42              :   {
      43           40 :     return visit_expr (expr, destination);
      44              :   }
      45              : 
      46              : private:
      47              :   template <typename T>
      48           11 :   std::vector<PlaceId> visit_list (std::vector<std::unique_ptr<T>> &list)
      49              :   {
      50           11 :     std::vector<PlaceId> result;
      51           22 :     for (auto &elem : list)
      52              :       {
      53           11 :         result.push_back (visit_expr (*elem));
      54              :       }
      55           11 :     return result;
      56              :   }
      57              : 
      58              :   /** Common infrastructure for loops. */
      59              :   BuilderContext::LoopAndLabelCtx &setup_loop (HIR::BaseLoopExpr &expr);
      60              : 
      61              :   BuilderContext::LoopAndLabelCtx &get_label_ctx (HIR::Lifetime &label);
      62              :   BuilderContext::LoopAndLabelCtx &get_unnamed_loop_ctx ();
      63              : 
      64              : protected: // Expr
      65              :   void visit (HIR::ClosureExpr &expr) override;
      66              :   void visit (HIR::StructExprStructFields &fields) override;
      67              :   void visit (HIR::StructExprStruct &expr) override;
      68              :   void visit (HIR::LiteralExpr &expr) override;
      69              :   void visit (HIR::BorrowExpr &expr) override;
      70              :   void visit (HIR::DereferenceExpr &expr) override;
      71              :   void visit (HIR::ErrorPropagationExpr &expr) override;
      72              :   void visit (HIR::NegationExpr &expr) override;
      73              :   void visit (HIR::ArithmeticOrLogicalExpr &expr) override;
      74              :   void visit (HIR::ComparisonExpr &expr) override;
      75              :   void visit (HIR::LazyBooleanExpr &expr) override;
      76              :   void visit (HIR::TypeCastExpr &expr) override;
      77              :   void visit (HIR::AssignmentExpr &expr) override;
      78              :   void visit (HIR::CompoundAssignmentExpr &expr) override;
      79              :   void visit (HIR::GroupedExpr &expr) override;
      80              :   void visit (HIR::ArrayExpr &expr) override;
      81              :   void visit (HIR::ArrayIndexExpr &expr) override;
      82              :   void visit (HIR::TupleExpr &expr) override;
      83              :   void visit (HIR::TupleIndexExpr &expr) override;
      84              :   void visit (HIR::CallExpr &expr) override;
      85              :   void visit (HIR::MethodCallExpr &expr) override;
      86              :   void visit (HIR::FieldAccessExpr &expr) override;
      87              :   void visit (HIR::BlockExpr &block) override;
      88              :   void visit (HIR::AnonConst &block) override;
      89              :   void visit (HIR::ConstBlock &block) override;
      90              :   void visit (HIR::ContinueExpr &cont) override;
      91              :   void visit (HIR::BreakExpr &brk) override;
      92              :   void visit (HIR::RangeFromToExpr &range) override;
      93              :   void visit (HIR::RangeFromExpr &expr) override;
      94              :   void visit (HIR::RangeToExpr &expr) override;
      95              :   void visit (HIR::RangeFullExpr &expr) override;
      96              :   void visit (HIR::RangeFromToInclExpr &expr) override;
      97              :   void visit (HIR::RangeToInclExpr &expr) override;
      98              :   void visit (HIR::ReturnExpr &ret) override;
      99              :   void visit (HIR::UnsafeBlockExpr &expr) override;
     100              :   void visit (HIR::LoopExpr &expr) override;
     101              :   void visit (HIR::WhileLoopExpr &expr) override;
     102              :   void visit (HIR::WhileLetLoopExpr &expr) override;
     103              :   void visit (HIR::IfExpr &expr) override;
     104              :   void visit (HIR::IfExprConseqElse &expr) override;
     105              :   void visit (HIR::InlineAsm &expr) override;
     106              :   void visit (HIR::LlvmInlineAsm &expr) override;
     107              :   void visit (HIR::OffsetOf &expr) override;
     108              : 
     109              :   void visit (HIR::MatchExpr &expr) override;
     110              :   void visit (HIR::AwaitExpr &expr) override;
     111              :   void visit (HIR::AsyncBlockExpr &expr) override;
     112              : 
     113              : protected: // Nodes not containing executable code. Nothing to do.
     114              :   void visit (HIR::QualifiedPathInExpression &expr) override;
     115              :   void visit (HIR::PathInExpression &expr) override;
     116              : 
     117              : protected: // Handled by other visitors
     118            0 :   void visit (HIR::StructExprFieldIdentifier &field) override
     119              :   {
     120            0 :     rust_unreachable ();
     121              :   }
     122            0 :   void visit (HIR::StructExprFieldIdentifierValue &field) override
     123              :   {
     124            0 :     rust_unreachable ();
     125              :   }
     126            0 :   void visit (HIR::StructExprFieldIndexValue &field) override
     127              :   {
     128            0 :     rust_unreachable ();
     129              :   }
     130              : 
     131              : protected: // Stmt
     132              :   void visit (HIR::LetStmt &stmt) override;
     133              : 
     134              :   void visit (HIR::ExprStmt &stmt) override;
     135              : 
     136              : protected: // Ignored.
     137              :   // Only executable code of a single function/method is translated.
     138            0 :   void visit (HIR::EnumItemTuple &tuple) override {}
     139            0 :   void visit (HIR::EnumItemStruct &a_struct) override {}
     140            0 :   void visit (HIR::EnumItem &item) override {}
     141            0 :   void visit (HIR::TupleStruct &tuple_struct) override {}
     142            0 :   void visit (HIR::EnumItemDiscriminant &discriminant) override {}
     143            0 :   void visit (HIR::TypePathSegmentFunction &segment) override {}
     144            0 :   void visit (HIR::TypePath &path) override {}
     145            0 :   void visit (HIR::QualifiedPathInType &path) override {}
     146            0 :   void visit (HIR::Module &module) override {}
     147            0 :   void visit (HIR::ExternCrate &crate) override {}
     148            0 :   void visit (HIR::UseDeclaration &use_decl) override {}
     149            0 :   void visit (HIR::Function &function) override {}
     150            0 :   void visit (HIR::TypeAlias &type_alias) override {}
     151            6 :   void visit (HIR::StructStruct &struct_item) override {}
     152            0 :   void visit (HIR::Enum &enum_item) override {}
     153            0 :   void visit (HIR::Union &union_item) override {}
     154            0 :   void visit (HIR::ConstantItem &const_item) override {}
     155            0 :   void visit (HIR::StaticItem &static_item) override {}
     156            0 :   void visit (HIR::Trait &trait) override {}
     157            0 :   void visit (HIR::ImplBlock &impl) override {}
     158            0 :   void visit (HIR::ExternBlock &block) override {}
     159            0 :   void visit (HIR::EmptyStmt &stmt) override {}
     160              : };
     161              : 
     162              : } // namespace BIR
     163              : } // namespace Rust
     164              : 
     165              : #endif // RUST_BIR_BUILDER_EXPR_H