lint.rs 37.4 KB
Newer Older
1 2 3 4 5 6 7 8 9 10
// Copyright 2012 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.

11 12
use core::prelude::*;

13
use driver::session;
P
Patrick Walton 已提交
14
use middle::ty;
15
use middle::pat_util;
P
Patrick Walton 已提交
16
use util::ppaux::{ty_to_str};
17

18 19
use core::char;
use core::cmp;
20
use core::hashmap::HashMap;
21 22 23 24 25 26 27 28 29 30
use core::i16;
use core::i32;
use core::i64;
use core::i8;
use core::str;
use core::u16;
use core::u32;
use core::u64;
use core::u8;
use core::vec;
31
use extra::smallintmap::SmallIntMap;
32 33
use syntax::attr;
use syntax::codemap::span;
J
John Clements 已提交
34
use syntax::codemap;
35
use syntax::{ast, visit, ast_util};
36

37 38 39 40 41 42 43
/**
 * A 'lint' check is a kind of miscellaneous constraint that a user _might_
 * want to enforce, but might reasonably want to permit as well, on a
 * module-by-module basis. They contrast with static constraints enforced by
 * other phases of the compiler, which are generally required to hold in order
 * to compile the program at all.
 *
44 45 46 47 48
 * The lint checking is all consolidated into one pass which runs just before
 * translation to LLVM bytecode. Throughout compilation, lint warnings can be
 * added via the `add_lint` method on the Session structure. This requires a
 * span and an id of the node that the lint is being added to. The lint isn't
 * actually emitted at that time because it is unknown what the actual lint
49
 * level at that location is.
50
 *
51 52 53 54 55 56
 * To actually emit lint warnings/errors, a separate pass is used just before
 * translation. A context keeps track of the current state of all lint levels.
 * Upon entering a node of the ast which can modify the lint settings, the
 * previous lint state is pushed onto a stack and the ast is then recursed upon.
 * As the ast is traversed, this keeps track of the current lint level for all
 * lint attributes.
57
 *
58 59 60 61 62 63 64 65 66 67 68 69 70 71
 * At each node of the ast which can modify lint attributes, all known lint
 * passes are also applied.  Each lint pass is a visit::vt<()> structure. These
 * visitors are constructed via the lint_*() functions below. There are also
 * some lint checks which operate directly on ast nodes (such as @ast::item),
 * and those are organized as check_item_*(). Each visitor added to the lint
 * context is modified to stop once it reaches a node which could alter the lint
 * levels. This means that everything is looked at once and only once by every
 * lint pass.
 *
 * With this all in place, to add a new lint warning, all you need to do is to
 * either invoke `add_lint` on the session at the appropriate time, or write a
 * lint pass in this module which is just an ast visitor. The context used when
 * traversing the ast has a `span_lint` method which only needs the span of the
 * item that's being warned about.
72
 */
73

74
#[deriving(Eq)]
75
pub enum lint {
P
Patrick Walton 已提交
76
    ctypes,
77
    unused_imports,
78 79
    while_true,
    path_statement,
80
    implicit_copies,
81
    unrecognized_lint,
82
    non_implicitly_copyable_typarams,
83
    deprecated_pattern,
84
    non_camel_case_types,
85
    type_limits,
86
    default_methods,
87
    unused_unsafe,
88

89 90 91 92
    managed_heap_memory,
    owned_heap_memory,
    heap_memory,

93 94
    unused_variable,
    dead_assignment,
95
    unused_mut,
96
    unnecessary_allocation,
97

98
    missing_doc,
99
    unreachable_code,
100 101
}

102
pub fn level_to_str(lv: level) -> &'static str {
103
    match lv {
104 105 106 107
      allow => "allow",
      warn => "warn",
      deny => "deny",
      forbid => "forbid"
108 109 110
    }
}

111
#[deriving(Eq)]
112
pub enum level {
113
    allow, warn, deny, forbid
114 115
}

116 117
struct LintSpec {
    lint: lint,
118
    desc: &'static str,
119
    default: level
120
}
121

122 123 124 125 126 127 128
pub type LintDict = HashMap<~str, LintSpec>;

enum AttributedNode<'self> {
    Item(@ast::item),
    Method(&'self ast::method),
    Crate(@ast::crate),
}
129

130 131 132 133 134 135 136
#[deriving(Eq)]
enum LintSource {
    Node(span),
    Default,
    CommandLine
}

