3 use rustc::session::Session;
5 use errors::{struct_span_err, Applicability};
6 use rustc::hir::intravisit::{self, NestedVisitorMap, Visitor};
7 use rustc::hir::map::Map;
8 use rustc::ty::query::Providers;
11 use rustc_hir::def_id::DefId;
12 use rustc_hir::{Destination, Movability, Node};
15 use rustc_error_codes::*;
17 #[derive(Clone, Copy, Debug, PartialEq)]
20 Loop(hir::LoopSource),
27 #[derive(Copy, Clone)]
28 struct CheckLoopVisitor<'a, 'hir> {
30 hir_map: &'a Map<'hir>,
34 fn check_mod_loops(tcx: TyCtxt<'_>, module_def_id: DefId) {
35 tcx.hir().visit_item_likes_in_module(
37 &mut CheckLoopVisitor { sess: &tcx.sess, hir_map: &tcx.hir(), cx: Normal }
42 pub(crate) fn provide(providers: &mut Providers<'_>) {
43 *providers = Providers { check_mod_loops, ..*providers };
46 impl<'a, 'hir> Visitor<'hir> for CheckLoopVisitor<'a, 'hir> {
49 fn nested_visit_map(&mut self) -> NestedVisitorMap<'_, Self::Map> {
50 NestedVisitorMap::OnlyBodies(&self.hir_map)
53 fn visit_anon_const(&mut self, c: &'hir hir::AnonConst) {
54 self.with_context(AnonConst, |v| intravisit::walk_anon_const(v, c));
57 fn visit_expr(&mut self, e: &'hir hir::Expr<'hir>) {
59 hir::ExprKind::Loop(ref b, _, source) => {
60 self.with_context(Loop(source), |v| v.visit_block(&b));
62 hir::ExprKind::Closure(_, ref function_decl, b, span, movability) => {
63 let cx = if let Some(Movability::Static) = movability {
68 self.visit_fn_decl(&function_decl);
69 self.with_context(cx, |v| v.visit_nested_body(b));
71 hir::ExprKind::Block(ref b, Some(_label)) => {
72 self.with_context(LabeledBlock, |v| v.visit_block(&b));
74 hir::ExprKind::Break(label, ref opt_expr) => {
75 opt_expr.as_ref().map(|e| self.visit_expr(e));
77 if self.require_label_in_labeled_block(e.span, &label, "break") {
78 // If we emitted an error about an unlabeled break in a labeled
79 // block, we don't need any further checking for this break any more
83 let loop_id = match label.target_id.into() {
84 Ok(loop_id) => loop_id,
85 Err(hir::LoopIdError::OutsideLoopScope) => hir::DUMMY_HIR_ID,
86 Err(hir::LoopIdError::UnlabeledCfInWhileCondition) => {
87 self.emit_unlabled_cf_in_while_condition(e.span, "break");
90 Err(hir::LoopIdError::UnresolvedLabel) => hir::DUMMY_HIR_ID,
93 if loop_id != hir::DUMMY_HIR_ID {
94 if let Node::Block(_) = self.hir_map.find(loop_id).unwrap() {
99 if opt_expr.is_some() {
100 let loop_kind = if loop_id == hir::DUMMY_HIR_ID {
103 Some(match self.hir_map.expect_expr(loop_id).kind {
104 hir::ExprKind::Loop(_, _, source) => source,
106 span_bug!(e.span, "break label resolved to a non-loop: {:?}", r)
111 None | Some(hir::LoopSource::Loop) => (),
117 "`break` with value from a `{}` loop",
122 "can only break with a value inside \
123 `loop` or breakable block",
128 "instead, use `break` on its own \
129 without a value inside this `{}` loop",
133 Applicability::MaybeIncorrect,
140 self.require_break_cx("break", e.span);
142 hir::ExprKind::Continue(destination) => {
143 self.require_label_in_labeled_block(e.span, &destination, "continue");
145 match destination.target_id {
147 if let Node::Block(block) = self.hir_map.find(loop_id).unwrap() {
152 "`continue` pointing to a labeled block"
154 .span_label(e.span, "labeled blocks cannot be `continue`'d")
155 .span_label(block.span, "labeled block the `continue` points to")
159 Err(hir::LoopIdError::UnlabeledCfInWhileCondition) => {
160 self.emit_unlabled_cf_in_while_condition(e.span, "continue");
164 self.require_break_cx("continue", e.span)
166 _ => intravisit::walk_expr(self, e),
171 impl<'a, 'hir> CheckLoopVisitor<'a, 'hir> {
172 fn with_context<F>(&mut self, cx: Context, f: F)
174 F: FnOnce(&mut CheckLoopVisitor<'a, 'hir>),
176 let old_cx = self.cx;
182 fn require_break_cx(&self, name: &str, span: Span) {
183 let err_inside_of = |article, ty, closure_span| {
184 struct_span_err!(self.sess, span, E0267, "`{}` inside of {} {}", name, article, ty)
185 .span_label(span, format!("cannot `{}` inside of {} {}", name, article, ty))
186 .span_label(closure_span, &format!("enclosing {}", ty))
191 LabeledBlock | Loop(_) => {}
192 Closure(closure_span) => err_inside_of("a", "closure", closure_span),
193 AsyncClosure(closure_span) => err_inside_of("an", "`async` block", closure_span),
194 Normal | AnonConst => {
195 struct_span_err!(self.sess, span, E0268, "`{}` outside of a loop", name)
196 .span_label(span, format!("cannot `{}` outside of a loop", name))
202 fn require_label_in_labeled_block(
208 if self.cx == LabeledBlock {
209 if label.label.is_none() {
214 "unlabeled `{}` inside of a labeled block",
220 "`{}` statements that would diverge to or through \
221 a labeled block need to bear a label",
231 fn emit_unlabled_cf_in_while_condition(&mut self, span: Span, cf_type: &str) {
236 "`break` or `continue` with no label in the condition of a `while` loop"
238 .span_label(span, format!("unlabeled `{}` in the condition of a `while` loop", cf_type))