about summary refs log tree commit diff
path: root/src/compiletest/errors.rs
blob: 9300cee432ff44a177e2e3c8b7a649294979ab95 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
// 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.

use std::io::{BufferedReader, File};

pub struct ExpectedError {
    pub line: uint,
    pub kind: ~str,
    pub msg: ~str,
}

// Load any test directives embedded in the file
pub fn load_errors(testfile: &Path) -> Vec<ExpectedError> {

    let mut error_patterns = Vec::new();
    let mut rdr = BufferedReader::new(File::open(testfile).unwrap());
    let mut line_num = 1u;
    for ln in rdr.lines() {
        error_patterns.push_all_move(parse_expected(line_num, ln.unwrap()));
        line_num += 1u;
    }
    return error_patterns;
}

fn parse_expected(line_num: uint, line: ~str) -> Vec<ExpectedError> {
    let line = line.trim();
    let error_tag = "//~".to_owned();
    let mut idx;
    match line.find_str(error_tag) {
      None => return Vec::new(),
      Some(nn) => { idx = (nn as uint) + error_tag.len(); }
    }

    // "//~^^^ kind msg" denotes a message expected
    // three lines above current line:
    let mut adjust_line = 0u;
    let len = line.len();
    while idx < len && line[idx] == ('^' as u8) {
        adjust_line += 1u;
        idx += 1u;
    }

    // Extract kind:
    while idx < len && line[idx] == (' ' as u8) { idx += 1u; }
    let start_kind = idx;
    while idx < len && line[idx] != (' ' as u8) { idx += 1u; }

    let kind = line.slice(start_kind, idx);
    let kind = kind.to_ascii().to_lower().into_str();

    // Extract msg:
    while idx < len && line[idx] == (' ' as u8) { idx += 1u; }
    let msg = line.slice(idx, len).to_owned();

    debug!("line={} kind={} msg={}", line_num - adjust_line, kind, msg);

    return vec!(ExpectedError{line: line_num - adjust_line, kind: kind,
                           msg: msg});
}