S
Sangeun Kim 已提交
137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262
static lint_table: &'static [(&'static str, LintSpec)] = &[
    ("ctypes",
     LintSpec {
        lint: ctypes,
        desc: "proper use of core::libc types in foreign modules",
        default: warn
     }),

    ("unused_imports",
     LintSpec {
        lint: unused_imports,
        desc: "imports that are never used",
        default: warn
     }),

    ("while_true",
     LintSpec {
        lint: while_true,
        desc: "suggest using loop { } instead of while(true) { }",
        default: warn
     }),

    ("path_statement",
     LintSpec {
        lint: path_statement,
        desc: "path statements with no effect",
        default: warn
     }),

    ("unrecognized_lint",
     LintSpec {
        lint: unrecognized_lint,
        desc: "unrecognized lint attribute",
        default: warn
     }),

    ("non_implicitly_copyable_typarams",
     LintSpec {
        lint: non_implicitly_copyable_typarams,
        desc: "passing non implicitly copyable types as copy type params",
        default: warn
     }),

    ("implicit_copies",
     LintSpec {
        lint: implicit_copies,
        desc: "implicit copies of non implicitly copyable data",
        default: warn
     }),

    ("deprecated_pattern",
     LintSpec {
        lint: deprecated_pattern,
        desc: "warn about deprecated uses of pattern bindings",
        default: allow
     }),

    ("non_camel_case_types",
     LintSpec {
        lint: non_camel_case_types,
        desc: "types, variants and traits should have camel case names",
        default: allow
     }),

    ("managed_heap_memory",
     LintSpec {
        lint: managed_heap_memory,
        desc: "use of managed (@ type) heap memory",
        default: allow
     }),

    ("owned_heap_memory",
     LintSpec {
        lint: owned_heap_memory,
        desc: "use of owned (~ type) heap memory",
        default: allow
     }),

    ("heap_memory",
     LintSpec {
        lint: heap_memory,
        desc: "use of any (~ type or @ type) heap memory",
        default: allow
     }),

    ("type_limits",
     LintSpec {
        lint: type_limits,
        desc: "comparisons made useless by limits of the types involved",
        default: warn
     }),

    ("default_methods",
     LintSpec {
        lint: default_methods,
        desc: "allow default methods",
        default: deny
     }),

    ("unused_unsafe",
     LintSpec {
        lint: unused_unsafe,
        desc: "unnecessary use of an `unsafe` block",
        default: warn
    }),

    ("unused_variable",
     LintSpec {
        lint: unused_variable,
        desc: "detect variables which are not used in any way",
        default: warn
    }),

    ("dead_assignment",
     LintSpec {
        lint: dead_assignment,
        desc: "detect assignments that will never be read",
        default: warn
    }),

    ("unused_mut",
     LintSpec {
        lint: unused_mut,
        desc: "detect mut variables which don't need to be mutable",
        default: warn
    }),
263 264 265 266 267 268 269

    ("unnecessary_allocation",
     LintSpec {
        lint: unnecessary_allocation,
        desc: "detects unnecessary allocations that can be eliminated",
        default: warn
    }),
270

271
    ("missing_doc",
272
     LintSpec {
273 274
        lint: missing_doc,
        desc: "detects missing documentation for public members",
275 276
        default: allow
    }),
277 278 279 280 281 282 283

    ("unreachable_code",
     LintSpec {
        lint: unreachable_code,
        desc: "detects unreachable code",
        default: warn
    }),
S
Sangeun Kim 已提交
284 285
];

286 287 288 289
/*
  Pass names should not contain a '-', as the compiler normalizes
  '-' to '_' in command-line flags
 */
290
pub fn get_lint_dict() -> LintDict {
291
    let mut map = HashMap::new();
S
Sangeun Kim 已提交
292
    for lint_table.each|&(k, v)| {
S
Sangeun Kim 已提交
293
        map.insert(k.to_str(), v);
294
    }
295
    return map;
296 297
}

298
struct Context {
299 300 301
    // All known lint modes (string versions)
    dict: @LintDict,
    // Current levels of each lint warning
302
    curr: SmallIntMap<(level, LintSource)>,
303 304
    // context we're checking in (used to access fields like sess)
    tcx: ty::ctxt,
305 306 307
    // Just a simple flag if we're currently recursing into a trait
    // implementation. This is only used by the lint_missing_doc() pass
    in_trait_impl: bool,
308 309 310 311
    // Another flag for doc lint emissions. Does some parent of the current node
    // have the doc(hidden) attribute? Treating this as allow(missing_doc) would
    // play badly with forbid(missing_doc) when it shouldn't.
    doc_hidden: bool,
312 313 314
    // When recursing into an attributed node of the ast which modifies lint
    // levels, this stack keeps track of the previous lint levels of whatever
    // was modified.
315
    lint_stack: ~[(lint, level, LintSource)],
316 317 318 319 320
    // Each of these visitors represents a lint pass. A number of the lint
    // attributes are registered by adding a visitor to iterate over the ast.
    // Others operate directly on @ast::item structures (or similar). Finally,
    // others still are added to the Session object via `add_lint`, and these
    // are all passed with the lint_session visitor.
321 322 323 324 325 326 327 328 329
    //
    // This is a pair so every visitor can visit every node. When a lint pass is
    // registered, another visitor is created which stops at all items which can
    // alter the attributes of the ast. This "item stopping visitor" is the
    // second element of the pair, while the original visitor is the first
    // element. This means that when visiting a node, the original recursive
    // call can used the original visitor's method, although the recursing
    // visitor supplied to the method is the item stopping visitor.
    visitors: ~[(visit::vt<@mut Context>, visit::vt<@mut Context>)],
330
}
331

332
impl Context {
333
    fn get_level(&self, lint: lint) -> level {
334
        match self.curr.find(&(lint as uint)) {
335
          Some(&(lvl, _)) => lvl,
336 337
          None => allow
        }
338 339
    }

340 341 342 343 344 345 346 347
    fn get_source(&self, lint: lint) -> LintSource {
        match self.curr.find(&(lint as uint)) {
          Some(&(_, src)) => src,
          None => Default
        }
    }

