]>
Commit | Line | Data |
---|---|---|
5e7ed085 | 1 | use rustc_errors::{struct_span_err, DiagnosticBuilder, DiagnosticId, ErrorGuaranteed}; |
ba9703b0 | 2 | use rustc_middle::ty::{self, Ty, TyCtxt}; |
dfeec247 | 3 | use rustc_span::{MultiSpan, Span}; |
60c5eb7d | 4 | |
c295e0f8 | 5 | impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> { |
5e7ed085 FG |
6 | crate fn cannot_move_when_borrowed( |
7 | &self, | |
8 | span: Span, | |
9 | desc: &str, | |
10 | ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> { | |
ba9703b0 | 11 | struct_span_err!(self, span, E0505, "cannot move out of {} because it is borrowed", desc,) |
3b2f2976 XL |
12 | } |
13 | ||
416331ca XL |
14 | crate fn cannot_use_when_mutably_borrowed( |
15 | &self, | |
8faf50e0 XL |
16 | span: Span, |
17 | desc: &str, | |
18 | borrow_span: Span, | |
19 | borrow_desc: &str, | |
5e7ed085 | 20 | ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> { |
8faf50e0 XL |
21 | let mut err = struct_span_err!( |
22 | self, | |
23 | span, | |
24 | E0503, | |
ba9703b0 | 25 | "cannot use {} because it was mutably borrowed", |
8faf50e0 | 26 | desc, |
8faf50e0 | 27 | ); |
ea8adc8c | 28 | |
ba9703b0 XL |
29 | err.span_label(borrow_span, format!("borrow of {} occurs here", borrow_desc)); |
30 | err.span_label(span, format!("use of borrowed {}", borrow_desc)); | |
416331ca | 31 | err |
3b2f2976 XL |
32 | } |
33 | ||
416331ca XL |
34 | crate fn cannot_act_on_uninitialized_variable( |
35 | &self, | |
8faf50e0 XL |
36 | span: Span, |
37 | verb: &str, | |
38 | desc: &str, | |
5e7ed085 | 39 | ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> { |
416331ca | 40 | struct_span_err!( |
8faf50e0 XL |
41 | self, |
42 | span, | |
43 | E0381, | |
e1599b0c | 44 | "{} of possibly-uninitialized variable: `{}`", |
8faf50e0 XL |
45 | verb, |
46 | desc, | |
416331ca | 47 | ) |
3b2f2976 XL |
48 | } |
49 | ||
416331ca XL |
50 | crate fn cannot_mutably_borrow_multiply( |
51 | &self, | |
8faf50e0 XL |
52 | new_loan_span: Span, |
53 | desc: &str, | |
54 | opt_via: &str, | |
55 | old_loan_span: Span, | |
56 | old_opt_via: &str, | |
57 | old_load_end_span: Option<Span>, | |
5e7ed085 | 58 | ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> { |
dfeec247 | 59 | let via = |
ba9703b0 | 60 | |msg: &str| if msg.is_empty() { "".to_string() } else { format!(" (via {})", msg) }; |
8faf50e0 XL |
61 | let mut err = struct_span_err!( |
62 | self, | |
63 | new_loan_span, | |
64 | E0499, | |
ba9703b0 | 65 | "cannot borrow {}{} as mutable more than once at a time", |
8faf50e0 | 66 | desc, |
0731742a | 67 | via(opt_via), |
8faf50e0 | 68 | ); |
ea8adc8c XL |
69 | if old_loan_span == new_loan_span { |
70 | // Both borrows are happening in the same place | |
71 | // Meaning the borrow is occurring in a loop | |
8faf50e0 XL |
72 | err.span_label( |
73 | new_loan_span, | |
74 | format!( | |
fc512014 XL |
75 | "{}{} was mutably borrowed here in the previous iteration of the loop{}", |
76 | desc, | |
77 | via(opt_via), | |
78 | opt_via, | |
8faf50e0 XL |
79 | ), |
80 | ); | |
abe05a73 XL |
81 | if let Some(old_load_end_span) = old_load_end_span { |
82 | err.span_label(old_load_end_span, "mutable borrow ends here"); | |
83 | } | |
ea8adc8c | 84 | } else { |
8faf50e0 XL |
85 | err.span_label( |
86 | old_loan_span, | |
0731742a | 87 | format!("first mutable borrow occurs here{}", via(old_opt_via)), |
8faf50e0 XL |
88 | ); |
89 | err.span_label( | |
90 | new_loan_span, | |
0731742a | 91 | format!("second mutable borrow occurs here{}", via(opt_via)), |
8faf50e0 | 92 | ); |
abe05a73 XL |
93 | if let Some(old_load_end_span) = old_load_end_span { |
94 | err.span_label(old_load_end_span, "first borrow ends here"); | |
95 | } | |
ea8adc8c | 96 | } |
416331ca | 97 | err |
3b2f2976 XL |
98 | } |
99 | ||
416331ca XL |
100 | crate fn cannot_uniquely_borrow_by_two_closures( |
101 | &self, | |
8faf50e0 XL |
102 | new_loan_span: Span, |
103 | desc: &str, | |
104 | old_loan_span: Span, | |
105 | old_load_end_span: Option<Span>, | |
5e7ed085 | 106 | ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> { |
8faf50e0 XL |
107 | let mut err = struct_span_err!( |
108 | self, | |
ea8adc8c | 109 | new_loan_span, |
8faf50e0 | 110 | E0524, |
ba9703b0 | 111 | "two closures require unique access to {} at the same time", |
8faf50e0 | 112 | desc, |
8faf50e0 | 113 | ); |
b7449926 XL |
114 | if old_loan_span == new_loan_span { |
115 | err.span_label( | |
116 | old_loan_span, | |
dfeec247 | 117 | "closures are constructed here in different iterations of loop", |
b7449926 XL |
118 | ); |
119 | } else { | |
120 | err.span_label(old_loan_span, "first closure is constructed here"); | |
121 | err.span_label(new_loan_span, "second closure is constructed here"); | |
122 | } | |
abe05a73 | 123 | if let Some(old_load_end_span) = old_load_end_span { |
8faf50e0 | 124 | err.span_label(old_load_end_span, "borrow from first closure ends here"); |
abe05a73 | 125 | } |
416331ca | 126 | err |
3b2f2976 XL |
127 | } |
128 | ||
416331ca XL |
129 | crate fn cannot_uniquely_borrow_by_one_closure( |
130 | &self, | |
8faf50e0 | 131 | new_loan_span: Span, |
0bf4aa26 | 132 | container_name: &str, |
8faf50e0 XL |
133 | desc_new: &str, |
134 | opt_via: &str, | |
135 | old_loan_span: Span, | |
136 | noun_old: &str, | |
137 | old_opt_via: &str, | |
138 | previous_end_span: Option<Span>, | |
5e7ed085 | 139 | ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> { |
8faf50e0 XL |
140 | let mut err = struct_span_err!( |
141 | self, | |
142 | new_loan_span, | |
143 | E0500, | |
ba9703b0 | 144 | "closure requires unique access to {} but {} is already borrowed{}", |
8faf50e0 XL |
145 | desc_new, |
146 | noun_old, | |
147 | old_opt_via, | |
8faf50e0 XL |
148 | ); |
149 | err.span_label( | |
150 | new_loan_span, | |
0bf4aa26 | 151 | format!("{} construction occurs here{}", container_name, opt_via), |
8faf50e0 XL |
152 | ); |
153 | err.span_label(old_loan_span, format!("borrow occurs here{}", old_opt_via)); | |
abe05a73 XL |
154 | if let Some(previous_end_span) = previous_end_span { |
155 | err.span_label(previous_end_span, "borrow ends here"); | |
156 | } | |
416331ca | 157 | err |
3b2f2976 XL |
158 | } |
159 | ||
416331ca XL |
160 | crate fn cannot_reborrow_already_uniquely_borrowed( |
161 | &self, | |
8faf50e0 | 162 | new_loan_span: Span, |
0bf4aa26 | 163 | container_name: &str, |
8faf50e0 XL |
164 | desc_new: &str, |
165 | opt_via: &str, | |
166 | kind_new: &str, | |
167 | old_loan_span: Span, | |
168 | old_opt_via: &str, | |
169 | previous_end_span: Option<Span>, | |
0731742a | 170 | second_borrow_desc: &str, |
5e7ed085 | 171 | ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> { |
8faf50e0 XL |
172 | let mut err = struct_span_err!( |
173 | self, | |
174 | new_loan_span, | |
175 | E0501, | |
ba9703b0 | 176 | "cannot borrow {}{} as {} because previous closure \ |
416331ca | 177 | requires unique access", |
8faf50e0 XL |
178 | desc_new, |
179 | opt_via, | |
180 | kind_new, | |
8faf50e0 | 181 | ); |
0731742a XL |
182 | err.span_label( |
183 | new_loan_span, | |
184 | format!("{}borrow occurs here{}", second_borrow_desc, opt_via), | |
185 | ); | |
8faf50e0 XL |
186 | err.span_label( |
187 | old_loan_span, | |
0bf4aa26 | 188 | format!("{} construction occurs here{}", container_name, old_opt_via), |
8faf50e0 | 189 | ); |
abe05a73 XL |
190 | if let Some(previous_end_span) = previous_end_span { |
191 | err.span_label(previous_end_span, "borrow from closure ends here"); | |
192 | } | |
416331ca | 193 | err |
3b2f2976 XL |
194 | } |
195 | ||
416331ca XL |
196 | crate fn cannot_reborrow_already_borrowed( |
197 | &self, | |
8faf50e0 XL |
198 | span: Span, |
199 | desc_new: &str, | |
200 | msg_new: &str, | |
201 | kind_new: &str, | |
202 | old_span: Span, | |
203 | noun_old: &str, | |
204 | kind_old: &str, | |
205 | msg_old: &str, | |
206 | old_load_end_span: Option<Span>, | |
5e7ed085 | 207 | ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> { |
dfeec247 | 208 | let via = |
ba9703b0 | 209 | |msg: &str| if msg.is_empty() { "".to_string() } else { format!(" (via {})", msg) }; |
8faf50e0 XL |
210 | let mut err = struct_span_err!( |
211 | self, | |
212 | span, | |
213 | E0502, | |
ba9703b0 | 214 | "cannot borrow {}{} as {} because {} is also borrowed as {}{}", |
8faf50e0 | 215 | desc_new, |
0731742a | 216 | via(msg_new), |
8faf50e0 XL |
217 | kind_new, |
218 | noun_old, | |
219 | kind_old, | |
0731742a | 220 | via(msg_old), |
8faf50e0 | 221 | ); |
0731742a XL |
222 | |
223 | if msg_new == "" { | |
224 | // If `msg_new` is empty, then this isn't a borrow of a union field. | |
225 | err.span_label(span, format!("{} borrow occurs here", kind_new)); | |
226 | err.span_label(old_span, format!("{} borrow occurs here", kind_old)); | |
227 | } else { | |
228 | // If `msg_new` isn't empty, then this a borrow of a union field. | |
229 | err.span_label( | |
230 | span, | |
231 | format!( | |
ba9703b0 | 232 | "{} borrow of {} -- which overlaps with {} -- occurs here", |
0731742a | 233 | kind_new, msg_new, msg_old, |
dfeec247 | 234 | ), |
0731742a | 235 | ); |
dfeec247 | 236 | err.span_label(old_span, format!("{} borrow occurs here{}", kind_old, via(msg_old))); |
0731742a XL |
237 | } |
238 | ||
abe05a73 XL |
239 | if let Some(old_load_end_span) = old_load_end_span { |
240 | err.span_label(old_load_end_span, format!("{} borrow ends here", kind_old)); | |
241 | } | |
416331ca | 242 | err |
3b2f2976 XL |
243 | } |
244 | ||
416331ca XL |
245 | crate fn cannot_assign_to_borrowed( |
246 | &self, | |
8faf50e0 XL |
247 | span: Span, |
248 | borrow_span: Span, | |
249 | desc: &str, | |
5e7ed085 | 250 | ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> { |
8faf50e0 XL |
251 | let mut err = struct_span_err!( |
252 | self, | |
253 | span, | |
254 | E0506, | |
ba9703b0 | 255 | "cannot assign to {} because it is borrowed", |
8faf50e0 | 256 | desc, |
8faf50e0 | 257 | ); |
ea8adc8c | 258 | |
ba9703b0 XL |
259 | err.span_label(borrow_span, format!("borrow of {} occurs here", desc)); |
260 | err.span_label(span, format!("assignment to borrowed {} occurs here", desc)); | |
416331ca | 261 | err |
3b2f2976 XL |
262 | } |
263 | ||
416331ca XL |
264 | crate fn cannot_reassign_immutable( |
265 | &self, | |
8faf50e0 XL |
266 | span: Span, |
267 | desc: &str, | |
268 | is_arg: bool, | |
5e7ed085 | 269 | ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> { |
dfeec247 | 270 | let msg = if is_arg { "to immutable argument" } else { "twice to immutable variable" }; |
ba9703b0 | 271 | struct_span_err!(self, span, E0384, "cannot assign {} {}", msg, desc) |
3b2f2976 XL |
272 | } |
273 | ||
5e7ed085 FG |
274 | crate fn cannot_assign( |
275 | &self, | |
276 | span: Span, | |
277 | desc: &str, | |
278 | ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> { | |
416331ca | 279 | struct_span_err!(self, span, E0594, "cannot assign to {}", desc) |
ea8adc8c XL |
280 | } |
281 | ||
416331ca XL |
282 | crate fn cannot_move_out_of( |
283 | &self, | |
8faf50e0 XL |
284 | move_from_span: Span, |
285 | move_from_desc: &str, | |
5e7ed085 | 286 | ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> { |
dfeec247 | 287 | struct_span_err!(self, move_from_span, E0507, "cannot move out of {}", move_from_desc,) |
ea8adc8c XL |
288 | } |
289 | ||
94b46f34 XL |
290 | /// Signal an error due to an attempt to move out of the interior |
291 | /// of an array or slice. `is_index` is None when error origin | |
292 | /// didn't capture whether there was an indexing operation or not. | |
416331ca XL |
293 | crate fn cannot_move_out_of_interior_noncopy( |
294 | &self, | |
8faf50e0 | 295 | move_from_span: Span, |
48663c56 | 296 | ty: Ty<'_>, |
8faf50e0 | 297 | is_index: Option<bool>, |
5e7ed085 | 298 | ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> { |
1b1a35ee | 299 | let type_name = match (&ty.kind(), is_index) { |
b7449926 XL |
300 | (&ty::Array(_, _), Some(true)) | (&ty::Array(_, _), None) => "array", |
301 | (&ty::Slice(_), _) => "slice", | |
ea8adc8c XL |
302 | _ => span_bug!(move_from_span, "this path should not cause illegal move"), |
303 | }; | |
8faf50e0 XL |
304 | let mut err = struct_span_err!( |
305 | self, | |
306 | move_from_span, | |
307 | E0508, | |
416331ca | 308 | "cannot move out of type `{}`, a non-copy {}", |
8faf50e0 XL |
309 | ty, |
310 | type_name, | |
8faf50e0 | 311 | ); |
ea8adc8c | 312 | err.span_label(move_from_span, "cannot move out of here"); |
416331ca | 313 | err |
ea8adc8c XL |
314 | } |
315 | ||
416331ca XL |
316 | crate fn cannot_move_out_of_interior_of_drop( |
317 | &self, | |
8faf50e0 | 318 | move_from_span: Span, |
48663c56 | 319 | container_ty: Ty<'_>, |
5e7ed085 | 320 | ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> { |
8faf50e0 XL |
321 | let mut err = struct_span_err!( |
322 | self, | |
323 | move_from_span, | |
324 | E0509, | |
416331ca | 325 | "cannot move out of type `{}`, which implements the `Drop` trait", |
8faf50e0 | 326 | container_ty, |
8faf50e0 | 327 | ); |
ea8adc8c | 328 | err.span_label(move_from_span, "cannot move out of here"); |
416331ca | 329 | err |
3b2f2976 | 330 | } |
abe05a73 | 331 | |
416331ca XL |
332 | crate fn cannot_act_on_moved_value( |
333 | &self, | |
8faf50e0 XL |
334 | use_span: Span, |
335 | verb: &str, | |
336 | optional_adverb_for_moved: &str, | |
337 | moved_path: Option<String>, | |
5e7ed085 | 338 | ) -> DiagnosticBuilder<'tcx, ErrorGuaranteed> { |
dfeec247 | 339 | let moved_path = moved_path.map(|mp| format!(": `{}`", mp)).unwrap_or_default(); |
8faf50e0 | 340 | |
416331ca | 341 | struct_span_err!( |
8faf50e0 XL |
342 | self, |
343 | use_span, | |
344 | E0382, | |
416331ca | 345 | "{} of {}moved value{}", |
8faf50e0 XL |
346 | verb, |
347 | optional_adverb_for_moved, | |
348 | moved_path, | |
416331ca | 349 | ) |
abe05a73 XL |
350 | } |
351 | ||
416331ca XL |
352 | crate fn cannot_borrow_path_as_mutable_because( |
353 | &self, | |
8faf50e0 XL |
354 | span: Span, |
355 | path: &str, | |
356 | reason: &str, | |
5e7ed085 | 357 | ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> { |
dfeec247 | 358 | struct_span_err!(self, span, E0596, "cannot borrow {} as mutable{}", path, reason,) |
abe05a73 XL |
359 | } |
360 | ||
60c5eb7d | 361 | crate fn cannot_mutate_in_immutable_section( |
416331ca | 362 | &self, |
0bf4aa26 | 363 | mutate_span: Span, |
60c5eb7d XL |
364 | immutable_span: Span, |
365 | immutable_place: &str, | |
366 | immutable_section: &str, | |
0bf4aa26 | 367 | action: &str, |
5e7ed085 | 368 | ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> { |
0bf4aa26 XL |
369 | let mut err = struct_span_err!( |
370 | self, | |
371 | mutate_span, | |
372 | E0510, | |
ba9703b0 | 373 | "cannot {} {} in {}", |
0bf4aa26 | 374 | action, |
60c5eb7d XL |
375 | immutable_place, |
376 | immutable_section, | |
0bf4aa26 XL |
377 | ); |
378 | err.span_label(mutate_span, format!("cannot {}", action)); | |
60c5eb7d | 379 | err.span_label(immutable_span, format!("value is immutable in {}", immutable_section)); |
416331ca | 380 | err |
0bf4aa26 XL |
381 | } |
382 | ||
416331ca XL |
383 | crate fn cannot_borrow_across_generator_yield( |
384 | &self, | |
8faf50e0 XL |
385 | span: Span, |
386 | yield_span: Span, | |
5e7ed085 | 387 | ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> { |
8faf50e0 XL |
388 | let mut err = struct_span_err!( |
389 | self, | |
390 | span, | |
391 | E0626, | |
416331ca | 392 | "borrow may still be in use when generator yields", |
8faf50e0 | 393 | ); |
abe05a73 | 394 | err.span_label(yield_span, "possible yield occurs here"); |
416331ca | 395 | err |
abe05a73 XL |
396 | } |
397 | ||
5e7ed085 FG |
398 | crate fn cannot_borrow_across_destructor( |
399 | &self, | |
400 | borrow_span: Span, | |
401 | ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> { | |
416331ca | 402 | struct_span_err!( |
0bf4aa26 XL |
403 | self, |
404 | borrow_span, | |
405 | E0713, | |
416331ca XL |
406 | "borrow may still be in use when destructor runs", |
407 | ) | |
0bf4aa26 XL |
408 | } |
409 | ||
416331ca XL |
410 | crate fn path_does_not_live_long_enough( |
411 | &self, | |
8faf50e0 XL |
412 | span: Span, |
413 | path: &str, | |
5e7ed085 | 414 | ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> { |
dfeec247 | 415 | struct_span_err!(self, span, E0597, "{} does not live long enough", path,) |
abe05a73 XL |
416 | } |
417 | ||
416331ca XL |
418 | crate fn cannot_return_reference_to_local( |
419 | &self, | |
0bf4aa26 | 420 | span: Span, |
48663c56 | 421 | return_kind: &str, |
0bf4aa26 XL |
422 | reference_desc: &str, |
423 | path_desc: &str, | |
5e7ed085 | 424 | ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> { |
0bf4aa26 XL |
425 | let mut err = struct_span_err!( |
426 | self, | |
427 | span, | |
428 | E0515, | |
416331ca | 429 | "cannot {RETURN} {REFERENCE} {LOCAL}", |
dfeec247 XL |
430 | RETURN = return_kind, |
431 | REFERENCE = reference_desc, | |
432 | LOCAL = path_desc, | |
0bf4aa26 XL |
433 | ); |
434 | ||
435 | err.span_label( | |
436 | span, | |
48663c56 | 437 | format!("{}s a {} data owned by the current function", return_kind, reference_desc), |
0bf4aa26 XL |
438 | ); |
439 | ||
416331ca | 440 | err |
abe05a73 XL |
441 | } |
442 | ||
416331ca XL |
443 | crate fn cannot_capture_in_long_lived_closure( |
444 | &self, | |
8faf50e0 | 445 | closure_span: Span, |
ba9703b0 | 446 | closure_kind: &str, |
8faf50e0 XL |
447 | borrowed_path: &str, |
448 | capture_span: Span, | |
5e7ed085 | 449 | ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> { |
8faf50e0 XL |
450 | let mut err = struct_span_err!( |
451 | self, | |
452 | closure_span, | |
453 | E0373, | |
ba9703b0 | 454 | "{} may outlive the current function, \ |
8faf50e0 | 455 | but it borrows {}, \ |
416331ca | 456 | which is owned by the current function", |
ba9703b0 | 457 | closure_kind, |
8faf50e0 | 458 | borrowed_path, |
8faf50e0 | 459 | ); |
abe05a73 | 460 | err.span_label(capture_span, format!("{} is borrowed here", borrowed_path)) |
dfeec247 | 461 | .span_label(closure_span, format!("may outlive borrowed value {}", borrowed_path)); |
416331ca | 462 | err |
abe05a73 | 463 | } |
b7449926 | 464 | |
416331ca XL |
465 | crate fn thread_local_value_does_not_live_long_enough( |
466 | &self, | |
b7449926 | 467 | span: Span, |
5e7ed085 | 468 | ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> { |
dfeec247 | 469 | struct_span_err!(self, span, E0712, "thread-local variable borrowed past end of function",) |
b7449926 | 470 | } |
0bf4aa26 | 471 | |
5e7ed085 FG |
472 | crate fn temporary_value_borrowed_for_too_long( |
473 | &self, | |
474 | span: Span, | |
475 | ) -> DiagnosticBuilder<'cx, ErrorGuaranteed> { | |
dfeec247 | 476 | struct_span_err!(self, span, E0716, "temporary value dropped while borrowed",) |
0bf4aa26 | 477 | } |
3b2f2976 | 478 | |
8faf50e0 | 479 | fn struct_span_err_with_code<S: Into<MultiSpan>>( |
416331ca | 480 | &self, |
8faf50e0 XL |
481 | sp: S, |
482 | msg: &str, | |
483 | code: DiagnosticId, | |
5e7ed085 | 484 | ) -> DiagnosticBuilder<'tcx, ErrorGuaranteed> { |
416331ca | 485 | self.infcx.tcx.sess.struct_span_err_with_code(sp, msg, code) |
3b2f2976 | 486 | } |
416331ca | 487 | } |
ff7c6d11 | 488 | |
416331ca XL |
489 | crate fn borrowed_data_escapes_closure<'tcx>( |
490 | tcx: TyCtxt<'tcx>, | |
491 | escape_span: Span, | |
492 | escapes_from: &str, | |
5e7ed085 | 493 | ) -> DiagnosticBuilder<'tcx, ErrorGuaranteed> { |
416331ca XL |
494 | struct_span_err!( |
495 | tcx.sess, | |
496 | escape_span, | |
497 | E0521, | |
498 | "borrowed data escapes outside of {}", | |
499 | escapes_from, | |
500 | ) | |
3b2f2976 | 501 | } |