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_COMPILE_BLOCK
      20              : #define RUST_COMPILE_BLOCK
      21              : 
      22              : #include "rust-compile-base.h"
      23              : #include "rust-hir-expr.h"
      24              : #include "rust-hir-visitor.h"
      25              : 
      26              : namespace Rust {
      27              : namespace Compile {
      28              : 
      29         7189 : class CompileBlock : private HIRCompileBase
      30              : {
      31              : public:
      32              :   static tree compile (HIR::BlockExpr &expr, Context *ctx, Bvariable *result);
      33              : 
      34              : protected:
      35              :   void visit (HIR::BlockExpr &expr);
      36              : 
      37              : private:
      38              :   CompileBlock (Context *ctx, Bvariable *result);
      39              : 
      40              :   tree translated;
      41              :   Bvariable *result;
      42              : };
      43              : 
      44         1530 : class CompileConditionalBlocks : public HIRCompileBase,
      45              :                                  public HIR::HIRExpressionVisitor
      46              : {
      47              : public:
      48         1530 :   static tree compile (HIR::IfExpr *expr, Context *ctx, Bvariable *result)
      49              :   {
      50         1530 :     CompileConditionalBlocks resolver (ctx, result);
      51         1530 :     expr->accept_vis (resolver);
      52         1530 :     return resolver.translated;
      53         1530 :   }
      54              : 
      55              :   void visit (HIR::IfExpr &expr) override;
      56              :   void visit (HIR::IfExprConseqElse &expr) override;
      57              : 
      58              :   // Empty visit for unused Expression HIR nodes.
      59            0 :   void visit (HIR::PathInExpression &) override {}
      60            0 :   void visit (HIR::QualifiedPathInExpression &) override {}
      61            0 :   void visit (HIR::ClosureExpr &) override {}
      62            0 :   void visit (HIR::StructExprFieldIdentifier &) override {}
      63            0 :   void visit (HIR::StructExprFieldIdentifierValue &) override {}
      64            0 :   void visit (HIR::StructExprFieldIndexValue &) override {}
      65            0 :   void visit (HIR::StructExprStruct &) override {}
      66            0 :   void visit (HIR::StructExprStructFields &) override {}
      67            0 :   void visit (HIR::LiteralExpr &) override {}
      68            0 :   void visit (HIR::BorrowExpr &) override {}
      69            0 :   void visit (HIR::DereferenceExpr &) override {}
      70            0 :   void visit (HIR::ErrorPropagationExpr &) override {}
      71            0 :   void visit (HIR::NegationExpr &) override {}
      72            0 :   void visit (HIR::ArithmeticOrLogicalExpr &) override {}
      73            0 :   void visit (HIR::ComparisonExpr &) override {}
      74            0 :   void visit (HIR::LazyBooleanExpr &) override {}
      75            0 :   void visit (HIR::TypeCastExpr &) override {}
      76            0 :   void visit (HIR::AssignmentExpr &) override {}
      77            0 :   void visit (HIR::CompoundAssignmentExpr &) override {}
      78            0 :   void visit (HIR::GroupedExpr &) override {}
      79            0 :   void visit (HIR::ArrayExpr &) override {}
      80            0 :   void visit (HIR::ArrayIndexExpr &) override {}
      81            0 :   void visit (HIR::TupleExpr &) override {}
      82            0 :   void visit (HIR::TupleIndexExpr &) override {}
      83            0 :   void visit (HIR::CallExpr &) override {}
      84            0 :   void visit (HIR::MethodCallExpr &) override {}
      85            0 :   void visit (HIR::FieldAccessExpr &) override {}
      86            0 :   void visit (HIR::BlockExpr &) override {}
      87            0 :   void visit (HIR::AnonConst &) override {}
      88            0 :   void visit (HIR::ConstBlock &) override {}
      89            0 :   void visit (HIR::ContinueExpr &) override {}
      90            0 :   void visit (HIR::BreakExpr &) override {}
      91            0 :   void visit (HIR::RangeFromToExpr &) override {}
      92            0 :   void visit (HIR::RangeFromExpr &) override {}
      93            0 :   void visit (HIR::RangeToExpr &) override {}
      94            0 :   void visit (HIR::RangeFullExpr &) override {}
      95            0 :   void visit (HIR::RangeFromToInclExpr &) override {}
      96            0 :   void visit (HIR::RangeToInclExpr &) override {}
      97            0 :   void visit (HIR::ReturnExpr &) override {}
      98            0 :   void visit (HIR::UnsafeBlockExpr &) override {}
      99            0 :   void visit (HIR::LoopExpr &) override {}
     100            0 :   void visit (HIR::WhileLoopExpr &) override {}
     101            0 :   void visit (HIR::WhileLetLoopExpr &) override {}
     102            0 :   void visit (HIR::MatchExpr &) override {}
     103            0 :   void visit (HIR::AwaitExpr &) override {}
     104            0 :   void visit (HIR::AsyncBlockExpr &) override {}
     105            0 :   void visit (HIR::InlineAsm &) override {}
     106            0 :   void visit (HIR::LlvmInlineAsm &) override {}
     107            0 :   void visit (HIR::OffsetOf &) override {}
     108              : 
     109              : private:
     110         1530 :   CompileConditionalBlocks (Context *ctx, Bvariable *result)
     111         1530 :     : HIRCompileBase (ctx), translated (nullptr), result (result)
     112              :   {}
     113              : 
     114              :   tree translated;
     115              :   Bvariable *result;
     116              : };
     117              : 
     118         1063 : class CompileExprWithBlock : public HIRCompileBase,
     119              :                              public HIR::HIRExpressionVisitor
     120              : {
     121              : public:
     122         1063 :   static tree compile (HIR::ExprWithBlock *expr, Context *ctx,
     123              :                        Bvariable *result)
     124              :   {
     125         1063 :     CompileExprWithBlock resolver (ctx, result);
     126         1063 :     expr->accept_vis (resolver);
     127         1063 :     return resolver.translated;
     128         1063 :   }
     129              : 
     130            9 :   void visit (HIR::IfExpr &expr) override
     131              :   {
     132            9 :     translated = CompileConditionalBlocks::compile (&expr, ctx, result);
     133            9 :   }
     134              : 
     135          256 :   void visit (HIR::IfExprConseqElse &expr) override
     136              :   {
     137          256 :     translated = CompileConditionalBlocks::compile (&expr, ctx, result);
     138          256 :   }
     139              : 
     140          797 :   void visit (HIR::BlockExpr &expr) override
     141              :   {
     142          797 :     translated = CompileBlock::compile (expr, ctx, result);
     143          797 :   }
     144              : 
     145            0 :   void visit (HIR::ConstBlock &expr) override
     146              :   {
     147            0 :     rust_unreachable ();
     148              :     // translated = CompileExpr::compile (expr, ctx, result);
     149              :   }
     150              : 
     151              :   // Empty visit for unused Expression HIR nodes.
     152            0 :   void visit (HIR::PathInExpression &) override {}
     153            0 :   void visit (HIR::QualifiedPathInExpression &) override {}
     154            0 :   void visit (HIR::ClosureExpr &) override {}
     155            0 :   void visit (HIR::StructExprFieldIdentifier &) override {}
     156            0 :   void visit (HIR::StructExprFieldIdentifierValue &) override {}
     157            0 :   void visit (HIR::StructExprFieldIndexValue &) override {}
     158            0 :   void visit (HIR::StructExprStruct &) override {}
     159            0 :   void visit (HIR::StructExprStructFields &) override {}
     160            0 :   void visit (HIR::LiteralExpr &) override {}
     161            0 :   void visit (HIR::BorrowExpr &) override {}
     162            0 :   void visit (HIR::DereferenceExpr &) override {}
     163            0 :   void visit (HIR::ErrorPropagationExpr &) override {}
     164            0 :   void visit (HIR::NegationExpr &) override {}
     165            0 :   void visit (HIR::ArithmeticOrLogicalExpr &) override {}
     166            0 :   void visit (HIR::ComparisonExpr &) override {}
     167            0 :   void visit (HIR::LazyBooleanExpr &) override {}
     168            0 :   void visit (HIR::TypeCastExpr &) override {}
     169            0 :   void visit (HIR::AssignmentExpr &) override {}
     170            0 :   void visit (HIR::CompoundAssignmentExpr &) override {}
     171            0 :   void visit (HIR::GroupedExpr &) override {}
     172            0 :   void visit (HIR::ArrayExpr &) override {}
     173            0 :   void visit (HIR::ArrayIndexExpr &) override {}
     174            0 :   void visit (HIR::TupleExpr &) override {}
     175            0 :   void visit (HIR::TupleIndexExpr &) override {}
     176            0 :   void visit (HIR::CallExpr &) override {}
     177            0 :   void visit (HIR::MethodCallExpr &) override {}
     178            0 :   void visit (HIR::FieldAccessExpr &) override {}
     179            0 :   void visit (HIR::ContinueExpr &) override {}
     180            0 :   void visit (HIR::BreakExpr &) override {}
     181            0 :   void visit (HIR::RangeFromToExpr &) override {}
     182            0 :   void visit (HIR::RangeFromExpr &) override {}
     183            0 :   void visit (HIR::RangeToExpr &) override {}
     184            0 :   void visit (HIR::RangeFullExpr &) override {}
     185            0 :   void visit (HIR::RangeFromToInclExpr &) override {}
     186            0 :   void visit (HIR::RangeToInclExpr &) override {}
     187            0 :   void visit (HIR::ReturnExpr &) override {}
     188            0 :   void visit (HIR::UnsafeBlockExpr &) override {}
     189            0 :   void visit (HIR::LoopExpr &) override {}
     190            0 :   void visit (HIR::WhileLoopExpr &) override {}
     191            0 :   void visit (HIR::WhileLetLoopExpr &) override {}
     192            1 :   void visit (HIR::MatchExpr &) override {}
     193            0 :   void visit (HIR::AwaitExpr &) override {}
     194            0 :   void visit (HIR::AsyncBlockExpr &) override {}
     195            0 :   void visit (HIR::InlineAsm &) override {}
     196            0 :   void visit (HIR::LlvmInlineAsm &) override {}
     197            0 :   void visit (HIR::OffsetOf &) override {}
     198            0 :   void visit (HIR::AnonConst &) override {}
     199              : 
     200              : private:
     201         1063 :   CompileExprWithBlock (Context *ctx, Bvariable *result)
     202         1063 :     : HIRCompileBase (ctx), translated (nullptr), result (result)
     203              :   {}
     204              : 
     205              :   tree translated;
     206              :   Bvariable *result;
     207              : };
     208              : 
     209              : } // namespace Compile
     210              : } // namespace Rust
     211              : 
     212              : #endif // RUST_COMPILE_BLOCK