    fn set_level(&mut self, lint: lint, level: level, src: LintSource) {
348
        if level == allow {
D
Daniel Micay 已提交
349
            self.curr.remove(&(lint as uint));
350
        } else {
351 352 353 354 355 356 357 358 359
            self.curr.insert(lint as uint, (level, src));
        }
    }

    fn lint_to_str(&self, lint: lint) -> ~str {
        for self.dict.each |k, v| {
            if v.lint == lint {
                return copy *k;
            }
360
        }
361
        fail!("unregistered lint %?", lint);
362 363
    }

364
    fn span_lint(&self, lint: lint, span: span, msg: &str) {
365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393
        let (level, src) = match self.curr.find(&(lint as uint)) {
            Some(&pair) => pair,
            None => { return; }
        };
        if level == allow { return; }

        let mut note = None;
        let msg = match src {
            Default | CommandLine => {
                fmt!("%s [-%c %s%s]", msg, match level {
                        warn => 'W', deny => 'D', forbid => 'F',
                        allow => fail!()
                    }, str::replace(self.lint_to_str(lint), "_", "-"),
                    if src == Default { " (default)" } else { "" })
            },
            Node(src) => {
                note = Some(src);
                msg.to_str()
            }
        };
        match level {
            warn =>          { self.tcx.sess.span_warn(span, msg); }
            deny | forbid => { self.tcx.sess.span_err(span, msg);  }
            allow => fail!(),
        }

        for note.each |&span| {
            self.tcx.sess.span_note(span, "lint level defined here");
        }
394 395
    }

396
    /**
397
     * Merge the lints specified by any lint attributes into the
398
     * current lint context, call the provided function, then reset the
399
     * lints in effect to their previous state.
400
     */
401 402 403 404 405 406
    fn with_lint_attrs(@mut self, attrs: &[ast::attribute], f: &fn()) {
        // Parse all of the lint attributes, and then add them all to the
        // current dictionary of lint information. Along the way, keep a history
        // of what we changed so we can roll everything back after invoking the
        // specified closure
        let mut pushed = 0u;
407
        for each_lint(self.tcx.sess, attrs) |meta, level, lintname| {
408
            let lint = match self.dict.find(lintname) {
B
Brian Anderson 已提交
409
              None => {
410
                self.span_lint(
411
                    unrecognized_lint,
412
                    meta.span,
P
Paul Stansifer 已提交
413
                    fmt!("unknown `%s` attribute: `%s`",
414
                         level_to_str(level), *lintname));
415
                loop
416
              }
417 418
              Some(lint) => { lint.lint }
            };
419

420 421 422 423 424 425
            let now = self.get_level(lint);
            if now == forbid && level != forbid {
                self.tcx.sess.span_err(meta.span,
                    fmt!("%s(%s) overruled by outer forbid(%s)",
                         level_to_str(level),
                         *lintname, *lintname));
426
                loop;
427
            }
428

429
            if now != level {
430 431
                let src = self.get_source(lint);
                self.lint_stack.push((lint, now, src));
432
                pushed += 1;
433
                self.set_level(lint, level, Node(meta.span));
434
            }
435
        }
436

437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454
        // detect doc(hidden)
        let mut doc_hidden = false;
        for attr::find_attrs_by_name(attrs, "doc").each |attr| {
            match attr::get_meta_item_list(attr.node.value) {
                Some(s) => {
                    if attr::find_meta_items_by_name(s, "hidden").len() > 0 {
                        doc_hidden = true;
                    }
                }
                None => {}
            }
        }
        if doc_hidden && !self.doc_hidden {
            self.doc_hidden = true;
        } else {
            doc_hidden = false;
        }

455
        f();
456

457
        // rollback
458 459 460
        if doc_hidden && self.doc_hidden {
            self.doc_hidden = false;
        }
461
        for pushed.times {
462 463
            let (lint, lvl, src) = self.lint_stack.pop();
            self.set_level(lint, lvl, src);
464
        }
465 466
    }

467
    fn add_lint(&mut self, v: visit::vt<@mut Context>) {
468
        self.visitors.push((v, item_stopping_visitor(v)));
469 470
    }

471
    fn process(@mut self, n: AttributedNode) {
472 473
        // see comment of the `visitors` field in the struct for why there's a
        // pair instead of just one visitor.
474
        match n {
475
            Item(it) => {
476 477
                for self.visitors.each |&(orig, stopping)| {
                    (orig.visit_item)(it, self, stopping);
478 479 480
                }
            }
            Crate(c) => {
481 482
                for self.visitors.each |&(_, stopping)| {
                    visit::visit_crate(c, self, stopping);
483 484
                }
            }
485 486 487
            // Can't use visit::visit_method_helper because the
            // item_stopping_visitor has overridden visit_fn(&fk_method(... ))
            // to be a no-op, so manually invoke visit_fn.
488 489
            Method(m) => {
                let fk = visit::fk_method(copy m.ident, &m.generics, m);
490 491 492
                for self.visitors.each |&(orig, stopping)| {
                    (orig.visit_fn)(&fk, &m.decl, &m.body, m.span, m.id,
                                    self, stopping);
493 494
                }
            }
495 496 497 498
        }
    }
}

