//!
//! let five = Arc::new(5);
//!
-//! for _ in 0u..10 {
+//! for _ in 0..10 {
//! let five = five.clone();
//!
//! Thread::spawn(move || {
//!
//! let five = Arc::new(Mutex::new(5));
//!
-//! for _ in 0u..10 {
+//! for _ in 0..10 {
//! let five = five.clone();
//!
//! Thread::spawn(move || {
/// let numbers: Vec<_> = (0..100u32).map(|i| i as f32).collect();
/// let shared_numbers = Arc::new(numbers);
///
-/// for _ in 0u..10 {
+/// for _ in 0..10 {
/// let child_numbers = shared_numbers.clone();
///
/// Thread::spawn(move || {
#[test]
fn test_cowarc_clone_make_unique() {
- let mut cow0 = Arc::new(75u);
+ let mut cow0 = Arc::new(75);
let mut cow1 = cow0.clone();
let mut cow2 = cow1.clone();
#[test]
fn test_cowarc_clone_unique2() {
- let mut cow0 = Arc::new(75u);
+ let mut cow0 = Arc::new(75);
let cow1 = cow0.clone();
let cow2 = cow1.clone();
#[test]
fn test_cowarc_clone_weak() {
- let mut cow0 = Arc::new(75u);
+ let mut cow0 = Arc::new(75);
let cow1_weak = cow0.downgrade();
assert!(75 == *cow0);
#[test]
fn any_move() {
- let a = Box::new(8u) as Box<Any>;
+ let a = Box::new(8u
s) as Box<Any>;
let b = Box::new(Test) as Box<Any>;
match a.downcast::<uint>() {
- Ok(a) => { assert!(a == Box::new(8u)); }
+ Ok(a) => { assert!(a == Box::new(8us)); }
Err(..) => panic!()
}
match b.downcast::<Test>() {
Err(..) => panic!()
}
- let a = Box::new(8
u) as Box<Any>;
+ let a = Box::new(8) as Box<Any>;
let b = Box::new(Test) as Box<Any>;
assert!(a.downcast::<Box<Test>>().is_err());
#[test]
fn test_show() {
- let a = Box::new(8
u) as Box<Any>;
+ let a = Box::new(8) as Box<Any>;
let b = Box::new(Test) as Box<Any>;
let a_str = format!("{:?}", a);
let b_str = format!("{:?}", b);
assert_eq!(a_str, "Box<Any>");
assert_eq!(b_str, "Box<Any>");
- static EIGHT: usize = 8us;
+ static EIGHT: usize = 8;
static TEST: Test = Test;
let a = &EIGHT as &Any;
let b = &TEST as &Any;
/// ```
/// use std::rc::{self, Rc};
///
-/// let x = Rc::new(3u);
-/// assert_eq!(rc::try_unwrap(x), Ok(3u));
+/// let x = Rc::new(3);
+/// assert_eq!(rc::try_unwrap(x), Ok(3));
///
-/// let x = Rc::new(4u);
+/// let x = Rc::new(4);
/// let _y = x.clone();
-/// assert_eq!(rc::try_unwrap(x), Err(Rc::new(4u)));
+/// assert_eq!(rc::try_unwrap(x), Err(Rc::new(4)));
/// ```
#[inline]
#[unstable(feature = "alloc")]
/// ```
/// use std::rc::{self, Rc};
///
-/// let mut x = Rc::new(3u);
-/// *rc::get_mut(&mut x).unwrap() = 4u;
-/// assert_eq!(*x, 4u);
+/// let mut x = Rc::new(3);
+/// *rc::get_mut(&mut x).unwrap() = 4;
+/// assert_eq!(*x, 4);
///
/// let _y = x.clone();
/// assert!(rc::get_mut(&mut x).is_none());
#[test]
fn is_unique() {
- let x = Rc::new(3u);
+ let x = Rc::new(3);
assert!(super::is_unique(&x));
let y = x.clone();
assert!(!super::is_unique(&x));
#[test]
fn try_unwrap() {
- let x = Rc::new(3u);
- assert_eq!(super::try_unwrap(x), Ok(3u));
- let x = Rc::new(4u);
+ let x = Rc::new(3);
+ assert_eq!(super::try_unwrap(x), Ok(3));
+ let x = Rc::new(4);
let _y = x.clone();
- assert_eq!(super::try_unwrap(x), Err(Rc::new(4u)));
- let x = Rc::new(5u);
+ assert_eq!(super::try_unwrap(x), Err(Rc::new(4)));
+ let x = Rc::new(5);
let _w = x.downgrade();
- assert_eq!(super::try_unwrap(x), Err(Rc::new(5u)));
+ assert_eq!(super::try_unwrap(x), Err(Rc::new(5)));
}
#[test]
fn get_mut() {
- let mut x = Rc::new(3u);
- *super::get_mut(&mut x).unwrap() = 4u;
- assert_eq!(*x, 4u);
+ let mut x = Rc::new(3);
+ *super::get_mut(&mut x).unwrap() = 4;
+ assert_eq!(*x, 4);
let y = x.clone();
assert!(super::get_mut(&mut x).is_none());
drop(y);
#[test]
fn test_cowrc_clone_make_unique() {
- let mut cow0 = Rc::new(75u);
+ let mut cow0 = Rc::new(75);
let mut cow1 = cow0.clone();
let mut cow2 = cow1.clone();
#[test]
fn test_cowrc_clone_unique2() {
- let mut cow0 = Rc::new(75u);
+ let mut cow0 = Rc::new(75);
let cow1 = cow0.clone();
let cow2 = cow1.clone();
#[test]
fn test_cowrc_clone_weak() {
- let mut cow0 = Rc::new(75u);
+ let mut cow0 = Rc::new(75);
let cow1_weak = cow0.downgrade();
assert!(75 == *cow0);
#[test]
fn test_show() {
- let foo = Rc::new(75u);
+ let foo = Rc::new(75);
assert_eq!(format!("{:?}", foo), "75");
}
impl BoxPointers {
fn check_heap_type<'a, 'tcx>(&self, cx: &Context<'a, 'tcx>,
span: Span, ty: Ty<'tcx>) {
- let mut n_uniq = 0u;
+ let mut n_uniq = 0us;
ty::fold_ty(cx.tcx, ty, |t| {
match t.sty {
ty::ty_uniq(_) => {
// current dictionary of lint information. Along the way, keep a history
// of what we changed so we can roll everything back after invoking the
// specified closure
- let mut pushed = 0u;
+ let mut pushed = 0;
for result in gather_attrs(attrs).into_iter() {
let v = match result {
items: rbml::Doc<'a>) -> Option<rbml::Doc<'a>> {
fn eq_item(bytes: &[u8], item_id: ast::NodeId) -> bool {
return u64_from_be_bytes(
- &bytes[0u..4u], 0u, 4u) as ast::NodeId
+ &bytes[0..4], 0, 4) as ast::NodeId
== item_id;
}
lookup_hash(items,
let meta_items = get_meta_items(attr_doc);
// Currently it's only possible to have a single meta item on
// an attribute
- assert_eq!(meta_items.len(), 1u);
+ assert_eq!(meta_items.len(), 1);
let meta_item = meta_items.into_iter().nth(0).unwrap();
attrs.push(
codemap::Spanned {
encode_name(rbml_w, item.ident.name);
encode_path(rbml_w, path);
encode_attributes(rbml_w, &item.attrs[]);
- if tps_len > 0u || should_inline(&item.attrs[]) {
+ if tps_len > 0 || should_inline(&item.attrs[]) {
encode_inlined_item(ecx, rbml_w, IIItemRef(item));
}
if tps_len == 0 {
fn extract_one(&mut self, m: HashMap<Path, PathKind>, flavor: &str,
slot: &mut Option<MetadataBlob>) -> Option<(Path, PathKind)> {
let mut ret = None::<(Path, PathKind)>;
- let mut error = 0u;
+ let mut error = 0;
if slot.is_some() {
// FIXME(#10786): for an optimization, we only read one of the
fn next(st: &mut PState) -> char {
let ch = st.data[st.pos] as char;
- st.pos = st.pos + 1u;
+ st.pos = st.pos + 1;
return ch;
}
fn next_byte(st: &mut PState) -> u8 {
let b = st.data[st.pos];
- st.pos = st.pos + 1u;
+ st.pos = st.pos + 1;
return b;
}
assert_eq!(next(st), '[');
let mut params = Vec::new();
while peek(st) != ']' { params.push(parse_ty_(st, conv)); }
- st.pos = st.pos + 1u;
+ st.pos = st.pos + 1;
return ty::mk_tup(tcx, params);
}
'F' => {
loop {
let cur = peek(st);
if cur < '0' || cur > '9' { return n; }
- st.pos = st.pos + 1u;
+ st.pos = st.pos + 1;
n *= 10;
n += (cur as uint) - ('0' as uint);
};
}
fn parse_hex(st: &mut PState) -> uint {
- let mut n = 0u;
+ let mut n = 0;
loop {
let cur = peek(st);
if (cur < '0' || cur > '9') && (cur < 'a' || cur > 'f') { return n; }
- st.pos = st.pos + 1u;
- n *= 16u;
+ st.pos = st.pos + 1;
+ n *= 16;
if '0' <= cur && cur <= '9' {
n += (cur as uint) - ('0' as uint);
- } else { n += 10u + (cur as uint) - ('a' as uint); }
+ } else { n += 10 + (cur as uint) - ('a' as uint); }
};
}
while peek(st) != ']' {
inputs.push(parse_ty_(st, conv));
}
- st.pos += 1u; // eat the ']'
+ st.pos += 1; // eat the ']'
let variadic = match next(st) {
'V' => true,
'N' => false,
};
let output = match peek(st) {
'z' => {
- st.pos += 1u;
+ st.pos += 1;
ty::FnDiverging
}
_ => ty::FnConverging(parse_ty_(st, conv))
// Rust metadata parsing
pub fn parse_def_id(buf: &[u8]) -> ast::DefId {
- let mut colon_idx = 0u;
+ let mut colon_idx = 0;
let len = buf.len();
- while colon_idx < len && buf[colon_idx] != ':' as u8 { colon_idx += 1u; }
+ while colon_idx < len && buf[colon_idx] != ':' as u8 { colon_idx += 1; }
if colon_idx == len {
error!("didn't find ':' when parsing def id");
panic!();
}
- let crate_part = &buf[0u..colon_idx];
- let def_part = &buf[colon_idx + 1u..len];
+ let crate_part = &buf[0..colon_idx];
+ let def_part = &buf[colon_idx + 1..len];
let crate_num = match str::from_utf8(crate_part).ok().and_then(|s| {
s.parse::<uint>().ok()
pub fn check_path_args(tcx: &ty::ctxt,
path: &ast::Path,
flags: uint) {
- if (flags & NO_TPS) != 0u {
+ if (flags & NO_TPS) != 0 {
if path.segments.iter().any(|s| s.parameters.has_types()) {
span_err!(tcx.sess, path.span, E0109,
"type parameters are not allowed on this type");
}
}
- if (flags & NO_REGIONS) != 0u {
+ if (flags & NO_REGIONS) != 0 {
if path.segments.iter().any(|s| s.parameters.has_lifetimes()) {
span_err!(tcx.sess, path.span, E0110,
"region parameters are not allowed on this type");
use serialize::Encoder;
rbml_w.emit_struct("MethodCallee", 4, |rbml_w| {
- rbml_w.emit_struct_field("adjustment", 0u, |rbml_w| {
+ rbml_w.emit_struct_field("adjustment", 0, |rbml_w| {
adjustment.encode(rbml_w)
});
- rbml_w.emit_struct_field("origin", 1u, |rbml_w| {
+ rbml_w.emit_struct_field("origin", 1, |rbml_w| {
Ok(rbml_w.emit_method_origin(ecx, &method.origin))
});
- rbml_w.emit_struct_field("ty", 2u, |rbml_w| {
+ rbml_w.emit_struct_field("ty", 2, |rbml_w| {
Ok(rbml_w.emit_ty(ecx, method.ty))
});
- rbml_w.emit_struct_field("substs", 3u, |rbml_w| {
+ rbml_w.emit_struct_field("substs", 3, |rbml_w| {
Ok(rbml_w.emit_substs(ecx, &method.substs))
})
}).unwrap();
Ok(match i {
0 => {
ty::vtable_static(
- this.read_enum_variant_arg(0u, |this| {
+ this.read_enum_variant_arg(0, |this| {
Ok(this.read_def_id_nodcx(cdata))
}).unwrap(),
- this.read_enum_variant_arg(1u, |this| {
+ this.read_enum_variant_arg(1, |this| {
Ok(this.read_substs_nodcx(tcx, cdata))
}).unwrap(),
- this.read_enum_variant_arg(2u, |this| {
+ this.read_enum_variant_arg(2, |this| {
Ok(this.read_vtable_res(tcx, cdata))
}).unwrap()
)
}
1 => {
ty::vtable_param(
- this.read_enum_variant_arg(0u, |this| {
+ this.read_enum_variant_arg(0, |this| {
Decodable::decode(this)
}).unwrap(),
- this.read_enum_variant_arg(1u, |this| {
+ this.read_enum_variant_arg(1, |this| {
this.read_uint()
}).unwrap()
)
}
2 => {
ty::vtable_closure(
- this.read_enum_variant_arg(0u, |this| {
+ this.read_enum_variant_arg(0, |this| {
Ok(this.read_def_id_nodcx(cdata))
}).unwrap()
)
.collect::<Vec<String>>()
}).collect();
- let column_count = m.iter().map(|row| row.len()).max().unwrap_or(0u);
+ let column_count = m.iter().map(|row| row.len()).max().unwrap_or(0);
assert!(m.iter().all(|row| row.len() == column_count));
let column_widths: Vec<uint> = (0..column_count).map(|col| {
- pretty_printed_matrix.iter().map(|row| row[col].len()).max().unwrap_or(0u)
+ pretty_printed_matrix.iter().map(|row| row[col].len()).max().unwrap_or(0)
}).collect();
let total_width = column_widths.iter().map(|n| *n).sum() + column_count * 3 + 1;
-> Usefulness {
let &Matrix(ref rows) = matrix;
debug!("{:?}", matrix);
- if rows.len() == 0u {
+ if rows.len() == 0 {
return match witness {
ConstructWitness => UsefulWithWitness(vec!()),
LeaveOutWitness => Useful
};
}
- if rows[0].len() == 0u {
+ if rows[0].len() == 0 {
return NotUseful;
}
let real_pat = match rows.iter().find(|r| (*r)[0].id != DUMMY_NODE_ID) {
witness: WitnessPreference) -> Usefulness {
let arity = constructor_arity(cx, &ctor, lty);
let matrix = Matrix(m.iter().filter_map(|r| {
- specialize(cx, &r[], &ctor, 0u, arity)
+ specialize(cx, &r[], &ctor, 0, arity)
}).collect());
- match specialize(cx, v, &ctor, 0u, arity) {
+ match specialize(cx, v, &ctor, 0, arity) {
Some(v) => is_useful(cx, &matrix, &v[], witness),
None => NotUseful
}
/// This computes the arity of a constructor. The arity of a constructor
/// is how many subpattern patterns of that constructor should be expanded to.
///
-/// For instance, a tuple pattern (_, 42u, Some([])) has the arity of 3.
+/// For instance, a tuple pattern (_, 42, Some([])) has the arity of 3.
/// A struct pattern's arity is the number of fields it contains, etc.
pub fn constructor_arity(cx: &MatchCheckCtxt, ctor: &Constructor, ty: Ty) -> uint {
match ty.sty {
ty::ty_tup(ref fs) => fs.len(),
- ty::ty_uniq(_) => 1u,
+ ty::ty_uniq(_) => 1,
ty::ty_rptr(_, ty::mt { ty, .. }) => match ty.sty {
ty::ty_vec(_, None) => match *ctor {
Slice(length) => length,
- ConstantValue(_) => 0u,
+ ConstantValue(_) => 0,
_ => unreachable!()
},
- ty::ty_str => 0u,
- _ => 1u
+ ty::ty_str => 0,
+ _ => 1
},
ty::ty_enum(eid, _) => {
match *ctor {
}
ty::ty_struct(cid, _) => ty::lookup_struct_fields(cx.tcx, cid).len(),
ty::ty_vec(_, Some(n)) => n,
- _ => 0u
+ _ => 0
}
}
for (word_index, &word) in words.iter().enumerate() {
if word != 0 {
let base_index = word_index * uint::BITS;
- for offset in 0u..uint::BITS {
+ for offset in 0..uint::BITS {
let bit = 1 << offset;
if (word & bit) != 0 {
// NB: we round up the total number of bits
changed: true
};
- let mut temp: Vec<_> = repeat(0u).take(words_per_id).collect();
+ let mut temp: Vec<_> = repeat(0).take(words_per_id).collect();
while propcx.changed {
propcx.changed = false;
propcx.reset(temp.as_mut_slice());
blk: &ast::Block) -> old_io::IoResult<()> {
let mut ps = pprust::rust_printer_annotated(wr, self);
try!(ps.cbox(pprust::indent_unit));
- try!(ps.ibox(0u));
+ try!(ps.ibox(0));
try!(ps.print_block(blk));
pp::eof(&mut ps.s)
}
for &word in words.iter() {
let mut v = word;
- for _ in 0u..uint::BYTES {
+ for _ in 0..uint::BYTES {
result.push(sep);
result.push_str(&format!("{:02x}", v & 0xFF)[]);
v >>= 8;
fn bit_str(bit: uint) -> String {
let byte = bit >> 8;
- let lobits = 1u << (bit & 0xFF);
+ let lobits = 1 << (bit & 0xFF);
format!("[{}:{}-{:02x}]", bit, byte, lobits)
}
let mut opt_graph = None;
- for idx in 0u..self.num_vars() as uint {
+ for idx in 0..self.num_vars() as uint {
match var_data[idx].value {
Value(_) => {
/* Inference successful */
fn iterate_until_fixed_point<F>(&self, tag: &str, mut body: F) where
F: FnMut(&Constraint) -> bool,
{
- let mut iteration = 0u;
+ let mut iteration = 0;
let mut changed = true;
while changed {
changed = false;
clean_exit_var: Variable
}
-static ACC_READ: uint = 1u;
-static ACC_WRITE: uint = 2u;
-static ACC_USE: uint = 4u;
+static ACC_READ: uint = 1;
+static ACC_WRITE: uint = 2;
+static ACC_USE: uint = 4;
struct Liveness<'a, 'tcx: 'a> {
ir: &'a mut IrMaps<'a, 'tcx>,
fn indices2<F>(&mut self, ln: LiveNode, succ_ln: LiveNode, mut op: F) where
F: FnMut(&mut Liveness<'a, 'tcx>, uint, uint),
{
- let node_base_idx = self.idx(ln, Variable(0u));
- let succ_base_idx = self.idx(succ_ln, Variable(0u));
- for var_idx in 0u..self.ir.num_vars {
+ let node_base_idx = self.idx(ln, Variable(0));
+ let succ_base_idx = self.idx(succ_ln, Variable(0));
+ for var_idx in 0..self.ir.num_vars {
op(self, node_base_idx + var_idx, succ_base_idx + var_idx);
}
}
F: FnMut(uint) -> LiveNode,
{
let node_base_idx = self.idx(ln, Variable(0));
- for var_idx in 0u..self.ir.num_vars {
+ for var_idx in 0..self.ir.num_vars {
let idx = node_base_idx + var_idx;
if test(idx).is_valid() {
try!(write!(wr, " {:?}", Variable(var_idx)));
// hack to skip the loop unless debug! is enabled:
debug!("^^ liveness computation results for body {} (entry={:?})",
{
- for ln_idx in 0u..self.ir.num_live_nodes {
+ for ln_idx in 0..self.ir.num_live_nodes {
debug!("{:?}", self.ln_str(LiveNode(ln_idx)));
}
body.id
match self.ir.tcx.def_map.borrow()[expr.id].clone() {
DefLocal(nid) => {
let ln = self.live_node(expr.id, expr.span);
- if acc != 0u {
+ if acc != 0 {
self.init_from_succ(ln, succ);
let var = self.variable(nid, expr.span);
self.acc(ln, var, acc);
debug!("cat_expr_autoderefd: autoderefs={}, cmt={}",
autoderefs,
cmt.repr(self.tcx()));
- for deref in 1u..autoderefs + 1 {
+ for deref in 1..autoderefs + 1 {
cmt = try!(self.cat_deref(expr, cmt, deref));
}
return Ok(cmt);
let a_ancestors = ancestors_of(self, scope_a);
let b_ancestors = ancestors_of(self, scope_b);
- let mut a_index = a_ancestors.len() - 1u;
- let mut b_index = b_ancestors.len() - 1u;
+ let mut a_index = a_ancestors.len() - 1;
+ let mut b_index = b_ancestors.len() - 1;
// Here, ~[ab]_ancestors is a vector going from narrow to broad.
// The end of each vector will be the item where the scope is
loop {
// Loop invariant: a_ancestors[a_index] == b_ancestors[b_index]
// for all indices between a_index and the end of the array
- if a_index == 0u { return Some(scope_a); }
- if b_index == 0u { return Some(scope_b); }
- a_index -= 1u;
- b_index -= 1u;
+ if a_index == 0 { return Some(scope_a); }
+ if b_index == 0 { return Some(scope_b); }
+ a_index -= 1;
+ b_index -= 1;
if a_ancestors[a_index] != b_ancestors[b_index] {
return Some(a_ancestors[a_index + 1]);
}
match resolve_expr(tcx, expr) {
def::DefVariant(tid, vid, _) => {
let variant_info = enum_variant_with_id(tcx, tid, vid);
- if variant_info.args.len() > 0u {
+ if variant_info.args.len() > 0 {
// N-ary variant.
RvalueDatumExpr
} else {
pub fn field_idx_strict(tcx: &ctxt, name: ast::Name, fields: &[field])
-> uint {
- let mut i = 0u;
- for f in fields.iter() { if f.name == name { return i; } i += 1u; }
+ let mut i = 0;
+ for f in fields.iter() { if f.name == name { return i; } i += 1; }
tcx.sess.bug(&format!(
"no field named `{}` found in the list of fields `{:?}`",
token::get_name(name),
}).map(|(a, b)| (a - 1, b));
let mut new_msg = String::new();
- let mut head = 0u;
+ let mut head = 0;
// Insert `\n` before expected and found.
for (pos1, pos2) in first.zip(second) {
pub fn ty_to_short_str<'tcx>(cx: &ctxt<'tcx>, typ: Ty<'tcx>) -> String {
let mut s = typ.repr(cx).to_string();
- if s.len() >= 32u {
- s = (&s[0u..32u]).to_string();
+ if s.len() >= 32 {
+ s = (&s[0u..32]).to_string();
}
return s;
}
}
// Underscore-qualify anything that didn't start as an ident.
- if result.len() > 0u &&
+ if result.len() > 0 &&
result.as_bytes()[0] != '_' as u8 &&
! (result.as_bytes()[0] as char).is_xid_start() {
return format!("_{}", &result[]);
let file = path.filename_str().unwrap();
let file = &file[3..file.len() - 5]; // chop off lib/.rlib
debug!("reading {}", file);
- for i in iter::count(0u, 1) {
+ for i in iter::count(0us, 1) {
let bc_encoded = time(sess.time_passes(),
format!("check for {}.{}.bytecode.deflate", name, i).as_slice(),
(),
self.check_and_record(Variable,
span,
sub_span,
- svec!(id, name, qualname, value, typ, 0u));
+ svec!(id, name, qualname, value, typ, 0));
}
// formal parameters
self.check_and_record(Variable,
span,
sub_span,
- svec!(id, name, qualname, "", typ, 0u));
+ svec!(id, name, qualname, "", typ, 0));
}
// value is the initialising expression of the static if it is not mut, otherwise "".
svec!(base_id.node,
base_id.krate,
deriv_id,
- 0u));
+ 0));
}
pub fn fn_call_str(&mut self,
self.record_with_span(ModRef,
span,
sub_span,
- svec!(0u, 0u, qualname, parent));
+ svec!(0, 0, qualname, parent));
}
pub fn typedef_str(&mut self,
self.record_with_span(TypeRef,
span,
sub_span,
- svec!(0u, 0u, qualname, 0u));
+ svec!(0, 0, qualname, 0));
}
// A slightly generic function for a reference to an item of any kind.
let mut result = None;
let mut toks = self.retokenise_span(span);
- let mut bracket_count = 0u;
+ let mut bracket_count = 0;
loop {
let ts = toks.real_token();
if ts.tok == token::Eof {
// Return the span for the first identifier in the path.
pub fn span_for_first_ident(&self, span: Span) -> Option<Span> {
let mut toks = self.retokenise_span(span);
- let mut bracket_count = 0u;
+ let mut bracket_count = 0;
loop {
let ts = toks.real_token();
if ts.tok == token::Eof {
let mut toks = self.retokenise_span(span);
let mut prev = toks.real_token();
let mut result = None;
- let mut bracket_count = 0u;
+ let mut bracket_count = 0;
let mut last_span = None;
while prev.tok != token::Eof {
last_span = None;
let mut toks = self.retokenise_span(span);
let mut prev = toks.real_token();
let mut result = None;
- let mut bracket_count = 0u;
+ let mut bracket_count = 0;
loop {
let next = toks.real_token();
//! match foo {
//! A => ...,
//! B(x) => ...,
-//! C(1u, 2) => ...,
+//! C(1, 2) => ...,
//! C(_) => ...
//! }
//!
//! various options and then compile the code for the case where `foo` is an
//! `A`, a `B`, and a `C`. When we generate the code for `C`, we would (1)
//! drop the two matches that do not match a `C` and (2) expand the other two
-//! into two patterns each. In the first case, the two patterns would be `1u`
+//! into two patterns each. In the first case, the two patterns would be `1`
//! and `2`, and the in the second case the _ pattern would be expanded into
//! `_` and `_`. The two values are of course the arguments to `C`.
//!
ty::mt {ty: vt.unit_ty, mutbl: ast::MutImmutable});
let scratch = rvalue_scratch_datum(bcx, slice_ty, "");
Store(bcx, slice_begin,
- GEPi(bcx, scratch.val, &[0u, abi::FAT_PTR_ADDR]));
- Store(bcx, slice_len, GEPi(bcx, scratch.val, &[0u, abi::FAT_PTR_EXTRA]));
+ GEPi(bcx, scratch.val, &[0, abi::FAT_PTR_ADDR]));
+ Store(bcx, slice_len, GEPi(bcx, scratch.val, &[0, abi::FAT_PTR_EXTRA]));
scratch.val
}
fn pat_score(def_map: &DefMap, pat: &ast::Pat) -> uint {
match pat.node {
ast::PatIdent(_, _, Some(ref inner)) => pat_score(def_map, &**inner),
- _ if pat_is_refutable(def_map, pat) => 1u,
- _ => 0u
+ _ if pat_is_refutable(def_map, pat) => 1,
+ _ => 0
}
}
let _indenter = indenter();
let _icx = push_ctxt("match::compile_submatch");
let mut bcx = bcx;
- if m.len() == 0u {
+ if m.len() == 0 {
if chk.is_fallible() {
chk.handle_fail(bcx);
}
let tcx = bcx.tcx();
let dm = &tcx.def_map;
- let mut vals_left = vals[0u..col].to_vec();
- vals_left.push_all(&vals[col + 1u..]);
+ let mut vals_left = vals[0..col].to_vec();
+ vals_left.push_all(&vals[col + 1..]);
let ccx = bcx.fcx.ccx;
// Find a real id (we're adding placeholder wildcard patterns, but
let mut kind = NoBranch;
let mut test_val = val;
debug!("test_val={}", bcx.val_to_string(test_val));
- if opts.len() > 0u {
+ if opts.len() > 0 {
match opts[0] {
ConstantValue(_) | ConstantRange(_, _) => {
test_val = load_if_immediate(bcx, val, left_ty);
};
let defaults = enter_default(else_cx, dm, m, col, val);
- let exhaustive = chk.is_infallible() && defaults.len() == 0u;
+ let exhaustive = chk.is_infallible() && defaults.len() == 0;
let len = opts.len();
// Compile subtrees for each option
Br(bcx, else_cx.llbb, DebugLoc::None);
}
- let mut size = 0u;
+ let mut size = 0;
let mut unpacked = Vec::new();
match *opt {
Variant(disr_val, ref repr, _) => {
_ => { }
}
- ccx.stats().n_static_tydescs.set(ccx.stats().n_static_tydescs.get() + 1u);
+ ccx.stats().n_static_tydescs.set(ccx.stats().n_static_tydescs.get() + 1);
let inf = Rc::new(glue::declare_tydesc(ccx, t));
ccx.tydescs().borrow_mut().insert(t, inf.clone());
panic!("struct variant kind unexpected in get_item_val")
}
};
- assert!(args.len() != 0u);
+ assert!(args.len() != 0);
let ty = ty::node_id_to_type(ccx.tcx(), id);
let parent = ccx.tcx().map.get_parent(id);
let enm = ccx.tcx().map.expect_item(parent);
// Pass 1: scan table mapping str -> rightmost pos.
let mut mm = FnvHashMap();
let len = v.len();
- let mut i = 0u;
+ let mut i = 0;
while i < len {
mm.insert(v[i], i);
- i += 1u;
+ i += 1;
}
// Pass 2: concat strings for each elt, skipping
// forwards over any cycles by advancing to rightmost
// occurrence of each element in path.
let mut s = String::from_str(".");
- i = 0u;
+ i = 0;
while i < len {
i = mm[v[i]];
s.push('/');
s.push_str(v[i]);
- i += 1u;
+ i += 1;
}
s.push('/');
let n = match h.get(&s) {
Some(&n) => n,
- _ => 0u
+ _ => 0
};
- h.insert(s, n+1u);
+ h.insert(s, n+1);
})
}
}
use std::cmp;
fn align_up_to(off: uint, a: uint) -> uint {
- return (off + a - 1u) / a * a;
+ return (off + a - 1) / a * a;
}
fn align(off: uint, ty: Type) -> uint {
type TyAlignFn = fn(ty: Type) -> uint;
fn align_up_to(off: uint, a: uint) -> uint {
- return (off + a - 1u) / a * a;
+ return (off + a - 1) / a * a;
}
fn align(off: uint, ty: Type, align_fn: TyAlignFn) -> uint {
use trans::type_::Type;
fn align_up_to(off: uint, a: uint) -> uint {
- return (off + a - 1u) / a * a;
+ return (off + a - 1) / a * a;
}
fn align(off: uint, ty: Type) -> uint {
use std::cmp;
fn align_up_to(off: uint, a: uint) -> uint {
- return (off + a - 1u) / a * a;
+ return (off + a - 1) / a * a;
}
fn align(off: uint, ty: Type) -> uint {
fn classify_ty(ty: Type) -> Vec<RegClass> {
fn align(off: uint, ty: Type) -> uint {
let a = ty_align(ty);
- return (off + a - 1u) / a * a;
+ return (off + a - 1) / a * a;
}
fn ty_align(ty: Type) -> uint {
let t_size = ty_size(ty);
let misalign = off % t_align;
- if misalign != 0u {
- let mut i = off / 8u;
- let e = (off + t_size + 7u) / 8u;
+ if misalign != 0 {
+ let mut i = off / 8;
+ let e = (off + t_size + 7) / 8;
while i < e {
unify(cls, ix + i, Memory);
- i += 1u;
+ i += 1;
}
return;
}
match ty.kind() {
Integer |
Pointer => {
- unify(cls, ix + off / 8u, Int);
+ unify(cls, ix + off / 8, Int);
}
Float => {
- if off % 8u == 4u {
- unify(cls, ix + off / 8u, SSEFv);
+ if off % 8 == 4 {
+ unify(cls, ix + off / 8, SSEFv);
} else {
- unify(cls, ix + off / 8u, SSEFs);
+ unify(cls, ix + off / 8, SSEFs);
}
}
Double => {
- unify(cls, ix + off / 8u, SSEDs);
+ unify(cls, ix + off / 8, SSEDs);
}
Struct => {
classify_struct(ty.field_types().as_slice(), cls, ix, off, ty.is_packed());
let len = ty.array_length();
let elt = ty.element_type();
let eltsz = ty_size(elt);
- let mut i = 0u;
+ let mut i = 0;
while i < len {
classify(elt, cls, ix, off + i * eltsz);
- i += 1u;
+ i += 1;
}
}
Vector => {
_ => panic!("classify: unhandled vector element type")
};
- let mut i = 0u;
+ let mut i = 0;
while i < len {
unify(cls, ix + (off + i * eltsz) / 8, reg);
// everything after the first one is the upper
// half of a register.
reg = SSEUp;
- i += 1u;
+ i += 1;
}
}
_ => panic!("classify: unhandled type")
}
fn fixup(ty: Type, cls: &mut [RegClass]) {
- let mut i = 0u;
+ let mut i = 0;
let ty_kind = ty.kind();
let e = cls.len();
- if cls.len() > 2u && (ty_kind == Struct || ty_kind == Array || ty_kind == Vector) {
+ if cls.len() > 2 && (ty_kind == Struct || ty_kind == Array || ty_kind == Vector) {
if cls[i].is_sse() {
- i += 1u;
+ i += 1;
while i < e {
if cls[i] != SSEUp {
all_mem(cls);
return;
}
- i += 1u;
+ i += 1;
}
} else {
all_mem(cls);
cls[i] = SSEDv;
} else if cls[i].is_sse() {
i += 1;
- while i != e && cls[i] == SSEUp { i += 1u; }
+ while i != e && cls[i] == SSEUp { i += 1; }
} else if cls[i] == X87 {
i += 1;
- while i != e && cls[i] == X87Up { i += 1u; }
+ while i != e && cls[i] == X87Up { i += 1; }
} else {
i += 1;
}
fn llreg_ty(ccx: &CrateContext, cls: &[RegClass]) -> Type {
fn llvec_len(cls: &[RegClass]) -> uint {
- let mut len = 1u;
+ let mut len = 1;
for c in cls.iter() {
if *c != SSEUp {
break;
}
- len += 1u;
+ len += 1;
}
return len;
}
let mut tys = Vec::new();
- let mut i = 0u;
+ let mut i = 0;
let e = cls.len();
while i < e {
match cls[i] {
}
_ => unreachable!(),
};
- let vec_len = llvec_len(&cls[i + 1u..]);
+ let vec_len = llvec_len(&cls[i + 1..]);
let vec_ty = Type::vector(&elt_ty, vec_len as u64 * elts_per_word);
tys.push(vec_ty);
i += vec_len;
}
_ => panic!("llregtype: unhandled class")
}
- i += 1u;
+ i += 1;
}
if tys.len() == 1 && tys[0].kind() == Vector {
// if the type contains only a vector, pass it as that vector.
bcx.fcx.param_substs);
// Nullary variants are not callable
- assert!(vinfo.args.len() > 0u);
+ assert!(vinfo.args.len() > 0);
Callee {
bcx: bcx,
};
// The only landing pad clause will be 'cleanup'
- let llretval = build::LandingPad(pad_bcx, llretty, llpersonality, 1u);
+ let llretval = build::LandingPad(pad_bcx, llretty, llpersonality, 1);
// The landing pad block is a cleanup
build::SetCleanup(pad_bcx, llretval);
symbol_hasher: RefCell::new(symbol_hasher),
tcx: tcx,
stats: Stats {
- n_static_tydescs: Cell::new(0u),
- n_glues_created: Cell::new(0u),
- n_null_glues: Cell::new(0u),
- n_real_glues: Cell::new(0u),
- n_fns: Cell::new(0u),
- n_monos: Cell::new(0u),
- n_inlines: Cell::new(0u),
- n_closures: Cell::new(0u),
- n_llvm_insns: Cell::new(0u),
+ n_static_tydescs: Cell::new(0),
+ n_glues_created: Cell::new(0),
+ n_null_glues: Cell::new(0),
+ n_real_glues: Cell::new(0),
+ n_fns: Cell::new(0),
+ n_monos: Cell::new(0),
+ n_inlines: Cell::new(0),
+ n_closures: Cell::new(0),
+ n_llvm_insns: Cell::new(0),
llvm_insns: RefCell::new(FnvHashMap()),
fn_stats: RefCell::new(Vec::new()),
},
dbg_cx: dbg_cx,
eh_personality: RefCell::new(None),
intrinsics: RefCell::new(FnvHashMap()),
- n_llvm_insns: Cell::new(0u),
+ n_llvm_insns: Cell::new(0),
trait_cache: RefCell::new(FnvHashMap()),
};
let work_dir = cx.sess().working_dir.as_str().unwrap();
let file_name =
if full_path.starts_with(work_dir) {
- &full_path[work_dir.len() + 1u..full_path.len()]
+ &full_path[work_dir.len() + 1..full_path.len()]
} else {
full_path
};
let null_variant_index = (1 - non_null_variant_index) as uint;
let null_variant_name = token::get_name((*self.variants)[null_variant_index].name);
let union_member_name = format!("RUST$ENCODED$ENUM${}${}",
- 0u,
+ 0,
null_variant_name);
// Finally create the (singleton) list of descriptions of union
output.push_str("::");
}
- let mut path_element_count = 0u;
+ let mut path_element_count = 0;
for path_element in path {
let name = token::get_name(path_element.name());
output.push_str(name.get());
}
pub fn get_len(bcx: Block, fat_ptr: ValueRef) -> ValueRef {
- GEPi(bcx, fat_ptr, &[0u, abi::FAT_PTR_EXTRA])
+ GEPi(bcx, fat_ptr, &[0, abi::FAT_PTR_EXTRA])
}
pub fn get_dataptr(bcx: Block, fat_ptr: ValueRef) -> ValueRef {
- GEPi(bcx, fat_ptr, &[0u, abi::FAT_PTR_ADDR])
+ GEPi(bcx, fat_ptr, &[0, abi::FAT_PTR_ADDR])
}
/// Helper for trans that apply adjustments from `expr` to `datum`, which should be the unadjusted
}, info),
ty::UnsizeLength(..) =>
into_fat_ptr(bcx, expr, datum, dest_ty, |bcx, val| {
- GEPi(bcx, val, &[0u, 0u])
+ GEPi(bcx, val, &[0, 0])
}, info),
ty::UnsizeVtable(..) =>
into_fat_ptr(bcx, expr, datum, dest_ty, |_bcx, val| {
match def {
def::DefVariant(tid, vid, _) => {
let variant_info = ty::enum_variant_with_id(bcx.tcx(), tid, vid);
- if variant_info.args.len() > 0u {
+ if variant_info.args.len() > 0 {
// N-ary variant.
let llfn = callee::trans_fn_ref(bcx.ccx(), vid,
ExprId(ref_expr.id),
// info points to the vtable and the second entry in the vtable is the
// dynamic size of the object.
let info = PointerCast(bcx, info, Type::int(bcx.ccx()).ptr_to());
- let size_ptr = GEPi(bcx, info, &[1u]);
- let align_ptr = GEPi(bcx, info, &[2u]);
+ let size_ptr = GEPi(bcx, info, &[1]);
+ let align_ptr = GEPi(bcx, info, &[2]);
(Load(bcx, size_ptr), Load(bcx, align_ptr))
}
ty::ty_vec(_, None) | ty::ty_str => {
update_linkage(ccx, llfn, None, OriginalTranslation);
- ccx.stats().n_glues_created.set(ccx.stats().n_glues_created.get() + 1u);
+ ccx.stats().n_glues_created.set(ccx.stats().n_glues_created.get() + 1);
// All glue functions take values passed *by alias*; this is a
// requirement since in many contexts glue is invoked indirectly and
// the caller has no idea if it's dealing with something that can be
for impl_item in impl_items.iter() {
match *impl_item {
ast::MethodImplItem(ref method) => {
- if method.pe_generics().ty_params.len() == 0u {
+ if method.pe_generics().ty_params.len() == 0 {
let trans_everywhere = attr::requests_inline(&method.attrs[]);
for (ref ccx, is_origin) in ccx.maybe_iter(trans_everywhere) {
let llfn = get_item_val(ccx, method.id);
callee_ty.repr(ccx.tcx()),
vtable_index,
bcx.val_to_string(llpair));
- let llboxptr = GEPi(bcx, llpair, &[0u, abi::FAT_PTR_ADDR]);
+ let llboxptr = GEPi(bcx, llpair, &[0, abi::FAT_PTR_ADDR]);
let llbox = Load(bcx, llboxptr);
let llself = PointerCast(bcx, llbox, Type::i8p(ccx));
let llvtable = Load(bcx,
PointerCast(bcx,
GEPi(bcx, llpair,
- &[0u, abi::FAT_PTR_EXTRA]),
+ &[0, abi::FAT_PTR_EXTRA]),
Type::vtable(ccx).ptr_to().ptr_to()));
- let mptr = Load(bcx, GEPi(bcx, llvtable, &[0u, vtable_index + VTABLE_OFFSET]));
+ let mptr = Load(bcx, GEPi(bcx, llvtable, &[0, vtable_index + VTABLE_OFFSET]));
let mptr = PointerCast(bcx, mptr, llcallee_ty.ptr_to());
return Callee {
let llbox_ty = type_of(bcx.ccx(), datum_ty);
// Store the pointer into the first half of pair.
- let llboxdest = GEPi(bcx, lldest, &[0u, abi::FAT_PTR_ADDR]);
+ let llboxdest = GEPi(bcx, lldest, &[0, abi::FAT_PTR_ADDR]);
let llboxdest = PointerCast(bcx, llboxdest, llbox_ty.ptr_to());
bcx = datum.store_to(bcx, llboxdest);
// Store the vtable into the second half of pair.
let vtable = get_vtable(bcx, datum_ty, trait_ref);
- let llvtabledest = GEPi(bcx, lldest, &[0u, abi::FAT_PTR_EXTRA]);
+ let llvtabledest = GEPi(bcx, lldest, &[0, abi::FAT_PTR_EXTRA]);
let llvtabledest = PointerCast(bcx, llvtabledest, val_ty(vtable).ptr_to());
Store(bcx, vtable, llvtabledest);
let unit_size = llsize_of_alloc(ccx, llty);
if unit_size != 0 {
let len = get_len(bcx, vptr);
- let not_empty = ICmp(bcx, llvm::IntNE, len, C_uint(ccx, 0u));
+ let not_empty = ICmp(bcx, llvm::IntNE, len, C_uint(ccx, 0us));
with_cond(bcx, not_empty, |bcx| {
let llalign = C_uint(ccx, machine::llalign_of_min(ccx, llty));
let size = Mul(bcx, C_uint(ccx, unit_size), len, DebugLoc::None);
let llbytes = C_uint(bcx.ccx(), bytes);
let llcstr = C_cstr(bcx.ccx(), str_lit, false);
let llcstr = consts::ptrcast(llcstr, Type::i8p(bcx.ccx()));
- Store(bcx, llcstr, GEPi(bcx, lldest, &[0u, abi::FAT_PTR_ADDR]));
- Store(bcx, llbytes, GEPi(bcx, lldest, &[0u, abi::FAT_PTR_EXTRA]));
+ Store(bcx, llcstr, GEPi(bcx, lldest, &[0, abi::FAT_PTR_ADDR]));
+ Store(bcx, llbytes, GEPi(bcx, lldest, &[0, abi::FAT_PTR_EXTRA]));
bcx
}
}
fn get_slice_base_and_len(bcx: Block,
llval: ValueRef)
-> (ValueRef, ValueRef) {
- let base = Load(bcx, GEPi(bcx, llval, &[0u, abi::FAT_PTR_ADDR]));
- let len = Load(bcx, GEPi(bcx, llval, &[0u, abi::FAT_PTR_EXTRA]));
+ let base = Load(bcx, GEPi(bcx, llval, &[0, abi::FAT_PTR_ADDR]));
+ let len = Load(bcx, GEPi(bcx, llval, &[0, abi::FAT_PTR_EXTRA]));
(base, len)
}
ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty, ..}) => match ty.sty {
ty::ty_vec(_, None) | ty::ty_str => get_slice_base_and_len(bcx, llval),
ty::ty_vec(_, Some(n)) => {
- let base = GEPi(bcx, Load(bcx, llval), &[0u, 0u]);
+ let base = GEPi(bcx, Load(bcx, llval), &[0, 0]);
(base, C_uint(ccx, n))
}
_ => ccx.sess().bug("unexpected type in get_base_and_len"),
let loop_counter = {
// i = 0
let i = alloca(loop_bcx, bcx.ccx().int_type(), "__i");
- Store(loop_bcx, C_uint(bcx.ccx(), 0u), i);
+ Store(loop_bcx, C_uint(bcx.ccx(), 0us), i);
Br(loop_bcx, cond_bcx.llbb, DebugLoc::None);
i
{ // i += 1
let i = Load(inc_bcx, loop_counter);
- let plusone = Add(inc_bcx, i, C_uint(bcx.ccx(), 1u), DebugLoc::None);
+ let plusone = Add(inc_bcx, i, C_uint(bcx.ccx(), 1us), DebugLoc::None);
Store(inc_bcx, plusone, loop_counter);
Br(inc_bcx, cond_bcx.llbb, DebugLoc::None);
projects / rust.git / commitdiff