0f6a0b58f9
This commit performs another pass over the `std::char` module for stabilization.
Some minor cleanup is performed such as migrating documentation from libcore to
libunicode (where the `std`-facing trait resides) as well as a slight
reorganiation in libunicode itself. Otherwise, the stability modifications made
are:
* `char::from_digit` is now stable
* `CharExt::is_digit` is now stable
* `CharExt::to_digit` is now stable
* `CharExt::to_{lower,upper}case` are now stable after being modified to return
an iterator over characters. While the implementation today has not changed
this should allow us to implement the full set of case conversions in unicode
where some characters can map to multiple when doing an upper or lower case
mapping.
* `StrExt::to_{lower,upper}case` was added as unstable for a convenience of not
having to worry about characters expanding to more characters when you just
want the whole string to get into upper or lower case.
This is a breaking change due to the change in the signatures of the
`CharExt::to_{upper,lower}case` methods. Code can be updated to use functions
like `flat_map` or `collect` to handle the difference.
[breaking-change]
98 lines
3.8 KiB
Rust
98 lines
3.8 KiB
Rust
// Copyright 2012-2014 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 self::WhichLine::*;
|
|
|
|
use std::fs::File;
|
|
use std::io::BufReader;
|
|
use std::io::prelude::*;
|
|
use std::path::Path;
|
|
|
|
pub struct ExpectedError {
|
|
pub line: uint,
|
|
pub kind: String,
|
|
pub msg: String,
|
|
}
|
|
|
|
#[derive(PartialEq, Debug)]
|
|
enum WhichLine { ThisLine, FollowPrevious(uint), AdjustBackward(uint) }
|
|
|
|
/// Looks for either "//~| KIND MESSAGE" or "//~^^... KIND MESSAGE"
|
|
/// The former is a "follow" that inherits its target from the preceding line;
|
|
/// the latter is an "adjusts" that goes that many lines up.
|
|
///
|
|
/// Goal is to enable tests both like: //~^^^ ERROR go up three
|
|
/// and also //~^ ERROR message one for the preceding line, and
|
|
/// //~| ERROR message two for that same line.
|
|
// Load any test directives embedded in the file
|
|
pub fn load_errors(testfile: &Path) -> Vec<ExpectedError> {
|
|
let rdr = BufReader::new(File::open(testfile).unwrap());
|
|
|
|
// `last_nonfollow_error` tracks the most recently seen
|
|
// line with an error template that did not use the
|
|
// follow-syntax, "//~| ...".
|
|
//
|
|
// (pnkfelix could not find an easy way to compose Iterator::scan
|
|
// and Iterator::filter_map to pass along this information into
|
|
// `parse_expected`. So instead I am storing that state here and
|
|
// updating it in the map callback below.)
|
|
let mut last_nonfollow_error = None;
|
|
|
|
rdr.lines().enumerate().filter_map(|(line_no, ln)| {
|
|
parse_expected(last_nonfollow_error,
|
|
line_no + 1,
|
|
&ln.unwrap())
|
|
.map(|(which, error)| {
|
|
match which {
|
|
FollowPrevious(_) => {}
|
|
_ => last_nonfollow_error = Some(error.line),
|
|
}
|
|
error
|
|
})
|
|
}).collect()
|
|
}
|
|
|
|
fn parse_expected(last_nonfollow_error: Option<uint>,
|
|
line_num: uint,
|
|
line: &str) -> Option<(WhichLine, ExpectedError)> {
|
|
let start = match line.find("//~") { Some(i) => i, None => return None };
|
|
let (follow, adjusts) = if line.char_at(start + 3) == '|' {
|
|
(true, 0)
|
|
} else {
|
|
(false, line[start + 3..].chars().take_while(|c| *c == '^').count())
|
|
};
|
|
let kind_start = start + 3 + adjusts + (follow as usize);
|
|
let letters = line[kind_start..].chars();
|
|
let kind = letters.skip_while(|c| c.is_whitespace())
|
|
.take_while(|c| !c.is_whitespace())
|
|
.flat_map(|c| c.to_lowercase())
|
|
.collect::<String>();
|
|
let letters = line[kind_start..].chars();
|
|
let msg = letters.skip_while(|c| c.is_whitespace())
|
|
.skip_while(|c| !c.is_whitespace())
|
|
.collect::<String>().trim().to_string();
|
|
|
|
let (which, line) = if follow {
|
|
assert!(adjusts == 0, "use either //~| or //~^, not both.");
|
|
let line = last_nonfollow_error.unwrap_or_else(|| {
|
|
panic!("encountered //~| without preceding //~^ line.")
|
|
});
|
|
(FollowPrevious(line), line)
|
|
} else {
|
|
let which =
|
|
if adjusts > 0 { AdjustBackward(adjusts) } else { ThisLine };
|
|
let line = line_num - adjusts;
|
|
(which, line)
|
|
};
|
|
|
|
debug!("line={} which={:?} kind={:?} msg={:?}", line_num, which, kind, msg);
|
|
Some((which, ExpectedError { line: line,
|
|
kind: kind,
|
|
msg: msg, }))
|
|
}
|