bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity

rollup merge of #17338 : nick29581/variants-namespace

Browse source
This commit is contained in:
Alex Crichton 2014-09-19 10:00:29 -07:00
commit 04f5fe5a08
72 changed files with 489 additions and 457 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/libcollections/string.rs
View file

@ -872,7 +872,7 @@ mod tests {
use {Mutable, MutableSeq}; use {Mutable, MutableSeq};
use str; use str;
use str::{Str, StrSlice, Owned, Slice}; use str::{Str, StrSlice, Owned};
use super::String; use super::String;
use vec::Vec; use vec::Vec;
@ -898,10 +898,10 @@ mod tests {
#[test] #[test]
fn test_from_utf8_lossy() { fn test_from_utf8_lossy() {
let xs = b"hello"; let xs = b"hello";
assert_eq!(String::from_utf8_lossy(xs), Slice("hello")); assert_eq!(String::from_utf8_lossy(xs), str::Slice("hello"));
let xs = "ศไทย中华Việt Nam".as_bytes(); let xs = "ศไทย中华Việt Nam".as_bytes();
assert_eq!(String::from_utf8_lossy(xs), Slice("ศไทย中华Việt Nam")); assert_eq!(String::from_utf8_lossy(xs), str::Slice("ศไทย中华Việt Nam"));
let xs = b"Hello\xC2 There\xFF Goodbye"; let xs = b"Hello\xC2 There\xFF Goodbye";
assert_eq!(String::from_utf8_lossy(xs), assert_eq!(String::from_utf8_lossy(xs),

37
src/libfmt_macros/lib.rs
View file

@ -23,6 +23,7 @@
use std::char; use std::char;
use std::str; use std::str;
use std::string;
/// A piece is a portion of the format string which represents the next part /// A piece is a portion of the format string which represents the next part
/// to emit. These are emitted as a stream by the `Parser` class. /// to emit. These are emitted as a stream by the `Parser` class.
@ -32,7 +33,7 @@ pub enum Piece<'a> {
String(&'a str), String(&'a str),
/// This describes that formatting should process the next argument (as /// This describes that formatting should process the next argument (as
/// specified inside) for emission. /// specified inside) for emission.
Argument(Argument<'a>), NextArgument(Argument<'a>),
} }
/// Representation of an argument specification. /// Representation of an argument specification.
@ -129,7 +130,7 @@ pub struct Parser<'a> {
input: &'a str, input: &'a str,
cur: str::CharOffsets<'a>, cur: str::CharOffsets<'a>,
/// Error messages accumulated during parsing /// Error messages accumulated during parsing
pub errors: Vec<String>, pub errors: Vec<string::String>,
} }
impl<'a> Iterator<Piece<'a>> for Parser<'a> { impl<'a> Iterator<Piece<'a>> for Parser<'a> {
@ -140,7 +141,7 @@ impl<'a> Iterator<Piece<'a>> for Parser<'a> {
if self.consume('{') { if self.consume('{') {
Some(String(self.string(pos + 1))) Some(String(self.string(pos + 1)))
} else { } else {
let ret = Some(Argument(self.argument())); let ret = Some(NextArgument(self.argument()));
self.must_consume('}'); self.must_consume('}');
ret ret
} }
@ -469,28 +470,28 @@ mod tests {
#[test] #[test]
fn format_nothing() { fn format_nothing() {
same("{}", [Argument(Argument { same("{}", [NextArgument(Argument {
position: ArgumentNext, position: ArgumentNext,
format: fmtdflt(), format: fmtdflt(),
})]); })]);
} }
#[test] #[test]
fn format_position() { fn format_position() {
same("{3}", [Argument(Argument { same("{3}", [NextArgument(Argument {
position: ArgumentIs(3), position: ArgumentIs(3),
format: fmtdflt(), format: fmtdflt(),
})]); })]);
} }
#[test] #[test]
fn format_position_nothing_else() { fn format_position_nothing_else() {
same("{3:}", [Argument(Argument { same("{3:}", [NextArgument(Argument {
position: ArgumentIs(3), position: ArgumentIs(3),
format: fmtdflt(), format: fmtdflt(),
})]); })]);
} }
#[test] #[test]
fn format_type() { fn format_type() {
same("{3:a}", [Argument(Argument { same("{3:a}", [NextArgument(Argument {
position: ArgumentIs(3), position: ArgumentIs(3),
format: FormatSpec { format: FormatSpec {
fill: None, fill: None,
@ -504,7 +505,7 @@ mod tests {
} }
#[test] #[test]
fn format_align_fill() { fn format_align_fill() {
same("{3:>}", [Argument(Argument { same("{3:>}", [NextArgument(Argument {
position: ArgumentIs(3), position: ArgumentIs(3),
format: FormatSpec { format: FormatSpec {
fill: None, fill: None,
@ -515,7 +516,7 @@ mod tests {
ty: "", ty: "",
}, },
})]); })]);
same("{3:0<}", [Argument(Argument { same("{3:0<}", [NextArgument(Argument {
position: ArgumentIs(3), position: ArgumentIs(3),
format: FormatSpec { format: FormatSpec {
fill: Some('0'), fill: Some('0'),
@ -526,7 +527,7 @@ mod tests {
ty: "", ty: "",
}, },
})]); })]);
same("{3:*<abcd}", [Argument(Argument { same("{3:*<abcd}", [NextArgument(Argument {
position: ArgumentIs(3), position: ArgumentIs(3),
format: FormatSpec { format: FormatSpec {
fill: Some('*'), fill: Some('*'),
@ -540,7 +541,7 @@ mod tests {
} }
#[test] #[test]
fn format_counts() { fn format_counts() {
same("{:10s}", [Argument(Argument { same("{:10s}", [NextArgument(Argument {
position: ArgumentNext, position: ArgumentNext,
format: FormatSpec { format: FormatSpec {
fill: None, fill: None,
@ -551,7 +552,7 @@ mod tests {
ty: "s", ty: "s",
}, },
})]); })]);
same("{:10$.10s}", [Argument(Argument { same("{:10$.10s}", [NextArgument(Argument {
position: ArgumentNext, position: ArgumentNext,
format: FormatSpec { format: FormatSpec {
fill: None, fill: None,
@ -562,7 +563,7 @@ mod tests {
ty: "s", ty: "s",
}, },
})]); })]);
same("{:.*s}", [Argument(Argument { same("{:.*s}", [NextArgument(Argument {
position: ArgumentNext, position: ArgumentNext,
format: FormatSpec { format: FormatSpec {
fill: None, fill: None,
@ -573,7 +574,7 @@ mod tests {
ty: "s", ty: "s",
}, },
})]); })]);
same("{:.10$s}", [Argument(Argument { same("{:.10$s}", [NextArgument(Argument {
position: ArgumentNext, position: ArgumentNext,
format: FormatSpec { format: FormatSpec {
fill: None, fill: None,
@ -584,7 +585,7 @@ mod tests {
ty: "s", ty: "s",
}, },
})]); })]);
same("{:a$.b$s}", [Argument(Argument { same("{:a$.b$s}", [NextArgument(Argument {
position: ArgumentNext, position: ArgumentNext,
format: FormatSpec { format: FormatSpec {
fill: None, fill: None,
@ -598,7 +599,7 @@ mod tests {
} }
#[test] #[test]
fn format_flags() { fn format_flags() {
same("{:-}", [Argument(Argument { same("{:-}", [NextArgument(Argument {
position: ArgumentNext, position: ArgumentNext,
format: FormatSpec { format: FormatSpec {
fill: None, fill: None,
@ -609,7 +610,7 @@ mod tests {
ty: "", ty: "",
}, },
})]); })]);
same("{:+#}", [Argument(Argument { same("{:+#}", [NextArgument(Argument {
position: ArgumentNext, position: ArgumentNext,
format: FormatSpec { format: FormatSpec {
fill: None, fill: None,
@ -623,7 +624,7 @@ mod tests {
} }
#[test] #[test]
fn format_mixture() { fn format_mixture() {
same("abcd {3:a} efg", [String("abcd "), Argument(Argument { same("abcd {3:a} efg", [String("abcd "), NextArgument(Argument {
position: ArgumentIs(3), position: ArgumentIs(3),
format: FormatSpec { format: FormatSpec {
fill: None, fill: None,

8
src/libnative/io/net.rs
View file

@ -37,7 +37,7 @@ pub fn ntohs(u: u16) -> u16 {
} }
enum InAddr { enum InAddr {
InAddr(libc::in_addr), In4Addr(libc::in_addr),
In6Addr(libc::in6_addr), In6Addr(libc::in6_addr),
} }
@ -48,7 +48,7 @@ fn ip_to_inaddr(ip: rtio::IpAddr) -> InAddr {
(b as u32 << 16) | (b as u32 << 16) |
(c as u32 << 8) | (c as u32 << 8) |
(d as u32 << 0); (d as u32 << 0);
InAddr(libc::in_addr { In4Addr(libc::in_addr {
s_addr: Int::from_be(ip) s_addr: Int::from_be(ip)
}) })
} }
@ -74,7 +74,7 @@ fn addr_to_sockaddr(addr: rtio::SocketAddr,
-> libc::socklen_t { -> libc::socklen_t {
unsafe { unsafe {
let len = match ip_to_inaddr(addr.ip) { let len = match ip_to_inaddr(addr.ip) {
InAddr(inaddr) => { In4Addr(inaddr) => {
let storage = storage as *mut _ as *mut libc::sockaddr_in; let storage = storage as *mut _ as *mut libc::sockaddr_in;
(*storage).sin_family = libc::AF_INET as libc::sa_family_t; (*storage).sin_family = libc::AF_INET as libc::sa_family_t;
(*storage).sin_port = htons(addr.port); (*storage).sin_port = htons(addr.port);
@ -723,7 +723,7 @@ impl UdpSocket {
pub fn set_membership(&mut self, addr: rtio::IpAddr, pub fn set_membership(&mut self, addr: rtio::IpAddr,
opt: libc::c_int) -> IoResult<()> { opt: libc::c_int) -> IoResult<()> {
match ip_to_inaddr(addr) { match ip_to_inaddr(addr) {
InAddr(addr) => { In4Addr(addr) => {
let mreq = libc::ip_mreq { let mreq = libc::ip_mreq {
imr_multiaddr: addr, imr_multiaddr: addr,
// interface == INADDR_ANY // interface == INADDR_ANY

62
src/libnum/bigint.rs
View file

@ -618,7 +618,7 @@ impl ToBigUint for BigInt {
fn to_biguint(&self) -> Option<BigUint> { fn to_biguint(&self) -> Option<BigUint> {
if self.sign == Plus { if self.sign == Plus {
Some(self.data.clone()) Some(self.data.clone())
} else if self.sign == Zero { } else if self.sign == NoSign {
Some(Zero::zero()) Some(Zero::zero())
} else { } else {
None None
@ -838,7 +838,7 @@ fn get_radix_base(radix: uint) -> (DoubleBigDigit, uint) {
/// A Sign is a `BigInt`'s composing element. /// A Sign is a `BigInt`'s composing element.
#[deriving(PartialEq, PartialOrd, Eq, Ord, Clone, Show)] #[deriving(PartialEq, PartialOrd, Eq, Ord, Clone, Show)]
pub enum Sign { Minus, Zero, Plus } pub enum Sign { Minus, NoSign, Plus }
impl Neg<Sign> for Sign { impl Neg<Sign> for Sign {
/// Negate Sign value. /// Negate Sign value.
@ -846,7 +846,7 @@ impl Neg<Sign> for Sign {
fn neg(&self) -> Sign { fn neg(&self) -> Sign {
match *self { match *self {
Minus => Plus, Minus => Plus,
Zero => Zero, NoSign => NoSign,
Plus => Minus Plus => Minus
} }
} }
@ -882,7 +882,7 @@ impl Ord for BigInt {
if scmp != Equal { return scmp; } if scmp != Equal { return scmp; }
match self.sign { match self.sign {
Zero => Equal, NoSign => Equal,
Plus => self.data.cmp(&other.data), Plus => self.data.cmp(&other.data),
Minus => other.data.cmp(&self.data), Minus => other.data.cmp(&self.data),
} }
@ -933,11 +933,11 @@ impl Shr<uint, BigInt> for BigInt {
impl Zero for BigInt { impl Zero for BigInt {
#[inline] #[inline]
fn zero() -> BigInt { fn zero() -> BigInt {
BigInt::from_biguint(Zero, Zero::zero()) BigInt::from_biguint(NoSign, Zero::zero())
} }
#[inline] #[inline]
fn is_zero(&self) -> bool { self.sign == Zero } fn is_zero(&self) -> bool { self.sign == NoSign }
} }
impl One for BigInt { impl One for BigInt {
@ -951,7 +951,7 @@ impl Signed for BigInt {
#[inline] #[inline]
fn abs(&self) -> BigInt { fn abs(&self) -> BigInt {
match self.sign { match self.sign {
Plus | Zero => self.clone(), Plus | NoSign => self.clone(),
Minus => BigInt::from_biguint(Plus, self.data.clone()) Minus => BigInt::from_biguint(Plus, self.data.clone())
} }
} }
@ -966,7 +966,7 @@ impl Signed for BigInt {
match self.sign { match self.sign {
Plus => BigInt::from_biguint(Plus, One::one()), Plus => BigInt::from_biguint(Plus, One::one()),
Minus => BigInt::from_biguint(Minus, One::one()), Minus => BigInt::from_biguint(Minus, One::one()),
Zero => Zero::zero(), NoSign => Zero::zero(),
} }
} }
@ -981,8 +981,8 @@ impl Add<BigInt, BigInt> for BigInt {
#[inline] #[inline]
fn add(&self, other: &BigInt) -> BigInt { fn add(&self, other: &BigInt) -> BigInt {
match (self.sign, other.sign) { match (self.sign, other.sign) {
(Zero, _) => other.clone(), (NoSign, _) => other.clone(),
(_, Zero) => self.clone(), (_, NoSign) => self.clone(),
(Plus, Plus) => BigInt::from_biguint(Plus, self.data + other.data), (Plus, Plus) => BigInt::from_biguint(Plus, self.data + other.data),
(Plus, Minus) => self - (-*other), (Plus, Minus) => self - (-*other),
(Minus, Plus) => other - (-*self), (Minus, Plus) => other - (-*self),
@ -995,8 +995,8 @@ impl Sub<BigInt, BigInt> for BigInt {
#[inline] #[inline]
fn sub(&self, other: &BigInt) -> BigInt { fn sub(&self, other: &BigInt) -> BigInt {
match (self.sign, other.sign) { match (self.sign, other.sign) {
(Zero, _) => -other, (NoSign, _) => -other,
(_, Zero) => self.clone(), (_, NoSign) => self.clone(),
(Plus, Plus) => match self.data.cmp(&other.data) { (Plus, Plus) => match self.data.cmp(&other.data) {
Less => BigInt::from_biguint(Minus, other.data - self.data), Less => BigInt::from_biguint(Minus, other.data - self.data),
Greater => BigInt::from_biguint(Plus, self.data - other.data), Greater => BigInt::from_biguint(Plus, self.data - other.data),
@ -1013,7 +1013,7 @@ impl Mul<BigInt, BigInt> for BigInt {
#[inline] #[inline]
fn mul(&self, other: &BigInt) -> BigInt { fn mul(&self, other: &BigInt) -> BigInt {
match (self.sign, other.sign) { match (self.sign, other.sign) {
(Zero, _) | (_, Zero) => Zero::zero(), (NoSign, _) | (_, NoSign) => Zero::zero(),
(Plus, Plus) | (Minus, Minus) => { (Plus, Plus) | (Minus, Minus) => {
BigInt::from_biguint(Plus, self.data * other.data) BigInt::from_biguint(Plus, self.data * other.data)
}, },
@ -1087,9 +1087,9 @@ impl Integer for BigInt {
let d = BigInt::from_biguint(Plus, d_ui); let d = BigInt::from_biguint(Plus, d_ui);
let r = BigInt::from_biguint(Plus, r_ui); let r = BigInt::from_biguint(Plus, r_ui);
match (self.sign, other.sign) { match (self.sign, other.sign) {
(_, Zero) => fail!(), (_, NoSign) => fail!(),
(Plus, Plus) | (Zero, Plus) => ( d, r), (Plus, Plus) | (NoSign, Plus) => ( d, r),
(Plus, Minus) | (Zero, Minus) => (-d, r), (Plus, Minus) | (NoSign, Minus) => (-d, r),
(Minus, Plus) => (-d, -r), (Minus, Plus) => (-d, -r),
(Minus, Minus) => ( d, -r) (Minus, Minus) => ( d, -r)
} }
@ -1113,9 +1113,9 @@ impl Integer for BigInt {
let d = BigInt::from_biguint(Plus, d_ui); let d = BigInt::from_biguint(Plus, d_ui);
let m = BigInt::from_biguint(Plus, m_ui); let m = BigInt::from_biguint(Plus, m_ui);
match (self.sign, other.sign) { match (self.sign, other.sign) {
(_, Zero) => fail!(), (_, NoSign) => fail!(),
(Plus, Plus) | (Zero, Plus) => (d, m), (Plus, Plus) | (NoSign, Plus) => (d, m),
(Plus, Minus) | (Zero, Minus) => if m.is_zero() { (Plus, Minus) | (NoSign, Minus) => if m.is_zero() {
(-d, Zero::zero()) (-d, Zero::zero())
} else { } else {
(-d - One::one(), m + *other) (-d - One::one(), m + *other)
@ -1166,7 +1166,7 @@ impl ToPrimitive for BigInt {
fn to_i64(&self) -> Option<i64> { fn to_i64(&self) -> Option<i64> {
match self.sign { match self.sign {
Plus => self.data.to_i64(), Plus => self.data.to_i64(),
Zero => Some(0), NoSign => Some(0),
Minus => { Minus => {
self.data.to_u64().and_then(|n| { self.data.to_u64().and_then(|n| {
let m: u64 = 1 << 63; let m: u64 = 1 << 63;
@ -1186,7 +1186,7 @@ impl ToPrimitive for BigInt {
fn to_u64(&self) -> Option<u64> { fn to_u64(&self) -> Option<u64> {
match self.sign { match self.sign {
Plus => self.data.to_u64(), Plus => self.data.to_u64(),
Zero => Some(0), NoSign => Some(0),
Minus => None Minus => None
} }
} }
@ -1272,7 +1272,7 @@ impl ToStrRadix for BigInt {
fn to_str_radix(&self, radix: uint) -> String { fn to_str_radix(&self, radix: uint) -> String {
match self.sign { match self.sign {
Plus => self.data.to_str_radix(radix), Plus => self.data.to_str_radix(radix),
Zero => "0".to_string(), NoSign => "0".to_string(),
Minus => format!("-{}", self.data.to_str_radix(radix)), Minus => format!("-{}", self.data.to_str_radix(radix)),
} }
} }
@ -1334,7 +1334,7 @@ impl<R: Rng> RandBigInt for R {
if self.gen() { if self.gen() {
return self.gen_bigint(bit_size); return self.gen_bigint(bit_size);
} else { } else {
Zero NoSign
} }
} else if self.gen() { } else if self.gen() {
Plus Plus
@ -1385,8 +1385,8 @@ impl BigInt {
/// The digits are be in base 2^32. /// The digits are be in base 2^32.
#[inline] #[inline]
pub fn from_biguint(sign: Sign, data: BigUint) -> BigInt { pub fn from_biguint(sign: Sign, data: BigUint) -> BigInt {
if sign == Zero || data.is_zero() { if sign == NoSign || data.is_zero() {
return BigInt { sign: Zero, data: Zero::zero() }; return BigInt { sign: NoSign, data: Zero::zero() };
} }
BigInt { sign: sign, data: data } BigInt { sign: sign, data: data }
} }
@ -1415,7 +1415,7 @@ impl BigInt {
pub fn to_biguint(&self) -> Option<BigUint> { pub fn to_biguint(&self) -> Option<BigUint> {
match self.sign { match self.sign {
Plus => Some(self.data.clone()), Plus => Some(self.data.clone()),
Zero => Some(Zero::zero()), NoSign => Some(Zero::zero()),
Minus => None Minus => None
} }
} }
@ -2288,7 +2288,7 @@ mod biguint_tests {
mod bigint_tests { mod bigint_tests {
use Integer; use Integer;
use super::{BigDigit, BigUint, ToBigUint}; use super::{BigDigit, BigUint, ToBigUint};
use super::{Sign, Minus, Zero, Plus, BigInt, RandBigInt, ToBigInt}; use super::{Sign, Minus, NoSign, Plus, BigInt, RandBigInt, ToBigInt};
use std::cmp::{Less, Equal, Greater}; use std::cmp::{Less, Equal, Greater};
use std::i64; use std::i64;
@ -2307,9 +2307,9 @@ mod bigint_tests {
assert_eq!(inp, ans); assert_eq!(inp, ans);
} }
check(Plus, 1, Plus, 1); check(Plus, 1, Plus, 1);
check(Plus, 0, Zero, 0); check(Plus, 0, NoSign, 0);
check(Minus, 1, Minus, 1); check(Minus, 1, Minus, 1);
check(Zero, 1, Zero, 0); check(NoSign, 1, NoSign, 0);
} }
#[test] #[test]
@ -2357,8 +2357,8 @@ mod bigint_tests {
#[test] #[test]
fn test_hash() { fn test_hash() {
let a = BigInt::new(Zero, vec!()); let a = BigInt::new(NoSign, vec!());
let b = BigInt::new(Zero, vec!(0)); let b = BigInt::new(NoSign, vec!(0));
let c = BigInt::new(Plus, vec!(1)); let c = BigInt::new(Plus, vec!(1));
let d = BigInt::new(Plus, vec!(1,0,0,0,0,0)); let d = BigInt::new(Plus, vec!(1,0,0,0,0,0));
let e = BigInt::new(Plus, vec!(0,0,0,0,0,1)); let e = BigInt::new(Plus, vec!(0,0,0,0,0,1));

4
src/libregex/compile.rs
View file

@ -16,7 +16,7 @@ use std::cmp;
use parse; use parse;
use parse::{ use parse::{
Flags, FLAG_EMPTY, Flags, FLAG_EMPTY,
Nothing, Literal, Dot, Class, Begin, End, WordBoundary, Capture, Cat, Alt, Nothing, Literal, Dot, AstClass, Begin, End, WordBoundary, Capture, Cat, Alt,
Rep, Rep,
ZeroOne, ZeroMore, OneMore, ZeroOne, ZeroMore, OneMore,
}; };
@ -148,7 +148,7 @@ impl<'r> Compiler<'r> {
Nothing => {}, Nothing => {},
Literal(c, flags) => self.push(OneChar(c, flags)), Literal(c, flags) => self.push(OneChar(c, flags)),
Dot(nl) => self.push(Any(nl)), Dot(nl) => self.push(Any(nl)),
Class(ranges, flags) => AstClass(ranges, flags) =>
self.push(CharClass(ranges, flags)), self.push(CharClass(ranges, flags)),
Begin(flags) => self.push(EmptyBegin(flags)), Begin(flags) => self.push(EmptyBegin(flags)),
End(flags) => self.push(EmptyEnd(flags)), End(flags) => self.push(EmptyEnd(flags)),

2
src/libregex/lib.rs
View file

@ -425,7 +425,7 @@ pub mod native {
FLAG_EMPTY, FLAG_NOCASE, FLAG_MULTI, FLAG_DOTNL, FLAG_EMPTY, FLAG_NOCASE, FLAG_MULTI, FLAG_DOTNL,
FLAG_SWAP_GREED, FLAG_NEGATED, FLAG_SWAP_GREED, FLAG_NEGATED,
}; };
pub use re::{Dynamic, Native}; pub use re::{Dynamic, ExDynamic, Native, ExNative};
pub use vm::{ pub use vm::{
MatchKind, Exists, Location, Submatches, MatchKind, Exists, Location, Submatches,
StepState, StepMatchEarlyReturn, StepMatch, StepContinue, StepState, StepMatchEarlyReturn, StepMatch, StepContinue,

26
src/libregex/parse.rs
View file

@ -53,7 +53,7 @@ pub enum Ast {
Nothing, Nothing,
Literal(char, Flags), Literal(char, Flags),
Dot(Flags), Dot(Flags),
Class(Vec<(char, char)>, Flags), AstClass(Vec<(char, char)>, Flags),
Begin(Flags), Begin(Flags),
End(Flags), End(Flags),
WordBoundary(Flags), WordBoundary(Flags),
@ -101,7 +101,7 @@ impl Greed {
/// state. /// state.
#[deriving(Show)] #[deriving(Show)]
enum BuildAst { enum BuildAst {
Ast(Ast), Expr(Ast),
Paren(Flags, uint, String), // '(' Paren(Flags, uint, String), // '('
Bar, // '|' Bar, // '|'
} }
@ -152,7 +152,7 @@ impl BuildAst {
fn unwrap(self) -> Result<Ast, Error> { fn unwrap(self) -> Result<Ast, Error> {
match self { match self {
Ast(x) => Ok(x), Expr(x) => Ok(x),
_ => fail!("Tried to unwrap non-AST item: {}", self), _ => fail!("Tried to unwrap non-AST item: {}", self),
} }
} }
@ -311,7 +311,7 @@ impl<'a> Parser<'a> {
} }
fn push(&mut self, ast: Ast) { fn push(&mut self, ast: Ast) {
self.stack.push(Ast(ast)) self.stack.push(Expr(ast))
} }
fn push_repeater(&mut self, c: char) -> Result<(), Error> { fn push_repeater(&mut self, c: char) -> Result<(), Error> {
@ -388,8 +388,8 @@ impl<'a> Parser<'a> {
match c { match c {
'[' => '[' =>
match self.try_parse_ascii() { match self.try_parse_ascii() {
Some(Class(asciis, flags)) => { Some(AstClass(asciis, flags)) => {
alts.push(Class(asciis, flags ^ negated)); alts.push(AstClass(asciis, flags ^ negated));
continue continue
} }
Some(ast) => Some(ast) =>
@ -399,8 +399,8 @@ impl<'a> Parser<'a> {
}, },
'\\' => { '\\' => {
match try!(self.parse_escape()) { match try!(self.parse_escape()) {
Class(asciis, flags) => { AstClass(asciis, flags) => {
alts.push(Class(asciis, flags ^ negated)); alts.push(AstClass(asciis, flags ^ negated));
continue continue
} }
Literal(c2, _) => c = c2, // process below Literal(c2, _) => c = c2, // process below
@ -417,7 +417,7 @@ impl<'a> Parser<'a> {
']' => { ']' => {
if ranges.len() > 0 { if ranges.len() > 0 {
let flags = negated | (self.flags & FLAG_NOCASE); let flags = negated | (self.flags & FLAG_NOCASE);
let mut ast = Class(combine_ranges(ranges), flags); let mut ast = AstClass(combine_ranges(ranges), flags);
for alt in alts.into_iter() { for alt in alts.into_iter() {
ast = Alt(box alt, box ast) ast = Alt(box alt, box ast)
} }
@ -485,7 +485,7 @@ impl<'a> Parser<'a> {
Some(ranges) => { Some(ranges) => {
self.chari = closer; self.chari = closer;
let flags = negated | (self.flags & FLAG_NOCASE); let flags = negated | (self.flags & FLAG_NOCASE);
Some(Class(combine_ranges(ranges), flags)) Some(AstClass(combine_ranges(ranges), flags))
} }
} }
} }
@ -611,7 +611,7 @@ impl<'a> Parser<'a> {
let ranges = perl_unicode_class(c); let ranges = perl_unicode_class(c);
let mut flags = self.flags & FLAG_NOCASE; let mut flags = self.flags & FLAG_NOCASE;
if c.is_uppercase() { flags |= FLAG_NEGATED } if c.is_uppercase() { flags |= FLAG_NEGATED }
Ok(Class(ranges, flags)) Ok(AstClass(ranges, flags))
} }
_ => { _ => {
self.err(format!("Invalid escape sequence '\\\\{}'", self.err(format!("Invalid escape sequence '\\\\{}'",
@ -655,7 +655,7 @@ impl<'a> Parser<'a> {
name).as_slice()) name).as_slice())
} }
Some(ranges) => { Some(ranges) => {
Ok(Class(ranges, negated | (self.flags & FLAG_NOCASE))) Ok(AstClass(ranges, negated | (self.flags & FLAG_NOCASE)))
} }
} }
} }
@ -888,7 +888,7 @@ impl<'a> Parser<'a> {
while i > from { while i > from {
i = i - 1; i = i - 1;
match self.stack.pop().unwrap() { match self.stack.pop().unwrap() {
Ast(x) => combined = mk(x, combined), Expr(x) => combined = mk(x, combined),
_ => {}, _ => {},
} }
} }

22
src/libregex/re.rs
View file

@ -110,14 +110,14 @@ pub enum Regex {
// See the comments for the `program` module in `lib.rs` for a more // See the comments for the `program` module in `lib.rs` for a more
// detailed explanation for what `regex!` requires. // detailed explanation for what `regex!` requires.
#[doc(hidden)] #[doc(hidden)]
Dynamic(Dynamic), Dynamic(ExDynamic),
#[doc(hidden)] #[doc(hidden)]
Native(Native), Native(ExNative),
} }
#[deriving(Clone)] #[deriving(Clone)]
#[doc(hidden)] #[doc(hidden)]
pub struct Dynamic { pub struct ExDynamic {
original: String, original: String,
names: Vec<Option<String>>, names: Vec<Option<String>>,
#[doc(hidden)] #[doc(hidden)]
@ -125,7 +125,7 @@ pub struct Dynamic {
} }
#[doc(hidden)] #[doc(hidden)]
pub struct Native { pub struct ExNative {
#[doc(hidden)] #[doc(hidden)]
pub original: &'static str, pub original: &'static str,
#[doc(hidden)] #[doc(hidden)]
@ -134,8 +134,8 @@ pub struct Native {
pub prog: fn(MatchKind, &str, uint, uint) -> Vec<Option<uint>> pub prog: fn(MatchKind, &str, uint, uint) -> Vec<Option<uint>>
} }
impl Clone for Native { impl Clone for ExNative {
fn clone(&self) -> Native { *self } fn clone(&self) -> ExNative { *self }
} }
impl fmt::Show for Regex { impl fmt::Show for Regex {
@ -156,7 +156,7 @@ impl Regex {
pub fn new(re: &str) -> Result<Regex, parse::Error> { pub fn new(re: &str) -> Result<Regex, parse::Error> {
let ast = try!(parse::parse(re)); let ast = try!(parse::parse(re));
let (prog, names) = Program::new(ast); let (prog, names) = Program::new(ast);
Ok(Dynamic(Dynamic { Ok(Dynamic(ExDynamic {
original: re.to_string(), original: re.to_string(),
names: names, names: names,
prog: prog, prog: prog,
@ -510,8 +510,8 @@ impl Regex {
/// Returns the original string of this regex. /// Returns the original string of this regex.
pub fn as_str<'a>(&'a self) -> &'a str { pub fn as_str<'a>(&'a self) -> &'a str {
match *self { match *self {
Dynamic(Dynamic { ref original, .. }) => original.as_slice(), Dynamic(ExDynamic { ref original, .. }) => original.as_slice(),
Native(Native { ref original, .. }) => original.as_slice(), Native(ExNative { ref original, .. }) => original.as_slice(),
} }
} }
@ -915,8 +915,8 @@ fn exec(re: &Regex, which: MatchKind, input: &str) -> CaptureLocs {
fn exec_slice(re: &Regex, which: MatchKind, fn exec_slice(re: &Regex, which: MatchKind,
input: &str, s: uint, e: uint) -> CaptureLocs { input: &str, s: uint, e: uint) -> CaptureLocs {
match *re { match *re {
Dynamic(Dynamic { ref prog, .. }) => vm::run(which, prog, input, s, e), Dynamic(ExDynamic { ref prog, .. }) => vm::run(which, prog, input, s, e),
Native(Native { prog, .. }) => prog(which, input, s, e), Native(ExNative { prog, .. }) => prog(which, input, s, e),
} }
} }

6
src/libregex_macros/lib.rs
View file

@ -42,7 +42,7 @@ use regex::Regex;
use regex::native::{ use regex::native::{
OneChar, CharClass, Any, Save, Jump, Split, OneChar, CharClass, Any, Save, Jump, Split,
Match, EmptyBegin, EmptyEnd, EmptyWordBoundary, Match, EmptyBegin, EmptyEnd, EmptyWordBoundary,
Program, Dynamic, Native, Program, Dynamic, ExDynamic, Native,
FLAG_NOCASE, FLAG_MULTI, FLAG_DOTNL, FLAG_NEGATED, FLAG_NOCASE, FLAG_MULTI, FLAG_DOTNL, FLAG_NEGATED,
}; };
@ -91,7 +91,7 @@ fn native(cx: &mut ExtCtxt, sp: codemap::Span, tts: &[ast::TokenTree])
} }
}; };
let prog = match re { let prog = match re {
Dynamic(Dynamic { ref prog, .. }) => prog.clone(), Dynamic(ExDynamic { ref prog, .. }) => prog.clone(),
Native(_) => unreachable!(), Native(_) => unreachable!(),
}; };
@ -322,7 +322,7 @@ fn exec<'t>(which: ::regex::native::MatchKind, input: &'t str,
} }
} }
::regex::native::Native(::regex::native::Native { ::regex::native::Native(::regex::native::ExNative {
original: $regex, original: $regex,
names: CAP_NAMES, names: CAP_NAMES,
prog: exec, prog: exec,

8
src/librustc/back/write.rs
View file

@ -11,7 +11,7 @@
use back::lto; use back::lto;
use back::link::{get_cc_prog, remove}; use back::link::{get_cc_prog, remove};
use driver::driver::{CrateTranslation, ModuleTranslation, OutputFilenames}; use driver::driver::{CrateTranslation, ModuleTranslation, OutputFilenames};
use driver::config::{NoDebugInfo, Passes, AllPasses}; use driver::config::{NoDebugInfo, Passes, SomePasses, AllPasses};
use driver::session::Session; use driver::session::Session;
use driver::config; use driver::config;
use llvm; use llvm;
@ -341,7 +341,7 @@ unsafe extern "C" fn diagnostic_handler(info: DiagnosticInfoRef, user: *mut c_vo
let pass_name = pass_name.as_str().expect("got a non-UTF8 pass name from LLVM"); let pass_name = pass_name.as_str().expect("got a non-UTF8 pass name from LLVM");
let enabled = match cgcx.remark { let enabled = match cgcx.remark {
AllPasses => true, AllPasses => true,
Passes(ref v) => v.iter().any(|s| s.as_slice() == pass_name), SomePasses(ref v) => v.iter().any(|s| s.as_slice() == pass_name),
}; };
if enabled { if enabled {
@ -482,14 +482,14 @@ unsafe fn optimize_and_codegen(cgcx: &CodegenContext,
if config.emit_asm { if config.emit_asm {
let path = output_names.with_extension(format!("{}.s", name_extra).as_slice()); let path = output_names.with_extension(format!("{}.s", name_extra).as_slice());
with_codegen(tm, llmod, config.no_builtins, |cpm| { with_codegen(tm, llmod, config.no_builtins, |cpm| {
write_output_file(cgcx.handler, tm, cpm, llmod, &path, llvm::AssemblyFile); write_output_file(cgcx.handler, tm, cpm, llmod, &path, llvm::AssemblyFileType);
}); });
} }
if config.emit_obj { if config.emit_obj {
let path = output_names.with_extension(format!("{}.o", name_extra).as_slice()); let path = output_names.with_extension(format!("{}.o", name_extra).as_slice());
with_codegen(tm, llmod, config.no_builtins, |cpm| { with_codegen(tm, llmod, config.no_builtins, |cpm| {
write_output_file(cgcx.handler, tm, cpm, llmod, &path, llvm::ObjectFile); write_output_file(cgcx.handler, tm, cpm, llmod, &path, llvm::ObjectFileType);
}); });
} }
}); });

10
src/librustc/driver/config.rs
View file

@ -237,14 +237,14 @@ pub fn debugging_opts_map() -> Vec<(&'static str, &'static str, u64)> {
#[deriving(Clone)] #[deriving(Clone)]
pub enum Passes { pub enum Passes {
Passes(Vec<String>), SomePasses(Vec<String>),
AllPasses, AllPasses,
} }
impl Passes { impl Passes {
pub fn is_empty(&self) -> bool { pub fn is_empty(&self) -> bool {
match *self { match *self {
Passes(ref v) => v.is_empty(), SomePasses(ref v) => v.is_empty(),
AllPasses => false, AllPasses => false,
} }
} }
@ -276,7 +276,7 @@ macro_rules! cgoptions(
&[ $( (stringify!($opt), cgsetters::$opt, $desc) ),* ]; &[ $( (stringify!($opt), cgsetters::$opt, $desc) ),* ];
mod cgsetters { mod cgsetters {
use super::{CodegenOptions, Passes, AllPasses}; use super::{CodegenOptions, Passes, SomePasses, AllPasses};
$( $(
pub fn $opt(cg: &mut CodegenOptions, v: Option<&str>) -> bool { pub fn $opt(cg: &mut CodegenOptions, v: Option<&str>) -> bool {
@ -335,7 +335,7 @@ macro_rules! cgoptions(
v => { v => {
let mut passes = vec!(); let mut passes = vec!();
if parse_list(&mut passes, v) { if parse_list(&mut passes, v) {
*slot = Passes(passes); *slot = SomePasses(passes);
true true
} else { } else {
false false
@ -389,7 +389,7 @@ cgoptions!(
"extra data to put in each output filename"), "extra data to put in each output filename"),
codegen_units: uint = (1, parse_uint, codegen_units: uint = (1, parse_uint,
"divide crate into N units to optimize in parallel"), "divide crate into N units to optimize in parallel"),
remark: Passes = (Passes(Vec::new()), parse_passes, remark: Passes = (SomePasses(Vec::new()), parse_passes,
"print remarks for these optimization passes (space separated, or \"all\")"), "print remarks for these optimization passes (space separated, or \"all\")"),
) )

6
src/librustc/lint/builtin.rs
View file

@ -1296,7 +1296,7 @@ impl LintPass for UnnecessaryAllocation {
match cx.tcx.adjustments.borrow().find(&e.id) { match cx.tcx.adjustments.borrow().find(&e.id) {
Some(adjustment) => { Some(adjustment) => {
match *adjustment { match *adjustment {
ty::AutoDerefRef(ty::AutoDerefRef { ref autoref, .. }) => { ty::AdjustDerefRef(ty::AutoDerefRef { ref autoref, .. }) => {
match (allocation, autoref) { match (allocation, autoref) {
(VectorAllocation, &Some(ty::AutoPtr(_, _, None))) => { (VectorAllocation, &Some(ty::AutoPtr(_, _, None))) => {
cx.span_lint(UNNECESSARY_ALLOCATION, e.span, cx.span_lint(UNNECESSARY_ALLOCATION, e.span,
@ -1511,12 +1511,12 @@ impl LintPass for Stability {
typeck::MethodStaticUnboxedClosure(def_id) => { typeck::MethodStaticUnboxedClosure(def_id) => {
def_id def_id
} }
typeck::MethodParam(typeck::MethodParam { typeck::MethodTypeParam(typeck::MethodParam {
trait_ref: ref trait_ref, trait_ref: ref trait_ref,
method_num: index, method_num: index,
.. ..
}) | }) |
typeck::MethodObject(typeck::MethodObject { typeck::MethodTraitObject(typeck::MethodObject {
trait_ref: ref trait_ref, trait_ref: ref trait_ref,
method_num: index, method_num: index,
.. ..

36
src/librustc/middle/astencode.rs
View file

@ -641,8 +641,8 @@ impl tr for MethodOrigin {
typeck::MethodStaticUnboxedClosure(did) => { typeck::MethodStaticUnboxedClosure(did) => {
typeck::MethodStaticUnboxedClosure(did.tr(dcx)) typeck::MethodStaticUnboxedClosure(did.tr(dcx))
} }
typeck::MethodParam(ref mp) => { typeck::MethodTypeParam(ref mp) => {
typeck::MethodParam( typeck::MethodTypeParam(
typeck::MethodParam { typeck::MethodParam {
// def-id is already translated when we read it out // def-id is already translated when we read it out
trait_ref: mp.trait_ref.clone(), trait_ref: mp.trait_ref.clone(),
@ -650,8 +650,8 @@ impl tr for MethodOrigin {
} }
) )
} }
typeck::MethodObject(ref mo) => { typeck::MethodTraitObject(ref mo) => {
typeck::MethodObject( typeck::MethodTraitObject(
typeck::MethodObject { typeck::MethodObject {
trait_ref: mo.trait_ref.clone(), trait_ref: mo.trait_ref.clone(),
.. *mo .. *mo
@ -957,8 +957,8 @@ impl<'a> rbml_writer_helpers for Encoder<'a> {
}) })
} }
typeck::MethodParam(ref p) => { typeck::MethodTypeParam(ref p) => {
this.emit_enum_variant("MethodParam", 2, 1, |this| { this.emit_enum_variant("MethodTypeParam", 2, 1, |this| {
this.emit_struct("MethodParam", 2, |this| { this.emit_struct("MethodParam", 2, |this| {
try!(this.emit_struct_field("trait_ref", 0, |this| { try!(this.emit_struct_field("trait_ref", 0, |this| {
Ok(this.emit_trait_ref(ecx, &*p.trait_ref)) Ok(this.emit_trait_ref(ecx, &*p.trait_ref))
@ -971,8 +971,8 @@ impl<'a> rbml_writer_helpers for Encoder<'a> {
}) })
} }
typeck::MethodObject(ref o) => { typeck::MethodTraitObject(ref o) => {
this.emit_enum_variant("MethodObject", 3, 1, |this| { this.emit_enum_variant("MethodTraitObject", 3, 1, |this| {
this.emit_struct("MethodObject", 2, |this| { this.emit_struct("MethodObject", 2, |this| {
try!(this.emit_struct_field("trait_ref", 0, |this| { try!(this.emit_struct_field("trait_ref", 0, |this| {
Ok(this.emit_trait_ref(ecx, &*o.trait_ref)) Ok(this.emit_trait_ref(ecx, &*o.trait_ref))
@ -1067,13 +1067,13 @@ impl<'a> rbml_writer_helpers for Encoder<'a> {
self.emit_enum("AutoAdjustment", |this| { self.emit_enum("AutoAdjustment", |this| {
match *adj { match *adj {
ty::AutoAddEnv(store) => { ty::AdjustAddEnv(store) => {
this.emit_enum_variant("AutoAddEnv", 0, 1, |this| { this.emit_enum_variant("AutoAddEnv", 0, 1, |this| {
this.emit_enum_variant_arg(0, |this| store.encode(this)) this.emit_enum_variant_arg(0, |this| store.encode(this))
}) })
} }
ty::AutoDerefRef(ref auto_deref_ref) => { ty::AdjustDerefRef(ref auto_deref_ref) => {
this.emit_enum_variant("AutoDerefRef", 1, 1, |this| { this.emit_enum_variant("AutoDerefRef", 1, 1, |this| {
this.emit_enum_variant_arg(0, this.emit_enum_variant_arg(0,
|this| Ok(this.emit_auto_deref_ref(ecx, auto_deref_ref))) |this| Ok(this.emit_auto_deref_ref(ecx, auto_deref_ref)))
@ -1369,7 +1369,7 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext,
}) })
} }
} }
ty::AutoDerefRef(ref adj) => { ty::AdjustDerefRef(ref adj) => {
assert!(!ty::adjust_is_object(adjustment)); assert!(!ty::adjust_is_object(adjustment));
for autoderef in range(0, adj.autoderefs) { for autoderef in range(0, adj.autoderefs) {
let method_call = MethodCall::autoderef(id, autoderef); let method_call = MethodCall::autoderef(id, autoderef);
@ -1500,7 +1500,7 @@ impl<'a> rbml_decoder_decoder_helpers for reader::Decoder<'a> {
{ {
self.read_enum("MethodOrigin", |this| { self.read_enum("MethodOrigin", |this| {
let variants = ["MethodStatic", "MethodStaticUnboxedClosure", let variants = ["MethodStatic", "MethodStaticUnboxedClosure",
"MethodParam", "MethodObject"]; "MethodTypeParam", "MethodTraitObject"];
this.read_enum_variant(variants, |this, i| { this.read_enum_variant(variants, |this, i| {
Ok(match i { Ok(match i {
0 => { 0 => {
@ -1514,8 +1514,8 @@ impl<'a> rbml_decoder_decoder_helpers for reader::Decoder<'a> {
} }
2 => { 2 => {
this.read_struct("MethodParam", 2, |this| { this.read_struct("MethodTypeParam", 2, |this| {
Ok(typeck::MethodParam( Ok(typeck::MethodTypeParam(
typeck::MethodParam { typeck::MethodParam {
trait_ref: { trait_ref: {
this.read_struct_field("trait_ref", 0, |this| { this.read_struct_field("trait_ref", 0, |this| {
@ -1532,8 +1532,8 @@ impl<'a> rbml_decoder_decoder_helpers for reader::Decoder<'a> {
} }
3 => { 3 => {
this.read_struct("MethodObject", 2, |this| { this.read_struct("MethodTraitObject", 2, |this| {
Ok(typeck::MethodObject( Ok(typeck::MethodTraitObject(
typeck::MethodObject { typeck::MethodObject {
trait_ref: { trait_ref: {
this.read_struct_field("trait_ref", 0, |this| { this.read_struct_field("trait_ref", 0, |this| {
@ -1680,14 +1680,14 @@ impl<'a> rbml_decoder_decoder_helpers for reader::Decoder<'a> {
let store: ty::TraitStore = let store: ty::TraitStore =
this.read_enum_variant_arg(0, |this| Decodable::decode(this)).unwrap(); this.read_enum_variant_arg(0, |this| Decodable::decode(this)).unwrap();
ty::AutoAddEnv(store.tr(dcx)) ty::AdjustAddEnv(store.tr(dcx))
} }
1 => { 1 => {
let auto_deref_ref: ty::AutoDerefRef = let auto_deref_ref: ty::AutoDerefRef =
this.read_enum_variant_arg(0, this.read_enum_variant_arg(0,
|this| Ok(this.read_auto_deref_ref(dcx))).unwrap(); |this| Ok(this.read_auto_deref_ref(dcx))).unwrap();
ty::AutoDerefRef(auto_deref_ref) ty::AdjustDerefRef(auto_deref_ref)
} }
_ => fail!("bad enum variant for ty::AutoAdjustment") _ => fail!("bad enum variant for ty::AutoAdjustment")
}) })

4
src/librustc/middle/borrowck/mod.rs
View file

@ -424,12 +424,12 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
adj: &ty::AutoAdjustment) adj: &ty::AutoAdjustment)
-> mc::cmt { -> mc::cmt {
let r = match *adj { let r = match *adj {
ty::AutoDerefRef( ty::AdjustDerefRef(
ty::AutoDerefRef { ty::AutoDerefRef {
autoderefs: autoderefs, ..}) => { autoderefs: autoderefs, ..}) => {
self.mc().cat_expr_autoderefd(expr, autoderefs) self.mc().cat_expr_autoderefd(expr, autoderefs)
} }
ty::AutoAddEnv(..) => { ty::AdjustAddEnv(..) => {
// no autoderefs // no autoderefs
self.mc().cat_expr_unadjusted(expr) self.mc().cat_expr_unadjusted(expr)
} }

4
src/librustc/middle/dead.rs
View file

@ -101,12 +101,12 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> {
} }
} }
typeck::MethodStaticUnboxedClosure(_) => {} typeck::MethodStaticUnboxedClosure(_) => {}
typeck::MethodParam(typeck::MethodParam { typeck::MethodTypeParam(typeck::MethodParam {
trait_ref: ref trait_ref, trait_ref: ref trait_ref,
method_num: index, method_num: index,
.. ..
}) | }) |
typeck::MethodObject(typeck::MethodObject { typeck::MethodTraitObject(typeck::MethodObject {
trait_ref: ref trait_ref, trait_ref: ref trait_ref,
method_num: index, method_num: index,
.. ..

11
src/librustc/middle/expr_use_visitor.rs
View file

@ -19,7 +19,8 @@ use middle::def;
use middle::mem_categorization::Typer; use middle::mem_categorization::Typer;
use middle::pat_util; use middle::pat_util;
use middle::ty; use middle::ty;
use middle::typeck::{MethodCall, MethodObject, MethodOrigin, MethodParam}; use middle::typeck::{MethodCall, MethodObject, MethodTraitObject};
use middle::typeck::{MethodOrigin, MethodParam, MethodTypeParam};
use middle::typeck::{MethodStatic, MethodStaticUnboxedClosure}; use middle::typeck::{MethodStatic, MethodStaticUnboxedClosure};
use middle::typeck; use middle::typeck;
use util::ppaux::Repr; use util::ppaux::Repr;
@ -177,8 +178,8 @@ impl OverloadedCallType {
MethodStaticUnboxedClosure(def_id) => { MethodStaticUnboxedClosure(def_id) => {
OverloadedCallType::from_unboxed_closure(tcx, def_id) OverloadedCallType::from_unboxed_closure(tcx, def_id)
} }
MethodParam(MethodParam { trait_ref: ref trait_ref, .. }) | MethodTypeParam(MethodParam { trait_ref: ref trait_ref, .. }) |
MethodObject(MethodObject { trait_ref: ref trait_ref, .. }) => { MethodTraitObject(MethodObject { trait_ref: ref trait_ref, .. }) => {
OverloadedCallType::from_trait_id(tcx, trait_ref.def_id) OverloadedCallType::from_trait_id(tcx, trait_ref.def_id)
} }
} }
@ -684,7 +685,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,TYPER> {
None => { } None => { }
Some(adjustment) => { Some(adjustment) => {
match *adjustment { match *adjustment {
ty::AutoAddEnv(..) => { ty::AdjustAddEnv(..) => {
// Creating a closure consumes the input and stores it // Creating a closure consumes the input and stores it
// into the resulting rvalue. // into the resulting rvalue.
debug!("walk_adjustment(AutoAddEnv)"); debug!("walk_adjustment(AutoAddEnv)");
@ -692,7 +693,7 @@ impl<'d,'t,'tcx,TYPER:mc::Typer<'tcx>> ExprUseVisitor<'d,'t,TYPER> {
return_if_err!(self.mc.cat_expr_unadjusted(expr)); return_if_err!(self.mc.cat_expr_unadjusted(expr));
self.delegate_consume(expr.id, expr.span, cmt_unadjusted); self.delegate_consume(expr.id, expr.span, cmt_unadjusted);
} }
ty::AutoDerefRef(ty::AutoDerefRef { ty::AdjustDerefRef(ty::AutoDerefRef {
autoref: ref opt_autoref, autoref: ref opt_autoref,
autoderefs: n autoderefs: n
}) => { }) => {

1
src/librustc/middle/kind.rs
View file

@ -272,6 +272,7 @@ pub fn check_expr(cx: &mut Context, e: &Expr) {
visit::walk_expr(cx, e); visit::walk_expr(cx, e);
} }
fn check_ty(cx: &mut Context, aty: &Ty) { fn check_ty(cx: &mut Context, aty: &Ty) {
match aty.node { match aty.node {
TyPath(_, _, id) => { TyPath(_, _, id) => {

11
src/librustc/middle/liveness.rs
View file

@ -115,6 +115,7 @@ use std::mem::transmute;
use std::rc::Rc; use std::rc::Rc;
use std::str; use std::str;
use std::uint; use std::uint;
use syntax::ast;
use syntax::ast::*; use syntax::ast::*;
use syntax::codemap::{BytePos, original_sp, Span}; use syntax::codemap::{BytePos, original_sp, Span};
use syntax::parse::token::special_idents; use syntax::parse::token::special_idents;
@ -182,7 +183,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for IrMaps<'a, 'tcx> {
b: &'v Block, s: Span, n: NodeId) { b: &'v Block, s: Span, n: NodeId) {
visit_fn(self, fk, fd, b, s, n); visit_fn(self, fk, fd, b, s, n);
} }
fn visit_local(&mut self, l: &Local) { visit_local(self, l); } fn visit_local(&mut self, l: &ast::Local) { visit_local(self, l); }
fn visit_expr(&mut self, ex: &Expr) { visit_expr(self, ex); } fn visit_expr(&mut self, ex: &Expr) { visit_expr(self, ex); }
fn visit_arm(&mut self, a: &Arm) { visit_arm(self, a); } fn visit_arm(&mut self, a: &Arm) { visit_arm(self, a); }
} }
@ -345,7 +346,7 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Liveness<'a, 'tcx> {
fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v FnDecl, b: &'v Block, s: Span, n: NodeId) { fn visit_fn(&mut self, fk: FnKind<'v>, fd: &'v FnDecl, b: &'v Block, s: Span, n: NodeId) {
check_fn(self, fk, fd, b, s, n); check_fn(self, fk, fd, b, s, n);
} }
fn visit_local(&mut self, l: &Local) { fn visit_local(&mut self, l: &ast::Local) {
check_local(self, l); check_local(self, l);
} }
fn visit_expr(&mut self, ex: &Expr) { fn visit_expr(&mut self, ex: &Expr) {
@ -407,7 +408,7 @@ fn visit_fn(ir: &mut IrMaps,
lsets.warn_about_unused_args(decl, entry_ln); lsets.warn_about_unused_args(decl, entry_ln);
} }
fn visit_local(ir: &mut IrMaps, local: &Local) { fn visit_local(ir: &mut IrMaps, local: &ast::Local) {
pat_util::pat_bindings(&ir.tcx.def_map, &*local.pat, |_, p_id, sp, path1| { pat_util::pat_bindings(&ir.tcx.def_map, &*local.pat, |_, p_id, sp, path1| {
debug!("adding local variable {}", p_id); debug!("adding local variable {}", p_id);
let name = path1.node; let name = path1.node;
@ -903,7 +904,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
} }
} }
fn propagate_through_local(&mut self, local: &Local, succ: LiveNode) fn propagate_through_local(&mut self, local: &ast::Local, succ: LiveNode)
-> LiveNode { -> LiveNode {
// Note: we mark the variable as defined regardless of whether // Note: we mark the variable as defined regardless of whether
// there is an initializer. Initially I had thought to only mark // there is an initializer. Initially I had thought to only mark
@ -1398,7 +1399,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
// _______________________________________________________________________ // _______________________________________________________________________
// Checking for error conditions // Checking for error conditions
fn check_local(this: &mut Liveness, local: &Local) { fn check_local(this: &mut Liveness, local: &ast::Local) {
match local.init { match local.init {
Some(_) => { Some(_) => {
this.warn_about_unused_or_dead_vars_in_pat(&*local.pat); this.warn_about_unused_or_dead_vars_in_pat(&*local.pat);

6
src/librustc/middle/mem_categorization.rs
View file

@ -404,14 +404,14 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
Some(adjustment) => { Some(adjustment) => {
match *adjustment { match *adjustment {
ty::AutoAddEnv(..) => { ty::AdjustAddEnv(..) => {
// Convert a bare fn to a closure by adding NULL env. // Convert a bare fn to a closure by adding NULL env.
// Result is an rvalue. // Result is an rvalue.
let expr_ty = if_ok!(self.expr_ty_adjusted(expr)); let expr_ty = if_ok!(self.expr_ty_adjusted(expr));
Ok(self.cat_rvalue_node(expr.id(), expr.span(), expr_ty)) Ok(self.cat_rvalue_node(expr.id(), expr.span(), expr_ty))
} }
ty::AutoDerefRef( ty::AdjustDerefRef(
ty::AutoDerefRef { ty::AutoDerefRef {
autoref: Some(_), ..}) => { autoref: Some(_), ..}) => {
// Equivalent to &*expr or something similar. // Equivalent to &*expr or something similar.
@ -420,7 +420,7 @@ impl<'t,'tcx,TYPER:Typer<'tcx>> MemCategorizationContext<'t,TYPER> {
Ok(self.cat_rvalue_node(expr.id(), expr.span(), expr_ty)) Ok(self.cat_rvalue_node(expr.id(), expr.span(), expr_ty))
} }
ty::AutoDerefRef( ty::AdjustDerefRef(
ty::AutoDerefRef { ty::AutoDerefRef {
autoref: None, autoderefs: autoderefs}) => { autoref: None, autoderefs: autoderefs}) => {
// Equivalent to *expr or something similar. // Equivalent to *expr or something similar.

8
src/librustc/middle/privacy.rs
View file

@ -19,8 +19,8 @@ use middle::def;
use lint; use lint;
use middle::resolve; use middle::resolve;
use middle::ty; use middle::ty;
use middle::typeck::{MethodCall, MethodMap, MethodOrigin, MethodParam}; use middle::typeck::{MethodCall, MethodMap, MethodOrigin, MethodParam, MethodTypeParam};
use middle::typeck::{MethodStatic, MethodStaticUnboxedClosure, MethodObject}; use middle::typeck::{MethodStatic, MethodStaticUnboxedClosure, MethodObject, MethodTraitObject};
use util::nodemap::{NodeMap, NodeSet}; use util::nodemap::{NodeMap, NodeSet};
use syntax::ast; use syntax::ast;
@ -829,8 +829,8 @@ impl<'a, 'tcx> PrivacyVisitor<'a, 'tcx> {
MethodStaticUnboxedClosure(_) => {} MethodStaticUnboxedClosure(_) => {}
// Trait methods are always all public. The only controlling factor // Trait methods are always all public. The only controlling factor
// is whether the trait itself is accessible or not. // is whether the trait itself is accessible or not.
MethodParam(MethodParam { trait_ref: ref trait_ref, .. }) | MethodTypeParam(MethodParam { trait_ref: ref trait_ref, .. }) |
MethodObject(MethodObject { trait_ref: ref trait_ref, .. }) => { MethodTraitObject(MethodObject { trait_ref: ref trait_ref, .. }) => {
self.report_error(self.ensure_public(span, trait_ref.def_id, self.report_error(self.ensure_public(span, trait_ref.def_id,
None, "source trait")); None, "source trait"));
} }

36
src/librustc/middle/resolve.rs
View file

@ -29,7 +29,7 @@ use syntax::ast::{ExprPath, ExprProc, ExprStruct, ExprUnboxedFn, FnDecl};
use syntax::ast::{ForeignItem, ForeignItemFn, ForeignItemStatic, Generics}; use syntax::ast::{ForeignItem, ForeignItemFn, ForeignItemStatic, Generics};
use syntax::ast::{Ident, ImplItem, Item, ItemEnum, ItemFn, ItemForeignMod}; use syntax::ast::{Ident, ImplItem, Item, ItemEnum, ItemFn, ItemForeignMod};
use syntax::ast::{ItemImpl, ItemMac, ItemMod, ItemStatic, ItemStruct}; use syntax::ast::{ItemImpl, ItemMac, ItemMod, ItemStatic, ItemStruct};
use syntax::ast::{ItemTrait, ItemTy, LOCAL_CRATE, Local, Method}; use syntax::ast::{ItemTrait, ItemTy, LOCAL_CRATE, Local};
use syntax::ast::{MethodImplItem, Mod, Name, NamedField, NodeId}; use syntax::ast::{MethodImplItem, Mod, Name, NamedField, NodeId};
use syntax::ast::{Pat, PatEnum, PatIdent, PatLit}; use syntax::ast::{Pat, PatEnum, PatIdent, PatLit};
use syntax::ast::{PatRange, PatStruct, Path, PathListIdent, PathListMod}; use syntax::ast::{PatRange, PatStruct, Path, PathListIdent, PathListMod};
@ -1529,33 +1529,31 @@ impl<'a> Resolver<'a> {
} }
// Constructs the reduced graph for one variant. Variants exist in the // Constructs the reduced graph for one variant. Variants exist in the
// type and/or value namespaces. // type and value namespaces.
fn build_reduced_graph_for_variant(&mut self, fn build_reduced_graph_for_variant(&mut self,
variant: &Variant, variant: &Variant,
item_id: DefId, item_id: DefId,
parent: ReducedGraphParent, parent: ReducedGraphParent,
is_public: bool) { is_public: bool) {
let ident = variant.node.name; let ident = variant.node.name;
let is_exported = match variant.node.kind {
match variant.node.kind { TupleVariantKind(_) => false,
TupleVariantKind(_) => {
let child = self.add_child(ident, parent, ForbidDuplicateValues, variant.span);
child.define_value(DefVariant(item_id,
local_def(variant.node.id), false),
variant.span, is_public);
}
StructVariantKind(_) => { StructVariantKind(_) => {
let child = self.add_child(ident, parent,
ForbidDuplicateTypesAndValues,
variant.span);
child.define_type(DefVariant(item_id,
local_def(variant.node.id), true),
variant.span, is_public);
// Not adding fields for variants as they are not accessed with a self receiver // Not adding fields for variants as they are not accessed with a self receiver
self.structs.insert(local_def(variant.node.id), Vec::new()); self.structs.insert(local_def(variant.node.id), Vec::new());
true
} }
} };
let child = self.add_child(ident, parent,
ForbidDuplicateTypesAndValues,
variant.span);
child.define_value(DefVariant(item_id,
local_def(variant.node.id), is_exported),
variant.span, is_public);
child.define_type(DefVariant(item_id,
local_def(variant.node.id), is_exported),
variant.span, is_public);
} }
/// Constructs the reduced graph for one 'view item'. View items consist /// Constructs the reduced graph for one 'view item'. View items consist
@ -4513,7 +4511,7 @@ impl<'a> Resolver<'a> {
// to be NormalRibKind? // to be NormalRibKind?
fn resolve_method(&mut self, fn resolve_method(&mut self,
rib_kind: RibKind, rib_kind: RibKind,
method: &Method) { method: &ast::Method) {
let method_generics = method.pe_generics(); let method_generics = method.pe_generics();
let type_parameters = HasTypeParameters(method_generics, let type_parameters = HasTypeParameters(method_generics,
FnSpace, FnSpace,

4
src/librustc/middle/save/mod.rs
View file

@ -895,14 +895,14 @@ impl <'l, 'tcx> DxrVisitor<'l, 'tcx> {
}; };
(Some(def_id), decl_id) (Some(def_id), decl_id)
} }
typeck::MethodParam(ref mp) => { typeck::MethodTypeParam(ref mp) => {
// method invoked on a type parameter // method invoked on a type parameter
let trait_item = ty::trait_item(&self.analysis.ty_cx, let trait_item = ty::trait_item(&self.analysis.ty_cx,
mp.trait_ref.def_id, mp.trait_ref.def_id,
mp.method_num); mp.method_num);
(None, Some(trait_item.def_id())) (None, Some(trait_item.def_id()))
} }
typeck::MethodObject(ref mo) => { typeck::MethodTraitObject(ref mo) => {
// method invoked on a trait instance // method invoked on a trait instance
let trait_item = ty::trait_item(&self.analysis.ty_cx, let trait_item = ty::trait_item(&self.analysis.ty_cx,
mo.trait_ref.def_id, mo.trait_ref.def_id,

10
src/librustc/middle/traits/fulfill.rs
View file

@ -13,10 +13,10 @@ use middle::typeck::infer::{InferCtxt, skolemize};
use util::nodemap::DefIdMap; use util::nodemap::DefIdMap;
use util::ppaux::Repr; use util::ppaux::Repr;
use super::Ambiguity; use super::CodeAmbiguity;
use super::Obligation; use super::Obligation;
use super::FulfillmentError; use super::FulfillmentError;
use super::SelectionError; use super::CodeSelectionError;
use super::select::SelectionContext; use super::select::SelectionContext;
use super::Unimplemented; use super::Unimplemented;
@ -78,7 +78,7 @@ impl FulfillmentContext {
let errors: Vec<FulfillmentError> = let errors: Vec<FulfillmentError> =
self.trait_obligations self.trait_obligations
.iter() .iter()
.map(|o| FulfillmentError::new((*o).clone(), Ambiguity)) .map(|o| FulfillmentError::new((*o).clone(), CodeAmbiguity))
.collect(); .collect();
if errors.is_empty() { if errors.is_empty() {
@ -129,7 +129,7 @@ impl FulfillmentContext {
errors.push(FulfillmentError::new( errors.push(FulfillmentError::new(
(*obligation).clone(), (*obligation).clone(),
SelectionError(selection_err))); CodeSelectionError(selection_err)));
false false
} }
} }
@ -237,7 +237,7 @@ impl FulfillmentContext {
errors.push( errors.push(
FulfillmentError::new( FulfillmentError::new(
(*obligation).clone(), (*obligation).clone(),
SelectionError(Unimplemented))); CodeSelectionError(Unimplemented)));
} }
if errors.is_empty() { if errors.is_empty() {

30
src/librustc/middle/traits/mod.rs
View file

@ -97,8 +97,8 @@ pub struct FulfillmentError {
#[deriving(Clone)] #[deriving(Clone)]
pub enum FulfillmentErrorCode { pub enum FulfillmentErrorCode {
SelectionError(SelectionError), CodeSelectionError(SelectionError),
Ambiguity, CodeAmbiguity,
} }
/** /**
@ -110,7 +110,7 @@ pub enum FulfillmentErrorCode {
* to inconclusive type inference. * to inconclusive type inference.
* - `Err(e)`: error `e` occurred * - `Err(e)`: error `e` occurred
*/ */
pub type SelectionResult<T> = Result<Option<T>,SelectionError>; pub type SelectionResult<T> = Result<Option<T>, SelectionError>;
#[deriving(PartialEq,Eq,Show)] #[deriving(PartialEq,Eq,Show)]
pub enum EvaluationResult { pub enum EvaluationResult {
@ -157,12 +157,12 @@ pub enum EvaluationResult {
* *
* ### The type parameter `N` * ### The type parameter `N`
* *
* See explanation on `VtableImpl`. * See explanation on `VtableImplData`.
*/ */
#[deriving(Show,Clone)] #[deriving(Show,Clone)]
pub enum Vtable<N> { pub enum Vtable<N> {
/// Vtable identifying a particular impl. /// Vtable identifying a particular impl.
VtableImpl(VtableImpl<N>), VtableImpl(VtableImplData<N>),
/// Vtable automatically generated for an unboxed closure. The def /// Vtable automatically generated for an unboxed closure. The def
/// ID is the ID of the closure expression. This is a `VtableImpl` /// ID is the ID of the closure expression. This is a `VtableImpl`
@ -172,7 +172,7 @@ pub enum Vtable<N> {
/// Successful resolution to an obligation provided by the caller /// Successful resolution to an obligation provided by the caller
/// for some type parameter. /// for some type parameter.
VtableParam(VtableParam), VtableParam(VtableParamData),
/// Successful resolution for a builtin trait. /// Successful resolution for a builtin trait.
VtableBuiltin, VtableBuiltin,
@ -191,7 +191,7 @@ pub enum Vtable<N> {
* impl, and nested obligations are satisfied later. * impl, and nested obligations are satisfied later.
*/ */
#[deriving(Clone)] #[deriving(Clone)]
pub struct VtableImpl<N> { pub struct VtableImplData<N> {
pub impl_def_id: ast::DefId, pub impl_def_id: ast::DefId,
pub substs: subst::Substs, pub substs: subst::Substs,
pub nested: subst::VecPerParamSpace<N> pub nested: subst::VecPerParamSpace<N>
@ -203,7 +203,7 @@ pub struct VtableImpl<N> {
* on an instance of `T`, the vtable would be of type `VtableParam`. * on an instance of `T`, the vtable would be of type `VtableParam`.
*/ */
#[deriving(Clone)] #[deriving(Clone)]
pub struct VtableParam { pub struct VtableParamData {
// In the above example, this would `Eq` // In the above example, this would `Eq`
pub bound: Rc<ty::TraitRef>, pub bound: Rc<ty::TraitRef>,
} }
@ -274,7 +274,7 @@ pub fn select_inherent_impl(infcx: &InferCtxt,
cause: ObligationCause, cause: ObligationCause,
impl_def_id: ast::DefId, impl_def_id: ast::DefId,
self_ty: ty::t) self_ty: ty::t)
-> SelectionResult<VtableImpl<Obligation>> -> SelectionResult<VtableImplData<Obligation>>
{ {
/*! /*!
* Matches the self type of the inherent impl `impl_def_id` * Matches the self type of the inherent impl `impl_def_id`
@ -398,21 +398,21 @@ impl<N> Vtable<N> {
} }
} }
impl<N> VtableImpl<N> { impl<N> VtableImplData<N> {
pub fn map_nested<M>(&self, pub fn map_nested<M>(&self,
op: |&N| -> M) op: |&N| -> M)
-> VtableImpl<M> -> VtableImplData<M>
{ {
VtableImpl { VtableImplData {
impl_def_id: self.impl_def_id, impl_def_id: self.impl_def_id,
substs: self.substs.clone(), substs: self.substs.clone(),
nested: self.nested.map(op) nested: self.nested.map(op)
} }
} }
pub fn map_move_nested<M>(self, op: |N| -> M) -> VtableImpl<M> { pub fn map_move_nested<M>(self, op: |N| -> M) -> VtableImplData<M> {
let VtableImpl { impl_def_id, substs, nested } = self; let VtableImplData { impl_def_id, substs, nested } = self;
VtableImpl { VtableImplData {
impl_def_id: impl_def_id, impl_def_id: impl_def_id,
substs: substs, substs: substs,
nested: nested.map_move(op) nested: nested.map_move(op)

15
src/librustc/middle/traits/select.rs
View file

@ -18,6 +18,7 @@ use super::{SelectionError, Unimplemented, Overflow,
use super::{Selection}; use super::{Selection};
use super::{SelectionResult}; use super::{SelectionResult};
use super::{VtableBuiltin, VtableImpl, VtableParam, VtableUnboxedClosure}; use super::{VtableBuiltin, VtableImpl, VtableParam, VtableUnboxedClosure};
use super::{VtableImplData, VtableParamData};
use super::{util}; use super::{util};
use middle::subst::{Subst, Substs, VecPerParamSpace}; use middle::subst::{Subst, Substs, VecPerParamSpace};
@ -82,7 +83,7 @@ enum MatchResult<T> {
enum Candidate { enum Candidate {
MatchedBuiltinCandidate, MatchedBuiltinCandidate,
AmbiguousBuiltinCandidate, AmbiguousBuiltinCandidate,
MatchedParamCandidate(VtableParam), MatchedParamCandidate(VtableParamData),
AmbiguousParamCandidate, AmbiguousParamCandidate,
Impl(ImplCandidate), Impl(ImplCandidate),
MatchedUnboxedClosureCandidate(/* closure */ ast::DefId) MatchedUnboxedClosureCandidate(/* closure */ ast::DefId)
@ -142,7 +143,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
impl_def_id: ast::DefId, impl_def_id: ast::DefId,
obligation_cause: ObligationCause, obligation_cause: ObligationCause,
obligation_self_ty: ty::t) obligation_self_ty: ty::t)
-> SelectionResult<VtableImpl<Obligation>> -> SelectionResult<VtableImplData<Obligation>>
{ {
debug!("select_inherent_impl(impl_def_id={}, obligation_self_ty={})", debug!("select_inherent_impl(impl_def_id={}, obligation_self_ty={})",
impl_def_id.repr(self.tcx()), impl_def_id.repr(self.tcx()),
@ -597,8 +598,8 @@ v */
fn confirm_param_candidate(&self, fn confirm_param_candidate(&self,
obligation: &Obligation, obligation: &Obligation,
param: VtableParam) param: VtableParamData)
-> Result<VtableParam,SelectionError> -> Result<VtableParamData,SelectionError>
{ {
debug!("confirm_param_candidate({},{})", debug!("confirm_param_candidate({},{})",
obligation.repr(self.tcx()), obligation.repr(self.tcx()),
@ -613,7 +614,7 @@ v */
fn confirm_impl_candidate(&self, fn confirm_impl_candidate(&self,
obligation: &Obligation, obligation: &Obligation,
impl_def_id: ast::DefId) impl_def_id: ast::DefId)
-> Result<VtableImpl<Obligation>,SelectionError> -> Result<VtableImplData<Obligation>,SelectionError>
{ {
debug!("confirm_impl_candidate({},{})", debug!("confirm_impl_candidate({},{})",
obligation.repr(self.tcx()), obligation.repr(self.tcx()),
@ -642,7 +643,7 @@ v */
obligation_cause: ObligationCause, obligation_cause: ObligationCause,
obligation_self_ty: ty::t, obligation_self_ty: ty::t,
obligation_recursion_depth: uint) obligation_recursion_depth: uint)
-> Result<VtableImpl<Obligation>, -> Result<VtableImplData<Obligation>,
SelectionError> SelectionError>
{ {
let substs = match self.match_impl_self_types(impl_def_id, let substs = match self.match_impl_self_types(impl_def_id,
@ -663,7 +664,7 @@ v */
obligation_recursion_depth, obligation_recursion_depth,
impl_def_id, impl_def_id,
&substs); &substs);
let vtable_impl = VtableImpl { impl_def_id: impl_def_id, let vtable_impl = VtableImplData { impl_def_id: impl_def_id,
substs: substs, substs: substs,
nested: impl_obligations }; nested: impl_obligations };

22
src/librustc/middle/traits/util.rs
View file

@ -19,7 +19,7 @@ use syntax::ast;
use syntax::codemap::Span; use syntax::codemap::Span;
use util::ppaux::Repr; use util::ppaux::Repr;
use super::{Obligation, ObligationCause, VtableImpl, VtableParam}; use super::{Obligation, ObligationCause, VtableImpl, VtableParam, VtableParamData, VtableImplData};
/////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////
// Supertrait iterator // Supertrait iterator
@ -137,13 +137,13 @@ pub fn fresh_substs_for_impl(infcx: &InferCtxt,
infcx.fresh_substs_for_generics(span, &impl_generics) infcx.fresh_substs_for_generics(span, &impl_generics)
} }
impl<N> fmt::Show for VtableImpl<N> { impl<N> fmt::Show for VtableImplData<N> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "VtableImpl({})", self.impl_def_id) write!(f, "VtableImpl({})", self.impl_def_id)
} }
} }
impl fmt::Show for VtableParam { impl fmt::Show for VtableParamData {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "VtableParam(...)") write!(f, "VtableParam(...)")
} }
@ -239,7 +239,7 @@ pub fn obligation_for_builtin_bound(
pub fn search_trait_and_supertraits_from_bound(tcx: &ty::ctxt, pub fn search_trait_and_supertraits_from_bound(tcx: &ty::ctxt,
caller_bound: Rc<ty::TraitRef>, caller_bound: Rc<ty::TraitRef>,
test: |ast::DefId| -> bool) test: |ast::DefId| -> bool)
-> Option<VtableParam> -> Option<VtableParamData>
{ {
/*! /*!
* Starting from a caller obligation `caller_bound` (which has * Starting from a caller obligation `caller_bound` (which has
@ -252,7 +252,7 @@ pub fn search_trait_and_supertraits_from_bound(tcx: &ty::ctxt,
for bound in transitive_bounds(tcx, &[caller_bound]) { for bound in transitive_bounds(tcx, &[caller_bound]) {
if test(bound.def_id) { if test(bound.def_id) {
let vtable_param = VtableParam { bound: bound }; let vtable_param = VtableParamData { bound: bound };
return Some(vtable_param); return Some(vtable_param);
} }
} }
@ -287,7 +287,7 @@ impl<N:Repr> Repr for super::Vtable<N> {
} }
} }
impl<N:Repr> Repr for super::VtableImpl<N> { impl<N:Repr> Repr for super::VtableImplData<N> {
fn repr(&self, tcx: &ty::ctxt) -> String { fn repr(&self, tcx: &ty::ctxt) -> String {
format!("VtableImpl(impl_def_id={}, substs={}, nested={})", format!("VtableImpl(impl_def_id={}, substs={}, nested={})",
self.impl_def_id.repr(tcx), self.impl_def_id.repr(tcx),
@ -296,7 +296,7 @@ impl<N:Repr> Repr for super::VtableImpl<N> {
} }
} }
impl Repr for super::VtableParam { impl Repr for super::VtableParamData {
fn repr(&self, tcx: &ty::ctxt) -> String { fn repr(&self, tcx: &ty::ctxt) -> String {
format!("VtableParam(bound={})", format!("VtableParam(bound={})",
self.bound.repr(tcx)) self.bound.repr(tcx))
@ -331,8 +331,8 @@ impl Repr for super::FulfillmentError {
impl Repr for super::FulfillmentErrorCode { impl Repr for super::FulfillmentErrorCode {
fn repr(&self, tcx: &ty::ctxt) -> String { fn repr(&self, tcx: &ty::ctxt) -> String {
match *self { match *self {
super::SelectionError(ref o) => o.repr(tcx), super::CodeSelectionError(ref o) => o.repr(tcx),
super::Ambiguity => format!("Ambiguity") super::CodeAmbiguity => format!("Ambiguity")
} }
} }
} }
@ -340,8 +340,8 @@ impl Repr for super::FulfillmentErrorCode {
impl fmt::Show for super::FulfillmentErrorCode { impl fmt::Show for super::FulfillmentErrorCode {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self { match *self {
super::SelectionError(ref e) => write!(f, "{}", e), super::CodeSelectionError(ref e) => write!(f, "{}", e),
super::Ambiguity => write!(f, "Ambiguity") super::CodeAmbiguity => write!(f, "Ambiguity")
} }
} }
} }

6
src/librustc/middle/trans/consts.rs
View file

@ -207,7 +207,7 @@ pub fn const_expr(cx: &CrateContext, e: &ast::Expr, is_local: bool) -> (ValueRef
None => { } None => { }
Some(adj) => { Some(adj) => {
match adj { match adj {
ty::AutoAddEnv(ty::RegionTraitStore(ty::ReStatic, _)) => { ty::AdjustAddEnv(ty::RegionTraitStore(ty::ReStatic, _)) => {
let def = ty::resolve_expr(cx.tcx(), e); let def = ty::resolve_expr(cx.tcx(), e);
let wrapper = closure::get_wrapper_for_bare_fn(cx, let wrapper = closure::get_wrapper_for_bare_fn(cx,
ety_adjusted, ety_adjusted,
@ -216,13 +216,13 @@ pub fn const_expr(cx: &CrateContext, e: &ast::Expr, is_local: bool) -> (ValueRef
is_local); is_local);
llconst = C_struct(cx, [wrapper, C_null(Type::i8p(cx))], false) llconst = C_struct(cx, [wrapper, C_null(Type::i8p(cx))], false)
} }
ty::AutoAddEnv(store) => { ty::AdjustAddEnv(store) => {
cx.sess() cx.sess()
.span_bug(e.span, .span_bug(e.span,
format!("unexpected static function: {:?}", format!("unexpected static function: {:?}",
store).as_slice()) store).as_slice())
} }
ty::AutoDerefRef(ref adj) => { ty::AdjustDerefRef(ref adj) => {
let mut ty = ety; let mut ty = ety;
// Save the last autoderef in case we can avoid it. // Save the last autoderef in case we can avoid it.
if adj.autoderefs > 0 { if adj.autoderefs > 0 {

12
src/librustc/middle/trans/debuginfo.rs
View file

@ -664,7 +664,7 @@ pub struct FunctionDebugContext {
} }
enum FunctionDebugContextRepr { enum FunctionDebugContextRepr {
FunctionDebugContext(Box<FunctionDebugContextData>), DebugInfo(Box<FunctionDebugContextData>),
DebugInfoDisabled, DebugInfoDisabled,
FunctionWithoutDebugInfo, FunctionWithoutDebugInfo,
} }
@ -675,7 +675,7 @@ impl FunctionDebugContext {
span: Span) span: Span)
-> &'a FunctionDebugContextData { -> &'a FunctionDebugContextData {
match self.repr { match self.repr {
FunctionDebugContext(box ref data) => data, DebugInfo(box ref data) => data,
DebugInfoDisabled => { DebugInfoDisabled => {
cx.sess().span_bug(span, cx.sess().span_bug(span,
FunctionDebugContext::debuginfo_disabled_message()); FunctionDebugContext::debuginfo_disabled_message());
@ -1044,7 +1044,7 @@ pub fn set_source_location(fcx: &FunctionContext,
set_debug_location(fcx.ccx, UnknownLocation); set_debug_location(fcx.ccx, UnknownLocation);
return; return;
} }
FunctionDebugContext(box ref function_debug_context) => { DebugInfo(box ref function_debug_context) => {
let cx = fcx.ccx; let cx = fcx.ccx;
debug!("set_source_location: {}", cx.sess().codemap().span_to_string(span)); debug!("set_source_location: {}", cx.sess().codemap().span_to_string(span));
@ -1082,7 +1082,7 @@ pub fn clear_source_location(fcx: &FunctionContext) {
/// first real statement/expression of the function is translated. /// first real statement/expression of the function is translated.
pub fn start_emitting_source_locations(fcx: &FunctionContext) { pub fn start_emitting_source_locations(fcx: &FunctionContext) {
match fcx.debug_context.repr { match fcx.debug_context.repr {
FunctionDebugContext(box ref data) => { DebugInfo(box ref data) => {
data.source_locations_enabled.set(true) data.source_locations_enabled.set(true)
}, },
_ => { /* safe to ignore */ } _ => { /* safe to ignore */ }
@ -1291,7 +1291,7 @@ pub fn create_function_debug_context(cx: &CrateContext,
fn_metadata, fn_metadata,
&mut *fn_debug_context.scope_map.borrow_mut()); &mut *fn_debug_context.scope_map.borrow_mut());
return FunctionDebugContext { repr: FunctionDebugContext(fn_debug_context) }; return FunctionDebugContext { repr: DebugInfo(fn_debug_context) };
fn get_function_signature(cx: &CrateContext, fn get_function_signature(cx: &CrateContext,
fn_ast_id: ast::NodeId, fn_ast_id: ast::NodeId,
@ -3134,7 +3134,7 @@ fn DIB(cx: &CrateContext) -> DIBuilderRef {
fn fn_should_be_ignored(fcx: &FunctionContext) -> bool { fn fn_should_be_ignored(fcx: &FunctionContext) -> bool {
match fcx.debug_context.repr { match fcx.debug_context.repr {
FunctionDebugContext(_) => false, DebugInfo(_) => false,
_ => true _ => true
} }
} }

6
src/librustc/middle/trans/expr.rs
View file

@ -64,7 +64,7 @@ use middle::trans::inline;
use middle::trans::tvec; use middle::trans::tvec;
use middle::trans::type_of; use middle::trans::type_of;
use middle::ty::{struct_fields, tup_fields}; use middle::ty::{struct_fields, tup_fields};
use middle::ty::{AutoDerefRef, AutoAddEnv, AutoUnsafe}; use middle::ty::{AdjustDerefRef, AdjustAddEnv, AutoUnsafe};
use middle::ty::{AutoPtr}; use middle::ty::{AutoPtr};
use middle::ty; use middle::ty;
use middle::typeck; use middle::typeck;
@ -189,10 +189,10 @@ fn apply_adjustments<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
debug!("unadjusted datum for expr {}: {}", debug!("unadjusted datum for expr {}: {}",
expr.id, datum.to_string(bcx.ccx())); expr.id, datum.to_string(bcx.ccx()));
match adjustment { match adjustment {
AutoAddEnv(..) => { AdjustAddEnv(..) => {
datum = unpack_datum!(bcx, add_env(bcx, expr, datum)); datum = unpack_datum!(bcx, add_env(bcx, expr, datum));
} }
AutoDerefRef(ref adj) => { AdjustDerefRef(ref adj) => {
let (autoderefs, use_autoref) = match adj.autoref { let (autoderefs, use_autoref) = match adj.autoref {
// Extracting a value from a box counts as a deref, but if we are // Extracting a value from a box counts as a deref, but if we are
// just converting Box<[T, ..n]> to Box<[T]> we aren't really doing // just converting Box<[T, ..n]> to Box<[T]> we aren't really doing

8
src/librustc/middle/trans/meth.rs
View file

@ -131,7 +131,7 @@ pub fn trans_method_callee<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
} }
} }
typeck::MethodParam(typeck::MethodParam { typeck::MethodTypeParam(typeck::MethodParam {
trait_ref: ref trait_ref, trait_ref: ref trait_ref,
method_num: method_num method_num: method_num
}) => { }) => {
@ -147,7 +147,7 @@ pub fn trans_method_callee<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
method_num, origin) method_num, origin)
} }
typeck::MethodObject(ref mt) => { typeck::MethodTraitObject(ref mt) => {
let self_expr = match self_expr { let self_expr = match self_expr {
Some(self_expr) => self_expr, Some(self_expr) => self_expr,
None => { None => {
@ -243,7 +243,7 @@ pub fn trans_static_method_callee(bcx: Block,
// Now that we know which impl is being used, we can dispatch to // Now that we know which impl is being used, we can dispatch to
// the actual function: // the actual function:
match vtbl { match vtbl {
traits::VtableImpl(traits::VtableImpl { traits::VtableImpl(traits::VtableImplData {
impl_def_id: impl_did, impl_def_id: impl_did,
substs: impl_substs, substs: impl_substs,
nested: _ }) => nested: _ }) =>
@ -562,7 +562,7 @@ pub fn get_vtable(bcx: Block,
trait_ref.clone()); trait_ref.clone());
match vtable { match vtable {
traits::VtableImpl( traits::VtableImpl(
traits::VtableImpl { traits::VtableImplData {
impl_def_id: id, impl_def_id: id,
substs: substs, substs: substs,
nested: _ }) => { nested: _ }) => {

18
src/librustc/middle/ty.rs
View file

@ -277,8 +277,8 @@ pub enum Variance {
#[deriving(Clone)] #[deriving(Clone)]
pub enum AutoAdjustment { pub enum AutoAdjustment {
AutoAddEnv(ty::TraitStore), AdjustAddEnv(ty::TraitStore),
AutoDerefRef(AutoDerefRef) AdjustDerefRef(AutoDerefRef)
} }
#[deriving(Clone, PartialEq)] #[deriving(Clone, PartialEq)]
@ -350,7 +350,7 @@ fn autoref_object_region(autoref: &AutoRef) -> (bool, bool, Option<Region>) {
// returns the region of the borrowed reference. // returns the region of the borrowed reference.
pub fn adjusted_object_region(adj: &AutoAdjustment) -> Option<Region> { pub fn adjusted_object_region(adj: &AutoAdjustment) -> Option<Region> {
match adj { match adj {
&AutoDerefRef(AutoDerefRef{autoref: Some(ref autoref), ..}) => { &AdjustDerefRef(AutoDerefRef{autoref: Some(ref autoref), ..}) => {
let (b, _, r) = autoref_object_region(autoref); let (b, _, r) = autoref_object_region(autoref);
if b { if b {
r r
@ -365,7 +365,7 @@ pub fn adjusted_object_region(adj: &AutoAdjustment) -> Option<Region> {
// Returns true if there is a trait cast at the bottom of the adjustment. // Returns true if there is a trait cast at the bottom of the adjustment.
pub fn adjust_is_object(adj: &AutoAdjustment) -> bool { pub fn adjust_is_object(adj: &AutoAdjustment) -> bool {
match adj { match adj {
&AutoDerefRef(AutoDerefRef{autoref: Some(ref autoref), ..}) => { &AdjustDerefRef(AutoDerefRef{autoref: Some(ref autoref), ..}) => {
let (b, _, _) = autoref_object_region(autoref); let (b, _, _) = autoref_object_region(autoref);
b b
} }
@ -407,7 +407,7 @@ pub fn type_of_adjust(cx: &ctxt, adj: &AutoAdjustment) -> Option<t> {
} }
match adj { match adj {
&AutoDerefRef(AutoDerefRef{autoref: Some(ref autoref), ..}) => { &AdjustDerefRef(AutoDerefRef{autoref: Some(ref autoref), ..}) => {
type_of_autoref(cx, autoref) type_of_autoref(cx, autoref)
} }
_ => None _ => None
@ -3423,7 +3423,7 @@ pub fn adjust_ty(cx: &ctxt,
return match adjustment { return match adjustment {
Some(adjustment) => { Some(adjustment) => {
match *adjustment { match *adjustment {
AutoAddEnv(store) => { AdjustAddEnv(store) => {
match ty::get(unadjusted_ty).sty { match ty::get(unadjusted_ty).sty {
ty::ty_bare_fn(ref b) => { ty::ty_bare_fn(ref b) => {
let bounds = ty::ExistentialBounds { let bounds = ty::ExistentialBounds {
@ -3449,7 +3449,7 @@ pub fn adjust_ty(cx: &ctxt,
} }
} }
AutoDerefRef(ref adj) => { AdjustDerefRef(ref adj) => {
let mut adjusted_ty = unadjusted_ty; let mut adjusted_ty = unadjusted_ty;
if !ty::type_is_error(adjusted_ty) { if !ty::type_is_error(adjusted_ty) {
@ -3582,12 +3582,12 @@ pub fn method_call_type_param_defs<'tcx, T>(typer: &T,
.trait_did(typer.tcx()); .trait_did(typer.tcx());
lookup_trait_def(typer.tcx(), def_id).generics.types.clone() lookup_trait_def(typer.tcx(), def_id).generics.types.clone()
} }
typeck::MethodParam(typeck::MethodParam{ typeck::MethodTypeParam(typeck::MethodParam{
trait_ref: ref trait_ref, trait_ref: ref trait_ref,
method_num: n_mth, method_num: n_mth,
.. ..
}) | }) |
typeck::MethodObject(typeck::MethodObject{ typeck::MethodTraitObject(typeck::MethodObject{
trait_ref: ref trait_ref, trait_ref: ref trait_ref,
method_num: n_mth, method_num: n_mth,
.. ..

12
src/librustc/middle/ty_fold.rs
View file

@ -353,9 +353,9 @@ impl TypeFoldable for traits::Obligation {
} }
} }
impl<N:TypeFoldable> TypeFoldable for traits::VtableImpl<N> { impl<N:TypeFoldable> TypeFoldable for traits::VtableImplData<N> {
fn fold_with<'tcx, F:TypeFolder<'tcx>>(&self, folder: &mut F) -> traits::VtableImpl<N> { fn fold_with<'tcx, F:TypeFolder<'tcx>>(&self, folder: &mut F) -> traits::VtableImplData<N> {
traits::VtableImpl { traits::VtableImplData {
impl_def_id: self.impl_def_id, impl_def_id: self.impl_def_id,
substs: self.substs.fold_with(folder), substs: self.substs.fold_with(folder),
nested: self.nested.fold_with(folder), nested: self.nested.fold_with(folder),
@ -374,9 +374,9 @@ impl<N:TypeFoldable> TypeFoldable for traits::Vtable<N> {
} }
} }
impl TypeFoldable for traits::VtableParam { impl TypeFoldable for traits::VtableParamData {
fn fold_with<'tcx, F:TypeFolder<'tcx>>(&self, folder: &mut F) -> traits::VtableParam { fn fold_with<'tcx, F:TypeFolder<'tcx>>(&self, folder: &mut F) -> traits::VtableParamData {
traits::VtableParam { traits::VtableParamData {
bound: self.bound.fold_with(folder), bound: self.bound.fold_with(folder),
} }
} }

28
src/librustc/middle/typeck/check/method.rs
View file

@ -90,8 +90,8 @@ use middle::typeck::check::{FnCtxt, PreferMutLvalue, impl_self_ty};
use middle::typeck::check; use middle::typeck::check;
use middle::typeck::infer; use middle::typeck::infer;
use middle::typeck::MethodCallee; use middle::typeck::MethodCallee;
use middle::typeck::{MethodOrigin, MethodParam}; use middle::typeck::{MethodOrigin, MethodParam, MethodTypeParam};
use middle::typeck::{MethodStatic, MethodStaticUnboxedClosure, MethodObject}; use middle::typeck::{MethodStatic, MethodStaticUnboxedClosure, MethodObject, MethodTraitObject};
use middle::typeck::check::regionmanip::replace_late_bound_regions_in_fn_sig; use middle::typeck::check::regionmanip::replace_late_bound_regions_in_fn_sig;
use middle::typeck::TypeAndSubsts; use middle::typeck::TypeAndSubsts;
use util::common::indenter; use util::common::indenter;
@ -636,7 +636,7 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
rcvr_match_condition: RcvrMatchesIfObject(did), rcvr_match_condition: RcvrMatchesIfObject(did),
rcvr_substs: new_trait_ref.substs.clone(), rcvr_substs: new_trait_ref.substs.clone(),
method_ty: Rc::new(m), method_ty: Rc::new(m),
origin: MethodObject(MethodObject { origin: MethodTraitObject(MethodObject {
trait_ref: new_trait_ref, trait_ref: new_trait_ref,
object_trait_id: did, object_trait_id: did,
method_num: method_num, method_num: method_num,
@ -702,7 +702,7 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
rcvr_match_condition: condition, rcvr_match_condition: condition,
rcvr_substs: trait_ref.substs.clone(), rcvr_substs: trait_ref.substs.clone(),
method_ty: m, method_ty: m,
origin: MethodParam(MethodParam { origin: MethodTypeParam(MethodParam {
trait_ref: trait_ref, trait_ref: trait_ref,
method_num: method_num, method_num: method_num,
}) })
@ -874,7 +874,7 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
} }
let (self_ty, auto_deref_ref) = self.consider_reborrow(self_ty, autoderefs); let (self_ty, auto_deref_ref) = self.consider_reborrow(self_ty, autoderefs);
let adjustment = Some((self.self_expr.unwrap().id, ty::AutoDerefRef(auto_deref_ref))); let adjustment = Some((self.self_expr.unwrap().id, ty::AdjustDerefRef(auto_deref_ref)));
match self.search_for_method(self_ty) { match self.search_for_method(self_ty) {
None => None, None => None,
@ -1159,7 +1159,7 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
self.fcx.write_adjustment( self.fcx.write_adjustment(
self_expr_id, self_expr_id,
self.span, self.span,
ty::AutoDerefRef(ty::AutoDerefRef { ty::AdjustDerefRef(ty::AutoDerefRef {
autoderefs: autoderefs, autoderefs: autoderefs,
autoref: Some(kind(region, *mutbl)) autoref: Some(kind(region, *mutbl))
})); }));
@ -1245,7 +1245,7 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
candidate_a.repr(self.tcx()), candidate_a.repr(self.tcx()),
candidate_b.repr(self.tcx())); candidate_b.repr(self.tcx()));
match (&candidate_a.origin, &candidate_b.origin) { match (&candidate_a.origin, &candidate_b.origin) {
(&MethodParam(ref p1), &MethodParam(ref p2)) => { (&MethodTypeParam(ref p1), &MethodTypeParam(ref p2)) => {
let same_trait = let same_trait =
p1.trait_ref.def_id == p2.trait_ref.def_id; p1.trait_ref.def_id == p2.trait_ref.def_id;
let same_method = let same_method =
@ -1330,7 +1330,7 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
let fn_sig = &bare_fn_ty.sig; let fn_sig = &bare_fn_ty.sig;
let inputs = match candidate.origin { let inputs = match candidate.origin {
MethodObject(..) => { MethodTraitObject(..) => {
// For annoying reasons, we've already handled the // For annoying reasons, we've already handled the
// substitution of self for object calls. // substitution of self for object calls.
let args = fn_sig.inputs.slice_from(1).iter().map(|t| { let args = fn_sig.inputs.slice_from(1).iter().map(|t| {
@ -1403,11 +1403,11 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
match candidate.origin { match candidate.origin {
MethodStatic(..) | MethodStatic(..) |
MethodParam(..) | MethodTypeParam(..) |
MethodStaticUnboxedClosure(..) => { MethodStaticUnboxedClosure(..) => {
return; // not a call to a trait instance return; // not a call to a trait instance
} }
MethodObject(..) => {} MethodTraitObject(..) => {}
} }
match candidate.method_ty.explicit_self { match candidate.method_ty.explicit_self {
@ -1463,8 +1463,8 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
MethodStaticUnboxedClosure(_) => bad = false, MethodStaticUnboxedClosure(_) => bad = false,
// FIXME: does this properly enforce this on everything now // FIXME: does this properly enforce this on everything now
// that self has been merged in? -sully // that self has been merged in? -sully
MethodParam(MethodParam { trait_ref: ref trait_ref, .. }) | MethodTypeParam(MethodParam { trait_ref: ref trait_ref, .. }) |
MethodObject(MethodObject { trait_ref: ref trait_ref, .. }) => { MethodTraitObject(MethodObject { trait_ref: ref trait_ref, .. }) => {
bad = self.tcx().destructor_for_type.borrow() bad = self.tcx().destructor_for_type.borrow()
.contains_key(&trait_ref.def_id); .contains_key(&trait_ref.def_id);
} }
@ -1612,10 +1612,10 @@ impl<'a, 'tcx> LookupContext<'a, 'tcx> {
MethodStaticUnboxedClosure(did) => { MethodStaticUnboxedClosure(did) => {
self.report_static_candidate(idx, did) self.report_static_candidate(idx, did)
} }
MethodParam(ref mp) => { MethodTypeParam(ref mp) => {
self.report_param_candidate(idx, mp.trait_ref.def_id) self.report_param_candidate(idx, mp.trait_ref.def_id)
} }
MethodObject(ref mo) => { MethodTraitObject(ref mo) => {
self.report_trait_candidate(idx, mo.trait_ref.def_id) self.report_trait_candidate(idx, mo.trait_ref.def_id)
} }
} }

6
src/librustc/middle/typeck/check/mod.rs
View file

@ -1702,7 +1702,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
self.write_adjustment( self.write_adjustment(
node_id, node_id,
span, span,
ty::AutoDerefRef(ty::AutoDerefRef { ty::AdjustDerefRef(ty::AutoDerefRef {
autoderefs: derefs, autoderefs: derefs,
autoref: None }) autoref: None })
); );
@ -1728,8 +1728,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
span: Span, span: Span,
adj: &ty::AutoAdjustment) { adj: &ty::AutoAdjustment) {
match *adj { match *adj {
ty::AutoAddEnv(..) => { } ty::AdjustAddEnv(..) => { }
ty::AutoDerefRef(ref d_r) => { ty::AdjustDerefRef(ref d_r) => {
match d_r.autoref { match d_r.autoref {
Some(ref a_r) => { Some(ref a_r) => {
self.register_autoref_obligations(span, a_r); self.register_autoref_obligations(span, a_r);

2
src/librustc/middle/typeck/check/regionck.rs
View file

@ -590,7 +590,7 @@ fn visit_expr(rcx: &mut Rcx, expr: &ast::Expr) {
for &adjustment in rcx.fcx.inh.adjustments.borrow().find(&expr.id).iter() { for &adjustment in rcx.fcx.inh.adjustments.borrow().find(&expr.id).iter() {
debug!("adjustment={:?}", adjustment); debug!("adjustment={:?}", adjustment);
match *adjustment { match *adjustment {
ty::AutoDerefRef(ty::AutoDerefRef {autoderefs, autoref: ref opt_autoref}) => { ty::AdjustDerefRef(ty::AutoDerefRef {autoderefs, autoref: ref opt_autoref}) => {
let expr_ty = rcx.resolve_node_type(expr.id); let expr_ty = rcx.resolve_node_type(expr.id);
constrain_autoderefs(rcx, expr, autoderefs, expr_ty); constrain_autoderefs(rcx, expr, autoderefs, expr_ty);
for autoref in opt_autoref.iter() { for autoref in opt_autoref.iter() {

6
src/librustc/middle/typeck/check/vtable2.rs
View file

@ -13,7 +13,7 @@ use middle::traits;
use middle::traits::{SelectionError, Overflow, use middle::traits::{SelectionError, Overflow,
OutputTypeParameterMismatch, Unimplemented}; OutputTypeParameterMismatch, Unimplemented};
use middle::traits::{Obligation, obligation_for_builtin_bound}; use middle::traits::{Obligation, obligation_for_builtin_bound};
use middle::traits::{FulfillmentError, Ambiguity}; use middle::traits::{FulfillmentError, CodeSelectionError, CodeAmbiguity};
use middle::traits::{ObligationCause}; use middle::traits::{ObligationCause};
use middle::ty; use middle::ty;
use middle::typeck::check::{FnCtxt, use middle::typeck::check::{FnCtxt,
@ -244,10 +244,10 @@ pub fn report_fulfillment_errors(fcx: &FnCtxt,
pub fn report_fulfillment_error(fcx: &FnCtxt, pub fn report_fulfillment_error(fcx: &FnCtxt,
error: &FulfillmentError) { error: &FulfillmentError) {
match error.code { match error.code {
SelectionError(ref e) => { CodeSelectionError(ref e) => {
report_selection_error(fcx, &error.obligation, e); report_selection_error(fcx, &error.obligation, e);
} }
Ambiguity => { CodeAmbiguity => {
maybe_report_ambiguity(fcx, &error.obligation); maybe_report_ambiguity(fcx, &error.obligation);
} }
} }

8
src/librustc/middle/typeck/check/writeback.rs
View file

@ -282,7 +282,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
Some(adjustment) => { Some(adjustment) => {
let adj_object = ty::adjust_is_object(&adjustment); let adj_object = ty::adjust_is_object(&adjustment);
let resolved_adjustment = match adjustment { let resolved_adjustment = match adjustment {
ty::AutoAddEnv(store) => { ty::AdjustAddEnv(store) => {
// FIXME(eddyb) #2190 Allow only statically resolved // FIXME(eddyb) #2190 Allow only statically resolved
// bare functions to coerce to a closure to avoid // bare functions to coerce to a closure to avoid
// constructing (slower) indirect call wrappers. // constructing (slower) indirect call wrappers.
@ -298,10 +298,10 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
} }
} }
ty::AutoAddEnv(self.resolve(&store, reason)) ty::AdjustAddEnv(self.resolve(&store, reason))
} }
ty::AutoDerefRef(adj) => { ty::AdjustDerefRef(adj) => {
for autoderef in range(0, adj.autoderefs) { for autoderef in range(0, adj.autoderefs) {
let method_call = MethodCall::autoderef(id, autoderef); let method_call = MethodCall::autoderef(id, autoderef);
self.visit_method_map_entry(reason, method_call); self.visit_method_map_entry(reason, method_call);
@ -312,7 +312,7 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
self.visit_method_map_entry(reason, method_call); self.visit_method_map_entry(reason, method_call);
} }
ty::AutoDerefRef(ty::AutoDerefRef { ty::AdjustDerefRef(ty::AutoDerefRef {
autoderefs: adj.autoderefs, autoderefs: adj.autoderefs,
autoref: self.resolve(&adj.autoref, reason), autoref: self.resolve(&adj.autoref, reason),
}) })

18
src/librustc/middle/typeck/infer/coercion.rs
View file

@ -65,7 +65,7 @@ we may want to adjust precisely when coercions occur.
*/ */
use middle::subst; use middle::subst;
use middle::ty::{AutoPtr, AutoDerefRef, AutoUnsize, AutoUnsafe}; use middle::ty::{AutoPtr, AutoDerefRef, AdjustDerefRef, AutoUnsize, AutoUnsafe};
use middle::ty::{mt}; use middle::ty::{mt};
use middle::ty; use middle::ty;
use middle::typeck::infer::{CoerceResult, resolve_type, Coercion}; use middle::typeck::infer::{CoerceResult, resolve_type, Coercion};
@ -270,7 +270,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
mt {ty: inner_ty, mutbl: mutbl_b}); mt {ty: inner_ty, mutbl: mutbl_b});
try!(sub.tys(a_borrowed, b)); try!(sub.tys(a_borrowed, b));
Ok(Some(AutoDerefRef(AutoDerefRef { Ok(Some(AdjustDerefRef(AutoDerefRef {
autoderefs: 1, autoderefs: 1,
autoref: Some(AutoPtr(r_borrow, mutbl_b, None)) autoref: Some(AutoPtr(r_borrow, mutbl_b, None))
}))) })))
@ -295,7 +295,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
let unsized_ty = ty::mk_slice(self.get_ref().infcx.tcx, r_borrow, let unsized_ty = ty::mk_slice(self.get_ref().infcx.tcx, r_borrow,
mt {ty: t_a, mutbl: mutbl_b}); mt {ty: t_a, mutbl: mutbl_b});
try!(self.get_ref().infcx.try(|| sub.tys(unsized_ty, b))); try!(self.get_ref().infcx.try(|| sub.tys(unsized_ty, b)));
Ok(Some(AutoDerefRef(AutoDerefRef { Ok(Some(AdjustDerefRef(AutoDerefRef {
autoderefs: 0, autoderefs: 0,
autoref: Some(ty::AutoPtr(r_borrow, autoref: Some(ty::AutoPtr(r_borrow,
mutbl_b, mutbl_b,
@ -343,7 +343,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
try!(self.get_ref().infcx.try(|| sub.tys(ty, b))); try!(self.get_ref().infcx.try(|| sub.tys(ty, b)));
debug!("Success, coerced with AutoDerefRef(1, \ debug!("Success, coerced with AutoDerefRef(1, \
AutoPtr(AutoUnsize({:?})))", kind); AutoPtr(AutoUnsize({:?})))", kind);
Ok(Some(AutoDerefRef(AutoDerefRef { Ok(Some(AdjustDerefRef(AutoDerefRef {
autoderefs: 1, autoderefs: 1,
autoref: Some(ty::AutoPtr(r_borrow, mt_b.mutbl, autoref: Some(ty::AutoPtr(r_borrow, mt_b.mutbl,
Some(box AutoUnsize(kind)))) Some(box AutoUnsize(kind))))
@ -366,7 +366,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
try!(self.get_ref().infcx.try(|| sub.tys(ty, b))); try!(self.get_ref().infcx.try(|| sub.tys(ty, b)));
debug!("Success, coerced with AutoDerefRef(1, \ debug!("Success, coerced with AutoDerefRef(1, \
AutoPtr(AutoUnsize({:?})))", kind); AutoPtr(AutoUnsize({:?})))", kind);
Ok(Some(AutoDerefRef(AutoDerefRef { Ok(Some(AdjustDerefRef(AutoDerefRef {
autoderefs: 1, autoderefs: 1,
autoref: Some(ty::AutoUnsafe(mt_b.mutbl, autoref: Some(ty::AutoUnsafe(mt_b.mutbl,
Some(box AutoUnsize(kind)))) Some(box AutoUnsize(kind))))
@ -384,7 +384,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
try!(self.get_ref().infcx.try(|| sub.tys(ty, b))); try!(self.get_ref().infcx.try(|| sub.tys(ty, b)));
debug!("Success, coerced with AutoDerefRef(1, \ debug!("Success, coerced with AutoDerefRef(1, \
AutoUnsizeUniq({:?}))", kind); AutoUnsizeUniq({:?}))", kind);
Ok(Some(AutoDerefRef(AutoDerefRef { Ok(Some(AdjustDerefRef(AutoDerefRef {
autoderefs: 1, autoderefs: 1,
autoref: Some(ty::AutoUnsizeUniq(kind)) autoref: Some(ty::AutoUnsizeUniq(kind))
}))) })))
@ -537,7 +537,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
let tr = ty::mk_trait(tcx, def_id, substs.clone(), bounds); let tr = ty::mk_trait(tcx, def_id, substs.clone(), bounds);
try!(self.subtype(mk_ty(tr), b)); try!(self.subtype(mk_ty(tr), b));
Ok(Some(AutoDerefRef(AutoDerefRef { Ok(Some(AdjustDerefRef(AutoDerefRef {
autoderefs: 1, autoderefs: 1,
autoref: Some(mk_adjust()) autoref: Some(mk_adjust())
}))) })))
@ -593,7 +593,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
_ => return self.subtype(a, b) _ => return self.subtype(a, b)
}; };
let adj = ty::AutoAddEnv(fn_ty_b.store); let adj = ty::AdjustAddEnv(fn_ty_b.store);
let a_closure = ty::mk_closure(self.get_ref().infcx.tcx, let a_closure = ty::mk_closure(self.get_ref().infcx.tcx,
ty::ClosureTy { ty::ClosureTy {
sig: fn_ty_a.sig.clone(), sig: fn_ty_a.sig.clone(),
@ -630,7 +630,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
// Although references and unsafe ptrs have the same // Although references and unsafe ptrs have the same
// representation, we still register an AutoDerefRef so that // representation, we still register an AutoDerefRef so that
// regionck knows that the region for `a` must be valid here. // regionck knows that the region for `a` must be valid here.
Ok(Some(AutoDerefRef(AutoDerefRef { Ok(Some(AdjustDerefRef(AutoDerefRef {
autoderefs: 1, autoderefs: 1,
autoref: Some(ty::AutoUnsafe(mutbl_b, None)) autoref: Some(ty::AutoUnsafe(mutbl_b, None))
}))) })))

4
src/librustc/middle/typeck/mod.rs
View file

@ -102,10 +102,10 @@ pub enum MethodOrigin {
MethodStaticUnboxedClosure(ast::DefId), MethodStaticUnboxedClosure(ast::DefId),
// method invoked on a type parameter with a bounded trait // method invoked on a type parameter with a bounded trait
MethodParam(MethodParam), MethodTypeParam(MethodParam),
// method invoked on a trait instance // method invoked on a trait instance
MethodObject(MethodObject), MethodTraitObject(MethodObject),
} }

6
src/librustc/plugin/registry.rs
View file

@ -13,7 +13,7 @@
use lint::{LintPassObject, LintId, Lint}; use lint::{LintPassObject, LintId, Lint};
use syntax::ext::base::{SyntaxExtension, NamedSyntaxExtension, NormalTT}; use syntax::ext::base::{SyntaxExtension, NamedSyntaxExtension, NormalTT};
use syntax::ext::base::{IdentTT, LetSyntaxTT, ItemDecorator, ItemModifier}; use syntax::ext::base::{IdentTT, LetSyntaxTT, Decorator, Modifier};
use syntax::ext::base::{MacroExpanderFn}; use syntax::ext::base::{MacroExpanderFn};
use syntax::codemap::Span; use syntax::codemap::Span;
use syntax::parse::token; use syntax::parse::token;
@ -61,8 +61,8 @@ impl Registry {
self.syntax_exts.push((name, match extension { self.syntax_exts.push((name, match extension {
NormalTT(ext, _) => NormalTT(ext, Some(self.krate_span)), NormalTT(ext, _) => NormalTT(ext, Some(self.krate_span)),
IdentTT(ext, _) => IdentTT(ext, Some(self.krate_span)), IdentTT(ext, _) => IdentTT(ext, Some(self.krate_span)),
ItemDecorator(ext) => ItemDecorator(ext), Decorator(ext) => Decorator(ext),
ItemModifier(ext) => ItemModifier(ext), Modifier(ext) => Modifier(ext),
// there's probably a nicer way to signal this: // there's probably a nicer way to signal this:
LetSyntaxTT(_, _) => fail!("can't register a new LetSyntax!"), LetSyntaxTT(_, _) => fail!("can't register a new LetSyntax!"),
})); }));

4
src/librustc/util/ppaux.rs
View file

@ -962,10 +962,10 @@ impl Repr for typeck::MethodOrigin {
&typeck::MethodStaticUnboxedClosure(def_id) => { &typeck::MethodStaticUnboxedClosure(def_id) => {
format!("MethodStaticUnboxedClosure({})", def_id.repr(tcx)) format!("MethodStaticUnboxedClosure({})", def_id.repr(tcx))
} }
&typeck::MethodParam(ref p) => { &typeck::MethodTypeParam(ref p) => {
p.repr(tcx) p.repr(tcx)
} }
&typeck::MethodObject(ref p) => { &typeck::MethodTraitObject(ref p) => {
p.repr(tcx) p.repr(tcx)
} }
} }

6
src/librustc_llvm/lib.rs
View file

@ -325,11 +325,11 @@ pub enum AtomicOrdering {
// Consts for the LLVMCodeGenFileType type (in include/llvm/c/TargetMachine.h) // Consts for the LLVMCodeGenFileType type (in include/llvm/c/TargetMachine.h)
#[repr(C)] #[repr(C)]
pub enum FileType { pub enum FileType {
AssemblyFile = 0, AssemblyFileType = 0,
ObjectFile = 1 ObjectFileType = 1
} }
pub enum Metadata { pub enum MetadataType {
MD_dbg = 0, MD_dbg = 0,
MD_tbaa = 1, MD_tbaa = 1,
MD_prof = 2, MD_prof = 2,

38
src/librustdoc/clean/mod.rs
View file

@ -99,7 +99,7 @@ pub struct Crate {
pub name: String, pub name: String,
pub module: Option<Item>, pub module: Option<Item>,
pub externs: Vec<(ast::CrateNum, ExternalCrate)>, pub externs: Vec<(ast::CrateNum, ExternalCrate)>,
pub primitives: Vec<Primitive>, pub primitives: Vec<PrimitiveType>,
} }
impl<'a, 'tcx> Clean<Crate> for visit_ast::RustdocVisitor<'a, 'tcx> { impl<'a, 'tcx> Clean<Crate> for visit_ast::RustdocVisitor<'a, 'tcx> {
@ -147,7 +147,7 @@ impl<'a, 'tcx> Clean<Crate> for visit_ast::RustdocVisitor<'a, 'tcx> {
ModuleItem(ref mut m) => m, ModuleItem(ref mut m) => m,
_ => continue, _ => continue,
}; };
let prim = match Primitive::find(child.attrs.as_slice()) { let prim = match PrimitiveType::find(child.attrs.as_slice()) {
Some(prim) => prim, Some(prim) => prim,
None => continue, None => continue,
}; };
@ -187,7 +187,7 @@ impl<'a, 'tcx> Clean<Crate> for visit_ast::RustdocVisitor<'a, 'tcx> {
pub struct ExternalCrate { pub struct ExternalCrate {
pub name: String, pub name: String,
pub attrs: Vec<Attribute>, pub attrs: Vec<Attribute>,
pub primitives: Vec<Primitive>, pub primitives: Vec<PrimitiveType>,
} }
impl Clean<ExternalCrate> for cstore::crate_metadata { impl Clean<ExternalCrate> for cstore::crate_metadata {
@ -202,7 +202,7 @@ impl Clean<ExternalCrate> for cstore::crate_metadata {
_ => return _ => return
}; };
let attrs = inline::load_attrs(cx, tcx, did); let attrs = inline::load_attrs(cx, tcx, did);
Primitive::find(attrs.as_slice()).map(|prim| primitives.push(prim)); PrimitiveType::find(attrs.as_slice()).map(|prim| primitives.push(prim));
}) })
}); });
ExternalCrate { ExternalCrate {
@ -316,7 +316,7 @@ pub enum ItemEnum {
/// `static`s from an extern block /// `static`s from an extern block
ForeignStaticItem(Static), ForeignStaticItem(Static),
MacroItem(Macro), MacroItem(Macro),
PrimitiveItem(Primitive), PrimitiveItem(PrimitiveType),
AssociatedTypeItem, AssociatedTypeItem,
} }
@ -901,7 +901,7 @@ impl Clean<RetStyle> for ast::RetStyle {
#[deriving(Clone, Encodable, Decodable)] #[deriving(Clone, Encodable, Decodable)]
pub struct Trait { pub struct Trait {
pub items: Vec<TraitItem>, pub items: Vec<TraitMethod>,
pub generics: Generics, pub generics: Generics,
pub bounds: Vec<TyParamBound>, pub bounds: Vec<TyParamBound>,
} }
@ -931,13 +931,13 @@ impl Clean<Type> for ast::TraitRef {
} }
#[deriving(Clone, Encodable, Decodable)] #[deriving(Clone, Encodable, Decodable)]
pub enum TraitItem { pub enum TraitMethod {
RequiredMethod(Item), RequiredMethod(Item),
ProvidedMethod(Item), ProvidedMethod(Item),
TypeTraitItem(Item), TypeTraitItem(Item),
} }
impl TraitItem { impl TraitMethod {
pub fn is_req(&self) -> bool { pub fn is_req(&self) -> bool {
match self { match self {
&RequiredMethod(..) => true, &RequiredMethod(..) => true,
@ -959,8 +959,8 @@ impl TraitItem {
} }
} }
impl Clean<TraitItem> for ast::TraitItem { impl Clean<TraitMethod> for ast::TraitItem {
fn clean(&self, cx: &DocContext) -> TraitItem { fn clean(&self, cx: &DocContext) -> TraitMethod {
match self { match self {
&ast::RequiredMethod(ref t) => RequiredMethod(t.clean(cx)), &ast::RequiredMethod(ref t) => RequiredMethod(t.clean(cx)),
&ast::ProvidedMethod(ref t) => ProvidedMethod(t.clean(cx)), &ast::ProvidedMethod(ref t) => ProvidedMethod(t.clean(cx)),
@ -970,13 +970,13 @@ impl Clean<TraitItem> for ast::TraitItem {
} }
#[deriving(Clone, Encodable, Decodable)] #[deriving(Clone, Encodable, Decodable)]
pub enum ImplItem { pub enum ImplMethod {
MethodImplItem(Item), MethodImplItem(Item),
TypeImplItem(Item), TypeImplItem(Item),
} }
impl Clean<ImplItem> for ast::ImplItem { impl Clean<ImplMethod> for ast::ImplItem {
fn clean(&self, cx: &DocContext) -> ImplItem { fn clean(&self, cx: &DocContext) -> ImplMethod {
match self { match self {
&ast::MethodImplItem(ref t) => MethodImplItem(t.clean(cx)), &ast::MethodImplItem(ref t) => MethodImplItem(t.clean(cx)),
&ast::TypeImplItem(ref t) => TypeImplItem(t.clean(cx)), &ast::TypeImplItem(ref t) => TypeImplItem(t.clean(cx)),
@ -1058,7 +1058,7 @@ pub enum Type {
/// For references to self /// For references to self
Self(ast::DefId), Self(ast::DefId),
/// Primitives are just the fixed-size numeric types (plus int/uint/float), and char. /// Primitives are just the fixed-size numeric types (plus int/uint/float), and char.
Primitive(Primitive), Primitive(PrimitiveType),
Closure(Box<ClosureDecl>), Closure(Box<ClosureDecl>),
Proc(Box<ClosureDecl>), Proc(Box<ClosureDecl>),
/// extern "ABI" fn /// extern "ABI" fn
@ -1080,7 +1080,7 @@ pub enum Type {
} }
#[deriving(Clone, Encodable, Decodable, PartialEq, Eq, Hash)] #[deriving(Clone, Encodable, Decodable, PartialEq, Eq, Hash)]
pub enum Primitive { pub enum PrimitiveType {
Int, I8, I16, I32, I64, Int, I8, I16, I32, I64,
Uint, U8, U16, U32, U64, Uint, U8, U16, U32, U64,
F32, F64, F32, F64,
@ -1104,8 +1104,8 @@ pub enum TypeKind {
TypeTypedef, TypeTypedef,
} }
impl Primitive { impl PrimitiveType {
fn from_str(s: &str) -> Option<Primitive> { fn from_str(s: &str) -> Option<PrimitiveType> {
match s.as_slice() { match s.as_slice() {
"int" => Some(Int), "int" => Some(Int),
"i8" => Some(I8), "i8" => Some(I8),
@ -1129,7 +1129,7 @@ impl Primitive {
} }
} }
fn find(attrs: &[Attribute]) -> Option<Primitive> { fn find(attrs: &[Attribute]) -> Option<PrimitiveType> {
for attr in attrs.iter() { for attr in attrs.iter() {
let list = match *attr { let list = match *attr {
List(ref k, ref l) if k.as_slice() == "doc" => l, List(ref k, ref l) if k.as_slice() == "doc" => l,
@ -1141,7 +1141,7 @@ impl Primitive {
if k.as_slice() == "primitive" => v.as_slice(), if k.as_slice() == "primitive" => v.as_slice(),
_ => continue, _ => continue,
}; };
match Primitive::from_str(value) { match PrimitiveType::from_str(value) {
Some(p) => return Some(p), Some(p) => return Some(p),
None => {} None => {}
} }

4
src/librustdoc/fold.rs
View file

@ -40,8 +40,8 @@ pub trait DocFolder {
EnumItem(i) EnumItem(i)
}, },
TraitItem(mut i) => { TraitItem(mut i) => {
fn vtrm<T: DocFolder>(this: &mut T, trm: TraitItem) fn vtrm<T: DocFolder>(this: &mut T, trm: TraitMethod)
-> Option<TraitItem> { -> Option<TraitMethod> {
match trm { match trm {
RequiredMethod(it) => { RequiredMethod(it) => {
match this.fold_item(it) { match this.fold_item(it) {

2
src/librustdoc/html/format.rs
View file

@ -277,7 +277,7 @@ fn path(w: &mut fmt::Formatter, path: &clean::Path, print_all: bool,
} }
fn primitive_link(f: &mut fmt::Formatter, fn primitive_link(f: &mut fmt::Formatter,
prim: clean::Primitive, prim: clean::PrimitiveType,
name: &str) -> fmt::Result { name: &str) -> fmt::Result {
let m = cache_key.get().unwrap(); let m = cache_key.get().unwrap();
let mut needs_termination = false; let mut needs_termination = false;

10
src/librustdoc/html/render.rs
View file

@ -177,7 +177,7 @@ pub struct Cache {
pub extern_locations: HashMap<ast::CrateNum, ExternalLocation>, pub extern_locations: HashMap<ast::CrateNum, ExternalLocation>,
/// Cache of where documentation for primitives can be found. /// Cache of where documentation for primitives can be found.
pub primitive_locations: HashMap<clean::Primitive, ast::CrateNum>, pub primitive_locations: HashMap<clean::PrimitiveType, ast::CrateNum>,
/// Set of definitions which have been inlined from external crates. /// Set of definitions which have been inlined from external crates.
pub inlined: HashSet<ast::DefId>, pub inlined: HashSet<ast::DefId>,
@ -1637,7 +1637,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
_ => false, _ => false,
} }
}) })
.collect::<Vec<&clean::TraitItem>>(); .collect::<Vec<&clean::TraitMethod>>();
let provided = t.items.iter() let provided = t.items.iter()
.filter(|m| { .filter(|m| {
match **m { match **m {
@ -1645,7 +1645,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
_ => false, _ => false,
} }
}) })
.collect::<Vec<&clean::TraitItem>>(); .collect::<Vec<&clean::TraitMethod>>();
if t.items.len() == 0 { if t.items.len() == 0 {
try!(write!(w, "{{ }}")); try!(write!(w, "{{ }}"));
@ -1671,7 +1671,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
// Trait documentation // Trait documentation
try!(document(w, it)); try!(document(w, it));
fn trait_item(w: &mut fmt::Formatter, m: &clean::TraitItem) fn trait_item(w: &mut fmt::Formatter, m: &clean::TraitMethod)
-> fmt::Result { -> fmt::Result {
try!(write!(w, "<h3 id='{}.{}' class='method'>{}<code>", try!(write!(w, "<h3 id='{}.{}' class='method'>{}<code>",
shortty(m.item()), shortty(m.item()),
@ -2180,7 +2180,7 @@ fn item_macro(w: &mut fmt::Formatter, it: &clean::Item,
fn item_primitive(w: &mut fmt::Formatter, fn item_primitive(w: &mut fmt::Formatter,
it: &clean::Item, it: &clean::Item,
_p: &clean::Primitive) -> fmt::Result { _p: &clean::PrimitiveType) -> fmt::Result {
try!(document(w, it)); try!(document(w, it));
render_methods(w, it) render_methods(w, it)
} }

4
src/librustdoc/stability_summary.rs
View file

@ -21,7 +21,7 @@ use syntax::attr::{Deprecated, Experimental, Unstable, Stable, Frozen, Locked};
use syntax::ast::Public; use syntax::ast::Public;
use clean::{Crate, Item, ModuleItem, Module, StructItem, Struct, EnumItem, Enum}; use clean::{Crate, Item, ModuleItem, Module, StructItem, Struct, EnumItem, Enum};
use clean::{ImplItem, Impl, Trait, TraitItem, ProvidedMethod, RequiredMethod}; use clean::{ImplItem, Impl, Trait, TraitItem, TraitMethod, ProvidedMethod, RequiredMethod};
use clean::{TypeTraitItem, ViewItemItem, PrimitiveItem}; use clean::{TypeTraitItem, ViewItemItem, PrimitiveItem};
#[deriving(Zero, Encodable, Decodable, PartialEq, Eq)] #[deriving(Zero, Encodable, Decodable, PartialEq, Eq)]
@ -128,7 +128,7 @@ fn summarize_item(item: &Item) -> (Counts, Option<ModuleSummary>) {
items: ref trait_items, items: ref trait_items,
.. ..
}) => { }) => {
fn extract_item<'a>(trait_item: &'a TraitItem) -> &'a Item { fn extract_item<'a>(trait_item: &'a TraitMethod) -> &'a Item {
match *trait_item { match *trait_item {
ProvidedMethod(ref item) | ProvidedMethod(ref item) |
RequiredMethod(ref item) | RequiredMethod(ref item) |

62
src/librustrt/local_data.rs
View file

@ -67,7 +67,7 @@ use task::{Task, LocalStorage};
pub type Key<T> = &'static KeyValue<T>; pub type Key<T> = &'static KeyValue<T>;
#[allow(missing_doc)] #[allow(missing_doc)]
pub enum KeyValue<T> { Key } pub enum KeyValue<T> { KeyValueKey }
// The task-local-map stores all TLD information for the currently running // The task-local-map stores all TLD information for the currently running
// task. It is stored as an owned pointer into the runtime, and it's only // task. It is stored as an owned pointer into the runtime, and it's only
@ -417,7 +417,7 @@ mod tests {
#[test] #[test]
fn test_tls_multitask() { fn test_tls_multitask() {
static my_key: Key<String> = &Key; static my_key: Key<String> = &KeyValueKey;
my_key.replace(Some("parent data".to_string())); my_key.replace(Some("parent data".to_string()));
task::spawn(proc() { task::spawn(proc() {
// TLD shouldn't carry over. // TLD shouldn't carry over.
@ -435,7 +435,7 @@ mod tests {
#[test] #[test]
fn test_tls_overwrite() { fn test_tls_overwrite() {
static my_key: Key<String> = &Key; static my_key: Key<String> = &KeyValueKey;
my_key.replace(Some("first data".to_string())); my_key.replace(Some("first data".to_string()));
my_key.replace(Some("next data".to_string())); // Shouldn't leak. my_key.replace(Some("next data".to_string())); // Shouldn't leak.
assert!(my_key.get().unwrap().as_slice() == "next data"); assert!(my_key.get().unwrap().as_slice() == "next data");
@ -443,7 +443,7 @@ mod tests {
#[test] #[test]
fn test_tls_pop() { fn test_tls_pop() {
static my_key: Key<String> = &Key; static my_key: Key<String> = &KeyValueKey;
my_key.replace(Some("weasel".to_string())); my_key.replace(Some("weasel".to_string()));
assert!(my_key.replace(None).unwrap() == "weasel".to_string()); assert!(my_key.replace(None).unwrap() == "weasel".to_string());
// Pop must remove the data from the map. // Pop must remove the data from the map.
@ -458,7 +458,7 @@ mod tests {
// to get recorded as something within a rust stack segment. Then a // to get recorded as something within a rust stack segment. Then a
// subsequent upcall (esp. for logging, think vsnprintf) would run on // subsequent upcall (esp. for logging, think vsnprintf) would run on
// a stack smaller than 1 MB. // a stack smaller than 1 MB.
static my_key: Key<String> = &Key; static my_key: Key<String> = &KeyValueKey;
task::spawn(proc() { task::spawn(proc() {
my_key.replace(Some("hax".to_string())); my_key.replace(Some("hax".to_string()));
}); });
@ -466,9 +466,9 @@ mod tests {
#[test] #[test]
fn test_tls_multiple_types() { fn test_tls_multiple_types() {
static str_key: Key<String> = &Key; static str_key: Key<String> = &KeyValueKey;
static box_key: Key<Gc<()>> = &Key; static box_key: Key<Gc<()>> = &KeyValueKey;
static int_key: Key<int> = &Key; static int_key: Key<int> = &KeyValueKey;
task::spawn(proc() { task::spawn(proc() {
str_key.replace(Some("string data".to_string())); str_key.replace(Some("string data".to_string()));
box_key.replace(Some(box(GC) ())); box_key.replace(Some(box(GC) ()));
@ -478,9 +478,9 @@ mod tests {
#[test] #[test]
fn test_tls_overwrite_multiple_types() { fn test_tls_overwrite_multiple_types() {
static str_key: Key<String> = &Key; static str_key: Key<String> = &KeyValueKey;
static box_key: Key<Gc<()>> = &Key; static box_key: Key<Gc<()>> = &KeyValueKey;
static int_key: Key<int> = &Key; static int_key: Key<int> = &KeyValueKey;
task::spawn(proc() { task::spawn(proc() {
str_key.replace(Some("string data".to_string())); str_key.replace(Some("string data".to_string()));
str_key.replace(Some("string data 2".to_string())); str_key.replace(Some("string data 2".to_string()));
@ -497,9 +497,9 @@ mod tests {
#[test] #[test]
#[should_fail] #[should_fail]
fn test_tls_cleanup_on_failure() { fn test_tls_cleanup_on_failure() {
static str_key: Key<String> = &Key; static str_key: Key<String> = &KeyValueKey;
static box_key: Key<Gc<()>> = &Key; static box_key: Key<Gc<()>> = &KeyValueKey;
static int_key: Key<int> = &Key; static int_key: Key<int> = &KeyValueKey;
str_key.replace(Some("parent data".to_string())); str_key.replace(Some("parent data".to_string()));
box_key.replace(Some(box(GC) ())); box_key.replace(Some(box(GC) ()));
task::spawn(proc() { task::spawn(proc() {
@ -524,7 +524,7 @@ mod tests {
self.tx.send(()); self.tx.send(());
} }
} }
static key: Key<Dropper> = &Key; static key: Key<Dropper> = &KeyValueKey;
let _ = task::try(proc() { let _ = task::try(proc() {
key.replace(Some(Dropper{ tx: tx })); key.replace(Some(Dropper{ tx: tx }));
}); });
@ -535,14 +535,14 @@ mod tests {
#[test] #[test]
fn test_static_pointer() { fn test_static_pointer() {
static key: Key<&'static int> = &Key; static key: Key<&'static int> = &KeyValueKey;
static VALUE: int = 0; static VALUE: int = 0;
key.replace(Some(&VALUE)); key.replace(Some(&VALUE));
} }
#[test] #[test]
fn test_owned() { fn test_owned() {
static key: Key<Box<int>> = &Key; static key: Key<Box<int>> = &KeyValueKey;
key.replace(Some(box 1)); key.replace(Some(box 1));
{ {
@ -559,11 +559,11 @@ mod tests {
#[test] #[test]
fn test_same_key_type() { fn test_same_key_type() {
static key1: Key<int> = &Key; static key1: Key<int> = &KeyValueKey;
static key2: Key<int> = &Key; static key2: Key<int> = &KeyValueKey;
static key3: Key<int> = &Key; static key3: Key<int> = &KeyValueKey;
static key4: Key<int> = &Key; static key4: Key<int> = &KeyValueKey;
static key5: Key<int> = &Key; static key5: Key<int> = &KeyValueKey;
key1.replace(Some(1)); key1.replace(Some(1));
key2.replace(Some(2)); key2.replace(Some(2));
key3.replace(Some(3)); key3.replace(Some(3));
@ -580,7 +580,7 @@ mod tests {
#[test] #[test]
#[should_fail] #[should_fail]
fn test_nested_get_set1() { fn test_nested_get_set1() {
static key: Key<int> = &Key; static key: Key<int> = &KeyValueKey;
assert_eq!(key.replace(Some(4)), None); assert_eq!(key.replace(Some(4)), None);
let _k = key.get(); let _k = key.get();
@ -602,7 +602,7 @@ mod tests {
#[bench] #[bench]
fn bench_replace_none(b: &mut test::Bencher) { fn bench_replace_none(b: &mut test::Bencher) {
static key: Key<uint> = &Key; static key: Key<uint> = &KeyValueKey;
let _clear = ClearKey(key); let _clear = ClearKey(key);
key.replace(None); key.replace(None);
b.iter(|| { b.iter(|| {
@ -612,7 +612,7 @@ mod tests {
#[bench] #[bench]
fn bench_replace_some(b: &mut test::Bencher) { fn bench_replace_some(b: &mut test::Bencher) {
static key: Key<uint> = &Key; static key: Key<uint> = &KeyValueKey;
let _clear = ClearKey(key); let _clear = ClearKey(key);
key.replace(Some(1u)); key.replace(Some(1u));
b.iter(|| { b.iter(|| {
@ -622,7 +622,7 @@ mod tests {
#[bench] #[bench]
fn bench_replace_none_some(b: &mut test::Bencher) { fn bench_replace_none_some(b: &mut test::Bencher) {
static key: Key<uint> = &Key; static key: Key<uint> = &KeyValueKey;
let _clear = ClearKey(key); let _clear = ClearKey(key);
key.replace(Some(0u)); key.replace(Some(0u));
b.iter(|| { b.iter(|| {
@ -634,7 +634,7 @@ mod tests {
#[bench] #[bench]
fn bench_100_keys_replace_last(b: &mut test::Bencher) { fn bench_100_keys_replace_last(b: &mut test::Bencher) {
static keys: [KeyValue<uint>, ..100] = [Key, ..100]; static keys: [KeyValue<uint>, ..100] = [KeyValueKey, ..100];
let _clear = keys.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>(); let _clear = keys.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>();
for (i, key) in keys.iter().enumerate() { for (i, key) in keys.iter().enumerate() {
key.replace(Some(i)); key.replace(Some(i));
@ -647,7 +647,7 @@ mod tests {
#[bench] #[bench]
fn bench_1000_keys_replace_last(b: &mut test::Bencher) { fn bench_1000_keys_replace_last(b: &mut test::Bencher) {
static keys: [KeyValue<uint>, ..1000] = [Key, ..1000]; static keys: [KeyValue<uint>, ..1000] = [KeyValueKey, ..1000];
let _clear = keys.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>(); let _clear = keys.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>();
for (i, key) in keys.iter().enumerate() { for (i, key) in keys.iter().enumerate() {
key.replace(Some(i)); key.replace(Some(i));
@ -661,7 +661,7 @@ mod tests {
#[bench] #[bench]
fn bench_get(b: &mut test::Bencher) { fn bench_get(b: &mut test::Bencher) {
static key: Key<uint> = &Key; static key: Key<uint> = &KeyValueKey;
let _clear = ClearKey(key); let _clear = ClearKey(key);
key.replace(Some(42)); key.replace(Some(42));
b.iter(|| { b.iter(|| {
@ -671,7 +671,7 @@ mod tests {
#[bench] #[bench]
fn bench_100_keys_get_last(b: &mut test::Bencher) { fn bench_100_keys_get_last(b: &mut test::Bencher) {
static keys: [KeyValue<uint>, ..100] = [Key, ..100]; static keys: [KeyValue<uint>, ..100] = [KeyValueKey, ..100];
let _clear = keys.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>(); let _clear = keys.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>();
for (i, key) in keys.iter().enumerate() { for (i, key) in keys.iter().enumerate() {
key.replace(Some(i)); key.replace(Some(i));
@ -684,7 +684,7 @@ mod tests {
#[bench] #[bench]
fn bench_1000_keys_get_last(b: &mut test::Bencher) { fn bench_1000_keys_get_last(b: &mut test::Bencher) {
static keys: [KeyValue<uint>, ..1000] = [Key, ..1000]; static keys: [KeyValue<uint>, ..1000] = [KeyValueKey, ..1000];
let _clear = keys.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>(); let _clear = keys.iter().map(ClearKey).collect::<Vec<ClearKey<uint>>>();
for (i, key) in keys.iter().enumerate() { for (i, key) in keys.iter().enumerate() {
key.replace(Some(i)); key.replace(Some(i));

105
src/libserialize/json.rs
View file

@ -28,7 +28,7 @@ Data types that can be encoded are JavaScript types (see the `Json` enum for mor
* `Boolean`: equivalent to rust's `bool` * `Boolean`: equivalent to rust's `bool`
* `Number`: equivalent to rust's `f64` * `Number`: equivalent to rust's `f64`
* `String`: equivalent to rust's `String` * `String`: equivalent to rust's `String`
* `Array`: equivalent to rust's `Vec<T>`, but also allowing objects of different types in the same * `List`: equivalent to rust's `Vec<T>`, but also allowing objects of different types in the same
array array
* `Object`: equivalent to rust's `Treemap<String, json::Json>` * `Object`: equivalent to rust's `Treemap<String, json::Json>`
* `Null` * `Null`
@ -201,7 +201,7 @@ use std::io::MemWriter;
use std::mem::{swap, transmute}; use std::mem::{swap, transmute};
use std::num::{FPNaN, FPInfinite}; use std::num::{FPNaN, FPInfinite};
use std::str::ScalarValue; use std::str::ScalarValue;
use std::string::String; use std::string;
use std::vec::Vec; use std::vec::Vec;
use Encodable; use Encodable;
@ -212,15 +212,15 @@ pub enum Json {
I64(i64), I64(i64),
U64(u64), U64(u64),
F64(f64), F64(f64),
String(String), String(string::String),
Boolean(bool), Boolean(bool),
List(List), List(JsonList),
Object(Object), Object(JsonObject),
Null, Null,
} }
pub type List = Vec<Json>; pub type JsonList = Vec<Json>;
pub type Object = TreeMap<String, Json>; pub type JsonObject = TreeMap<string::String, Json>;
/// The errors that can arise while parsing a JSON stream. /// The errors that can arise while parsing a JSON stream.
#[deriving(Clone, PartialEq)] #[deriving(Clone, PartialEq)]
@ -257,10 +257,10 @@ pub type BuilderError = ParserError;
#[deriving(Clone, PartialEq, Show)] #[deriving(Clone, PartialEq, Show)]
pub enum DecoderError { pub enum DecoderError {
ParseError(ParserError), ParseError(ParserError),
ExpectedError(String, String), ExpectedError(string::String, string::String),
MissingFieldError(String), MissingFieldError(string::String),
UnknownVariantError(String), UnknownVariantError(string::String),
ApplicationError(String) ApplicationError(string::String)
} }
/// Returns a readable error string for a given error code. /// Returns a readable error string for a given error code.
@ -298,9 +298,9 @@ pub fn decode<T: ::Decodable<Decoder, DecoderError>>(s: &str) -> DecodeResult<T>
} }
/// Shortcut function to encode a `T` into a JSON `String` /// Shortcut function to encode a `T` into a JSON `String`
pub fn encode<'a, T: Encodable<Encoder<'a>, io::IoError>>(object: &T) -> String { pub fn encode<'a, T: Encodable<Encoder<'a>, io::IoError>>(object: &T) -> string::String {
let buff = Encoder::buffer_encode(object); let buff = Encoder::buffer_encode(object);
String::from_utf8(buff).unwrap() string::String::from_utf8(buff).unwrap()
} }
impl fmt::Show for ErrorCode { impl fmt::Show for ErrorCode {
@ -375,9 +375,9 @@ fn spaces(wr: &mut io::Writer, mut n: uint) -> Result<(), io::IoError> {
} }
} }
fn fmt_number_or_null(v: f64) -> String { fn fmt_number_or_null(v: f64) -> string::String {
match v.classify() { match v.classify() {
FPNaN | FPInfinite => String::from_str("null"), FPNaN | FPInfinite => string::String::from_str("null"),
_ => f64::to_str_digits(v, 6u) _ => f64::to_str_digits(v, 6u)
} }
} }
@ -411,7 +411,7 @@ impl<'a> Encoder<'a> {
/// ///
/// Note: this function is deprecated. Consider using `json::encode` instead. /// Note: this function is deprecated. Consider using `json::encode` instead.
#[deprecated = "Replaced by `json::encode`"] #[deprecated = "Replaced by `json::encode`"]
pub fn str_encode<T: Encodable<Encoder<'a>, io::IoError>>(object: &T) -> String { pub fn str_encode<T: Encodable<Encoder<'a>, io::IoError>>(object: &T) -> string::String {
encode(object) encode(object)
} }
} }
@ -877,15 +877,15 @@ impl Json {
} }
/// Encodes a json value into a string /// Encodes a json value into a string
pub fn to_pretty_str(&self) -> String { pub fn to_pretty_str(&self) -> string::String {
let mut s = MemWriter::new(); let mut s = MemWriter::new();
self.to_pretty_writer(&mut s as &mut io::Writer).unwrap(); self.to_pretty_writer(&mut s as &mut io::Writer).unwrap();
String::from_utf8(s.unwrap()).unwrap() string::String::from_utf8(s.unwrap()).unwrap()
} }
/// If the Json value is an Object, returns the value associated with the provided key. /// If the Json value is an Object, returns the value associated with the provided key.
/// Otherwise, returns None. /// Otherwise, returns None.
pub fn find<'a>(&'a self, key: &String) -> Option<&'a Json>{ pub fn find<'a>(&'a self, key: &string::String) -> Option<&'a Json>{
match self { match self {
&Object(ref map) => map.find(key), &Object(ref map) => map.find(key),
_ => None _ => None
@ -895,7 +895,7 @@ impl Json {
/// Attempts to get a nested Json Object for each key in `keys`. /// Attempts to get a nested Json Object for each key in `keys`.
/// If any key is found not to exist, find_path will return None. /// If any key is found not to exist, find_path will return None.
/// Otherwise, it will return the Json value associated with the final key. /// Otherwise, it will return the Json value associated with the final key.
pub fn find_path<'a>(&'a self, keys: &[&String]) -> Option<&'a Json>{ pub fn find_path<'a>(&'a self, keys: &[&string::String]) -> Option<&'a Json>{
let mut target = self; let mut target = self;
for key in keys.iter() { for key in keys.iter() {
match target.find(*key) { match target.find(*key) {
@ -909,7 +909,7 @@ impl Json {
/// If the Json value is an Object, performs a depth-first search until /// If the Json value is an Object, performs a depth-first search until
/// a value associated with the provided key is found. If no value is found /// a value associated with the provided key is found. If no value is found
/// or the Json value is not an Object, returns None. /// or the Json value is not an Object, returns None.
pub fn search<'a>(&'a self, key: &String) -> Option<&'a Json> { pub fn search<'a>(&'a self, key: &string::String) -> Option<&'a Json> {
match self { match self {
&Object(ref map) => { &Object(ref map) => {
match map.find(key) { match map.find(key) {
@ -937,7 +937,7 @@ impl Json {
/// If the Json value is an Object, returns the associated TreeMap. /// If the Json value is an Object, returns the associated TreeMap.
/// Returns None otherwise. /// Returns None otherwise.
pub fn as_object<'a>(&'a self) -> Option<&'a Object> { pub fn as_object<'a>(&'a self) -> Option<&'a JsonObject> {
match self { match self {
&Object(ref map) => Some(map), &Object(ref map) => Some(map),
_ => None _ => None
@ -951,7 +951,7 @@ impl Json {
/// If the Json value is a List, returns the associated vector. /// If the Json value is a List, returns the associated vector.
/// Returns None otherwise. /// Returns None otherwise.
pub fn as_list<'a>(&'a self) -> Option<&'a List> { pub fn as_list<'a>(&'a self) -> Option<&'a JsonList> {
match self { match self {
&List(ref list) => Some(&*list), &List(ref list) => Some(&*list),
_ => None _ => None
@ -1075,7 +1075,7 @@ pub enum JsonEvent {
I64Value(i64), I64Value(i64),
U64Value(u64), U64Value(u64),
F64Value(f64), F64Value(f64),
StringValue(String), StringValue(string::String),
NullValue, NullValue,
Error(ParserError), Error(ParserError),
} }
@ -1083,7 +1083,7 @@ pub enum JsonEvent {
#[deriving(PartialEq, Show)] #[deriving(PartialEq, Show)]
enum ParserState { enum ParserState {
// Parse a value in a list, true means first element. // Parse a value in a list, true means first element.
ParseList(bool), ParseArray(bool),
// Parse ',' or ']' after an element in a list. // Parse ',' or ']' after an element in a list.
ParseListComma, ParseListComma,
// Parse a key:value in an object, true means first element. // Parse a key:value in an object, true means first element.
@ -1191,7 +1191,7 @@ impl Stack {
} }
// Used by Parser to insert Key elements at the top of the stack. // Used by Parser to insert Key elements at the top of the stack.
fn push_key(&mut self, key: String) { fn push_key(&mut self, key: string::String) {
self.stack.push(InternalKey(self.str_buffer.len() as u16, key.len() as u16)); self.stack.push(InternalKey(self.str_buffer.len() as u16, key.len() as u16));
for c in key.as_bytes().iter() { for c in key.as_bytes().iter() {
self.str_buffer.push(*c); self.str_buffer.push(*c);
@ -1502,9 +1502,9 @@ impl<T: Iterator<char>> Parser<T> {
Ok(n) Ok(n)
} }
fn parse_str(&mut self) -> Result<String, ParserError> { fn parse_str(&mut self) -> Result<string::String, ParserError> {
let mut escape = false; let mut escape = false;
let mut res = String::new(); let mut res = string::String::new();
loop { loop {
self.bump(); self.bump();
@ -1574,7 +1574,7 @@ impl<T: Iterator<char>> Parser<T> {
// The only paths where the loop can spin a new iteration // The only paths where the loop can spin a new iteration
// are in the cases ParseListComma and ParseObjectComma if ',' // are in the cases ParseListComma and ParseObjectComma if ','
// is parsed. In these cases the state is set to (respectively) // is parsed. In these cases the state is set to (respectively)
// ParseList(false) and ParseObject(false), which always return, // ParseArray(false) and ParseObject(false), which always return,
// so there is no risk of getting stuck in an infinite loop. // so there is no risk of getting stuck in an infinite loop.
// All other paths return before the end of the loop's iteration. // All other paths return before the end of the loop's iteration.
self.parse_whitespace(); self.parse_whitespace();
@ -1583,7 +1583,7 @@ impl<T: Iterator<char>> Parser<T> {
ParseStart => { ParseStart => {
return self.parse_start(); return self.parse_start();
} }
ParseList(first) => { ParseArray(first) => {
return self.parse_list(first); return self.parse_list(first);
} }
ParseListComma => { ParseListComma => {
@ -1615,7 +1615,7 @@ impl<T: Iterator<char>> Parser<T> {
let val = self.parse_value(); let val = self.parse_value();
self.state = match val { self.state = match val {
Error(_) => { ParseFinished } Error(_) => { ParseFinished }
ListStart => { ParseList(true) } ListStart => { ParseArray(true) }
ObjectStart => { ParseObject(true) } ObjectStart => { ParseObject(true) }
_ => { ParseBeforeFinish } _ => { ParseBeforeFinish }
}; };
@ -1647,7 +1647,7 @@ impl<T: Iterator<char>> Parser<T> {
self.state = match val { self.state = match val {
Error(_) => { ParseFinished } Error(_) => { ParseFinished }
ListStart => { ParseList(true) } ListStart => { ParseArray(true) }
ObjectStart => { ParseObject(true) } ObjectStart => { ParseObject(true) }
_ => { ParseListComma } _ => { ParseListComma }
}; };
@ -1657,7 +1657,7 @@ impl<T: Iterator<char>> Parser<T> {
fn parse_list_comma_or_end(&mut self) -> Option<JsonEvent> { fn parse_list_comma_or_end(&mut self) -> Option<JsonEvent> {
if self.ch_is(',') { if self.ch_is(',') {
self.stack.bump_index(); self.stack.bump_index();
self.state = ParseList(false); self.state = ParseArray(false);
self.bump(); self.bump();
return None; return None;
} else if self.ch_is(']') { } else if self.ch_is(']') {
@ -1728,7 +1728,7 @@ impl<T: Iterator<char>> Parser<T> {
self.state = match val { self.state = match val {
Error(_) => { ParseFinished } Error(_) => { ParseFinished }
ListStart => { ParseList(true) } ListStart => { ParseArray(true) }
ObjectStart => { ParseObject(true) } ObjectStart => { ParseObject(true) }
_ => { ParseObjectComma } _ => { ParseObjectComma }
}; };
@ -1830,7 +1830,7 @@ impl<T: Iterator<char>> Builder<T> {
Some(F64Value(n)) => { Ok(F64(n)) } Some(F64Value(n)) => { Ok(F64(n)) }
Some(BooleanValue(b)) => { Ok(Boolean(b)) } Some(BooleanValue(b)) => { Ok(Boolean(b)) }
Some(StringValue(ref mut s)) => { Some(StringValue(ref mut s)) => {
let mut temp = String::new(); let mut temp = string::String::new();
swap(s, &mut temp); swap(s, &mut temp);
Ok(String(temp)) Ok(String(temp))
} }
@ -2034,7 +2034,7 @@ impl ::Decoder<DecoderError> for Decoder {
Err(ExpectedError("single character string".to_string(), format!("{}", s))) Err(ExpectedError("single character string".to_string(), format!("{}", s)))
} }
fn read_str(&mut self) -> DecodeResult<String> { fn read_str(&mut self) -> DecodeResult<string::String> {
debug!("read_str"); debug!("read_str");
expect!(self.pop(), String) expect!(self.pop(), String)
} }
@ -2284,7 +2284,7 @@ impl ToJson for bool {
fn to_json(&self) -> Json { Boolean(*self) } fn to_json(&self) -> Json { Boolean(*self) }
} }
impl ToJson for String { impl ToJson for string::String {
fn to_json(&self) -> Json { String((*self).clone()) } fn to_json(&self) -> Json { String((*self).clone()) }
} }
@ -2328,7 +2328,7 @@ impl<A: ToJson> ToJson for Vec<A> {
fn to_json(&self) -> Json { List(self.iter().map(|elt| elt.to_json()).collect()) } fn to_json(&self) -> Json { List(self.iter().map(|elt| elt.to_json()).collect()) }
} }
impl<A: ToJson> ToJson for TreeMap<String, A> { impl<A: ToJson> ToJson for TreeMap<string::String, A> {
fn to_json(&self) -> Json { fn to_json(&self) -> Json {
let mut d = TreeMap::new(); let mut d = TreeMap::new();
for (key, value) in self.iter() { for (key, value) in self.iter() {
@ -2338,7 +2338,7 @@ impl<A: ToJson> ToJson for TreeMap<String, A> {
} }
} }
impl<A: ToJson> ToJson for HashMap<String, A> { impl<A: ToJson> ToJson for HashMap<string::String, A> {
fn to_json(&self) -> Json { fn to_json(&self) -> Json {
let mut d = TreeMap::new(); let mut d = TreeMap::new();
for (key, value) in self.iter() { for (key, value) in self.iter() {
@ -2375,7 +2375,7 @@ mod tests {
extern crate test; extern crate test;
use self::test::Bencher; use self::test::Bencher;
use {Encodable, Decodable}; use {Encodable, Decodable};
use super::{Encoder, Decoder, Error, Boolean, I64, U64, F64, List, String, Null, use super::{List, Encoder, Decoder, Error, Boolean, I64, U64, F64, String, Null,
PrettyEncoder, Object, Json, from_str, ParseError, ExpectedError, PrettyEncoder, Object, Json, from_str, ParseError, ExpectedError,
MissingFieldError, UnknownVariantError, DecodeResult, DecoderError, MissingFieldError, UnknownVariantError, DecodeResult, DecoderError,
JsonEvent, Parser, StackElement, JsonEvent, Parser, StackElement,
@ -2386,6 +2386,7 @@ mod tests {
TrailingCharacters, TrailingComma}; TrailingCharacters, TrailingComma};
use std::{i64, u64, f32, f64, io}; use std::{i64, u64, f32, f64, io};
use std::collections::TreeMap; use std::collections::TreeMap;
use std::string;
#[deriving(Decodable, Eq, PartialEq, Show)] #[deriving(Decodable, Eq, PartialEq, Show)]
struct OptionData { struct OptionData {
@ -2417,14 +2418,14 @@ mod tests {
#[deriving(PartialEq, Encodable, Decodable, Show)] #[deriving(PartialEq, Encodable, Decodable, Show)]
enum Animal { enum Animal {
Dog, Dog,
Frog(String, int) Frog(string::String, int)
} }
#[deriving(PartialEq, Encodable, Decodable, Show)] #[deriving(PartialEq, Encodable, Decodable, Show)]
struct Inner { struct Inner {
a: (), a: (),
b: uint, b: uint,
c: Vec<String>, c: Vec<string::String>,
} }
#[deriving(PartialEq, Encodable, Decodable, Show)] #[deriving(PartialEq, Encodable, Decodable, Show)]
@ -2432,7 +2433,7 @@ mod tests {
inner: Vec<Inner>, inner: Vec<Inner>,
} }
fn mk_object(items: &[(String, Json)]) -> Json { fn mk_object(items: &[(string::String, Json)]) -> Json {
let mut d = TreeMap::new(); let mut d = TreeMap::new();
for item in items.iter() { for item in items.iter() {
@ -2610,7 +2611,7 @@ mod tests {
from_str(a.to_pretty_str().as_slice()).unwrap()); from_str(a.to_pretty_str().as_slice()).unwrap());
} }
fn with_str_writer(f: |&mut io::Writer|) -> String { fn with_str_writer(f: |&mut io::Writer|) -> string::String {
use std::io::MemWriter; use std::io::MemWriter;
use std::str; use std::str;
@ -2678,7 +2679,7 @@ mod tests {
#[test] #[test]
fn test_write_none() { fn test_write_none() {
let value: Option<String> = None; let value: Option<string::String> = None;
let s = with_str_writer(|writer| { let s = with_str_writer(|writer| {
let mut encoder = Encoder::new(writer); let mut encoder = Encoder::new(writer);
value.encode(&mut encoder).unwrap(); value.encode(&mut encoder).unwrap();
@ -2825,7 +2826,7 @@ mod tests {
("\"\\uAB12\"", "\uAB12")]; ("\"\\uAB12\"", "\uAB12")];
for &(i, o) in s.iter() { for &(i, o) in s.iter() {
let v: String = super::decode(i).unwrap(); let v: string::String = super::decode(i).unwrap();
assert_eq!(v.as_slice(), o); assert_eq!(v.as_slice(), o);
} }
} }
@ -2959,10 +2960,10 @@ mod tests {
#[test] #[test]
fn test_decode_option() { fn test_decode_option() {
let value: Option<String> = super::decode("null").unwrap(); let value: Option<string::String> = super::decode("null").unwrap();
assert_eq!(value, None); assert_eq!(value, None);
let value: Option<String> = super::decode("\"jodhpurs\"").unwrap(); let value: Option<string::String> = super::decode("\"jodhpurs\"").unwrap();
assert_eq!(value, Some("jodhpurs".to_string())); assert_eq!(value, Some("jodhpurs".to_string()));
} }
@ -2980,7 +2981,7 @@ mod tests {
fn test_decode_map() { fn test_decode_map() {
let s = "{\"a\": \"Dog\", \"b\": {\"variant\":\"Frog\",\ let s = "{\"a\": \"Dog\", \"b\": {\"variant\":\"Frog\",\
\"fields\":[\"Henry\", 349]}}"; \"fields\":[\"Henry\", 349]}}";
let mut map: TreeMap<String, Animal> = super::decode(s).unwrap(); let mut map: TreeMap<string::String, Animal> = super::decode(s).unwrap();
assert_eq!(map.pop(&"a".to_string()), Some(Dog)); assert_eq!(map.pop(&"a".to_string()), Some(Dog));
assert_eq!(map.pop(&"b".to_string()), Some(Frog("Henry".to_string(), 349))); assert_eq!(map.pop(&"b".to_string()), Some(Frog("Henry".to_string(), 349)));
@ -2997,13 +2998,13 @@ mod tests {
struct DecodeStruct { struct DecodeStruct {
x: f64, x: f64,
y: bool, y: bool,
z: String, z: string::String,
w: Vec<DecodeStruct> w: Vec<DecodeStruct>
} }
#[deriving(Decodable)] #[deriving(Decodable)]
enum DecodeEnum { enum DecodeEnum {
A(f64), A(f64),
B(String) B(string::String)
} }
fn check_err<T: Decodable<Decoder, DecoderError>>(to_parse: &'static str, fn check_err<T: Decodable<Decoder, DecoderError>>(to_parse: &'static str,
expected: DecoderError) { expected: DecoderError) {
@ -3709,7 +3710,7 @@ mod tests {
}); });
} }
fn big_json() -> String { fn big_json() -> string::String {
let mut src = "[\n".to_string(); let mut src = "[\n".to_string();
for _ in range(0i, 500) { for _ in range(0i, 500) {
src.push_str(r#"{ "a": true, "b": null, "c":3.1415, "d": "Hello world", "e": \ src.push_str(r#"{ "a": true, "b": null, "c":3.1415, "d": "Hello world", "e": \

4
src/libstd/macros.rs
View file

@ -304,10 +304,10 @@ macro_rules! println(
#[macro_export] #[macro_export]
macro_rules! local_data_key( macro_rules! local_data_key(
($name:ident: $ty:ty) => ( ($name:ident: $ty:ty) => (
static $name: ::std::local_data::Key<$ty> = &::std::local_data::Key; static $name: ::std::local_data::Key<$ty> = &::std::local_data::KeyValueKey;
); );
(pub $name:ident: $ty:ty) => ( (pub $name:ident: $ty:ty) => (
pub static $name: ::std::local_data::Key<$ty> = &::std::local_data::Key; pub static $name: ::std::local_data::Key<$ty> = &::std::local_data::KeyValueKey;
); );
) )

6
src/libsyntax/ext/base.rs
View file

@ -299,11 +299,11 @@ pub enum SyntaxExtension {
/// based upon it. /// based upon it.
/// ///
/// `#[deriving(...)]` is an `ItemDecorator`. /// `#[deriving(...)]` is an `ItemDecorator`.
ItemDecorator(Box<ItemDecorator + 'static>), Decorator(Box<ItemDecorator + 'static>),
/// A syntax extension that is attached to an item and modifies it /// A syntax extension that is attached to an item and modifies it
/// in-place. /// in-place.
ItemModifier(Box<ItemModifier + 'static>), Modifier(Box<ItemModifier + 'static>),
/// A normal, function-like syntax extension. /// A normal, function-like syntax extension.
/// ///
@ -381,7 +381,7 @@ fn initial_syntax_expander_table() -> SyntaxEnv {
builtin_normal_expander( builtin_normal_expander(
ext::log_syntax::expand_syntax_ext)); ext::log_syntax::expand_syntax_ext));
syntax_expanders.insert(intern("deriving"), syntax_expanders.insert(intern("deriving"),
ItemDecorator(box ext::deriving::expand_meta_deriving)); Decorator(box ext::deriving::expand_meta_deriving));
// Quasi-quoting expanders // Quasi-quoting expanders
syntax_expanders.insert(intern("quote_tokens"), syntax_expanders.insert(intern("quote_tokens"),

6
src/libsyntax/ext/expand.rs
View file

@ -252,7 +252,7 @@ pub fn expand_item(it: P<ast::Item>, fld: &mut MacroExpander)
match fld.cx.syntax_env.find(&intern(mname.get())) { match fld.cx.syntax_env.find(&intern(mname.get())) {
Some(rc) => match *rc { Some(rc) => match *rc {
ItemDecorator(ref dec) => { Decorator(ref dec) => {
attr::mark_used(attr); attr::mark_used(attr);
fld.cx.bt_push(ExpnInfo { fld.cx.bt_push(ExpnInfo {
@ -309,7 +309,7 @@ fn expand_item_modifiers(mut it: P<ast::Item>, fld: &mut MacroExpander)
// partition the attributes into ItemModifiers and others // partition the attributes into ItemModifiers and others
let (modifiers, other_attrs) = it.attrs.partitioned(|attr| { let (modifiers, other_attrs) = it.attrs.partitioned(|attr| {
match fld.cx.syntax_env.find(&intern(attr.name().get())) { match fld.cx.syntax_env.find(&intern(attr.name().get())) {
Some(rc) => match *rc { ItemModifier(_) => true, _ => false }, Some(rc) => match *rc { Modifier(_) => true, _ => false },
_ => false _ => false
} }
}); });
@ -328,7 +328,7 @@ fn expand_item_modifiers(mut it: P<ast::Item>, fld: &mut MacroExpander)
match fld.cx.syntax_env.find(&intern(mname.get())) { match fld.cx.syntax_env.find(&intern(mname.get())) {
Some(rc) => match *rc { Some(rc) => match *rc {
ItemModifier(ref mac) => { Modifier(ref mac) => {
attr::mark_used(attr); attr::mark_used(attr);
fld.cx.bt_push(ExpnInfo { fld.cx.bt_push(ExpnInfo {
call_site: attr.span, call_site: attr.span,

33
src/libsyntax/ext/format.rs
View file

@ -19,17 +19,18 @@ use parse::token;
use ptr::P; use ptr::P;
use std::collections::HashMap; use std::collections::HashMap;
use std::string;
#[deriving(PartialEq)] #[deriving(PartialEq)]
enum ArgumentType { enum ArgumentType {
Known(String), Known(string::String),
Unsigned, Unsigned,
String, String,
} }
enum Position { enum Position {
Exact(uint), Exact(uint),
Named(String), Named(string::String),
} }
struct Context<'a, 'b:'a> { struct Context<'a, 'b:'a> {
@ -44,12 +45,12 @@ struct Context<'a, 'b:'a> {
/// Note that we keep a side-array of the ordering of the named arguments /// Note that we keep a side-array of the ordering of the named arguments
/// found to be sure that we can translate them in the same order that they /// found to be sure that we can translate them in the same order that they
/// were declared in. /// were declared in.
names: HashMap<String, P<ast::Expr>>, names: HashMap<string::String, P<ast::Expr>>,
name_types: HashMap<String, ArgumentType>, name_types: HashMap<string::String, ArgumentType>,
name_ordering: Vec<String>, name_ordering: Vec<string::String>,
/// The latest consecutive literal strings, or empty if there weren't any. /// The latest consecutive literal strings, or empty if there weren't any.
literal: String, literal: string::String,
/// Collection of the compiled `rt::Argument` structures /// Collection of the compiled `rt::Argument` structures
pieces: Vec<P<ast::Expr>>, pieces: Vec<P<ast::Expr>>,
@ -58,7 +59,7 @@ struct Context<'a, 'b:'a> {
/// Stays `true` if all formatting parameters are default (as in "{}{}"). /// Stays `true` if all formatting parameters are default (as in "{}{}").
all_pieces_simple: bool, all_pieces_simple: bool,
name_positions: HashMap<String, uint>, name_positions: HashMap<string::String, uint>,
method_statics: Vec<P<ast::Item>>, method_statics: Vec<P<ast::Item>>,
/// Updated as arguments are consumed or methods are entered /// Updated as arguments are consumed or methods are entered
@ -81,10 +82,10 @@ pub enum Invocation {
/// named arguments)) /// named arguments))
fn parse_args(ecx: &mut ExtCtxt, sp: Span, allow_method: bool, fn parse_args(ecx: &mut ExtCtxt, sp: Span, allow_method: bool,
tts: &[ast::TokenTree]) tts: &[ast::TokenTree])
-> (Invocation, Option<(P<ast::Expr>, Vec<P<ast::Expr>>, Vec<String>, -> (Invocation, Option<(P<ast::Expr>, Vec<P<ast::Expr>>, Vec<string::String>,
HashMap<String, P<ast::Expr>>)>) { HashMap<string::String, P<ast::Expr>>)>) {
let mut args = Vec::new(); let mut args = Vec::new();
let mut names = HashMap::<String, P<ast::Expr>>::new(); let mut names = HashMap::<string::String, P<ast::Expr>>::new();
let mut order = Vec::new(); let mut order = Vec::new();
let mut p = ecx.new_parser_from_tts(tts); let mut p = ecx.new_parser_from_tts(tts);
@ -167,7 +168,7 @@ impl<'a, 'b> Context<'a, 'b> {
fn verify_piece(&mut self, p: &parse::Piece) { fn verify_piece(&mut self, p: &parse::Piece) {
match *p { match *p {
parse::String(..) => {} parse::String(..) => {}
parse::Argument(ref arg) => { parse::NextArgument(ref arg) => {
// width/precision first, if they have implicit positional // width/precision first, if they have implicit positional
// parameters it makes more sense to consume them first. // parameters it makes more sense to consume them first.
self.verify_count(arg.format.width); self.verify_count(arg.format.width);
@ -222,7 +223,7 @@ impl<'a, 'b> Context<'a, 'b> {
} }
} }
fn describe_num_args(&self) -> String { fn describe_num_args(&self) -> string::String {
match self.args.len() { match self.args.len() {
0 => "no arguments given".to_string(), 0 => "no arguments given".to_string(),
1 => "there is 1 argument".to_string(), 1 => "there is 1 argument".to_string(),
@ -391,7 +392,7 @@ impl<'a, 'b> Context<'a, 'b> {
self.literal.push_str(s); self.literal.push_str(s);
None None
} }
parse::Argument(ref arg) => { parse::NextArgument(ref arg) => {
// Translate the position // Translate the position
let pos = match arg.position { let pos = match arg.position {
// These two have a direct mapping // These two have a direct mapping
@ -747,8 +748,8 @@ pub fn expand_preparsed_format_args(ecx: &mut ExtCtxt, sp: Span,
invocation: Invocation, invocation: Invocation,
efmt: P<ast::Expr>, efmt: P<ast::Expr>,
args: Vec<P<ast::Expr>>, args: Vec<P<ast::Expr>>,
name_ordering: Vec<String>, name_ordering: Vec<string::String>,
names: HashMap<String, P<ast::Expr>>) names: HashMap<string::String, P<ast::Expr>>)
-> P<ast::Expr> { -> P<ast::Expr> {
let arg_types = Vec::from_fn(args.len(), |_| None); let arg_types = Vec::from_fn(args.len(), |_| None);
let mut cx = Context { let mut cx = Context {
@ -761,7 +762,7 @@ pub fn expand_preparsed_format_args(ecx: &mut ExtCtxt, sp: Span,
name_ordering: name_ordering, name_ordering: name_ordering,
nest_level: 0, nest_level: 0,
next_arg: 0, next_arg: 0,
literal: String::new(), literal: string::String::new(),
pieces: Vec::new(), pieces: Vec::new(),
str_pieces: Vec::new(), str_pieces: Vec::new(),
all_pieces_simple: true, all_pieces_simple: true,

10
src/libsyntax/print/pp.rs
View file

@ -60,7 +60,7 @@
//! avoid combining it with other lines and making matters even worse. //! avoid combining it with other lines and making matters even worse.
use std::io; use std::io;
use std::string::String; use std::string;
#[deriving(Clone, PartialEq)] #[deriving(Clone, PartialEq)]
pub enum Breaks { pub enum Breaks {
@ -82,7 +82,7 @@ pub struct BeginToken {
#[deriving(Clone)] #[deriving(Clone)]
pub enum Token { pub enum Token {
String(String, int), String(string::String, int),
Break(BreakToken), Break(BreakToken),
Begin(BeginToken), Begin(BeginToken),
End, End,
@ -107,7 +107,7 @@ impl Token {
} }
} }
pub fn tok_str(t: Token) -> String { pub fn tok_str(t: Token) -> string::String {
match t { match t {
String(s, len) => return format!("STR({},{})", s, len), String(s, len) => return format!("STR({},{})", s, len),
Break(_) => return "BREAK".to_string(), Break(_) => return "BREAK".to_string(),
@ -122,12 +122,12 @@ pub fn buf_str(toks: Vec<Token>,
left: uint, left: uint,
right: uint, right: uint,
lim: uint) lim: uint)
-> String { -> string::String {
let n = toks.len(); let n = toks.len();
assert_eq!(n, szs.len()); assert_eq!(n, szs.len());
let mut i = left; let mut i = left;
let mut l = lim; let mut l = lim;
let mut s = String::from_str("["); let mut s = string::String::from_str("[");
while i != right && l != 0u { while i != right && l != 0u {
l -= 1u; l -= 1u;
if i != left { if i != left {

22
src/libterm/terminfo/parm.rs
View file

@ -41,7 +41,7 @@ enum FormatState {
#[allow(missing_doc)] #[allow(missing_doc)]
#[deriving(Clone)] #[deriving(Clone)]
pub enum Param { pub enum Param {
String(String), Words(String),
Number(int) Number(int)
} }
@ -140,8 +140,8 @@ pub fn expand(cap: &[u8], params: &[Param], vars: &mut Variables)
'{' => state = IntConstant(0), '{' => state = IntConstant(0),
'l' => if stack.len() > 0 { 'l' => if stack.len() > 0 {
match stack.pop().unwrap() { match stack.pop().unwrap() {
String(s) => stack.push(Number(s.len() as int)), Words(s) => stack.push(Number(s.len() as int)),
_ => return Err("a non-str was used with %l".to_string()) _ => return Err("a non-str was used with %l".to_string())
} }
} else { return Err("stack is empty".to_string()) }, } else { return Err("stack is empty".to_string()) },
'+' => if stack.len() > 1 { '+' => if stack.len() > 1 {
@ -543,7 +543,7 @@ fn format(val: Param, op: FormatOp, flags: Flags) -> Result<Vec<u8> ,String> {
} }
s s
} }
String(s) => { Words(s) => {
match op { match op {
FormatString => { FormatString => {
let mut s = Vec::from_slice(s.as_bytes()); let mut s = Vec::from_slice(s.as_bytes());
@ -575,7 +575,7 @@ fn format(val: Param, op: FormatOp, flags: Flags) -> Result<Vec<u8> ,String> {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use super::{expand,String,Variables,Number}; use super::{expand,Words,Variables,Number};
use std::result::Ok; use std::result::Ok;
#[test] #[test]
@ -611,7 +611,7 @@ mod test {
assert!(res.is_err(), assert!(res.is_err(),
"Op {} succeeded incorrectly with 0 stack entries", *cap); "Op {} succeeded incorrectly with 0 stack entries", *cap);
let p = if *cap == "%s" || *cap == "%l" { let p = if *cap == "%s" || *cap == "%l" {
String("foo".to_string()) Words("foo".to_string())
} else { } else {
Number(97) Number(97)
}; };
@ -689,12 +689,12 @@ mod test {
let mut varstruct = Variables::new(); let mut varstruct = Variables::new();
let vars = &mut varstruct; let vars = &mut varstruct;
assert_eq!(expand(b"%p1%s%p2%2s%p3%2s%p4%.2s", assert_eq!(expand(b"%p1%s%p2%2s%p3%2s%p4%.2s",
[String("foo".to_string()), [Words("foo".to_string()),
String("foo".to_string()), Words("foo".to_string()),
String("f".to_string()), Words("f".to_string()),
String("foo".to_string())], vars), Words("foo".to_string())], vars),
Ok("foofoo ffo".bytes().collect())); Ok("foofoo ffo".bytes().collect()));
assert_eq!(expand(b"%p1%:-4.2s", [String("foo".to_string())], vars), assert_eq!(expand(b"%p1%:-4.2s", [Words("foo".to_string())], vars),
Ok("fo ".bytes().collect())); Ok("fo ".bytes().collect()));
assert_eq!(expand(b"%p1%d%p1%.3d%p1%5d%p1%:+d", [Number(1)], vars), assert_eq!(expand(b"%p1%d%p1%.3d%p1%5d%p1%:+d", [Number(1)], vars),

2
src/test/auxiliary/macro_crate_test.rs
View file

@ -35,7 +35,7 @@ pub fn plugin_registrar(reg: &mut Registry) {
reg.register_macro("identity", expand_identity); reg.register_macro("identity", expand_identity);
reg.register_syntax_extension( reg.register_syntax_extension(
token::intern("into_foo"), token::intern("into_foo"),
ItemModifier(box expand_into_foo)); Modifier(box expand_into_foo));
} }
fn expand_make_a_1(cx: &mut ExtCtxt, sp: Span, tts: &[TokenTree]) fn expand_make_a_1(cx: &mut ExtCtxt, sp: Span, tts: &[TokenTree])

2
src/test/auxiliary/xcrate_unit_struct.rs
View file

@ -15,7 +15,7 @@
pub struct Struct; pub struct Struct;
pub enum Unit { pub enum Unit {
Unit, UnitVariant,
Argument(Struct) Argument(Struct)
} }

12
src/test/run-pass/issue-3186.rs → src/test/compile-fail/enum-variant-type-2.rs
View file

@ -1,4 +1,4 @@
// Copyright 2012 The Rust Project Developers. See the COPYRIGHT // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at // file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT. // http://rust-lang.org/COPYRIGHT.
// //
@ -8,8 +8,12 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
enum y { x } // Test that enum variants are not actually types.
enum x {} enum Foo {
Bar
}
pub fn main() {} fn foo(x: Bar) {} //~ERROR found value name used as a type
fn main() {}

23
src/test/compile-fail/enum-variant-type.rs Normal file
View file

@ -0,0 +1,23 @@
// Copyright 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.
// Test that enum variants are in the type namespace.
enum Foo {
Foo //~ERROR duplicate definition of type or module `Foo`
}
enum Bar {
Baz
}
trait Baz {} //~ERROR duplicate definition of type or module `Baz`
pub fn main() {}

2
src/test/compile-fail/issue-3008-1.rs
View file

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
enum foo { foo(bar) } enum foo { foo_(bar) }
enum bar { bar_none, bar_some(bar) } enum bar { bar_none, bar_some(bar) }
//~^ ERROR illegal recursive enum type; wrap the inner value in a box to make it representable //~^ ERROR illegal recursive enum type; wrap the inner value in a box to make it representable

2
src/test/compile-fail/issue-3008-2.rs
View file

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
enum foo { foo(bar) } enum foo { foo_(bar) }
struct bar { x: bar } struct bar { x: bar }
//~^ ERROR illegal recursive struct type; wrap the inner value in a box to make it representable //~^ ERROR illegal recursive struct type; wrap the inner value in a box to make it representable
//~^^ ERROR this type cannot be instantiated without an instance of itself //~^^ ERROR this type cannot be instantiated without an instance of itself

4
src/test/compile-fail/recursion.rs
View file

@ -8,7 +8,7 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
enum Nil {Nil} enum Nil {NilValue}
struct Cons<T> {head:int, tail:T} struct Cons<T> {head:int, tail:T}
trait Dot {fn dot(&self, other:Self) -> int;} trait Dot {fn dot(&self, other:Self) -> int;}
impl Dot for Nil { impl Dot for Nil {
@ -29,6 +29,6 @@ fn test<T:Dot> (n:int, i:int, first:T, second:T) ->int {
} }
} }
pub fn main() { pub fn main() {
let n = test(1, 0, Nil, Nil); let n = test(1, 0, NilValue, NilValue);
println!("{}", n); println!("{}", n);
} }

4
src/test/pretty/tag-blank-lines.rs
View file

@ -11,8 +11,8 @@
// pp-exact // pp-exact
enum foo { enum foo {
foo, // a foo. bar, // a bar.
bar, baz,
} }
fn main() { } fn main() { }

2
src/test/run-fail/issue-2444.rs
View file

@ -12,7 +12,7 @@
use std::sync::Arc; use std::sync::Arc;
enum e<T> { e(Arc<T>) } enum e<T> { ee(Arc<T>) }
fn foo() -> e<int> {fail!();} fn foo() -> e<int> {fail!();}

6
src/test/run-pass/borrowck-univariant-enum.rs
View file

@ -13,7 +13,7 @@ use std::cell::Cell;
use std::gc::GC; use std::gc::GC;
enum newtype { enum newtype {
newtype(int) newvar(int)
} }
pub fn main() { pub fn main() {
@ -22,9 +22,9 @@ pub fn main() {
// specially. // specially.
let x = box(GC) Cell::new(5); let x = box(GC) Cell::new(5);
let y = box(GC) Cell::new(newtype(3)); let y = box(GC) Cell::new(newvar(3));
let z = match y.get() { let z = match y.get() {
newtype(b) => { newvar(b) => {
x.set(x.get() + 1); x.set(x.get() + 1);
x.get() * b x.get() * b
} }

10
src/test/run-pass/coerce-to-closure-and-proc.rs
View file

@ -17,7 +17,7 @@ struct Foo<T>(T);
#[deriving(PartialEq, Show)] #[deriving(PartialEq, Show)]
enum Bar<T> { enum Bar<T> {
Bar(T) Baz(T)
} }
pub fn main() { pub fn main() {
@ -33,11 +33,11 @@ pub fn main() {
let f: proc(int) -> Foo<int> = Foo; let f: proc(int) -> Foo<int> = Foo;
assert_eq!(f(5), Foo(5)); assert_eq!(f(5), Foo(5));
let f: |int| -> Bar<int> = Bar; let f: |int| -> Bar<int> = Baz;
assert_eq!(f(5), Bar(5)); assert_eq!(f(5), Baz(5));
let f: proc(int) -> Bar<int> = Bar; let f: proc(int) -> Bar<int> = Baz;
assert_eq!(f(5), Bar(5)); assert_eq!(f(5), Baz(5));
let f: |int| -> Option<int> = Some; let f: |int| -> Option<int> = Some;
assert_eq!(f(5), Some(5)); assert_eq!(f(5), Some(5));

2
src/test/run-pass/issue-2804.rs
View file

@ -22,7 +22,7 @@ enum object {
int_value(i64), int_value(i64),
} }
fn lookup(table: json::Object, key: String, default: String) -> String fn lookup(table: json::JsonObject, key: String, default: String) -> String
{ {
match table.find(&key.to_string()) { match table.find(&key.to_string()) {
option::Some(&json::String(ref s)) => { option::Some(&json::String(ref s)) => {

4
src/test/run-pass/issue-3874.rs
View file

@ -8,10 +8,10 @@
// option. This file may not be copied, modified, or distributed // option. This file may not be copied, modified, or distributed
// except according to those terms. // except according to those terms.
enum PureCounter { PureCounter(uint) } enum PureCounter { PureCounterVariant(uint) }
fn each(thing: PureCounter, blk: |v: &uint|) { fn each(thing: PureCounter, blk: |v: &uint|) {
let PureCounter(ref x) = thing; let PureCounterVariant(ref x) = thing;
blk(x); blk(x);
} }

6
src/test/run-pass/match-arm-statics.rs
View file

@ -88,10 +88,10 @@ fn issue_14576() {
} }
fn issue_13731() { fn issue_13731() {
enum A { A(()) } enum A { AA(()) }
static B: A = A(()); static B: A = AA(());
match A(()) { match AA(()) {
B => () B => ()
} }
} }

6
src/test/run-pass/tag-align-shape.rs
View file

@ -11,7 +11,7 @@
extern crate debug; extern crate debug;
enum a_tag { enum a_tag {
a_tag(u64) a_tag_var(u64)
} }
struct t_rec { struct t_rec {
@ -20,8 +20,8 @@ struct t_rec {
} }
pub fn main() { pub fn main() {
let x = t_rec {c8: 22u8, t: a_tag(44u64)}; let x = t_rec {c8: 22u8, t: a_tag_var(44u64)};
let y = format!("{:?}", x); let y = format!("{:?}", x);
println!("y = {}", y); println!("y = {}", y);
assert_eq!(y, "t_rec{c8: 22u8, t: a_tag(44u64)}".to_string()); assert_eq!(y, "t_rec{c8: 22u8, t: a_tag_var(44u64)}".to_string());
} }

4
src/test/run-pass/tag-align-u64.rs
View file

@ -14,7 +14,7 @@
use std::mem; use std::mem;
enum Tag { enum Tag {
Tag(u64) TagInner(u64)
} }
struct Rec { struct Rec {
@ -23,7 +23,7 @@ struct Rec {
} }
fn mk_rec() -> Rec { fn mk_rec() -> Rec {
return Rec { c8:0u8, t:Tag(0u64) }; return Rec { c8:0u8, t:TagInner(0u64) };
} }
fn is_8_byte_aligned(u: &Tag) -> bool { fn is_8_byte_aligned(u: &Tag) -> bool {

4
src/test/run-pass/xcrate-unit-struct.rs
View file

@ -12,7 +12,7 @@
extern crate xcrate_unit_struct; extern crate xcrate_unit_struct;
static s1: xcrate_unit_struct::Struct = xcrate_unit_struct::Struct; static s1: xcrate_unit_struct::Struct = xcrate_unit_struct::Struct;
static s2: xcrate_unit_struct::Unit = xcrate_unit_struct::Unit; static s2: xcrate_unit_struct::Unit = xcrate_unit_struct::UnitVariant;
static s3: xcrate_unit_struct::Unit = static s3: xcrate_unit_struct::Unit =
xcrate_unit_struct::Argument(xcrate_unit_struct::Struct); xcrate_unit_struct::Argument(xcrate_unit_struct::Struct);
static s4: xcrate_unit_struct::Unit = xcrate_unit_struct::Argument(s1); static s4: xcrate_unit_struct::Unit = xcrate_unit_struct::Argument(s1);
@ -22,7 +22,7 @@ fn f2(_: xcrate_unit_struct::Unit) {}
pub fn main() { pub fn main() {
f1(xcrate_unit_struct::Struct); f1(xcrate_unit_struct::Struct);
f2(xcrate_unit_struct::Unit); f2(xcrate_unit_struct::UnitVariant);
f2(xcrate_unit_struct::Argument(xcrate_unit_struct::Struct)); f2(xcrate_unit_struct::Argument(xcrate_unit_struct::Struct));
f1(s1); f1(s1);