---

yaml
---
r: 30748
b: refs/heads/incoming
c: 62649f0
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: d324a424d8f84b1eb049b12cf34182bda91b0024
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: d0c6ce338884ee21843f4b40bf6bf18d222ce5df
-refs/heads/incoming: e500659eb5482aea8b4675416449b03d5cfbe898
+refs/heads/incoming: 62649f0412630f8bfe284996c82b6a723d2ffea9
 refs/heads/dist-snap: 2f32a1581f522e524009138b33b1c7049ced668d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/incoming/src/libcore/option.rs

@@ -9,7 +9,7 @@
  */
 
 // NB: transitionary, de-mode-ing.
-#[forbid(deprecated_mode)];
+#[warn(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
 use cmp::Eq;

branches/incoming/src/libstd/fun_treemap.rs

@@ -1,4 +1,4 @@
-#[forbid(deprecated_mode)];
+#[warn(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
 /*!

branches/incoming/src/libstd/list.rs

@@ -1,5 +1,5 @@
 //! A standard linked list
-#[forbid(deprecated_mode)];
+#[warn(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
 use core::cmp::Eq;

branches/incoming/src/libstd/test.rs

@@ -5,7 +5,7 @@
 // simplest interface possible for representing and running tests
 // while providing a base that other test frameworks may build off of.
 
-#[forbid(deprecated_mode)];
+#[warn(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
 use core::cmp::Eq;

branches/incoming/src/libstd/treemap.rs

@@ -5,7 +5,7 @@
  * very naive algorithm, but it will probably be updated to be a
  * red-black tree or something else.
  */
-#[forbid(deprecated_mode)];
+#[warn(deprecated_mode)];
 #[forbid(deprecated_pattern)];
 
 use core::cmp::{Eq, Ord};

branches/incoming/src/rustc/middle/lint.rs

@@ -396,6 +396,7 @@ fn check_item(i: @ast::item, cx: ty::ctxt) {
     check_item_non_camel_case_types(cx, i);
     check_item_heap(cx, i);
     check_item_structural_records(cx, i);
+    check_item_deprecated_modes(cx, i);
 }
 
 // Take a visitor, and modify it so that it will not proceed past subitems.
@@ -666,43 +667,107 @@ fn check_fn(tcx: ty::ctxt, fk: visit::fn_kind, decl: ast::fn_decl,
     }
 
     let fn_ty = ty::node_id_to_type(tcx, id);
+    check_fn_deprecated_modes(tcx, fn_ty, decl, span, id);
+}
+
+fn check_fn_deprecated_modes(tcx: ty::ctxt, fn_ty: ty::t, decl: ast::fn_decl,
+                             span: span, id: ast::node_id) {
     match ty::get(fn_ty).sty {
-      ty::ty_fn(fn_ty) => {
-        let mut counter = 0;
-        do vec::iter2(fn_ty.sig.inputs, decl.inputs) |arg_ty, arg_ast| {
-            counter += 1;
-            debug!("arg %d, ty=%s, mode=%s",
-                   counter,
-                   ty_to_str(tcx, arg_ty.ty),
-                   mode_to_str(arg_ast.mode));
-            match arg_ast.mode {
-              ast::expl(ast::by_copy) => {
-                /* always allow by-copy */
-              }
+        ty::ty_fn(fn_ty) => {
+            let mut counter = 0;
+            do vec::iter2(fn_ty.sig.inputs, decl.inputs) |arg_ty, arg_ast| {
+                counter += 1;
+                debug!("arg %d, ty=%s, mode=%s",
+                       counter,
+                       ty_to_str(tcx, arg_ty.ty),
+                       mode_to_str(arg_ast.mode));
+                match arg_ast.mode {
+                    ast::expl(ast::by_copy) => {
+                        /* always allow by-copy */
+                    }
 
-              ast::expl(_) => {
-                tcx.sess.span_lint(
-                    deprecated_mode, id, id,
-                    span,
-                    fmt!("argument %d uses an explicit mode", counter));
-              }
+                    ast::expl(_) => {
+                        tcx.sess.span_lint(
+                            deprecated_mode, id, id,
+                            span,
+                            fmt!("argument %d uses an explicit mode", counter));
+                    }
 
-              ast::infer(_) => {
-                let kind = ty::type_kind(tcx, arg_ty.ty);
-                if !ty::kind_is_safe_for_default_mode(kind) {
-                    tcx.sess.span_lint(
-                        deprecated_mode, id, id,
-                        span,
-                        fmt!("argument %d uses the default mode \
-                              but shouldn't",
-                             counter));
+                    ast::infer(_) => {
+                        let kind = ty::type_kind(tcx, arg_ty.ty);
+                        if !ty::kind_is_safe_for_default_mode(kind) {
+                            tcx.sess.span_lint(
+                                deprecated_mode, id, id,
+                                span,
+                                fmt!("argument %d uses the default mode \
+                                      but shouldn't",
+                                     counter));
+                        }
+                    }
+                }
+
+                match ty::get(arg_ty.ty).sty {
+                    ty::ty_fn(*) => {
+                        let span = arg_ast.ty.span;
+                        // Recurse to check fn-type argument
+                        match arg_ast.ty.node {
+                            ast::ty_fn(_, _, _, decl) => {
+                                check_fn_deprecated_modes(tcx, arg_ty.ty,
+                                                          decl, span, id);
+                            }
+                            ast::ty_path(*) => {
+                                // This is probably a typedef, so we can't
+                                // see the actual fn decl
+                                // e.g. fn foo(f: InitOp<T>)
+                            }
+                            ast::ty_rptr(_, mt)
+                            | ast::ty_box(mt)
+                            | ast::ty_uniq(mt) => {
+                                // Functions with preceding sigil are parsed
+                                // as pointers of functions
+                                match mt.ty.node {
+                                    ast::ty_fn(_, _, _, decl) => {
+                                        check_fn_deprecated_modes(
+                                            tcx, arg_ty.ty,
+                                            decl, span, id);
+                                    }
+                                    _ => fail
+                                }
+                            }
+                            _ => {
+                                tcx.sess.span_warn(span, ~"what");
+                                error!("arg %d, ty=%s, mode=%s",
+                                       counter,
+                                       ty_to_str(tcx, arg_ty.ty),
+                                       mode_to_str(arg_ast.mode));
+                                error!("%?",arg_ast.ty.node);
+                                fail
+                            }
+                        };
+                    }
+                    _ => ()
                 }
-              }
             }
         }
-      }
-      _ => tcx.sess.impossible_case(span, ~"check_fn: function has \
-             non-fn type")
+
+        _ => tcx.sess.impossible_case(span, ~"check_fn: function has \
+                                              non-fn type")
+    }
+}
+
+fn check_item_deprecated_modes(tcx: ty::ctxt, it: @ast::item) {
+    match it.node {
+        ast::item_ty(ty, _) => {
+            match ty.node {
+                ast::ty_fn(_, _, _, decl) => {
+                    let fn_ty = ty::node_id_to_type(tcx, it.id);
+                    check_fn_deprecated_modes(
+                        tcx, fn_ty, decl, ty.span, it.id)
+                }
+                _ => ()
+            }
+        }
+        _ => ()
     }
 }
 

branches/incoming/src/test/compile-fail/deprecated-mode-fn-arg.rs

@@ -0,0 +1,9 @@
+#[forbid(deprecated_mode)];
+
+fn foo(_f: fn(&i: int)) { //~ ERROR explicit mode
+}
+
+type Bar = fn(&i: int); //~ ERROR explicit mode
+
+fn main() {
+}