499 500 501 502 503 504 505 506 507 508 509 510
pub fn each_lint(sess: session::Session,
                 attrs: &[ast::attribute],
                 f: &fn(@ast::meta_item, level, &~str) -> bool) -> bool
{
    for [allow, warn, deny, forbid].each |&level| {
        let level_name = level_to_str(level);
        let attrs = attr::find_attrs_by_name(attrs, level_name);
        for attrs.each |attr| {
            let meta = attr.node.value;
            let metas = match meta.node {
                ast::meta_list(_, ref metas) => metas,
                _ => {
511
                    sess.span_err(meta.span, "malformed lint attribute");
512 513 514 515 516 517 518 519 520 521 522
                    loop;
                }
            };
            for metas.each |meta| {
                match meta.node {
                    ast::meta_word(lintname) => {
                        if !f(*meta, level, lintname) {
                            return false;
                        }
                    }
                    _ => {
523
                        sess.span_err(meta.span, "malformed lint attribute");
524 525 526 527 528
                    }
                }
            }
        }
    }
529
    return true;
530 531
}

532 533 534 535
// Take a visitor, and modify it so that it will not proceed past subitems.
// This is used to make the simple visitors used for the lint passes
// not traverse into subitems, since that is handled by the outer
// lint visitor.
536
fn item_stopping_visitor<E: Copy>(outer: visit::vt<E>) -> visit::vt<E> {
537 538 539 540 541
    visit::mk_vt(@visit::Visitor {
        visit_item: |_i, _e, _v| { },
        visit_fn: |fk, fd, b, s, id, e, v| {
            match *fk {
                visit::fk_method(*) => {}
542
                _ => (outer.visit_fn)(fk, fd, b, s, id, e, v)
543 544
            }
        },
545
    .. **(ty_stopping_visitor(outer))})
546 547 548 549
}

fn ty_stopping_visitor<E>(v: visit::vt<E>) -> visit::vt<E> {
    visit::mk_vt(@visit::Visitor {visit_ty: |_t, _e, _v| { },.. **v})
550 551
}

552 553 554
fn lint_while_true() -> visit::vt<@mut Context> {
    visit::mk_vt(@visit::Visitor {
        visit_expr: |e, cx: @mut Context, vt| {
555 556 557 558 559 560 561 562 563
            match e.node {
                ast::expr_while(cond, _) => {
                    match cond.node {
                        ast::expr_lit(@codemap::spanned {
                            node: ast::lit_bool(true), _}) =>
                        {
                            cx.span_lint(while_true, e.span,
                                         "denote infinite loops with \
                                          loop { ... }");
564
                        }
565
                        _ => ()
566 567
                    }
                }
568 569
                _ => ()
            }
570
            visit::visit_expr(e, cx, vt);
571
        },
572
        .. *visit::default_visitor()
573
    })
V
Viktor Dahl 已提交
574 575
}

576
fn lint_type_limits() -> visit::vt<@mut Context> {
577
    fn is_valid<T:cmp::Ord>(binop: ast::binop, v: T,
578 579 580 581 582 583 584
            min: T, max: T) -> bool {
        match binop {
            ast::lt => v <= max,
            ast::le => v < max,
            ast::gt => v >= min,
            ast::ge => v > min,
            ast::eq | ast::ne => v >= min && v <= max,
585
            _ => fail!()
586 587 588
        }
    }

589
    fn rev_binop(binop: ast::binop) -> ast::binop {
590 591 592 593 594 595 596 597 598
        match binop {
            ast::lt => ast::gt,
            ast::le => ast::ge,
            ast::gt => ast::lt,
            ast::ge => ast::le,
            _ => binop
        }
    }

599 600
    // for int & uint, be conservative with the warnings, so that the
    // warnings are consistent between 32- and 64-bit platforms
601
    fn int_ty_range(int_ty: ast::int_ty) -> (i64, i64) {
602
        match int_ty {
603
            ast::ty_i =>    (i64::min_value,        i64::max_value),
604 605 606 607 608 609 610 611
            ast::ty_char => (u32::min_value as i64, u32::max_value as i64),
            ast::ty_i8 =>   (i8::min_value  as i64, i8::max_value  as i64),
            ast::ty_i16 =>  (i16::min_value as i64, i16::max_value as i64),
            ast::ty_i32 =>  (i32::min_value as i64, i32::max_value as i64),
            ast::ty_i64 =>  (i64::min_value,        i64::max_value)
        }
    }

612
    fn uint_ty_range(uint_ty: ast::uint_ty) -> (u64, u64) {
613
        match uint_ty {
614
            ast::ty_u =>   (u64::min_value,         u64::max_value),
615 616 617 618 619 620 621
            ast::ty_u8 =>  (u8::min_value   as u64, u8::max_value   as u64),
            ast::ty_u16 => (u16::min_value  as u64, u16::max_value  as u64),
            ast::ty_u32 => (u32::min_value  as u64, u32::max_value  as u64),
            ast::ty_u64 => (u64::min_value,         u64::max_value)
        }
    }

622
    fn check_limits(cx: &Context, binop: ast::binop, l: &ast::expr,
623
                    r: &ast::expr) -> bool {
624 625 626
        let (lit, expr, swap) = match (&l.node, &r.node) {
            (&ast::expr_lit(_), _) => (l, r, true),
            (_, &ast::expr_lit(_)) => (r, l, false),
627 628 629 630
            _ => return true
        };
        // Normalize the binop so that the literal is always on the RHS in
        // the comparison
631
        let norm_binop = if swap {
632 633 634 635
            rev_binop(binop)
        } else {
            binop
        };
636
        match ty::get(ty::expr_ty(cx.tcx, @/*bad*/copy *expr)).sty {
637 638 639 640 641 642 643 644 645
            ty::ty_int(int_ty) => {
                let (min, max) = int_ty_range(int_ty);
                let lit_val: i64 = match lit.node {
                    ast::expr_lit(@li) => match li.node {
                        ast::lit_int(v, _) => v,
                        ast::lit_uint(v, _) => v as i64,
                        ast::lit_int_unsuffixed(v) => v,
                        _ => return true
                    },
646
                    _ => fail!()
647 648 649 650 651 652 653 654 655 656 657 658
                };
                is_valid(norm_binop, lit_val, min, max)
            }
            ty::ty_uint(uint_ty) => {
                let (min, max): (u64, u64) = uint_ty_range(uint_ty);
                let lit_val: u64 = match lit.node {
                    ast::expr_lit(@li) => match li.node {
                        ast::lit_int(v, _) => v as u64,
                        ast::lit_uint(v, _) => v,
                        ast::lit_int_unsuffixed(v) => v as u64,
                        _ => return true
                    },
659
                    _ => fail!()
660 661 662 663 664 665 666
                };
                is_valid(norm_binop, lit_val, min, max)
            }
            _ => true
        }
    }

667
    fn is_comparison(binop: ast::binop) -> bool {
668 669 670 671 672 673 674
        match binop {
            ast::eq | ast::lt | ast::le |
            ast::ne | ast::ge | ast::gt => true,
            _ => false
        }
    }

675 676 677
    visit::mk_vt(@visit::Visitor {
        visit_expr: |e, cx: @mut Context, vt| {
            match e.node {
678
                ast::expr_binary(_, ref binop, @ref l, @ref r) => {
679 680 681 682 683
                    if is_comparison(*binop)
                        && !check_limits(cx, *binop, l, r) {
                        cx.span_lint(type_limits, e.span,
                                     "comparison is useless due to type limits");
                    }
684
                }
685
                _ => ()
686
            }
687 688
            visit::visit_expr(e, cx, vt);
        },
689

690
        .. *visit::default_visitor()
691
    })
692 693
}

