LCOV - code coverage report
Current view: top level - gcc/rust/hir - rust-ast-lower-block.h (source / functions) Coverage Total Hit
Test: gcc.info Lines: 93.3 % 89 83
Test Date: 2026-11-14 16:39:50 Functions: 88.9 % 18 16
Legend: Lines:     hit not hit

            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_AST_LOWER_BLOCK
      20              : #define RUST_AST_LOWER_BLOCK
      21              : 
      22              : #include "rust-diagnostics.h"
      23              : #include "rust-ast-lower-base.h"
      24              : 
      25              : namespace Rust {
      26              : namespace HIR {
      27              : 
      28       178000 : class ASTLoweringBlock : public ASTLoweringBase
      29              : {
      30              :   using Rust::HIR::ASTLoweringBase::visit;
      31              : 
      32              : public:
      33       165028 :   static HIR::BlockExpr *translate (AST::BlockExpr &expr, bool *terminated)
      34              :   {
      35       330056 :     ASTLoweringBlock resolver;
      36       165028 :     expr.normalize_tail_expr ();
      37       165028 :     expr.accept_vis (resolver);
      38       165028 :     if (resolver.translated != nullptr)
      39              :       {
      40       165028 :         resolver.mappings.hir.exprs.insert (resolver.translated);
      41              :       }
      42              : 
      43       165028 :     *terminated = resolver.terminated;
      44       165028 :     return resolver.translated;
      45       165028 :   }
      46              : 
      47        12972 :   static HIR::UnsafeBlockExpr *translate (AST::UnsafeBlockExpr &expr,
      48              :                                           bool *terminated)
      49              :   {
      50        25944 :     ASTLoweringBlock resolver;
      51              : 
      52        12972 :     HIR::BlockExpr *block
      53        12972 :       = ASTLoweringBlock::translate (expr.get_block_expr (), terminated);
      54        12972 :     auto crate_num = resolver.mappings.crate.get_current_crate ();
      55        25944 :     Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
      56              :                                    resolver.mappings.get_next_hir_id (
      57              :                                      crate_num),
      58        12972 :                                    UNKNOWN_LOCAL_DEFID);
      59              : 
      60        12972 :     HIR::UnsafeBlockExpr *translated
      61              :       = new HIR::UnsafeBlockExpr (mapping,
      62        12972 :                                   std::unique_ptr<HIR::BlockExpr> (block),
      63        12972 :                                   expr.get_outer_attrs (), expr.get_locus ());
      64              : 
      65        12972 :     resolver.mappings.hir.exprs.insert (translated);
      66              : 
      67        12972 :     return translated;
      68        12972 :   }
      69              : 
      70              :   void visit (AST::BlockExpr &expr) override;
      71              : 
      72              : private:
      73       178000 :   ASTLoweringBlock ()
      74       178000 :     : ASTLoweringBase (), translated (nullptr), terminated (false)
      75              :   {}
      76              : 
      77              :   HIR::BlockExpr *translated;
      78              :   bool terminated;
      79              : };
      80              : 
      81              : class ASTLoweringIfBlock : public ASTLoweringBase
      82              : {
      83              :   using Rust::HIR::ASTLoweringBase::visit;
      84              : 
      85              : public:
      86        17452 :   static HIR::IfExpr *translate (AST::IfExpr &expr, bool *terminated)
      87              :   {
      88        34904 :     ASTLoweringIfBlock resolver;
      89        17452 :     expr.accept_vis (resolver);
      90        17452 :     if (resolver.translated != nullptr)
      91              :       {
      92        17452 :         resolver.mappings.hir.exprs.insert (resolver.translated);
      93              :       }
      94        17452 :     *terminated = resolver.terminated;
      95        17452 :     return resolver.translated;
      96        17452 :   }
      97              : 
      98        17452 :   ~ASTLoweringIfBlock () {}
      99              : 
     100              :   void visit (AST::IfExpr &expr) override;
     101              : 
     102              :   void visit (AST::IfExprConseqElse &expr) override;
     103              : 
     104              : private:
     105        17452 :   ASTLoweringIfBlock ()
     106        17452 :     : ASTLoweringBase (), translated (nullptr), terminated (false)
     107              :   {}
     108              : 
     109              :   HIR::IfExpr *translated;
     110              :   bool terminated;
     111              : };
     112              : 
     113              : class ASTLoweringIfLetBlock : public ASTLoweringBase
     114              : {
     115              :   using Rust::HIR::ASTLoweringBase::visit;
     116              : 
     117              : public:
     118          799 :   static HIR::MatchExpr *translate (AST::IfLetExpr &expr)
     119              :   {
     120         1598 :     ASTLoweringIfLetBlock resolver;
     121          799 :     expr.accept_vis (resolver);
     122          799 :     if (resolver.translated != nullptr)
     123              :       {
     124          799 :         resolver.mappings.hir.exprs.insert (resolver.translated);
     125              :       }
     126          799 :     return resolver.translated;
     127          799 :   }
     128              : 
     129          799 :   ~ASTLoweringIfLetBlock () {}
     130              : 
     131              :   void visit (AST::IfLetExpr &expr) override;
     132              : 
     133              :   void visit (AST::IfLetExprConseqElse &expr) override;
     134              : 
     135              : private:
     136          799 :   ASTLoweringIfLetBlock () : ASTLoweringBase (), translated (nullptr) {}
     137              : 
     138              :   void desugar_iflet (AST::IfLetExpr &, HIR::Expr **, HIR::Expr *,
     139              :                       std::vector<HIR::MatchCase> &);
     140              : 
     141              :   HIR::MatchExpr *translated;
     142              : };
     143              : 
     144              : class ASTLoweringExprWithBlock : public ASTLoweringBase
     145              : {
     146              :   using Rust::HIR::ASTLoweringBase::visit;
     147              : 
     148              : public:
     149        55352 :   static HIR::ExprWithBlock *translate (AST::ExprWithBlock &expr,
     150              :                                         bool *terminated)
     151              :   {
     152       110704 :     ASTLoweringExprWithBlock resolver;
     153        55352 :     expr.accept_vis (resolver);
     154        55352 :     if (resolver.translated != nullptr)
     155        55352 :       resolver.mappings.hir.exprs.insert (resolver.translated);
     156              : 
     157        55352 :     *terminated = resolver.terminated;
     158        55352 :     return resolver.translated;
     159        55352 :   }
     160              : 
     161        55352 :   ~ASTLoweringExprWithBlock () {}
     162              : 
     163           76 :   void visit (AST::IfExpr &expr) override
     164              :   {
     165           76 :     translated = ASTLoweringIfBlock::translate (expr, &terminated);
     166           76 :   }
     167              : 
     168          865 :   void visit (AST::IfExprConseqElse &expr) override
     169              :   {
     170          865 :     translated = ASTLoweringIfBlock::translate (expr, &terminated);
     171          865 :   }
     172              : 
     173            0 :   void visit (AST::IfLetExpr &expr) override
     174              :   {
     175            0 :     translated = ASTLoweringIfLetBlock::translate (expr);
     176            0 :   }
     177              : 
     178            1 :   void visit (AST::IfLetExprConseqElse &expr) override
     179              :   {
     180            1 :     translated = ASTLoweringIfLetBlock::translate (expr);
     181            1 :   }
     182              : 
     183         9338 :   void visit (AST::BlockExpr &expr) override
     184              :   {
     185         9338 :     translated = ASTLoweringBlock::translate (expr, &terminated);
     186         9338 :   }
     187              : 
     188            0 :   void visit (AST::UnsafeBlockExpr &expr) override
     189              :   {
     190            0 :     translated = ASTLoweringBlock::translate (expr, &terminated);
     191            0 :   }
     192              : 
     193         1721 :   void visit (AST::LoopExpr &expr) override
     194              :   {
     195         1721 :     HIR::BlockExpr *loop_block
     196         1721 :       = ASTLoweringBlock::translate (expr.get_loop_block (), &terminated);
     197              : 
     198         1721 :     tl::optional<HIR::LoopLabel> loop_label = tl::nullopt;
     199         1721 :     if (expr.has_loop_label ())
     200           60 :       loop_label = lower_loop_label (expr.get_loop_label ());
     201              : 
     202         1721 :     auto crate_num = mappings.crate.get_current_crate ();
     203         3442 :     Analysis::NodeMapping mapping (crate_num, expr.get_node_id (),
     204         1721 :                                    mappings.get_next_hir_id (crate_num),
     205         1721 :                                    UNKNOWN_LOCAL_DEFID);
     206              : 
     207         1721 :     translated
     208         1721 :       = new HIR::LoopExpr (mapping,
     209         1721 :                            std::unique_ptr<HIR::BlockExpr> (loop_block),
     210              :                            expr.get_locus (), std::move (loop_label),
     211         3442 :                            expr.get_outer_attrs ());
     212         1721 :   }
     213              : 
     214              :   void visit (AST::WhileLoopExpr &expr) override;
     215              : 
     216              :   void visit (AST::MatchExpr &expr) override;
     217              : 
     218              : private:
     219        55352 :   ASTLoweringExprWithBlock ()
     220        55352 :     : ASTLoweringBase (), translated (nullptr), terminated (false)
     221              :   {}
     222              : 
     223              :   HIR::ExprWithBlock *translated;
     224              :   bool terminated;
     225              : };
     226              : 
     227              : } // namespace HIR
     228              : } // namespace Rust
     229              : 
     230              : #endif // RUST_AST_LOWER_BLOCK
        

Generated by: LCOV version 2.5.0-beta

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.