Check for duplicate loop labels in function bodies.

Author: pnkfelix

src/librustc_typeck/check/labels.rs

@@ -0,0 +1,71 @@
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! labels.rs
+//!
+//! Issue #21633: Check for duplicate loop-labels anywhere in a
+//! function body.
+
+
+use CrateCtxt;
+
+use syntax::ast;
+use syntax::codemap::Span;
+use syntax::visit::{self, Visitor};
+
+use std::mem::replace;
+
+pub struct CheckLoopLabelsVisitor<'a, 'tcx: 'a> {
+    ccx: &'a CrateCtxt<'a, 'tcx>,
+    labels_in_fn: Vec<(ast::Ident, Span)>,
+}
+
+impl<'a, 'tcx:'a> CheckLoopLabelsVisitor<'a, 'tcx> {
+    pub fn new(ccx: &'a CrateCtxt<'a, 'tcx>) -> CheckLoopLabelsVisitor<'a, 'tcx> {
+        CheckLoopLabelsVisitor { ccx: ccx, labels_in_fn: vec![] }
+    }
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for CheckLoopLabelsVisitor<'a, 'tcx> {
+    fn visit_fn(&mut self, fk: visit::FnKind<'tcx>, fd: &'tcx ast::FnDecl,
+                b: &'tcx ast::Block, s: Span, _: ast::NodeId)
+    {
+        let saved = replace(&mut self.labels_in_fn, vec![]);
+        visit::walk_fn(self, fk, fd, b, s);
+        replace(&mut self.labels_in_fn, saved);
+    }
+
+    fn visit_expr(&mut self, ex: &'tcx ast::Expr) {
+        let opt_label = match ex.node {
+            ast::ExprWhile(_, _, label)       |
+            ast::ExprWhileLet(_, _, _, label) |
+            ast::ExprForLoop(_, _, _, label)  |
+            ast::ExprLoop(_, label)           => label,
+            _ => None,
+        };
+        let tcx = self.ccx.tcx;
+        if let Some(curr_id) = opt_label {
+            // Note: non-hygienic comparision here may reject code
+            // that should actually be accepted.
+            if let Some(&(_, span)) = self.labels_in_fn.iter()
+                .find(|id_span| curr_id.name == id_span.0.name )
+            {
+                span_err!(tcx.sess, ex.span, E0373,
+                          "duplicate loop label {} in function",
+                          curr_id);
+                span_note!(tcx.sess, span, "first label occurrence here");
+            } else {
+                self.labels_in_fn.push((curr_id, ex.span));
+            }
+        }
+
+        visit::walk_expr(self, ex)
+    }
+}

src/librustc_typeck/check/mod.rs

@@ -143,6 +143,7 @@ mod closure;
 mod callee;
 mod compare_method;
 mod op;
+mod labels;
 
 /// closures defined within the function.  For example:
 ///
@@ -482,6 +483,11 @@ pub fn check_item_types(ccx: &CrateCtxt) {
 
     ccx.tcx.sess.abort_if_errors();
 
+    let mut visit = labels::CheckLoopLabelsVisitor::new(ccx);
+    visit::walk_crate(&mut visit, krate);
+
+    ccx.tcx.sess.abort_if_errors();
+
     for drop_method_did in ccx.tcx.destructors.borrow().iter() {
         if drop_method_did.krate == ast::LOCAL_CRATE {
             let drop_impl_did = ccx.tcx.map.get_parent_did(drop_method_did.node);

src/librustc_typeck/diagnostics.rs

@@ -181,7 +181,8 @@ register_diagnostics! {
     E0368, // binary operation `<op>=` cannot be applied to types
     E0369, // binary operation `<op>` cannot be applied to types
     E0371, // impl Trait for Trait is illegal
-    E0372  // impl Trait for Trait where Trait is not object safe
+    E0372, // impl Trait for Trait where Trait is not object safe
+    E0373 // duplicate loop label in single block
 }
 
 __build_diagnostic_array! { DIAGNOSTICS }