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
|