694
fn check_item_default_methods(cx: &Context, item: @ast::item) {
695 696
    match item.node {
        ast::item_trait(_, _, ref methods) => {
697 698 699 700
            for methods.each |method| {
                match *method {
                    ast::required(*) => {}
                    ast::provided(*) => {
701 702
                        cx.span_lint(default_methods, item.span,
                                     "default methods are experimental");
703 704 705 706 707 708 709 710
                    }
                }
            }
        }
        _ => {}
    }
}

711
fn check_item_ctypes(cx: &Context, it: @ast::item) {
712

713
    fn check_foreign_fn(cx: &Context, decl: &ast::fn_decl) {
B
Brian Anderson 已提交
714
        let tys = vec::map(decl.inputs, |a| a.ty );
715
        for vec::each(vec::append_one(tys, decl.output)) |ty| {
716
            match ty.node {
B
Brian Anderson 已提交
717
              ast::ty_path(_, id) => {
718
                match cx.tcx.def_map.get_copy(&id) {
B
Brian Anderson 已提交
719
                  ast::def_prim_ty(ast::ty_int(ast::ty_i)) => {
720
                    cx.span_lint(ctypes, ty.span,
S
Seo Sanghyeon 已提交
721
                        "found rust type `int` in foreign module, while \
722
                         libc::c_int or libc::c_long should be used");
723
                  }
B
Brian Anderson 已提交
724
                  ast::def_prim_ty(ast::ty_uint(ast::ty_u)) => {
725
                    cx.span_lint(ctypes, ty.span,
S
Seo Sanghyeon 已提交
726
                        "found rust type `uint` in foreign module, while \
727
                         libc::c_uint or libc::c_ulong should be used");
728
                  }
B
Brian Anderson 已提交
729
                  _ => ()
730
                }
731
              }
B
Brian Anderson 已提交
732
              _ => ()
733 734 735 736
            }
        }
    }

737
    match it.node {
738
      ast::item_foreign_mod(ref nmod) if !nmod.abis.is_intrinsic() => {
B
Brian Anderson 已提交
739
        for nmod.items.each |ni| {
740
            match ni.node {
741
              ast::foreign_item_fn(ref decl, _, _) => {
742
                check_foreign_fn(cx, decl);
743
              }
744 745
              // FIXME #4622: Not implemented.
              ast::foreign_item_const(*) => {}
746 747
            }
        }
748
      }
B
Brian Anderson 已提交
749
      _ => {/* nothing to do */ }
750 751
    }
}
752

753
fn check_type_for_lint(cx: &Context, lint: lint, span: span, ty: ty::t) {
754
    if cx.get_level(lint) == allow { return }
755

756 757 758 759 760 761 762 763 764 765
    let mut n_box = 0;
    let mut n_uniq = 0;
    ty::fold_ty(cx.tcx, ty, |t| {
        match ty::get(t).sty {
          ty::ty_box(_) => n_box += 1,
          ty::ty_uniq(_) => n_uniq += 1,
          _ => ()
        };
        t
    });
766

767 768 769 770 771
    if n_uniq > 0 && lint != managed_heap_memory {
        let s = ty_to_str(cx.tcx, ty);
        let m = ~"type uses owned (~ type) pointers: " + s;
        cx.span_lint(lint, span, m);
    }
772

773 774 775 776
    if n_box > 0 && lint != owned_heap_memory {
        let s = ty_to_str(cx.tcx, ty);
        let m = ~"type uses managed (@ type) pointers: " + s;
        cx.span_lint(lint, span, m);
777
    }
778
}
779

780
fn check_type(cx: &Context, span: span, ty: ty::t) {
781 782
    for [managed_heap_memory, owned_heap_memory, heap_memory].each |lint| {
        check_type_for_lint(cx, *lint, span, ty);
783
    }
784
}
785

786
fn check_item_heap(cx: &Context, it: @ast::item) {
787 788 789 790 791 792 793 794 795
    match it.node {
      ast::item_fn(*) |
      ast::item_ty(*) |
      ast::item_enum(*) |
      ast::item_struct(*) => check_type(cx, it.span,
                                        ty::node_id_to_type(cx.tcx,
                                                            it.id)),
      _ => ()
    }
796

797 798 799 800 801 802 803
    // If it's a struct, we also have to check the fields' types
    match it.node {
        ast::item_struct(struct_def, _) => {
            for struct_def.fields.each |struct_field| {
                check_type(cx, struct_field.span,
                           ty::node_id_to_type(cx.tcx,
                                               struct_field.node.id));
804 805 806 807
            }
        }
        _ => ()
    }
808
}
809

810 811 812
fn lint_heap() -> visit::vt<@mut Context> {
    visit::mk_vt(@visit::Visitor {
        visit_expr: |e, cx: @mut Context, vt| {
813 814
            let ty = ty::expr_ty(cx.tcx, e);
            check_type(cx, e.span, ty);
815
            visit::visit_expr(e, cx, vt);
816
        },
817
        .. *visit::default_visitor()
818
    })
819 820
}

821 822 823
fn lint_path_statement() -> visit::vt<@mut Context> {
    visit::mk_vt(@visit::Visitor {
        visit_stmt: |s, cx: @mut Context, vt| {
824 825 826 827 828 829 830
            match s.node {
                ast::stmt_semi(
                    @ast::expr { node: ast::expr_path(_), _ },
                    _
                ) => {
                    cx.span_lint(path_statement, s.span,
                                 "path statement with no effect");
831
                }
832 833
                _ => ()
            }
834
            visit::visit_stmt(s, cx, vt);
835
        },
836
        .. *visit::default_visitor()
837
    })
838 839
}

840
fn check_item_non_camel_case_types(cx: &Context, it: @ast::item) {
P
Paul Stansifer 已提交
841 842
    fn is_camel_case(cx: ty::ctxt, ident: ast::ident) -> bool {
        let ident = cx.sess.str_of(ident);
P
Patrick Walton 已提交
843
        assert!(!ident.is_empty());
844
        let ident = ident.trim_chars(&['_']);
845
        char::is_uppercase(ident.char_at(0)) &&
846 847 848
            !ident.contains_char('_')
    }

849
    fn check_case(cx: &Context, ident: ast::ident, span: span) {
850 851 852 853
        if !is_camel_case(cx.tcx, ident) {
            cx.span_lint(non_camel_case_types, span,
                         "type, variant, or trait should have \
                          a camel case identifier");
854 855 856
        }
    }

857
    match it.node {
E
Erick Tryzelaar 已提交
858 859
        ast::item_ty(*) | ast::item_struct(*) |
        ast::item_trait(*) => {
860
            check_case(cx, it.ident, it.span)
861
        }
E
Erick Tryzelaar 已提交
862
        ast::item_enum(ref enum_definition, _) => {
863
            check_case(cx, it.ident, it.span);
E
Erick Tryzelaar 已提交
864
            for enum_definition.variants.each |variant| {
865
                check_case(cx, variant.node.name, variant.span);
E
Erick Tryzelaar 已提交
866 867 868
            }
        }
        _ => ()
869 870 871
    }
}

872 873 874 875 876 877 878 879 880
fn lint_unused_unsafe() -> visit::vt<@mut Context> {
    visit::mk_vt(@visit::Visitor {
        visit_expr: |e, cx: @mut Context, vt| {
            match e.node {
                ast::expr_block(ref blk) if blk.node.rules == ast::unsafe_blk => {
                    if !cx.tcx.used_unsafe.contains(&blk.node.id) {
                        cx.span_lint(unused_unsafe, blk.span,
                                     "unnecessary `unsafe` block");
                    }
881
                }
882
                _ => ()
883
            }
884 885 886
            visit::visit_expr(e, cx, vt);
        },
        .. *visit::default_visitor()
887
    })
888 889
}

890 891
fn lint_unused_mut() -> visit::vt<@mut Context> {
    fn check_pat(cx: &Context, p: @ast::pat) {
892 893
        let mut used = false;
        let mut bindings = 0;
894 895
        do pat_util::pat_bindings(cx.tcx.def_map, p) |_, id, _, _| {
            used = used || cx.tcx.used_mut_nodes.contains(&id);
896 897 898 899
            bindings += 1;
        }
        if !used {
            let msg = if bindings == 1 {
S
Seo Sanghyeon 已提交
900
                "variable does not need to be mutable"
901
            } else {
S
Seo Sanghyeon 已提交
902
                "variables do not need to be mutable"
903
            };
904
            cx.span_lint(unused_mut, p.span, msg);
905
        }
906
    }
907

908
    fn visit_fn_decl(cx: &Context, fd: &ast::fn_decl) {
909 910
        for fd.inputs.each |arg| {
            if arg.is_mutbl {
911
                check_pat(cx, arg.pat);
912 913
            }
        }
914
    }
915

916 917
    visit::mk_vt(@visit::Visitor {
        visit_local: |l, cx: @mut Context, vt| {
918
            if l.node.is_mutbl {
919
                check_pat(cx, l.node.pat);
920
            }
921 922 923 924 925 926 927 928 929
            visit::visit_local(l, cx, vt);
        },
        visit_fn: |a, fd, b, c, d, cx, vt| {
            visit_fn_decl(cx, fd);
            visit::visit_fn(a, fd, b, c, d, cx, vt);
        },
        visit_ty_method: |tm, cx, vt| {
            visit_fn_decl(cx, &tm.decl);
            visit::visit_ty_method(tm, cx, vt);
930
        },
931 932 933 934 935
        visit_struct_method: |sm, cx, vt| {
            visit_fn_decl(cx, &sm.decl);
            visit::visit_struct_method(sm, cx, vt);
        },
        visit_trait_method: |tm, cx, vt| {
936
            match *tm {
937 938
                ast::required(ref tm) => visit_fn_decl(cx, &tm.decl),
                ast::provided(m) => visit_fn_decl(cx, &m.decl)
939
            }
940
            visit::visit_trait_method(tm, cx, vt);
941
        },
942
        .. *visit::default_visitor()
943
    })
944 945
}

946 947
fn lint_session() -> visit::vt<@mut Context> {
    ast_util::id_visitor(|id, cx: @mut Context| {
948 949 950 951 952
        match cx.tcx.sess.lints.pop(&id) {
            None => {},
            Some(l) => {
                do vec::consume(l) |_, (lint, span, msg)| {
                    cx.span_lint(lint, span, msg)
953
                }
954 955
            }
        }
956
    })
957 958
}

959
fn lint_unnecessary_allocations() -> visit::vt<@mut Context> {
960 961
    // Warn if string and vector literals with sigils are immediately borrowed.
    // Those can have the sigil removed.
962
    fn check(cx: &Context, e: @ast::expr) {
963 964 965 966 967 968 969 970 971 972 973 974 975 976
        match e.node {
            ast::expr_vstore(e2, ast::expr_vstore_uniq) |
            ast::expr_vstore(e2, ast::expr_vstore_box) => {
                match e2.node {
                    ast::expr_lit(@codemap::spanned{
                            node: ast::lit_str(*), _}) |
                    ast::expr_vec(*) => {}
                    _ => return
                }
            }

            _ => return
        }

977 978 979
        match cx.tcx.adjustments.find_copy(&e.id) {
            Some(@ty::AutoDerefRef(ty::AutoDerefRef {
                autoref: Some(ty::AutoBorrowVec(*)), _ })) => {
980 981 982 983 984 985 986 987 988
                cx.span_lint(unnecessary_allocation,
                             e.span, "unnecessary allocation, the sigil can be \
                                      removed");
            }

            _ => ()
        }
    }

989 990 991 992 993 994
    visit::mk_vt(@visit::Visitor {
        visit_expr: |e, cx: @mut Context, vt| {
            check(cx, e);
            visit::visit_expr(e, cx, vt);
        },
        .. *visit::default_visitor()
995 996 997
    })
}

998 999 1000
fn lint_missing_doc() -> visit::vt<@mut Context> {
    fn check_attrs(cx: @mut Context, attrs: &[ast::attribute],
                   sp: span, msg: &str) {
1001 1002 1003 1004 1005 1006 1007 1008 1009 1010
        // If we're building a test harness, then warning about documentation is
        // probably not really relevant right now
        if cx.tcx.sess.opts.test { return }
        // If we have doc(hidden), nothing to do
        if cx.doc_hidden { return }
        // If we're documented, nothing to do
        if attrs.any(|a| a.node.is_sugared_doc) { return }

        // otherwise, warn!
        cx.span_lint(missing_doc, sp, msg);
1011 1012
    }

1013
    visit::mk_vt(@visit::Visitor {
1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028
        visit_struct_method: |m, cx, vt| {
            if m.vis == ast::public {
                check_attrs(cx, m.attrs, m.span,
                            "missing documentation for a method");
            }
            visit::visit_struct_method(m, cx, vt);
        },

        visit_ty_method: |m, cx, vt| {
            // All ty_method objects are linted about because they're part of a
            // trait (no visibility)
            check_attrs(cx, m.attrs, m.span,
                        "missing documentation for a method");
            visit::visit_ty_method(m, cx, vt);
        },
1029

1030 1031 1032 1033 1034 1035 1036 1037 1038 1039
        visit_fn: |fk, d, b, sp, id, cx, vt| {
            // Only warn about explicitly public methods. Soon implicit
            // public-ness will hopefully be going away.
            match *fk {
                visit::fk_method(_, _, m) if m.vis == ast::public => {
                    // If we're in a trait implementation, no need to duplicate
                    // documentation
                    if !cx.in_trait_impl {
                        check_attrs(cx, m.attrs, sp,
                                    "missing documentation for a method");
1040 1041
                    }
                }
1042

1043 1044 1045
                _ => {}
            }
            visit::visit_fn(fk, d, b, sp, id, cx, vt);
1046 1047
        },

1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060
        visit_item: |it, cx, vt| {
            match it.node {
                // Go ahead and match the fields here instead of using
                // visit_struct_field while we have access to the enclosing
                // struct's visibility
                ast::item_struct(sdef, _) if it.vis == ast::public => {
                    check_attrs(cx, it.attrs, it.span,
                                "missing documentation for a struct");
                    for sdef.fields.each |field| {
                        match field.node.kind {
                            ast::named_field(_, vis) if vis != ast::private => {
                                check_attrs(cx, field.node.attrs, field.span,
                                            "missing documentation for a field");
1061
                            }
1062
                            ast::unnamed_field | ast::named_field(*) => {}
1063 1064 1065
                        }
                    }
                }
1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077

                ast::item_trait(*) if it.vis == ast::public => {
                    check_attrs(cx, it.attrs, it.span,
                                "missing documentation for a trait");
                }

                ast::item_fn(*) if it.vis == ast::public => {
                    check_attrs(cx, it.attrs, it.span,
                                "missing documentation for a function");
                }

                _ => {}
1078
            };
1079 1080

            visit::visit_item(it, cx, vt);
1081
        },
1082

1083
        .. *visit::default_visitor()
1084 1085 1086
    })
}

1087
pub fn check_crate(tcx: ty::ctxt, crate: @ast::crate) {
1088 1089 1090 1091 1092
    let cx = @mut Context {
        dict: @get_lint_dict(),
        curr: SmallIntMap::new(),
        tcx: tcx,
        lint_stack: ~[],
1093
        visitors: ~[],
1094
        in_trait_impl: false,
1095
        doc_hidden: false,
1096 1097 1098 1099
    };

    // Install defaults.
    for cx.dict.each_value |spec| {
1100
        cx.set_level(spec.lint, spec.default, Default);
1101 1102 1103 1104
    }

    // Install command-line options, overriding defaults.
    for tcx.sess.opts.lint_opts.each |&(lint, level)| {
1105
        cx.set_level(lint, level, CommandLine);
1106 1107
    }

1108
    // Register each of the lint passes with the context
1109 1110 1111 1112 1113 1114 1115 1116
    cx.add_lint(lint_while_true());
    cx.add_lint(lint_path_statement());
    cx.add_lint(lint_heap());
    cx.add_lint(lint_type_limits());
    cx.add_lint(lint_unused_unsafe());
    cx.add_lint(lint_unused_mut());
    cx.add_lint(lint_session());
    cx.add_lint(lint_unnecessary_allocations());
1117
    cx.add_lint(lint_missing_doc());
1118

1119
    // Actually perform the lint checks (iterating the ast)
1120
    do cx.with_lint_attrs(crate.node.attrs) {
1121
        cx.process(Crate(crate));
1122 1123

        visit::visit_crate(crate, cx, visit::mk_vt(@visit::Visitor {
1124 1125
            visit_item: |it, cx: @mut Context, vt| {
                do cx.with_lint_attrs(it.attrs) {
1126 1127 1128 1129 1130 1131
                    match it.node {
                        ast::item_impl(_, Some(*), _, _) => {
                            cx.in_trait_impl = true;
                        }
                        _ => {}
                    }
1132 1133 1134 1135 1136 1137 1138
                    check_item_ctypes(cx, it);
                    check_item_non_camel_case_types(cx, it);
                    check_item_default_methods(cx, it);
                    check_item_heap(cx, it);

                    cx.process(Item(it));
                    visit::visit_item(it, cx, vt);
1139
                    cx.in_trait_impl = false;
1140 1141
                }
            },
1142 1143 1144 1145
            visit_fn: |fk, decl, body, span, id, cx, vt| {
                match *fk {
                    visit::fk_method(_, _, m) => {
                        do cx.with_lint_attrs(m.attrs) {
1146
                            cx.process(Method(m));
1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158
                            visit::visit_fn(fk, decl, body, span, id, cx, vt);
                        }
                    }
                    _ => {
                        visit::visit_fn(fk, decl, body, span, id, cx, vt);
                    }
                }
            },
            .. *visit::default_visitor()
        }));
    }

1159 1160
    // If we missed any lints added to the session, then there's a bug somewhere
    // in the iteration code.
1161 1162 1163 1164 1165 1166 1167 1168 1169
    for tcx.sess.lints.each |_, v| {
        for v.each |t| {
            match *t {
                (lint, span, ref msg) =>
                    tcx.sess.span_bug(span, fmt!("unprocessed lint %?: %s",
                                                 lint, *msg))
            }
        }
    }
1170

1171
    tcx.sess.abort_if_errors();
1172
}