Lint for unnecessary type casts

src/libextra/bitv.rs

@@ -80,7 +80,7 @@ impl SmallBitv {
             self.bits |= 1<<i;
         }
         else {
-            self.bits &= !(1<<i as uint);
+            self.bits &= !(1<<i);
         }
     }
 

src/libextra/ebml.rs

@@ -647,7 +647,7 @@ pub mod writer {
             let cur_pos = self.writer.tell();
             self.writer.seek(last_size_pos as i64, io::SeekSet);
             let size = (cur_pos as uint - last_size_pos - 4);
-            write_sized_vuint(self.writer, size as uint, 4u);
+            write_sized_vuint(self.writer, size, 4u);
             self.writer.seek(cur_pos as i64, io::SeekSet);
 
             debug!("End tag (size = {})", size);

src/libextra/test.rs

@@ -926,8 +926,8 @@ fn calc_result(desc: &TestDesc, task_succeeded: bool) -> TestResult {
 impl ToJson for Metric {
     fn to_json(&self) -> json::Json {
         let mut map = ~TreeMap::new();
-        map.insert(~"value", json::Number(self.value as f64));
-        map.insert(~"noise", json::Number(self.noise as f64));
+        map.insert(~"value", json::Number(self.value));
+        map.insert(~"noise", json::Number(self.noise));
         json::Object(map)
     }
 }
@@ -1124,15 +1124,15 @@ impl BenchHarness {
             let loop_start = precise_time_ns();
 
             for p in samples.mut_iter() {
-                self.bench_n(n as u64, |x| f(x));
+                self.bench_n(n, |x| f(x));
                 *p = self.ns_per_iter() as f64;
             };
 
             stats::winsorize(samples, 5.0);
             let summ = stats::Summary::new(samples);
 
             for p in samples.mut_iter() {
-                self.bench_n(5 * n as u64, |x| f(x));
+                self.bench_n(5 * n, |x| f(x));
                 *p = self.ns_per_iter() as f64;
             };
 

src/libextra/time.rs

@@ -767,13 +767,13 @@ pub fn strptime(s: &str, format: &str) -> Result<Tm, ~str> {
 
         let mut buf = [0];
         let c = match rdr.read(buf) {
-            Some(..) => buf[0] as u8 as char,
+            Some(..) => buf[0] as char,
             None => break
         };
         match c {
             '%' => {
                 let ch = match rdr.read(buf) {
-                    Some(..) => buf[0] as u8 as char,
+                    Some(..) => buf[0] as char,
                     None => break
                 };
                 match parse_type(s, pos, ch, &mut tm) {

src/libnative/io/file.rs

@@ -39,7 +39,7 @@ pub fn keep_going(data: &[u8], f: |*u8, uint| -> i64) -> i64 {
             ret = f(data, amt);
             if cfg!(windows) { break } // windows has no eintr
             // if we get an eintr, then try again
-            if ret != -1 || os::errno() as int != eintr { break }
+            if ret != -1 || os::errno() != eintr { break }
         }
         if ret == 0 {
             break
@@ -81,7 +81,7 @@ impl FileDesc {
         #[cfg(not(windows))] type rlen = libc::size_t;
         let ret = keep_going(buf, |buf, len| {
             unsafe {
-                libc::read(self.fd, buf as *mut libc::c_void, len as rlen) as i64
+                libc::read(self.fd, buf as *mut libc::c_void, len as rlen)
             }
         });
         if ret == 0 {
@@ -97,7 +97,7 @@ impl FileDesc {
         #[cfg(not(windows))] type wlen = libc::size_t;
         let ret = keep_going(buf, |buf, len| {
             unsafe {
-                libc::write(self.fd, buf as *libc::c_void, len as wlen) as i64
+                libc::write(self.fd, buf as *libc::c_void, len as wlen)
             }
         });
         if ret < 0 {
@@ -213,7 +213,7 @@ impl rtio::RtioFileStream for FileDesc {
             io::SeekEnd => libc::SEEK_END,
             io::SeekCur => libc::SEEK_CUR,
         };
-        let n = unsafe { libc::lseek(self.fd, pos as libc::off_t, whence) };
+        let n = unsafe { libc::lseek(self.fd, pos, whence) };
         if n < 0 {
             Err(super::last_error())
         } else {
@@ -279,7 +279,7 @@ impl rtio::RtioFileStream for FileDesc {
     #[cfg(unix)]
     fn truncate(&mut self, offset: i64) -> Result<(), IoError> {
         super::mkerr_libc(unsafe {
-            libc::ftruncate(self.fd, offset as libc::off_t)
+            libc::ftruncate(self.fd, offset)
         })
     }
 }
@@ -385,7 +385,7 @@ impl rtio::RtioFileStream for CFile {
             io::SeekEnd => libc::SEEK_END,
             io::SeekCur => libc::SEEK_CUR,
         };
-        let n = unsafe { libc::fseek(self.file, pos as libc::c_long, whence) };
+        let n = unsafe { libc::fseek(self.file, pos, whence) };
         if n < 0 {
             Err(super::last_error())
         } else {
@@ -816,15 +816,15 @@ fn mkstat(stat: &libc::stat, path: &CString) -> io::FileStat {
         path: Path::new(path),
         size: stat.st_size as u64,
         kind: kind,
-        perm: (stat.st_mode) as io::FilePermission & io::AllPermissions,
+        perm: stat.st_mode & io::AllPermissions,
         created: mktime(stat.st_ctime as u64, stat.st_ctime_nsec as u64),
         modified: mktime(stat.st_mtime as u64, stat.st_mtime_nsec as u64),
         accessed: mktime(stat.st_atime as u64, stat.st_atime_nsec as u64),
         unstable: io::UnstableFileStat {
-            device: stat.st_dev as u64,
-            inode: stat.st_ino as u64,
-            rdev: stat.st_rdev as u64,
-            nlink: stat.st_nlink as u64,
+            device: stat.st_dev,
+            inode: stat.st_ino,
+            rdev: stat.st_rdev,
+            nlink: stat.st_nlink,
             uid: stat.st_uid as u64,
             gid: stat.st_gid as u64,
             blksize: stat.st_blksize as u64,

src/librustc/middle/cfg/construct.rs

@@ -396,7 +396,7 @@ impl CFGBuilder {
 
             ast::ExprAddrOf(_, e) |
             ast::ExprDoBody(e) |
-            ast::ExprCast(e, _) |
+            ast::ExprCast(e, _, _) |
             ast::ExprUnary(_, _, e) |
             ast::ExprParen(e) |
             ast::ExprVstore(e, _) |

src/librustc/middle/check_const.rs

@@ -130,7 +130,7 @@ pub fn check_expr(v: &mut CheckCrateVisitor,
             }
           }
           ExprLit(_) => (),
-          ExprCast(_, _) => {
+          ExprCast(..) => {
             let ety = ty::expr_ty(tcx, e);
             if !ty::type_is_numeric(ety) && !ty::type_is_unsafe_ptr(ety) {
                 sess.span_err(e.span, ~"can not cast to `" +

src/librustc/middle/const_eval.rs

@@ -248,7 +248,7 @@ impl ConstEvalVisitor {
                 join_all(cs)
             }
 
-            ast::ExprCast(base, _) => {
+            ast::ExprCast(base, _, _) => {
                 let ty = ty::expr_ty(self.tcx, e);
                 let base = self.classify(base);
                 if ty::type_is_integral(ty) {
@@ -447,7 +447,7 @@ pub fn eval_const_expr_partial<T: ty::ExprTyProvider>(tcx: &T, e: &Expr)
           _ => Err(~"Bad operands for binary")
         }
       }
-      ExprCast(base, _) => {
+      ExprCast(base, _, _) => {
         let ety = tcx.expr_ty(e);
         let base = eval_const_expr_partial(tcx, base);
         match base {

src/librustc/middle/dataflow.rs

@@ -713,7 +713,7 @@ impl<'a, O:DataFlowOperator> PropagationContext<'a, O> {
 
             ast::ExprAddrOf(_, e) |
             ast::ExprDoBody(e) |
-            ast::ExprCast(e, _) |
+            ast::ExprCast(e, _, _) |
             ast::ExprUnary(_, _, e) |
             ast::ExprParen(e) |
             ast::ExprVstore(e, _) |

src/librustc/middle/kind.rs

@@ -310,7 +310,7 @@ pub fn check_expr(cx: &mut Context, e: @Expr) {
             let interior_type = ty::expr_ty(cx.tcx, interior);
             let _ = check_durable(cx.tcx, interior_type, interior.span);
         }
-        ExprCast(source, _) => {
+        ExprCast(source, _, _) => {
             let source_ty = ty::expr_ty(cx.tcx, source);
             let target_ty = ty::expr_ty(cx.tcx, e);
             check_trait_cast(cx, source_ty, target_ty, source.span);

src/librustc/middle/lint.rs

@@ -41,6 +41,10 @@ use middle::typeck;
 use middle::pat_util;
 use metadata::csearch;
 use util::ppaux::{ty_to_str};
+use std::to_str::ToStr;
+
+use middle::typeck::infer;
+use middle::typeck::astconv::{ast_ty_to_ty, AstConv};
 
 use std::cmp;
 use std::hashmap::HashMap;
@@ -91,6 +95,7 @@ pub enum lint {
     unused_mut,
     unnecessary_allocation,
     dead_code,
+    unnecessary_cast,
 
     missing_doc,
     unreachable_code,
@@ -267,6 +272,13 @@ static lint_table: &'static [(&'static str, LintSpec)] = &[
         default: warn
     }),
 
+    ("unnecessary_cast",
+     LintSpec {
+        lint: unnecessary_cast,
+        desc: "detects unnecessary type casts, that can be removed",
+        default: allow,
+    }),
+
     ("unused_mut",
      LintSpec {
         lint: unused_mut,
@@ -336,7 +348,6 @@ static lint_table: &'static [(&'static str, LintSpec)] = &[
         desc: "unknown features found in crate-level #[feature] directives",
         default: deny,
     }),
-
      ("unknown_crate_type",
      LintSpec {
          lint: unknown_crate_type,
@@ -569,6 +580,56 @@ fn check_while_true_expr(cx: &Context, e: &ast::Expr) {
         _ => ()
     }
 }
+impl<'a> AstConv for Context<'a>{
+    fn tcx(&self) -> ty::ctxt { self.tcx }
+
+    fn get_item_ty(&self, id: ast::DefId) -> ty::ty_param_bounds_and_ty {
+        ty::lookup_item_type(self.tcx, id)
+    }
+
+    fn get_trait_def(&self, id: ast::DefId) -> @ty::TraitDef {
+        ty::lookup_trait_def(self.tcx, id)
+    }
+
+    fn ty_infer(&self, _span: Span) -> ty::t {
+        let infcx: @mut infer::InferCtxt = infer::new_infer_ctxt(self.tcx);
+        infcx.next_ty_var()
+    }
+}
+
+
+fn check_unused_casts(cx: &Context, e: &ast::Expr) {
+    fn check_cast(cx: &Context, expr: &ast::Expr, ty: &ast::Ty) {
+        let infcx: @mut infer::InferCtxt = infer::new_infer_ctxt(cx.tcx);
+        let t_t = ast_ty_to_ty(cx, &infcx, ty);
+        if  ty::get(ty::expr_ty(cx.tcx, expr)).sty == ty::get(t_t).sty {
+            cx.span_lint(unnecessary_cast, ty.span,
+                         "unnecessary type cast");
+        }
+    }
+
+    return match e.node {
+        ast::ExprCast(e1, t, expanded) => {
+            let ffi_type: bool = match t.node {
+                ast::ty_path(ref p, _, _) => {
+                    let type_name = token::interner_get(
+                        p.segments[p.segments.len()-1].identifier.name
+                    );
+                    if type_name == @"size_t" {
+                        true
+                    } else {
+                        false
+                    }
+                }
+                _ => false
+            };
+            if !ffi_type && !expanded {
+                check_cast(cx, e1, t);
+            }
+        }
+        _ => ()
+    };
+}
 
 fn check_type_limits(cx: &Context, e: &ast::Expr) {
     return match e.node {
@@ -1361,6 +1422,7 @@ impl<'a> Visitor<()> for Context<'a> {
         check_heap_expr(self, e);
 
         check_type_limits(self, e);
+        check_unused_casts(self, e);
 
         visit::walk_expr(self, e, ());
     }

src/librustc/middle/liveness.rs

@@ -1250,7 +1250,7 @@ impl Liveness {
 
           ExprAddrOf(_, e) |
           ExprDoBody(e) |
-          ExprCast(e, _) |
+          ExprCast(e, _, _) |
           ExprUnary(_, _, e) |
           ExprParen(e) => {
             self.propagate_through_expr(e, succ)

src/librustc/middle/moves.rs

@@ -549,7 +549,7 @@ impl VisitContext {
                 self.consume_expr(rhs);
             }
 
-            ExprCast(base, _) => {
+            ExprCast(base, _, _) => {
                 self.consume_expr(base);
             }
 

src/librustc/middle/trans/consts.rs

@@ -448,7 +448,7 @@ fn const_expr_unadjusted(cx: @CrateContext,
               }
               (const_get_elt(cx, arr, [iv as c_uint]), inlineable)
           }
-          ast::ExprCast(base, _) => {
+          ast::ExprCast(base, _, _) => {
             let ety = ty::expr_ty(cx.tcx, e);
             let llty = type_of::type_of(cx, ety);
             let basety = ty::expr_ty(cx.tcx, base);

src/librustc/middle/trans/debuginfo.rs

@@ -2613,7 +2613,7 @@ fn populate_scope_map(cx: &CrateContext,
             ast::ExprPath(_)  => (),
 
             ast::ExprVstore(@ref sub_exp, _)   |
-            ast::ExprCast(@ref sub_exp, _)     |
+            ast::ExprCast(@ref sub_exp, _, _)     |
             ast::ExprAddrOf(_, @ref sub_exp)  |
             ast::ExprField(@ref sub_exp, _, _) |
             ast::ExprParen(@ref sub_exp)       => walk_expr(cx, sub_exp, scope_stack, scope_map),

src/librustc/middle/trans/expr.rs

@@ -617,7 +617,7 @@ fn trans_rvalue_datum_unadjusted(bcx: @Block, expr: &ast::Expr) -> DatumBlock {
         ast::ExprAddrOf(_, x) => {
             return trans_addr_of(bcx, expr, x);
         }
-        ast::ExprCast(val, _) => {
+        ast::ExprCast(val, _, _) => {
             return trans_imm_cast(bcx, val, expr.id);
         }
         ast::ExprParen(e) => {
@@ -789,7 +789,7 @@ fn trans_rvalue_dps_unadjusted(bcx: @Block, expr: &ast::Expr,
                                        expr_ty(bcx, expr),
                                        dest);
         }
-        ast::ExprCast(val, _) => {
+        ast::ExprCast(val, _, _) => {
             match ty::get(node_id_type(bcx, expr.id)).sty {
                 ty::ty_trait(_, _, store, _, _) => {
                     return meth::trans_trait_cast(bcx, val, expr.id,

src/librustc/middle/ty.rs

@@ -2871,6 +2871,11 @@ pub fn expr_ty(cx: ctxt, expr: &ast::Expr) -> t {
     return node_id_to_type(cx, expr.id);
 }
 
+pub fn ast_ty_to_ty(cx: ctxt, expr: &ast::Ty) -> t {
+    return node_id_to_type(cx, expr.id);
+}
+
+
 pub fn expr_ty_adjusted(cx: ctxt, expr: &ast::Expr) -> t {
     /*!
      *

src/librustc/middle/typeck/check/mod.rs

@@ -101,7 +101,6 @@ use middle::typeck::check::vtable::{LocationInfo, VtableContext};
 use middle::typeck::CrateCtxt;
 use middle::typeck::infer::{resolve_type, force_tvar};
 use middle::typeck::infer;
-use middle::typeck::rscope::RegionScope;
 use middle::typeck::{lookup_def_ccx};
 use middle::typeck::no_params;
 use middle::typeck::{require_same_types, method_map, vtable_map};
@@ -3037,7 +3036,7 @@ pub fn check_expr_with_unifier(fcx: @FnCtxt,
             fcx.write_bot(id);
         }
       }
-      ast::ExprCast(e, t) => {
+      ast::ExprCast(e, t, _) => {
         check_expr(fcx, e);
         let t_1 = fcx.to_ty(t);
         let t_e = fcx.expr_ty(e);

src/librustc/middle/typeck/check/regionck.rs

@@ -400,7 +400,7 @@ fn visit_expr(rcx: &mut Rcx, expr: @ast::Expr) {
             visit::walk_expr(rcx, expr, ());
         }
 
-        ast::ExprCast(source, _) => {
+        ast::ExprCast(source, _, _) => {
             // Determine if we are casting `source` to an trait
             // instance.  If so, we have to be sure that the type of
             // the source obeys the trait's region bound.

src/librustc/middle/typeck/check/vtable.rs

@@ -730,7 +730,7 @@ pub fn early_resolve_expr(ex: @ast::Expr,
           None => ()
         }
       }
-      ast::ExprCast(src, _) => {
+      ast::ExprCast(src, _, _) => {
           debug!("vtable resolution on expr {}", ex.repr(fcx.tcx()));
           let target_ty = fcx.expr_ty(ex);
           resolve_object_cast(src, target_ty);